From 687d25a752650f9f2b896452ce748c31929abb6c Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Tue, 30 Jun 2015 11:27:28 -0700
Subject: [PATCH 01/57] initial changes

---
 src/compiler/declarationEmitter.ts | 125 +++++++++++++++++++++++++++--
 src/compiler/tsconfig.json         |   4 +-
 2 files changed, 123 insertions(+), 6 deletions(-)

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index 6c0803f8761f7..22963e39f74aa 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -63,6 +63,16 @@ namespace ts {
         // and we could be collecting these paths from multiple files into single one with --out option
         let referencePathsOutput = "";
 
+        interface NodeLinks {
+            visibleChildren?: Node[];
+        }
+
+        let nodeLinks: NodeLinks[] = [];
+        function getNodeLinks(node: Node): NodeLinks {
+            let nodeId = getNodeId(node);
+            return nodeLinks[nodeId] || (nodeLinks[nodeId] = {});
+        }
+
         if (root) {
             // Emitting just a single file, so emit references in this file only
             if (!compilerOptions.noResolve) {
@@ -452,7 +462,8 @@ namespace ts {
         function emitSourceFile(node: SourceFile) {
             currentSourceFile = node;
             enclosingDeclaration = node;
-            emitLines(node.statements);
+//            emitLines(node.statements);
+            emitSourceFileDeclarations(node);
         }
 
         // Return a temp variable name to be used in `export default` statements.
@@ -742,7 +753,8 @@ namespace ts {
             write(" {");
             writeLine();
             increaseIndent();
-            emitLines((<ModuleBlock>node.body).statements);
+            //emitLines((<ModuleBlock>node.body).statements);
+            writeChildDeclarations(node);
             decreaseIndent();
             write("}");
             writeLine();
@@ -779,7 +791,8 @@ namespace ts {
             write(" {");
             writeLine();
             increaseIndent();
-            emitLines(node.members);
+            //emitLines(node.members);
+            writeChildDeclarations(node);
             decreaseIndent();
             write("}");
             writeLine();
@@ -947,7 +960,8 @@ namespace ts {
             writeLine();
             increaseIndent();
             emitParameterProperties(getFirstConstructorWithBody(node));
-            emitLines(node.members);
+            //emitLines(node.members);
+            writeChildDeclarations(node);
             decreaseIndent();
             write("}");
             writeLine();
@@ -966,7 +980,8 @@ namespace ts {
             write(" {");
             writeLine();
             increaseIndent();
-            emitLines(node.members);
+            //emitLines(node.members);
+            writeChildDeclarations(node);
             decreaseIndent();
             write("}");
             writeLine();
@@ -1584,6 +1599,106 @@ namespace ts {
 
             referencePathsOutput += "/// <reference path=\"" + declFileName + "\" />" + newLine;
         }
+
+        function walkTypes(node: Node): void {
+
+        }
+
+        function isDeclarationVisible(node: Node): boolean {
+            switch (node.kind) {
+                case SyntaxKind.TypeParameter:
+                case SyntaxKind.Parameter:
+                case SyntaxKind.PropertySignature:
+                case SyntaxKind.PropertyDeclaration:
+                case SyntaxKind.MethodSignature:
+                case SyntaxKind.MethodDeclaration:
+                case SyntaxKind.Constructor:
+                case SyntaxKind.GetAccessor:
+                case SyntaxKind.SetAccessor:
+                case SyntaxKind.CallSignature:
+                case SyntaxKind.ConstructSignature:
+                case SyntaxKind.IndexSignature:
+                case SyntaxKind.EnumMember:
+                case SyntaxKind.ExportAssignment:
+                case SyntaxKind.ExportDeclaration:
+                    // TODO: filter on @internal
+                    return true;
+
+                case SyntaxKind.VariableStatement:
+                case SyntaxKind.ClassDeclaration:
+                case SyntaxKind.EnumDeclaration:
+                case SyntaxKind.FunctionDeclaration:
+                case SyntaxKind.ImportEqualsDeclaration:
+                case SyntaxKind.InterfaceDeclaration:
+                case SyntaxKind.ModuleDeclaration:
+                case SyntaxKind.TypeAliasDeclaration:
+                    // TODO: handel ambient context
+                    return (node.flags & NodeFlags.Export) !== 0;
+            }
+
+            return false;
+        }
+
+        function forEachTopLevelDeclaration(node: Node, action: (node: Node) => void): void {
+            switch (node.kind) {
+                case SyntaxKind.SourceFile:
+                    forEach((<SourceFile>node).statements, action);
+                    break;
+                case SyntaxKind.InterfaceDeclaration:
+                case SyntaxKind.EnumDeclaration:
+                case SyntaxKind.ClassDeclaration:
+                    forEach((<InterfaceDeclaration|EnumDeclaration|ClassDeclaration>node).members, action);
+                    break;
+                case SyntaxKind.ModuleDeclaration:
+                    if ((<ModuleDeclaration>node).body.kind === SyntaxKind.ModuleBlock) {
+                        forEach((<ModuleBlock>(<ModuleDeclaration>node).body).statements, action);
+                    }
+                    else {
+                        action((<ModuleDeclaration>node).body);
+                    }
+                    break;
+            }
+        }
+
+        function collectChildDeclarations(node: Node): void {
+            let links = getNodeLinks(node);
+            forEachTopLevelDeclaration(node, child => {
+                if (!isDeclarationVisible(child)) {
+                    return;
+                }
+
+                if (!links.visibleChildren) {
+                    links.visibleChildren = [];
+                }
+                links.visibleChildren.push(child);
+
+                // if there are any types we need to write later on
+                // make sure to visit them and collect their declarations
+                walkTypes(child);
+
+                // visit nested declarations
+                switch (child.kind) {
+                    case SyntaxKind.ModuleDeclaration:
+                    case SyntaxKind.InterfaceDeclaration:
+                    case SyntaxKind.ClassDeclaration:
+                    case SyntaxKind.EnumDeclaration:
+                        collectChildDeclarations(child);
+                        break;
+                }
+            });
+        }
+
+        function writeChildDeclarations(node: Node): void {
+            forEach(getNodeLinks(node).visibleChildren, emitNode);
+        }
+
+        function emitSourceFileDeclarations(sourceFile: SourceFile): void {
+            // Collect all visible declarations
+            collectChildDeclarations(sourceFile);
+
+            // write the declarations
+            writeChildDeclarations(sourceFile);
+        }
     }
 
     /* @internal */
diff --git a/src/compiler/tsconfig.json b/src/compiler/tsconfig.json
index fd541a8ca80c1..81e807b105355 100644
--- a/src/compiler/tsconfig.json
+++ b/src/compiler/tsconfig.json
@@ -5,7 +5,8 @@
         "removeComments": true,
         "preserveConstEnums": true,
         "out": "../../built/local/tsc.js",
-        "sourceMap": true
+        "sourceMap": true,
+        "mapRoot": "file:///C:\\ts\\built\\local"
     },
     "files": [
         "core.ts",
@@ -16,6 +17,7 @@
         "utilities.ts",
         "binder.ts",
         "checker.ts",
+        "declarationEmitter.ts",
         "emitter.ts",
         "program.ts",
         "commandLineParser.ts",

From c5c4835b975b84b5baddb6c644812ea81661fa04 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Tue, 30 Jun 2015 23:18:48 -0700
Subject: [PATCH 02/57] visit nodes

---
 src/compiler/checker.ts            |  19 ++
 src/compiler/declarationEmitter.ts | 427 ++++++++++++++++++++++-------
 src/compiler/types.ts              |   4 +
 3 files changed, 352 insertions(+), 98 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index f8bafa7a38fff..071c0c95d1b80 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -783,6 +783,21 @@ namespace ts {
             }
         }
 
+
+
+        function getLocalTargetOfAliasDeclaration(node: Declaration): Symbol {
+            switch (node.kind) {
+                case SyntaxKind.ImportEqualsDeclaration:
+                    return ((<ImportEqualsDeclaration>node).moduleReference.kind === SyntaxKind.ExternalModuleReference) ? undefined :
+                        getSymbolOfPartOfRightHandSideOfImportEquals(<EntityName>(<ImportEqualsDeclaration>node).moduleReference, <ImportEqualsDeclaration>node);
+                case SyntaxKind.ExportSpecifier:
+                    return (<ExportDeclaration>(<ExportSpecifier>node).parent.parent).moduleSpecifier ? undefined :
+                        resolveEntityName((<ExportSpecifier>node).propertyName || (<ExportSpecifier>node).name, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace | SymbolFlags.Alias);
+                case SyntaxKind.ExportAssignment:
+                    return resolveEntityName(<Identifier>(<ExportAssignment>node).expression, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace | SymbolFlags.Alias);
+            }
+        }
+
         function resolveSymbol(symbol: Symbol): Symbol {
             return symbol && symbol.flags & SymbolFlags.Alias && !(symbol.flags & (SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace)) ? resolveAlias(symbol) : symbol;
         }
@@ -14158,6 +14173,10 @@ namespace ts {
                 getBlockScopedVariableId,
                 getReferencedValueDeclaration,
                 getTypeReferenceSerializationKind,
+                resolveName,
+                getSymbolAtLocation,
+                resolveAlias,
+                getLocalTargetOfAliasDeclaration,
             };
         }
 
diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index 22963e39f74aa..dd4b2c4132214 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -65,6 +65,7 @@ namespace ts {
 
         interface NodeLinks {
             visibleChildren?: Node[];
+            visited?: boolean;
         }
 
         let nodeLinks: NodeLinks[] = [];
@@ -222,7 +223,7 @@ namespace ts {
                             Debug.assert(asynchronousSubModuleDeclarationEmitInfo === undefined);
                             asynchronousSubModuleDeclarationEmitInfo = [];
                         }
-                        writeModuleElement(nodeToCheck);
+                        //writeModuleElement(nodeToCheck);
                         if (nodeToCheck.kind === SyntaxKind.ModuleDeclaration) {
                             moduleElementEmitInfo.subModuleElementDeclarationEmitInfo = asynchronousSubModuleDeclarationEmitInfo;
                             asynchronousSubModuleDeclarationEmitInfo = undefined;
@@ -521,69 +522,71 @@ namespace ts {
             }
         }
 
-        function isModuleElementVisible(node: Declaration) {
-            return resolver.isDeclarationVisible(node);
-        }
-
-        function emitModuleElement(node: Node, isModuleElementVisible: boolean) {
-            if (isModuleElementVisible) {
-                writeModuleElement(node);
-            }
-            // Import equals declaration in internal module can become visible as part of any emit so lets make sure we add these irrespective
-            else if (node.kind === SyntaxKind.ImportEqualsDeclaration ||
-                (node.parent.kind === SyntaxKind.SourceFile && isExternalModule(currentSourceFile))) {
-                let isVisible: boolean;
-                if (asynchronousSubModuleDeclarationEmitInfo && node.parent.kind !== SyntaxKind.SourceFile) {
-                    // Import declaration of another module that is visited async so lets put it in right spot
-                    asynchronousSubModuleDeclarationEmitInfo.push({
-                        node,
-                        outputPos: writer.getTextPos(),
-                        indent: writer.getIndent(),
-                        isVisible
-                    });
-                }
-                else {
-                    if (node.kind === SyntaxKind.ImportDeclaration) {
-                        let importDeclaration = <ImportDeclaration>node;
-                        if (importDeclaration.importClause) {
-                            isVisible = (importDeclaration.importClause.name && resolver.isDeclarationVisible(importDeclaration.importClause)) ||
-                            isVisibleNamedBinding(importDeclaration.importClause.namedBindings);
-                        }
-                    }
-                    moduleElementDeclarationEmitInfo.push({
-                        node,
-                        outputPos: writer.getTextPos(),
-                        indent: writer.getIndent(),
-                        isVisible
-                    });
-                }
-            }
-        }
-
-        function writeModuleElement(node: Node) {
-            switch (node.kind) {
-                case SyntaxKind.FunctionDeclaration:
-                    return writeFunctionDeclaration(<FunctionLikeDeclaration>node);
-                case SyntaxKind.VariableStatement:
-                    return writeVariableStatement(<VariableStatement>node);
-                case SyntaxKind.InterfaceDeclaration:
-                    return writeInterfaceDeclaration(<InterfaceDeclaration>node);
-                case SyntaxKind.ClassDeclaration:
-                    return writeClassDeclaration(<ClassDeclaration>node);
-                case SyntaxKind.TypeAliasDeclaration:
-                    return writeTypeAliasDeclaration(<TypeAliasDeclaration>node);
-                case SyntaxKind.EnumDeclaration:
-                    return writeEnumDeclaration(<EnumDeclaration>node);
-                case SyntaxKind.ModuleDeclaration:
-                    return writeModuleDeclaration(<ModuleDeclaration>node);
-                case SyntaxKind.ImportEqualsDeclaration:
-                    return writeImportEqualsDeclaration(<ImportEqualsDeclaration>node);
-                case SyntaxKind.ImportDeclaration:
-                    return writeImportDeclaration(<ImportDeclaration>node);
-                default:
-                    Debug.fail("Unknown symbol kind");
-            }
-        }
+        //function isModuleElementVisible(node: Declaration) {
+        //    return resolver.isDeclarationVisible(node);
+        //}
+
+        //function emitModuleElement(node: Node, isModuleElementVisible: boolean) {
+        //    writeModuleElement(node);
+           
+        //    if (isModuleElementVisible) {
+        //        writeModuleElement(node);
+        //    }
+        //    // Import equals declaration in internal module can become visible as part of any emit so lets make sure we add these irrespective
+        //    else if (node.kind === SyntaxKind.ImportEqualsDeclaration ||
+        //        (node.parent.kind === SyntaxKind.SourceFile && isExternalModule(currentSourceFile))) {
+        //        let isVisible: boolean;
+        //        if (asynchronousSubModuleDeclarationEmitInfo && node.parent.kind !== SyntaxKind.SourceFile) {
+        //            // Import declaration of another module that is visited async so lets put it in right spot
+        //            asynchronousSubModuleDeclarationEmitInfo.push({
+        //                node,
+        //                outputPos: writer.getTextPos(),
+        //                indent: writer.getIndent(),
+        //                isVisible
+        //            });
+        //        }
+        //        else {
+        //            if (node.kind === SyntaxKind.ImportDeclaration) {
+        //                let importDeclaration = <ImportDeclaration>node;
+        //                if (importDeclaration.importClause) {
+        //                    isVisible = (importDeclaration.importClause.name && resolver.isDeclarationVisible(importDeclaration.importClause)) ||
+        //                    isVisibleNamedBinding(importDeclaration.importClause.namedBindings);
+        //                }
+        //            }
+        //            moduleElementDeclarationEmitInfo.push({
+        //                node,
+        //                outputPos: writer.getTextPos(),
+        //                indent: writer.getIndent(),
+        //                isVisible
+        //            });
+        //        }
+        //    }
+        //}
+
+        //function writeModuleElement(node: Node) {
+        //    switch (node.kind) {
+        //        case SyntaxKind.FunctionDeclaration:
+        //            return writeFunctionDeclaration(<FunctionLikeDeclaration>node);
+        //        case SyntaxKind.VariableStatement:
+        //            return writeVariableStatement(<VariableStatement>node);
+        //        case SyntaxKind.InterfaceDeclaration:
+        //            return writeInterfaceDeclaration(<InterfaceDeclaration>node);
+        //        case SyntaxKind.ClassDeclaration:
+        //            return writeClassDeclaration(<ClassDeclaration>node);
+        //        case SyntaxKind.TypeAliasDeclaration:
+        //            return writeTypeAliasDeclaration(<TypeAliasDeclaration>node);
+        //        case SyntaxKind.EnumDeclaration:
+        //            return writeEnumDeclaration(<EnumDeclaration>node);
+        //        case SyntaxKind.ModuleDeclaration:
+        //            return writeModuleDeclaration(<ModuleDeclaration>node);
+        //        case SyntaxKind.ImportEqualsDeclaration:
+        //            return writeImportEqualsDeclaration(<ImportEqualsDeclaration>node);
+        //        case SyntaxKind.ImportDeclaration:
+        //            return writeImportDeclaration(<ImportDeclaration>node);
+        //        default:
+        //            Debug.fail("Unknown symbol kind");
+        //    }
+        //}
 
         function emitModuleElementDeclarationFlags(node: Node) {
             // If the node is parented in the current source file we need to emit export declare or just export
@@ -1003,7 +1006,7 @@ namespace ts {
         function emitVariableDeclaration(node: VariableDeclaration) {
             // If we are emitting property it isn't moduleElement and hence we already know it needs to be emitted
             // so there is no check needed to see if declaration is visible
-            if (node.kind !== SyntaxKind.VariableDeclaration || resolver.isDeclarationVisible(node)) {
+            //if (node.kind !== SyntaxKind.VariableDeclaration) {
                 if (isBindingPattern(node.name)) {
                     emitBindingPattern(<BindingPattern>node.name);
                 }
@@ -1023,7 +1026,7 @@ namespace ts {
                         writeTypeOfDeclaration(node, node.type, getVariableDeclarationTypeVisibilityError);
                     }
                 }
-            }
+            //}
 
             function getVariableDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult: SymbolAccessiblityResult) {
                 if (node.kind === SyntaxKind.VariableDeclaration) {
@@ -1136,6 +1139,25 @@ namespace ts {
             writeLine();
         }
 
+        // TODO: we only should have either statement or declaration
+        function writeVariableDeclaration(node: VariableDeclaration) {
+            emitJsDocComments(node);
+            emitModuleElementDeclarationFlags(node);
+            var declarationList = node.parent;
+            if (isLet(declarationList)) {
+                write("let ");
+            }
+            else if (isConst(declarationList)) {
+                write("const ");
+            }
+            else {
+                write("var ");
+            }
+            emitVariableDeclaration(node);
+            write(";");
+            writeLine();
+        }
+
         function emitAccessorDeclaration(node: AccessorDeclaration) {
             if (hasDynamicName(node)) {
                 return;
@@ -1546,18 +1568,27 @@ namespace ts {
         function emitNode(node: Node) {
             switch (node.kind) {
                 case SyntaxKind.FunctionDeclaration:
-                case SyntaxKind.ModuleDeclaration:
-                case SyntaxKind.ImportEqualsDeclaration:
+                    return writeFunctionDeclaration(<FunctionLikeDeclaration>node);
+                case SyntaxKind.VariableStatement:
+                    return writeVariableStatement(<VariableStatement>node);
+
+                case SyntaxKind.VariableDeclaration:
+                    return writeVariableDeclaration(<VariableDeclaration>node);
                 case SyntaxKind.InterfaceDeclaration:
+                    return writeInterfaceDeclaration(<InterfaceDeclaration>node);
                 case SyntaxKind.ClassDeclaration:
+                    return writeClassDeclaration(<ClassDeclaration>node);
                 case SyntaxKind.TypeAliasDeclaration:
+                    return writeTypeAliasDeclaration(<TypeAliasDeclaration>node);
                 case SyntaxKind.EnumDeclaration:
-                    return emitModuleElement(node, isModuleElementVisible(<Declaration>node));
-                case SyntaxKind.VariableStatement:
-                    return emitModuleElement(node, isVariableStatementVisible(<VariableStatement>node));
+                    return writeEnumDeclaration(<EnumDeclaration>node);
+                case SyntaxKind.ModuleDeclaration:
+                    return writeModuleDeclaration(<ModuleDeclaration>node);
+                case SyntaxKind.ImportEqualsDeclaration:
+                    return writeImportEqualsDeclaration(<ImportEqualsDeclaration>node);
                 case SyntaxKind.ImportDeclaration:
-                    // Import declaration without import clause is visible, otherwise it is not visible
-                    return emitModuleElement(node, /*isModuleElementVisible*/!(<ImportDeclaration>node).importClause);
+                    return writeImportDeclaration(<ImportDeclaration>node);
+
                 case SyntaxKind.ExportDeclaration:
                     return emitExportDeclaration(<ExportDeclaration>node);
                 case SyntaxKind.Constructor:
@@ -1600,8 +1631,149 @@ namespace ts {
             referencePathsOutput += "/// <reference path=\"" + declFileName + "\" />" + newLine;
         }
 
-        function walkTypes(node: Node): void {
 
+        function visitNode(node: Node): void {
+            switch (node.kind) {
+                // import/export aliases
+                case SyntaxKind.ExportDeclaration:
+                    return visitExportDeclaration(<ExportDeclaration> node);
+                case SyntaxKind.ImportEqualsDeclaration:
+                    return visitImportEqualsDeclaration(<ImportEqualsDeclaration> node);
+                case SyntaxKind.ExportAssignment:
+                    return visitExportAssignment(<ExportAssignment> node);
+
+                // declarations
+                case SyntaxKind.FunctionDeclaration:
+                case SyntaxKind.Constructor:
+                case SyntaxKind.MethodDeclaration:
+                case SyntaxKind.MethodSignature:
+                case SyntaxKind.ConstructSignature:
+                case SyntaxKind.CallSignature:
+                case SyntaxKind.IndexSignature:
+                    return visitSignatureDeclaration(<FunctionLikeDeclaration>node);
+
+                //case SyntaxKind.GetAccessor:
+                //case SyntaxKind.SetAccessor:
+                //    return emitAccessorDeclaration(<AccessorDeclaration>node);
+
+                case SyntaxKind.TypeParameter:
+                    return visitNode((<TypeParameterDeclaration>node).constraint);
+
+                case SyntaxKind.InterfaceDeclaration:
+                case SyntaxKind.ClassDeclaration:
+                    return visitNodes((<InterfaceDeclaration|ClassDeclaration>node).typeParameters) ||
+                        visitNodes((<InterfaceDeclaration|ClassDeclaration>node).heritageClauses);
+
+                case SyntaxKind.TypeAliasDeclaration:
+                    return visitNodes((<TypeAliasDeclaration>node).typeParameters) ||
+                        visitNode((<TypeAliasDeclaration>node).type);
+
+                case SyntaxKind.VariableStatement:
+                    return visitNodes((<VariableStatement>node).declarationList.declarations);
+
+                case SyntaxKind.VariableDeclaration:
+                case SyntaxKind.PropertyDeclaration:
+                case SyntaxKind.PropertySignature:
+                    return visitPropertyDeclaration(<PropertyDeclaration>node);
+
+                // TypeNodes
+                case SyntaxKind.AnyKeyword:
+                case SyntaxKind.StringKeyword:
+                case SyntaxKind.NumberKeyword:
+                case SyntaxKind.BooleanKeyword:
+                case SyntaxKind.SymbolKeyword:
+                case SyntaxKind.VoidKeyword:
+                case SyntaxKind.StringLiteral:
+                    // Nothing to visit
+                    return;
+
+                case SyntaxKind.TypePredicate:
+                    return visitNode((<TypePredicateNode>node).type);
+                case SyntaxKind.ArrayType:
+                    return visitNode((<ArrayTypeNode>node).elementType);
+                case SyntaxKind.TupleType:
+                    return visitNodes((<TupleTypeNode>node).elementTypes);
+                case SyntaxKind.UnionType:
+                    return visitNodes((<UnionTypeNode>node).types);
+                case SyntaxKind.ParenthesizedType:
+                    return visitNode((<ParenthesizedTypeNode>node).type);
+                case SyntaxKind.FunctionType:
+                case SyntaxKind.ConstructorType:
+                    return visitSignatureDeclaration(<FunctionOrConstructorTypeNode>node);
+                case SyntaxKind.TypeLiteral:
+                    return visitNodes((<TypeLiteralNode>node).members);
+                //case SyntaxKind.ExpressionWithTypeArguments:
+                //    return getTypeFromTypeReference(<ExpressionWithTypeArguments>node);
+                case SyntaxKind.TypeQuery:
+                    return visitTypeName((<TypeQueryNode>node).exprName);
+                case SyntaxKind.TypeReference:
+                    return visitTypeName((<TypeReferenceNode>node).typeName) ||
+                        visitNodes((<TypeReferenceNode>node).typeArguments);
+                case SyntaxKind.Identifier:
+                case SyntaxKind.QualifiedName:
+                    return visitTypeName(<Identifier|QualifiedName>node);
+            }
+        }
+
+        function visitNodes(nodes: NodeArray<any>): void{
+            forEach(nodes, visitNode);
+        }
+
+        function visitExportDeclaration(node: ExportDeclaration): void {
+            if (!node.moduleSpecifier) {
+                forEach(node.exportClause.elements, collectAliasDeclaration);
+            }
+        }
+
+        function visitImportEqualsDeclaration(node: ImportEqualsDeclaration): void {
+            if (node.moduleReference.kind !== SyntaxKind.ExternalModuleReference) {
+                collectAliasDeclaration(node);
+            }
+        }
+
+        function visitExportAssignment(node: ExportAssignment): void {
+            collectAliasDeclaration(node);
+        }
+
+        function visitSignatureDeclaration(node: SignatureDeclaration): void {
+            if (hasDynamicName(node) || node.flags & NodeFlags.Private) {
+                return;
+            }
+
+            visitNodes(node.typeParameters);
+            visitNodes(node.parameters);
+
+            if (node.type) {
+                visitNode(node.type);
+            }
+            else if (node.kind !== SyntaxKind.Constructor) {
+                // TODO: handel infered type
+            }
+        }
+
+        function visitPropertyDeclaration(node: PropertyDeclaration): void {
+            if (hasDynamicName(node) || node.flags & NodeFlags.Private) {
+                return;
+            }
+
+            if (node.type) {
+                visitNode(node.type);
+            }
+            else {
+                // TODO: handel infered type
+            }
+        }
+
+        function visitTypeName(node: Identifier|QualifiedName): void {
+            let symbol = resolver.getSymbolAtLocation(node);
+            Debug.assert(!!symbol);
+            collectDeclarations(symbol);
+        }
+
+        function collectAliasDeclaration(node: ImportOrExportSpecifier|ImportEqualsDeclaration|ExportAssignment) {
+            let target = resolver.getLocalTargetOfAliasDeclaration(node);
+            Debug.assert(!!target);
+            collectDeclarations(target);
         }
 
         function isDeclarationVisible(node: Node): boolean {
@@ -1660,41 +1832,100 @@ namespace ts {
             }
         }
 
-        function collectChildDeclarations(node: Node): void {
-            let links = getNodeLinks(node);
-            forEachTopLevelDeclaration(node, child => {
-                if (!isDeclarationVisible(child)) {
-                    return;
+        function getEnclosingDeclaration(node: Node): Node {
+            while (node.parent) {
+                switch (node.parent.kind) {
+                    case SyntaxKind.SourceFile:
+                    case SyntaxKind.EnumDeclaration:
+                    case SyntaxKind.ModuleDeclaration:
+                    case SyntaxKind.ClassDeclaration:
+                    case SyntaxKind.InterfaceDeclaration:
+                        return node.parent;
+                    default:
+                        node = node.parent;
                 }
+            }
+            return undefined;
+        }
+
+        function collectDeclarations(symbol: Symbol): void {
+            forEach(symbol.declarations, collectDeclaration);
+        }
 
-                if (!links.visibleChildren) {
-                    links.visibleChildren = [];
+        function collectDeclaration(node: Node) {
+            let links = getNodeLinks(node);
+            if (!links.visited) {
+                links.visited = true;
+
+                // Make the declaration visble by attaching it to its
+                // parent's visible declarations.
+                // also make sure the parent is reachable from a top-level
+                // declaration
+                let parent = getEnclosingDeclaration(node);
+                if (parent) {
+                    ensureDeclarationVisible(parent);
+                    attachVisibleChild(parent, node);
                 }
-                links.visibleChildren.push(child);
 
-                // if there are any types we need to write later on
-                // make sure to visit them and collect their declarations
-                walkTypes(child);
+                visitNode(node);
+            }
 
-                // visit nested declarations
-                switch (child.kind) {
-                    case SyntaxKind.ModuleDeclaration:
-                    case SyntaxKind.InterfaceDeclaration:
-                    case SyntaxKind.ClassDeclaration:
-                    case SyntaxKind.EnumDeclaration:
-                        collectChildDeclarations(child);
-                        break;
+            // Collect children as well
+            switch (node.kind) {
+                case SyntaxKind.ModuleDeclaration:
+                case SyntaxKind.InterfaceDeclaration:
+                case SyntaxKind.ClassDeclaration:
+                case SyntaxKind.EnumDeclaration:
+                    forEachTopLevelDeclaration(node, child => {
+                        if (isDeclarationVisible(child)) {
+                            collectDeclaration(child);
+                        }
+                    });
+                    break;
+            }
+
+        }
+
+        function ensureDeclarationVisible(node: Node): void {
+            let links = getNodeLinks(node);
+            if (!links.visited) {
+                links.visited = true;
+
+                var parent = getEnclosingDeclaration(node);
+                if (parent) {
+                    ensureDeclarationVisible(parent);
+                    attachVisibleChild(parent, node);
                 }
-            });
+            }
+        }
+
+        function attachVisibleChild(node: Node, child: Node): void {
+            let links = getNodeLinks(node);
+            if (!links.visibleChildren) {
+                links.visibleChildren = [];
+            }
+            links.visibleChildren.push(child);
+        }
+
+        function compareDeclarations(d1: Node, d2: Node): Comparison {
+            return compareValues(d1.pos, d2.pos) || Comparison.EqualTo;
+        }
+
+        function sortDeclarations(nodes: Node[]): Node[] {
+            return nodes && nodes.sort(compareDeclarations);
         }
 
         function writeChildDeclarations(node: Node): void {
-            forEach(getNodeLinks(node).visibleChildren, emitNode);
+            forEach(sortDeclarations(getNodeLinks(node).visibleChildren), emitNode);
         }
 
         function emitSourceFileDeclarations(sourceFile: SourceFile): void {
             // Collect all visible declarations
-            collectChildDeclarations(sourceFile);
+            forEachTopLevelDeclaration(sourceFile, child => {
+                if (isDeclarationVisible(child)) {
+                    collectDeclaration(child);
+                }
+            });
 
             // write the declarations
             writeChildDeclarations(sourceFile);
@@ -1706,11 +1937,11 @@ namespace ts {
         let emitDeclarationResult = emitDeclarations(host, resolver, diagnostics, jsFilePath, sourceFile);
         // TODO(shkamat): Should we not write any declaration file if any of them can produce error,
         // or should we just not write this file like we are doing now
-        if (!emitDeclarationResult.reportedDeclarationError) {
+        //if (!emitDeclarationResult.reportedDeclarationError) {
             let declarationOutput = emitDeclarationResult.referencePathsOutput
                 + getDeclarationOutput(emitDeclarationResult.synchronousDeclarationOutput, emitDeclarationResult.moduleElementDeclarationEmitInfo);
             writeFile(host, diagnostics, removeFileExtension(jsFilePath) + ".d.ts", declarationOutput, host.getCompilerOptions().emitBOM);
-        }
+        //}
 
         function getDeclarationOutput(synchronousDeclarationOutput: string, moduleElementDeclarationEmitInfo: ModuleElementDeclarationEmitInfo[]) {
             let appliedSyncOutputPos = 0;
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index e0f16a00c2bec..5aeeaea56fd26 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -1574,6 +1574,10 @@ namespace ts {
         getBlockScopedVariableId(node: Identifier): number;
         getReferencedValueDeclaration(reference: Identifier): Declaration;
         getTypeReferenceSerializationKind(node: TypeReferenceNode): TypeReferenceSerializationKind; 
+        resolveName(location: Node, name: string, meaning: SymbolFlags, nameNotFoundMessage: DiagnosticMessage, nameArg: string | Identifier): Symbol;
+        getSymbolAtLocation(node: Node): Symbol;
+        resolveAlias(symbol: Symbol): Symbol;
+        getLocalTargetOfAliasDeclaration(node: Declaration): Symbol;
     }
 
     export const enum SymbolFlags {

From 5865c0261918e50a33a4cb7912440ded1f218364 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Sat, 4 Jul 2015 13:15:15 -0700
Subject: [PATCH 03/57] Add error reporting

---
 src/compiler/declarationEmitter.ts | 216 +++++++++++++++++++++--------
 1 file changed, 160 insertions(+), 56 deletions(-)

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index dd4b2c4132214..05342bae47b08 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -463,7 +463,7 @@ namespace ts {
         function emitSourceFile(node: SourceFile) {
             currentSourceFile = node;
             enclosingDeclaration = node;
-//            emitLines(node.statements);
+            //            emitLines(node.statements);
             emitSourceFileDeclarations(node);
         }
 
@@ -1007,25 +1007,25 @@ namespace ts {
             // If we are emitting property it isn't moduleElement and hence we already know it needs to be emitted
             // so there is no check needed to see if declaration is visible
             //if (node.kind !== SyntaxKind.VariableDeclaration) {
-                if (isBindingPattern(node.name)) {
-                    emitBindingPattern(<BindingPattern>node.name);
+            if (isBindingPattern(node.name)) {
+                emitBindingPattern(<BindingPattern>node.name);
+            }
+            else {
+                // If this node is a computed name, it can only be a symbol, because we've already skipped
+                // it if it's not a well known symbol. In that case, the text of the name will be exactly
+                // what we want, namely the name expression enclosed in brackets.
+                writeTextOfNode(currentSourceFile, node.name);
+                // If optional property emit ?
+                if ((node.kind === SyntaxKind.PropertyDeclaration || node.kind === SyntaxKind.PropertySignature) && hasQuestionToken(node)) {
+                    write("?");
                 }
-                else {
-                    // If this node is a computed name, it can only be a symbol, because we've already skipped
-                    // it if it's not a well known symbol. In that case, the text of the name will be exactly
-                    // what we want, namely the name expression enclosed in brackets.
-                    writeTextOfNode(currentSourceFile, node.name);
-                    // If optional property emit ?
-                    if ((node.kind === SyntaxKind.PropertyDeclaration || node.kind === SyntaxKind.PropertySignature) && hasQuestionToken(node)) {
-                        write("?");
-                    }
-                    if ((node.kind === SyntaxKind.PropertyDeclaration || node.kind === SyntaxKind.PropertySignature) && node.parent.kind === SyntaxKind.TypeLiteral) {
-                        emitTypeOfVariableDeclarationFromTypeLiteral(node);
-                    }
-                    else if (!(node.flags & NodeFlags.Private)) {
-                        writeTypeOfDeclaration(node, node.type, getVariableDeclarationTypeVisibilityError);
-                    }
+                if ((node.kind === SyntaxKind.PropertyDeclaration || node.kind === SyntaxKind.PropertySignature) && node.parent.kind === SyntaxKind.TypeLiteral) {
+                    emitTypeOfVariableDeclarationFromTypeLiteral(node);
                 }
+                else if (!(node.flags & NodeFlags.Private)) {
+                    writeTypeOfDeclaration(node, node.type, getVariableDeclarationTypeVisibilityError);
+                }
+            }
             //}
 
             function getVariableDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult: SymbolAccessiblityResult) {
@@ -1079,7 +1079,7 @@ namespace ts {
                 //      emitted: declare var c: number; // instead of declare var c:number, ;
                 let elements: Node[] = [];
                 for (let element of bindingPattern.elements) {
-                    if (element.kind !== SyntaxKind.OmittedExpression){
+                    if (element.kind !== SyntaxKind.OmittedExpression) {
                         elements.push(element);
                     }
                 }
@@ -1134,7 +1134,7 @@ namespace ts {
             else {
                 write("var ");
             }
-            emitCommaList(node.declarationList.declarations, emitVariableDeclaration, resolver.isDeclarationVisible);
+            emitCommaList(node.declarationList.declarations, emitVariableDeclaration/*, resolver.isDeclarationVisible*/);
             write(";");
             writeLine();
         }
@@ -1462,7 +1462,7 @@ namespace ts {
                                 Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1;
                         }
                         else if (node.parent.parent.kind === SyntaxKind.ClassDeclaration) {
-                             return symbolAccesibilityResult.errorModuleName ?
+                            return symbolAccesibilityResult.errorModuleName ?
                                 symbolAccesibilityResult.accessibility === SymbolAccessibility.CannotBeNamed ?
                                     Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
                                     Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_private_module_2 :
@@ -1632,15 +1632,15 @@ namespace ts {
         }
 
 
-        function visitNode(node: Node): void {
+        function visitNode(node: Node, errorNode: Declaration): void {
             switch (node.kind) {
                 // import/export aliases
                 case SyntaxKind.ExportDeclaration:
-                    return visitExportDeclaration(<ExportDeclaration> node);
+                    return visitExportDeclaration(<ExportDeclaration> node, errorNode);
                 case SyntaxKind.ImportEqualsDeclaration:
-                    return visitImportEqualsDeclaration(<ImportEqualsDeclaration> node);
+                    return visitImportEqualsDeclaration(<ImportEqualsDeclaration> node, errorNode);
                 case SyntaxKind.ExportAssignment:
-                    return visitExportAssignment(<ExportAssignment> node);
+                    return visitExportAssignment(<ExportAssignment> node, errorNode);
 
                 // declarations
                 case SyntaxKind.FunctionDeclaration:
@@ -1657,16 +1657,16 @@ namespace ts {
                 //    return emitAccessorDeclaration(<AccessorDeclaration>node);
 
                 case SyntaxKind.TypeParameter:
-                    return visitNode((<TypeParameterDeclaration>node).constraint);
+                    return visitNode((<TypeParameterDeclaration>node).constraint, <TypeParameterDeclaration>node);
 
                 case SyntaxKind.InterfaceDeclaration:
                 case SyntaxKind.ClassDeclaration:
                     return visitNodes((<InterfaceDeclaration|ClassDeclaration>node).typeParameters) ||
-                        visitNodes((<InterfaceDeclaration|ClassDeclaration>node).heritageClauses);
+                        visitNodes((<InterfaceDeclaration|ClassDeclaration>node).heritageClauses, <InterfaceDeclaration|ClassDeclaration>node);
 
                 case SyntaxKind.TypeAliasDeclaration:
                     return visitNodes((<TypeAliasDeclaration>node).typeParameters) ||
-                        visitNode((<TypeAliasDeclaration>node).type);
+                        visitNode((<TypeAliasDeclaration>node).type, <TypeAliasDeclaration>node);
 
                 case SyntaxKind.VariableStatement:
                     return visitNodes((<VariableStatement>node).declarationList.declarations);
@@ -1688,51 +1688,53 @@ namespace ts {
                     return;
 
                 case SyntaxKind.TypePredicate:
-                    return visitNode((<TypePredicateNode>node).type);
+                    return visitNode((<TypePredicateNode>node).type, errorNode);
                 case SyntaxKind.ArrayType:
-                    return visitNode((<ArrayTypeNode>node).elementType);
+                    return visitNode((<ArrayTypeNode>node).elementType, errorNode);
                 case SyntaxKind.TupleType:
-                    return visitNodes((<TupleTypeNode>node).elementTypes);
+                    return visitNodes((<TupleTypeNode>node).elementTypes, errorNode);
                 case SyntaxKind.UnionType:
-                    return visitNodes((<UnionTypeNode>node).types);
+                    return visitNodes((<UnionTypeNode>node).types, errorNode);
                 case SyntaxKind.ParenthesizedType:
-                    return visitNode((<ParenthesizedTypeNode>node).type);
+                    return visitNode((<ParenthesizedTypeNode>node).type, errorNode);
                 case SyntaxKind.FunctionType:
                 case SyntaxKind.ConstructorType:
                     return visitSignatureDeclaration(<FunctionOrConstructorTypeNode>node);
                 case SyntaxKind.TypeLiteral:
-                    return visitNodes((<TypeLiteralNode>node).members);
+                    return visitNodes((<TypeLiteralNode>node).members, errorNode);
                 //case SyntaxKind.ExpressionWithTypeArguments:
                 //    return getTypeFromTypeReference(<ExpressionWithTypeArguments>node);
                 case SyntaxKind.TypeQuery:
-                    return visitTypeName((<TypeQueryNode>node).exprName);
+                    return visitTypeName((<TypeQueryNode>node).exprName, errorNode);
                 case SyntaxKind.TypeReference:
-                    return visitTypeName((<TypeReferenceNode>node).typeName) ||
-                        visitNodes((<TypeReferenceNode>node).typeArguments);
+                    return visitTypeName((<TypeReferenceNode>node).typeName, errorNode) ||
+                        visitNodes((<TypeReferenceNode>node).typeArguments, errorNode);
                 case SyntaxKind.Identifier:
                 case SyntaxKind.QualifiedName:
-                    return visitTypeName(<Identifier|QualifiedName>node);
+                    return visitTypeName(<Identifier|QualifiedName>node, errorNode);
             }
         }
 
-        function visitNodes(nodes: NodeArray<any>): void{
-            forEach(nodes, visitNode);
+        function visitNodes(nodes: NodeArray<any>, errorNode?: Declaration): void {
+            forEach(nodes, n => visitNode(n, errorNode));
         }
 
-        function visitExportDeclaration(node: ExportDeclaration): void {
+        function visitExportDeclaration(node: ExportDeclaration, errorNode: Declaration): void {
             if (!node.moduleSpecifier) {
-                forEach(node.exportClause.elements, collectAliasDeclaration);
+                forEach(node.exportClause.elements, e => collectAliasDeclaration(e, errorNode));
             }
         }
 
-        function visitImportEqualsDeclaration(node: ImportEqualsDeclaration): void {
+        function visitImportEqualsDeclaration(node: ImportEqualsDeclaration, errorNode: Declaration): void {
             if (node.moduleReference.kind !== SyntaxKind.ExternalModuleReference) {
-                collectAliasDeclaration(node);
+                collectAliasDeclaration(node, errorNode);
             }
         }
 
-        function visitExportAssignment(node: ExportAssignment): void {
-            collectAliasDeclaration(node);
+        function visitExportAssignment(node: ExportAssignment, errorNode: Declaration): void {
+            if (node.expression.kind === SyntaxKind.Identifier) {
+                collectAliasDeclaration(node, errorNode);
+            }
         }
 
         function visitSignatureDeclaration(node: SignatureDeclaration): void {
@@ -1744,7 +1746,7 @@ namespace ts {
             visitNodes(node.parameters);
 
             if (node.type) {
-                visitNode(node.type);
+                visitNode(node.type, node);
             }
             else if (node.kind !== SyntaxKind.Constructor) {
                 // TODO: handel infered type
@@ -1757,23 +1759,23 @@ namespace ts {
             }
 
             if (node.type) {
-                visitNode(node.type);
+                visitNode(node.type, node);
             }
             else {
                 // TODO: handel infered type
             }
         }
 
-        function visitTypeName(node: Identifier|QualifiedName): void {
+        function visitTypeName(node: Identifier|QualifiedName, errorNode: Declaration): void {
             let symbol = resolver.getSymbolAtLocation(node);
             Debug.assert(!!symbol);
-            collectDeclarations(symbol);
+            collectDeclarations(symbol, errorNode);
         }
 
-        function collectAliasDeclaration(node: ImportOrExportSpecifier|ImportEqualsDeclaration|ExportAssignment) {
+        function collectAliasDeclaration(node: ImportOrExportSpecifier|ImportEqualsDeclaration|ExportAssignment, errorNode: Declaration) {
             let target = resolver.getLocalTargetOfAliasDeclaration(node);
             Debug.assert(!!target);
-            collectDeclarations(target);
+            collectDeclarations(target, errorNode);
         }
 
         function isDeclarationVisible(node: Node): boolean {
@@ -1848,15 +1850,117 @@ namespace ts {
             return undefined;
         }
 
-        function collectDeclarations(symbol: Symbol): void {
-            forEach(symbol.declarations, collectDeclaration);
+        function collectDeclarations(symbol: Symbol, errorNode: Declaration): void {
+            forEach(symbol.declarations, d => collectDeclaration(d, errorNode));
         }
 
-        function collectDeclaration(node: Node) {
+        function isDeclarationAccessible(node: Node) {
+            if (isDeclarationVisible(node)) {
+                return true;
+            }
+
+            let hasScopeAlteringExport = false;
+            let parent = getEnclosingDeclaration(node);
+            if (parent) {
+                forEachTopLevelDeclaration(parent, (n) => {
+                    if (n.kind === SyntaxKind.ExportAssignment || n.kind === SyntaxKind.ExportDeclaration) {
+                        hasScopeAlteringExport = true;
+                    }
+                });
+            }
+            return hasScopeAlteringExport
+        }
+
+        function reportDeclarationAccessiblityMessage(errorNode: Declaration, referencedDeclaration: Declaration): void {
+            Debug.assert(referencedDeclaration.name && referencedDeclaration.name.kind === SyntaxKind.Identifier);
+            let referencedDeclarationName = (<Identifier>referencedDeclaration.name).text;
+            switch (errorNode.kind) {
+                case SyntaxKind.ClassDeclaration:
+                    diagnostics.push(createDiagnosticForNode((<ClassDeclaration>errorNode),
+                        Diagnostics.Extends_clause_of_exported_class_0_has_or_is_using_private_name_1, referencedDeclarationName));
+                    break;
+                case SyntaxKind.InterfaceDeclaration:
+                    diagnostics.push(createDiagnosticForNode((<InterfaceDeclaration>errorNode),
+                        Diagnostics.Extends_clause_of_exported_interface_0_has_or_is_using_private_name_1, referencedDeclarationName));
+                    break;
+                case SyntaxKind.VariableDeclaration:
+                    diagnostics.push(createDiagnosticForNode((<VariableDeclaration>errorNode).type,
+                        Diagnostics.Exported_variable_0_has_or_is_using_private_name_1, referencedDeclarationName));
+                    break;
+                case SyntaxKind.PropertySignature:
+                    diagnostics.push(createDiagnosticForNode((<PropertyDeclaration>errorNode).type,
+                        Diagnostics.Public_property_0_of_exported_class_has_or_is_using_private_name_1, referencedDeclarationName));
+                    break;
+                case SyntaxKind.PropertyDeclaration:
+                    diagnostics.push(createDiagnosticForNode((<PropertyDeclaration>errorNode).type,
+                        Diagnostics.Property_0_of_exported_interface_has_or_is_using_private_name_1, referencedDeclarationName));
+                    break;
+                case SyntaxKind.VariableDeclaration:
+                    diagnostics.push(createDiagnosticForNode((<VariableDeclaration>errorNode).type,
+                        Diagnostics.Property_0_of_exported_interface_has_or_is_using_private_name_1, referencedDeclarationName));
+                    break;
+                case SyntaxKind.GetAccessor:
+                    diagnostics.push(createDiagnosticForNode((<AccessorDeclaration>errorNode).type,
+                        Diagnostics.Return_type_of_public_property_getter_from_exported_class_has_or_is_using_private_name_0, referencedDeclarationName));
+                    break;
+                case SyntaxKind.ConstructSignature:
+                    diagnostics.push(createDiagnosticForNode((<SignatureDeclaration>errorNode).type,
+                        Diagnostics.Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_0, referencedDeclarationName));
+                    break;
+                case SyntaxKind.CallSignature:
+                    diagnostics.push(createDiagnosticForNode((<SignatureDeclaration>errorNode).type,
+                        Diagnostics.Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_name_0, referencedDeclarationName));
+                    break;
+                case SyntaxKind.IndexSignature:
+                    diagnostics.push(createDiagnosticForNode((<SignatureDeclaration>errorNode).type,
+                        Diagnostics.Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_name_0, referencedDeclarationName));
+                    break;
+                case SyntaxKind.MethodDeclaration:
+                    diagnostics.push(createDiagnosticForNode((<MethodDeclaration>errorNode).type,
+                        Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_private_name_0, referencedDeclarationName));
+                    break;
+                case SyntaxKind.MethodSignature:
+                    diagnostics.push(createDiagnosticForNode((<SignatureDeclaration>errorNode).type,
+                        Diagnostics.Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0, referencedDeclarationName));
+                    break;
+                case SyntaxKind.FunctionDeclaration:
+                    diagnostics.push(createDiagnosticForNode((<FunctionDeclaration>errorNode).type,
+                        Diagnostics.Return_type_of_exported_function_has_or_is_using_private_name_0, referencedDeclarationName));
+                    break;
+                case SyntaxKind.Parameter:
+                    diagnostics.push(createDiagnosticForNode((<ParameterDeclaration>errorNode).type,
+                        Diagnostics.Parameter_0_of_exported_function_has_or_is_using_private_name_1, referencedDeclarationName));
+                    break;
+                case SyntaxKind.TypeAliasDeclaration:
+                    diagnostics.push(createDiagnosticForNode((<TypeAliasDeclaration>errorNode).type,
+                        Diagnostics.Exported_type_alias_0_has_or_is_using_private_name_1, referencedDeclarationName));
+                    break;
+                case SyntaxKind.ExportAssignment:
+                    diagnostics.push(createDiagnosticForNode((<ExportAssignment>errorNode).expression,
+                        Diagnostics.Default_export_of_the_module_has_or_is_using_private_name_0, referencedDeclarationName));
+                    break;
+                case SyntaxKind.TypeParameter:
+                    diagnostics.push(createDiagnosticForNode((<TypeParameterDeclaration>errorNode).constraint,
+                        Diagnostics.Type_parameter_0_of_exported_class_has_or_is_using_private_name_1, referencedDeclarationName));
+                    break;
+                case SyntaxKind.ImportEqualsDeclaration:
+                    diagnostics.push(createDiagnosticForNode((<ImportEqualsDeclaration>errorNode).moduleReference,
+                        Diagnostics.Import_declaration_0_is_using_private_name_1, referencedDeclarationName));
+                    break;
+            }
+        }
+
+        function collectDeclaration(node: Node, errorNode?:Declaration): void {
             let links = getNodeLinks(node);
             if (!links.visited) {
                 links.visited = true;
 
+                if (errorNode) {
+                    if (!isDeclarationAccessible(node)) {
+                        reportDeclarationAccessiblityMessage(errorNode, <Declaration>node);
+                    }
+                }
+
                 // Make the declaration visble by attaching it to its
                 // parent's visible declarations.
                 // also make sure the parent is reachable from a top-level
@@ -1867,7 +1971,7 @@ namespace ts {
                     attachVisibleChild(parent, node);
                 }
 
-                visitNode(node);
+                visitNode(node, <Declaration>node);
             }
 
             // Collect children as well

From 96a2b7fc0f727b1ea730d8ae9efe3c266872ebd7 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Sat, 4 Jul 2015 14:22:04 -0700
Subject: [PATCH 04/57] Do error reporting slightlly difrrentelly

---
 src/compiler/declarationEmitter.ts | 264 ++++++++++++++++-------------
 1 file changed, 149 insertions(+), 115 deletions(-)

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index 05342bae47b08..3845ae494706d 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -1632,15 +1632,15 @@ namespace ts {
         }
 
 
-        function visitNode(node: Node, errorNode: Declaration): void {
+        function visitNode(node: Node): void {
             switch (node.kind) {
                 // import/export aliases
                 case SyntaxKind.ExportDeclaration:
-                    return visitExportDeclaration(<ExportDeclaration> node, errorNode);
+                    return visitExportDeclaration(<ExportDeclaration>node);
                 case SyntaxKind.ImportEqualsDeclaration:
-                    return visitImportEqualsDeclaration(<ImportEqualsDeclaration> node, errorNode);
+                    return visitImportEqualsDeclaration(<ImportEqualsDeclaration>node);
                 case SyntaxKind.ExportAssignment:
-                    return visitExportAssignment(<ExportAssignment> node, errorNode);
+                    return visitExportAssignment(<ExportAssignment>node);
 
                 // declarations
                 case SyntaxKind.FunctionDeclaration:
@@ -1657,16 +1657,16 @@ namespace ts {
                 //    return emitAccessorDeclaration(<AccessorDeclaration>node);
 
                 case SyntaxKind.TypeParameter:
-                    return visitNode((<TypeParameterDeclaration>node).constraint, <TypeParameterDeclaration>node);
+                    return visitNode((<TypeParameterDeclaration>node).constraint);
 
                 case SyntaxKind.InterfaceDeclaration:
                 case SyntaxKind.ClassDeclaration:
                     return visitNodes((<InterfaceDeclaration|ClassDeclaration>node).typeParameters) ||
-                        visitNodes((<InterfaceDeclaration|ClassDeclaration>node).heritageClauses, <InterfaceDeclaration|ClassDeclaration>node);
+                        visitNodes((<InterfaceDeclaration|ClassDeclaration>node).heritageClauses);
 
                 case SyntaxKind.TypeAliasDeclaration:
                     return visitNodes((<TypeAliasDeclaration>node).typeParameters) ||
-                        visitNode((<TypeAliasDeclaration>node).type, <TypeAliasDeclaration>node);
+                        visitNode((<TypeAliasDeclaration>node).type);
 
                 case SyntaxKind.VariableStatement:
                     return visitNodes((<VariableStatement>node).declarationList.declarations);
@@ -1688,52 +1688,54 @@ namespace ts {
                     return;
 
                 case SyntaxKind.TypePredicate:
-                    return visitNode((<TypePredicateNode>node).type, errorNode);
+                    return visitNode((<TypePredicateNode>node).type);
                 case SyntaxKind.ArrayType:
-                    return visitNode((<ArrayTypeNode>node).elementType, errorNode);
+                    return visitNode((<ArrayTypeNode>node).elementType);
                 case SyntaxKind.TupleType:
-                    return visitNodes((<TupleTypeNode>node).elementTypes, errorNode);
+                    return visitNodes((<TupleTypeNode>node).elementTypes);
                 case SyntaxKind.UnionType:
-                    return visitNodes((<UnionTypeNode>node).types, errorNode);
+                    return visitNodes((<UnionTypeNode>node).types);
                 case SyntaxKind.ParenthesizedType:
-                    return visitNode((<ParenthesizedTypeNode>node).type, errorNode);
+                    return visitNode((<ParenthesizedTypeNode>node).type);
                 case SyntaxKind.FunctionType:
                 case SyntaxKind.ConstructorType:
                     return visitSignatureDeclaration(<FunctionOrConstructorTypeNode>node);
                 case SyntaxKind.TypeLiteral:
-                    return visitNodes((<TypeLiteralNode>node).members, errorNode);
+                    return visitNodes((<TypeLiteralNode>node).members);
                 //case SyntaxKind.ExpressionWithTypeArguments:
                 //    return getTypeFromTypeReference(<ExpressionWithTypeArguments>node);
                 case SyntaxKind.TypeQuery:
-                    return visitTypeName((<TypeQueryNode>node).exprName, errorNode);
+                    return visitNode((<TypeQueryNode>node).exprName);
                 case SyntaxKind.TypeReference:
-                    return visitTypeName((<TypeReferenceNode>node).typeName, errorNode) ||
-                        visitNodes((<TypeReferenceNode>node).typeArguments, errorNode);
-                case SyntaxKind.Identifier:
+                    return visitNode((<TypeReferenceNode>node).typeName) ||
+                        visitNodes((<TypeReferenceNode>node).typeArguments);
                 case SyntaxKind.QualifiedName:
-                    return visitTypeName(<Identifier|QualifiedName>node, errorNode);
+                    return visitNode((<QualifiedName>node).left) ||
+                        visitNode((<QualifiedName>node).right);
+                case SyntaxKind.Identifier:
+                    return visitTypeName(<Identifier|QualifiedName>node);
             }
         }
 
-        function visitNodes(nodes: NodeArray<any>, errorNode?: Declaration): void {
-            forEach(nodes, n => visitNode(n, errorNode));
+        function visitNodes(nodes: NodeArray<any>): void {
+            forEach(nodes, visitNode);
         }
 
-        function visitExportDeclaration(node: ExportDeclaration, errorNode: Declaration): void {
+        function visitExportDeclaration(node: ExportDeclaration): void {
             if (!node.moduleSpecifier) {
-                forEach(node.exportClause.elements, e => collectAliasDeclaration(e, errorNode));
+                forEach(node.exportClause.elements, collectAliasDeclaration);
             }
         }
 
-        function visitImportEqualsDeclaration(node: ImportEqualsDeclaration, errorNode: Declaration): void {
+        function visitImportEqualsDeclaration(node: ImportEqualsDeclaration): void {
             if (node.moduleReference.kind !== SyntaxKind.ExternalModuleReference) {
-                collectAliasDeclaration(node, errorNode);
+                collectAliasDeclaration(node);
             }
         }
 
-        function visitExportAssignment(node: ExportAssignment, errorNode: Declaration): void {
+        function visitExportAssignment(node: ExportAssignment): void {
             if (node.expression.kind === SyntaxKind.Identifier) {
-                collectAliasDeclaration(node, errorNode);
+                collectAliasDeclaration(node);
             }
         }
 
@@ -1746,7 +1748,7 @@ namespace ts {
             visitNodes(node.parameters);
 
             if (node.type) {
-                visitNode(node.type, node);
+                visitNode(node.type);
             }
             else if (node.kind !== SyntaxKind.Constructor) {
                 // TODO: handel infered type
@@ -1759,23 +1761,23 @@ namespace ts {
             }
 
             if (node.type) {
-                visitNode(node.type, node);
+                visitNode(node.type);
             }
             else {
                 // TODO: handel infered type
             }
         }
 
-        function visitTypeName(node: Identifier|QualifiedName, errorNode: Declaration): void {
+        function visitTypeName(node: Identifier|QualifiedName): void {
             let symbol = resolver.getSymbolAtLocation(node);
             Debug.assert(!!symbol);
-            collectDeclarations(symbol, errorNode);
+            collectDeclarations(symbol, node);
         }
 
-        function collectAliasDeclaration(node: ImportOrExportSpecifier|ImportEqualsDeclaration|ExportAssignment, errorNode: Declaration) {
+        function collectAliasDeclaration(node: ImportOrExportSpecifier|ImportEqualsDeclaration|ExportAssignment) {
             let target = resolver.getLocalTargetOfAliasDeclaration(node);
             Debug.assert(!!target);
-            collectDeclarations(target, errorNode);
+            collectDeclarations(target, node);
         }
 
         function isDeclarationVisible(node: Node): boolean {
@@ -1808,6 +1810,10 @@ namespace ts {
                 case SyntaxKind.TypeAliasDeclaration:
                     // TODO: handel ambient context
                     return (node.flags & NodeFlags.Export) !== 0;
+
+                case SyntaxKind.VariableDeclaration:
+                    // TODO: do we need this
+                    return (node.parent.parent.flags & NodeFlags.Export) !== 0;
             }
 
             return false;
@@ -1850,7 +1856,7 @@ namespace ts {
             return undefined;
         }
 
-        function collectDeclarations(symbol: Symbol, errorNode: Declaration): void {
+        function collectDeclarations(symbol: Symbol, errorNode: Node): void {
             forEach(symbol.declarations, d => collectDeclaration(d, errorNode));
         }
 
@@ -1871,96 +1877,118 @@ namespace ts {
             return hasScopeAlteringExport
         }
 
-        function reportDeclarationAccessiblityMessage(errorNode: Declaration, referencedDeclaration: Declaration): void {
+        // TODO: remove this and update error messages to not use names
+        function getNameText(node: ParameterDeclaration|PropertyDeclaration|VariableDeclaration):string {
+            if (node.name.kind === SyntaxKind.Identifier) {
+                return (<Identifier>node.name).text;
+            }
+            return "__bindingpattern";
+        }
+
+        function reportDeclarationAccessiblityMessage(referencedDeclaration: Declaration, errorNode: Node): void {
             Debug.assert(referencedDeclaration.name && referencedDeclaration.name.kind === SyntaxKind.Identifier);
             let referencedDeclarationName = (<Identifier>referencedDeclaration.name).text;
-            switch (errorNode.kind) {
-                case SyntaxKind.ClassDeclaration:
-                    diagnostics.push(createDiagnosticForNode((<ClassDeclaration>errorNode),
-                        Diagnostics.Extends_clause_of_exported_class_0_has_or_is_using_private_name_1, referencedDeclarationName));
-                    break;
-                case SyntaxKind.InterfaceDeclaration:
-                    diagnostics.push(createDiagnosticForNode((<InterfaceDeclaration>errorNode),
-                        Diagnostics.Extends_clause_of_exported_interface_0_has_or_is_using_private_name_1, referencedDeclarationName));
-                    break;
-                case SyntaxKind.VariableDeclaration:
-                    diagnostics.push(createDiagnosticForNode((<VariableDeclaration>errorNode).type,
-                        Diagnostics.Exported_variable_0_has_or_is_using_private_name_1, referencedDeclarationName));
-                    break;
-                case SyntaxKind.PropertySignature:
-                    diagnostics.push(createDiagnosticForNode((<PropertyDeclaration>errorNode).type,
-                        Diagnostics.Public_property_0_of_exported_class_has_or_is_using_private_name_1, referencedDeclarationName));
-                    break;
-                case SyntaxKind.PropertyDeclaration:
-                    diagnostics.push(createDiagnosticForNode((<PropertyDeclaration>errorNode).type,
-                        Diagnostics.Property_0_of_exported_interface_has_or_is_using_private_name_1, referencedDeclarationName));
-                    break;
-                case SyntaxKind.VariableDeclaration:
-                    diagnostics.push(createDiagnosticForNode((<VariableDeclaration>errorNode).type,
-                        Diagnostics.Property_0_of_exported_interface_has_or_is_using_private_name_1, referencedDeclarationName));
-                    break;
-                case SyntaxKind.GetAccessor:
-                    diagnostics.push(createDiagnosticForNode((<AccessorDeclaration>errorNode).type,
-                        Diagnostics.Return_type_of_public_property_getter_from_exported_class_has_or_is_using_private_name_0, referencedDeclarationName));
-                    break;
-                case SyntaxKind.ConstructSignature:
-                    diagnostics.push(createDiagnosticForNode((<SignatureDeclaration>errorNode).type,
-                        Diagnostics.Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_0, referencedDeclarationName));
-                    break;
-                case SyntaxKind.CallSignature:
-                    diagnostics.push(createDiagnosticForNode((<SignatureDeclaration>errorNode).type,
-                        Diagnostics.Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_name_0, referencedDeclarationName));
-                    break;
-                case SyntaxKind.IndexSignature:
-                    diagnostics.push(createDiagnosticForNode((<SignatureDeclaration>errorNode).type,
-                        Diagnostics.Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_name_0, referencedDeclarationName));
-                    break;
-                case SyntaxKind.MethodDeclaration:
-                    diagnostics.push(createDiagnosticForNode((<MethodDeclaration>errorNode).type,
-                        Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_private_name_0, referencedDeclarationName));
-                    break;
-                case SyntaxKind.MethodSignature:
-                    diagnostics.push(createDiagnosticForNode((<SignatureDeclaration>errorNode).type,
-                        Diagnostics.Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0, referencedDeclarationName));
-                    break;
-                case SyntaxKind.FunctionDeclaration:
-                    diagnostics.push(createDiagnosticForNode((<FunctionDeclaration>errorNode).type,
-                        Diagnostics.Return_type_of_exported_function_has_or_is_using_private_name_0, referencedDeclarationName));
-                    break;
-                case SyntaxKind.Parameter:
-                    diagnostics.push(createDiagnosticForNode((<ParameterDeclaration>errorNode).type,
-                        Diagnostics.Parameter_0_of_exported_function_has_or_is_using_private_name_1, referencedDeclarationName));
-                    break;
-                case SyntaxKind.TypeAliasDeclaration:
-                    diagnostics.push(createDiagnosticForNode((<TypeAliasDeclaration>errorNode).type,
-                        Diagnostics.Exported_type_alias_0_has_or_is_using_private_name_1, referencedDeclarationName));
-                    break;
-                case SyntaxKind.ExportAssignment:
-                    diagnostics.push(createDiagnosticForNode((<ExportAssignment>errorNode).expression,
-                        Diagnostics.Default_export_of_the_module_has_or_is_using_private_name_0, referencedDeclarationName));
-                    break;
-                case SyntaxKind.TypeParameter:
-                    diagnostics.push(createDiagnosticForNode((<TypeParameterDeclaration>errorNode).constraint,
-                        Diagnostics.Type_parameter_0_of_exported_class_has_or_is_using_private_name_1, referencedDeclarationName));
-                    break;
-                case SyntaxKind.ImportEqualsDeclaration:
-                    diagnostics.push(createDiagnosticForNode((<ImportEqualsDeclaration>errorNode).moduleReference,
-                        Diagnostics.Import_declaration_0_is_using_private_name_1, referencedDeclarationName));
-                    break;
+
+
+            referencedDeclarationName = "---" + referencedDeclarationName +"---";
+            let container = errorNode.parent;
+            while (true) {
+                switch (container.kind) {
+                    case SyntaxKind.ClassDeclaration:
+                        diagnostics.push(createDiagnosticForNode(errorNode,
+                            Diagnostics.Extends_clause_of_exported_class_0_has_or_is_using_private_name_1,
+                            (<ClassDeclaration>container).name.text, referencedDeclarationName));
+                        return;
+                    case SyntaxKind.InterfaceDeclaration:
+                        diagnostics.push(createDiagnosticForNode(errorNode,
+                            Diagnostics.Extends_clause_of_exported_interface_0_has_or_is_using_private_name_1,
+                            (<InterfaceDeclaration>container).name.text, referencedDeclarationName));
+                        return;
+                    case SyntaxKind.VariableDeclaration:
+                        diagnostics.push(createDiagnosticForNode(errorNode,
+                            Diagnostics.Exported_variable_0_has_or_is_using_private_name_1,
+                            getNameText(<VariableDeclaration>container), referencedDeclarationName));
+                        return;
+                    case SyntaxKind.PropertySignature:
+                        diagnostics.push(createDiagnosticForNode(errorNode,
+                            Diagnostics.Public_property_0_of_exported_class_has_or_is_using_private_name_1,
+                            getNameText(<PropertyDeclaration>container), referencedDeclarationName));
+                        return;
+                    case SyntaxKind.PropertyDeclaration:
+                        diagnostics.push(createDiagnosticForNode(errorNode,
+                            Diagnostics.Property_0_of_exported_interface_has_or_is_using_private_name_1,
+                            getNameText(<PropertyDeclaration>container), referencedDeclarationName));
+                        return;
+                    case SyntaxKind.Parameter:
+                        diagnostics.push(createDiagnosticForNode(errorNode,
+                            Diagnostics.Parameter_0_of_exported_function_has_or_is_using_private_name_1,
+                            getNameText(<ParameterDeclaration>container), referencedDeclarationName));
+                        return;
+                    case SyntaxKind.GetAccessor:
+                        diagnostics.push(createDiagnosticForNode(errorNode,
+                            Diagnostics.Return_type_of_public_property_getter_from_exported_class_has_or_is_using_private_name_0,
+                            referencedDeclarationName));
+                        return;
+                    case SyntaxKind.ConstructSignature:
+                        diagnostics.push(createDiagnosticForNode(errorNode,
+                            Diagnostics.Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_0,
+                            referencedDeclarationName));
+                        return;
+                    case SyntaxKind.CallSignature:
+                        diagnostics.push(createDiagnosticForNode(errorNode,
+                            Diagnostics.Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_name_0,
+                            referencedDeclarationName));
+                        return;
+                    case SyntaxKind.IndexSignature:
+                        diagnostics.push(createDiagnosticForNode(errorNode,
+                            Diagnostics.Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_name_0,
+                            referencedDeclarationName));
+                        return;
+                    case SyntaxKind.MethodDeclaration:
+                        diagnostics.push(createDiagnosticForNode(errorNode,
+                            Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_private_name_0,
+                            referencedDeclarationName));
+                        return;
+                    case SyntaxKind.MethodSignature:
+                        diagnostics.push(createDiagnosticForNode(errorNode,
+                            Diagnostics.Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0,
+                            referencedDeclarationName));
+                        return;
+                    case SyntaxKind.FunctionDeclaration:
+                        diagnostics.push(createDiagnosticForNode(errorNode,
+                            Diagnostics.Return_type_of_exported_function_has_or_is_using_private_name_0,
+                            referencedDeclarationName));
+                        return;
+                    case SyntaxKind.TypeAliasDeclaration:
+                        diagnostics.push(createDiagnosticForNode(errorNode,
+                            Diagnostics.Exported_type_alias_0_has_or_is_using_private_name_1,
+                            (<TypeAliasDeclaration>container).name.text, referencedDeclarationName));
+                        return;
+                    case SyntaxKind.ExportAssignment:
+                        diagnostics.push(createDiagnosticForNode((<ExportAssignment>errorNode).expression,
+                            Diagnostics.Default_export_of_the_module_has_or_is_using_private_name_0,
+                            referencedDeclarationName));
+                        return;
+                    case SyntaxKind.TypeParameter:
+                        diagnostics.push(createDiagnosticForNode((<TypeParameterDeclaration>errorNode).constraint,
+                            Diagnostics.Type_parameter_0_of_exported_class_has_or_is_using_private_name_1,
+                            (<TypeParameterDeclaration>container).name.text, referencedDeclarationName));
+                        return;
+                    case SyntaxKind.ImportEqualsDeclaration:
+                        diagnostics.push(createDiagnosticForNode((<ImportEqualsDeclaration>errorNode).moduleReference,
+                            Diagnostics.Import_declaration_0_is_using_private_name_1,
+                            (<ImportEqualsDeclaration>container).name.text, referencedDeclarationName));
+                        return;
+                }
+                container = container.parent;
             }
         }
 
-        function collectDeclaration(node: Node, errorNode?:Declaration): void {
+        function collectDeclaration(node: Node, errorNode?:Node): void {
             let links = getNodeLinks(node);
             if (!links.visited) {
                 links.visited = true;
 
-                if (errorNode) {
-                    if (!isDeclarationAccessible(node)) {
-                        reportDeclarationAccessiblityMessage(errorNode, <Declaration>node);
-                    }
-                }
-
                 // Make the declaration visble by attaching it to its
                 // parent's visible declarations.
                 // also make sure the parent is reachable from a top-level
@@ -1971,7 +1999,13 @@ namespace ts {
                     attachVisibleChild(parent, node);
                 }
 
-                visitNode(node, <Declaration>node);
+                visitNode(node);
+            }
+
+            if (errorNode) {
+                if (!isDeclarationAccessible(node)) {
+                    reportDeclarationAccessiblityMessage(<Declaration>node, errorNode);
+                }
             }
 
             // Collect children as well

From 46ddcbf8a233bde2e079bc0d9476d355f981d2c3 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Mon, 6 Jul 2015 22:32:25 -0700
Subject: [PATCH 05/57] Walk types

---
 src/compiler/checker.ts            |   7 +-
 src/compiler/declarationEmitter.ts | 100 ++++++++++++++++++++++++++++-
 src/compiler/types.ts              |   8 +++
 3 files changed, 113 insertions(+), 2 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 071c0c95d1b80..97b88dd47d0dc 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -13731,7 +13731,7 @@ namespace ts {
                     }
                     break;
             }
-            return undefined;
+            return getSymbolOfNode(node);
         }
 
         function getShorthandAssignmentValueSymbol(location: Node): Symbol {
@@ -14177,6 +14177,11 @@ namespace ts {
                 getSymbolAtLocation,
                 resolveAlias,
                 getLocalTargetOfAliasDeclaration,
+                getTypeOfSymbol,
+                getReturnTypeOfSignature,
+                getSignatureFromDeclaration,
+                getSignaturesOfType,
+                resolveObjectOrUnionTypeMembers
             };
         }
 
diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index 3845ae494706d..262a81d367cfd 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -1752,6 +1752,9 @@ namespace ts {
             }
             else if (node.kind !== SyntaxKind.Constructor) {
                 // TODO: handel infered type
+                let signature = resolver.getSignatureFromDeclaration(node);
+                Debug.assert(!!signature);
+                visitType(resolver.getReturnTypeOfSignature(signature), node);
             }
         }
 
@@ -1765,7 +1768,102 @@ namespace ts {
             }
             else {
                 // TODO: handel infered type
+                let symbol = resolver.getSymbolAtLocation(node);
+                Debug.assert(!!symbol);
+                if (symbol && !(symbol.flags & (SymbolFlags.TypeLiteral | SymbolFlags.Signature))) {
+                    visitType(resolver.getTypeOfSymbol(symbol), node);
+                }
+            }
+        }
+
+        function visitType(type: Type, referenceNode: Node, symbolStack?: Symbol[]): void {
+            if (type.flags & TypeFlags.Reference) {
+                // TODO: handel array
+                visitType((<TypeReference>type).target, referenceNode);
+                forEach((<TypeReference>type).typeArguments, t => visitType(t, referenceNode));
+           }
+            else if (type.flags & (TypeFlags.Class | TypeFlags.Interface | TypeFlags.Enum | TypeFlags.TypeParameter)) {
+                visitTypePart(type.symbol, referenceNode);
+            }
+            else if (type.flags & TypeFlags.Tuple) {
+                forEach((<TupleType>type).elementTypes, t => visitType(t, referenceNode));
+            }
+            else if (type.flags & TypeFlags.Union) {
+                forEach((<UnionType>type).types, t => visitType(t, referenceNode));
+            }
+            else if (type.flags & TypeFlags.Anonymous) {
+                visitAnonymousType(type, referenceNode, symbolStack);
+            }
+        }
+
+        function visitAnonymousType(type: Type, referenceNode: Node, symbolStack: Symbol[]): void {
+            let symbol = type.symbol;
+            if (symbol) {
+                if (contains(symbolStack, symbol)) {
+                    return;
+                }
+
+                // Always use 'typeof T' for type of class, enum, and module objects
+                if (symbol.flags & (SymbolFlags.Class | SymbolFlags.Enum | SymbolFlags.ValueModule)) {
+                    visitTypePart(type.symbol, referenceNode);
+                }
+                else {
+                    // Since instantiations of the same anonymous type have the same symbol, tracking symbols instead
+                    // of types allows us to catch circular references to instantiations of the same anonymous type
+                    if (!symbolStack) {
+                        symbolStack = [];
+                    }
+                    symbolStack.push(symbol);
+                    visitTypeLiteral(type, referenceNode, symbolStack);
+                    symbolStack.pop();
+                }
+            }
+            else {
+                // Anonymous types with no symbol are never circular
+                visitTypeLiteral(type, referenceNode, /*symbolStack*/ undefined);
+            }
+        }
+
+        function visitTypeLiteral(type: ObjectType, referenceNode: Node, symbolStack: Symbol[]): void {
+            let resolved = resolver.resolveObjectOrUnionTypeMembers(type);
+            forEach(resolved.callSignatures, s => visitSignatureType(s, referenceNode, symbolStack));
+            forEach(resolved.constructSignatures, s => visitSignatureType(s, referenceNode, symbolStack));
+            if (resolved.stringIndexType) visitType(resolved.stringIndexType, referenceNode, symbolStack);
+            if (resolved.numberIndexType) visitType(resolved.numberIndexType, referenceNode, symbolStack);
+            forEach(resolved.properties, p => {
+                let t = resolver.getTypeOfSymbol(p);
+                if (p.flags & (SymbolFlags.Function | SymbolFlags.Method)) {
+                    let signatures = resolver.getSignaturesOfType(t, SignatureKind.Call);
+                    for (let signature of signatures) {
+                        visitSignatureType(signature, referenceNode, symbolStack);
+                    }
+                }
+                else {
+                    visitType(t, referenceNode, symbolStack);
+                }
+            });
+        }
+
+        function visitSignatureType(signature: Signature, referenceNode: Node, symbolStack: Symbol[]) {
+            if (signature.target) {
+                // Instantiated signature, write type arguments instead
+                // This is achieved by passing in the mapper separately
+                forEach(signature.target.typeParameters, p => visitType(p, referenceNode, symbolStack));
+            }
+            else {
+                forEach(signature.typeParameters, p => visitType(p, referenceNode, symbolStack));
             }
+
+            forEach(signature.parameters, p => {
+                let t = resolver.getTypeOfSymbol(p);
+                visitType(t, referenceNode, symbolStack);
+            });
+            visitType(resolver.getReturnTypeOfSignature(signature), referenceNode, symbolStack);
+        }
+
+        function visitTypePart(symbol: Symbol, referenceNode: Node): void {
+            // if the symbol can be accessided by its name
+            collectDeclarations(symbol, referenceNode);
         }
 
         function visitTypeName(node: Identifier|QualifiedName): void {
@@ -1891,7 +1989,7 @@ namespace ts {
 
 
             referencedDeclarationName = "---" + referencedDeclarationName +"---";
-            let container = errorNode.parent;
+            let container = errorNode;
             while (true) {
                 switch (container.kind) {
                     case SyntaxKind.ClassDeclaration:
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 5aeeaea56fd26..c82a9b9b8cee3 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -1578,6 +1578,11 @@ namespace ts {
         getSymbolAtLocation(node: Node): Symbol;
         resolveAlias(symbol: Symbol): Symbol;
         getLocalTargetOfAliasDeclaration(node: Declaration): Symbol;
+        getTypeOfSymbol(symbol: Symbol): Type;
+        getReturnTypeOfSignature(signature: Signature): Type;
+        getSignatureFromDeclaration(declaration: SignatureDeclaration): Signature;
+        getSignaturesOfType(type: Type, kind: SignatureKind): Signature[];
+        resolveObjectOrUnionTypeMembers(type: ObjectType): ResolvedType;
     }
 
     export const enum SymbolFlags {
@@ -1751,8 +1756,11 @@ namespace ts {
         Void                    = 0x00000010,
         Undefined               = 0x00000020,
         Null                    = 0x00000040,
+        
         Enum                    = 0x00000080,  // Enum type
+        
         StringLiteral           = 0x00000100,  // String literal type
+
         TypeParameter           = 0x00000200,  // Type parameter
         Class                   = 0x00000400,  // Class
         Interface               = 0x00000800,  // Interface

From e3444c1af2c3930ae3ebdd1b4bc36061880af8a1 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Mon, 6 Jul 2015 22:54:13 -0700
Subject: [PATCH 06/57] use track symbol insted of walking types

---
 src/compiler/declarationEmitter.ts | 125 ++++++-----------------------
 1 file changed, 26 insertions(+), 99 deletions(-)

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index 262a81d367cfd..2f84e0dd5561d 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -264,8 +264,12 @@ namespace ts {
             }
         }
 
+        var currentErrorNode: Node;
         function trackSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags) {
-            handleSymbolAccessibilityError(resolver.isSymbolAccessible(symbol, enclosingDeclaration, meaning));
+            if (currentErrorNode) {
+                collectDeclarations(symbol, currentErrorNode);
+            }
+            //   handleSymbolAccessibilityError(resolver.isSymbolAccessible(symbol, enclosingDeclaration, meaning));
         }
 
         function writeTypeOfDeclaration(declaration: AccessorDeclaration | VariableLikeDeclaration, type: TypeNode, getSymbolAccessibilityDiagnostic: GetSymbolAccessibilityDiagnostic) {
@@ -1569,11 +1573,12 @@ namespace ts {
             switch (node.kind) {
                 case SyntaxKind.FunctionDeclaration:
                     return writeFunctionDeclaration(<FunctionLikeDeclaration>node);
+
                 case SyntaxKind.VariableStatement:
                     return writeVariableStatement(<VariableStatement>node);
-
                 case SyntaxKind.VariableDeclaration:
                     return writeVariableDeclaration(<VariableDeclaration>node);
+
                 case SyntaxKind.InterfaceDeclaration:
                     return writeInterfaceDeclaration(<InterfaceDeclaration>node);
                 case SyntaxKind.ClassDeclaration:
@@ -1702,8 +1707,8 @@ namespace ts {
                     return visitSignatureDeclaration(<FunctionOrConstructorTypeNode>node);
                 case SyntaxKind.TypeLiteral:
                     return visitNodes((<TypeLiteralNode>node).members);
-                //case SyntaxKind.ExpressionWithTypeArguments:
-                //    return getTypeFromTypeReference(<ExpressionWithTypeArguments>node);
+                case SyntaxKind.ExpressionWithTypeArguments:
+                    return visitExpressionWithTypeArguments(<ExpressionWithTypeArguments>node);
                 case SyntaxKind.TypeQuery:
                     return visitNode((<TypeQueryNode>node).exprName);
                 case SyntaxKind.TypeReference:
@@ -1752,9 +1757,10 @@ namespace ts {
             }
             else if (node.kind !== SyntaxKind.Constructor) {
                 // TODO: handel infered type
-                let signature = resolver.getSignatureFromDeclaration(node);
-                Debug.assert(!!signature);
-                visitType(resolver.getReturnTypeOfSignature(signature), node);
+                // TODO: Cache the result
+                currentErrorNode = node;
+                resolver.writeReturnTypeOfSignatureDeclaration(node, enclosingDeclaration, TypeFormatFlags.UseTypeOfFunction, writer);
+                currentErrorNode = undefined;
             }
         }
 
@@ -1768,102 +1774,21 @@ namespace ts {
             }
             else {
                 // TODO: handel infered type
-                let symbol = resolver.getSymbolAtLocation(node);
-                Debug.assert(!!symbol);
-                if (symbol && !(symbol.flags & (SymbolFlags.TypeLiteral | SymbolFlags.Signature))) {
-                    visitType(resolver.getTypeOfSymbol(symbol), node);
-                }
-            }
-        }
-
-        function visitType(type: Type, referenceNode: Node, symbolStack?: Symbol[]): void {
-            if (type.flags & TypeFlags.Reference) {
-                // TODO: handel array
-                visitType((<TypeReference>type).target, referenceNode);
-                forEach((<TypeReference>type).typeArguments, t => visitType(t, referenceNode));
-           }
-            else if (type.flags & (TypeFlags.Class | TypeFlags.Interface | TypeFlags.Enum | TypeFlags.TypeParameter)) {
-                visitTypePart(type.symbol, referenceNode);
-            }
-            else if (type.flags & TypeFlags.Tuple) {
-                forEach((<TupleType>type).elementTypes, t => visitType(t, referenceNode));
-            }
-            else if (type.flags & TypeFlags.Union) {
-                forEach((<UnionType>type).types, t => visitType(t, referenceNode));
-            }
-            else if (type.flags & TypeFlags.Anonymous) {
-                visitAnonymousType(type, referenceNode, symbolStack);
-            }
-        }
-
-        function visitAnonymousType(type: Type, referenceNode: Node, symbolStack: Symbol[]): void {
-            let symbol = type.symbol;
-            if (symbol) {
-                if (contains(symbolStack, symbol)) {
-                    return;
-                }
-
-                // Always use 'typeof T' for type of class, enum, and module objects
-                if (symbol.flags & (SymbolFlags.Class | SymbolFlags.Enum | SymbolFlags.ValueModule)) {
-                    visitTypePart(type.symbol, referenceNode);
-                }
-                else {
-                    // Since instantiations of the same anonymous type have the same symbol, tracking symbols instead
-                    // of types allows us to catch circular references to instantiations of the same anonymous type
-                    if (!symbolStack) {
-                        symbolStack = [];
-                    }
-                    symbolStack.push(symbol);
-                    visitTypeLiteral(type, referenceNode, symbolStack);
-                    symbolStack.pop();
-                }
+                // TODO: Cache the result
+                currentErrorNode = node;
+                resolver.writeTypeOfDeclaration(node, enclosingDeclaration, TypeFormatFlags.UseTypeOfFunction, writer);
+                currentErrorNode = undefined;
             }
-            else {
-                // Anonymous types with no symbol are never circular
-                visitTypeLiteral(type, referenceNode, /*symbolStack*/ undefined);
-            }
-        }
-
-        function visitTypeLiteral(type: ObjectType, referenceNode: Node, symbolStack: Symbol[]): void {
-            let resolved = resolver.resolveObjectOrUnionTypeMembers(type);
-            forEach(resolved.callSignatures, s => visitSignatureType(s, referenceNode, symbolStack));
-            forEach(resolved.constructSignatures, s => visitSignatureType(s, referenceNode, symbolStack));
-            if (resolved.stringIndexType) visitType(resolved.stringIndexType, referenceNode, symbolStack);
-            if (resolved.numberIndexType) visitType(resolved.numberIndexType, referenceNode, symbolStack);
-            forEach(resolved.properties, p => {
-                let t = resolver.getTypeOfSymbol(p);
-                if (p.flags & (SymbolFlags.Function | SymbolFlags.Method)) {
-                    let signatures = resolver.getSignaturesOfType(t, SignatureKind.Call);
-                    for (let signature of signatures) {
-                        visitSignatureType(signature, referenceNode, symbolStack);
-                    }
-                }
-                else {
-                    visitType(t, referenceNode, symbolStack);
-                }
-            });
         }
 
-        function visitSignatureType(signature: Signature, referenceNode: Node, symbolStack: Symbol[]) {
-            if (signature.target) {
-                // Instantiated signature, write type arguments instead
-                // This is achieved by passing in the mapper separately
-                forEach(signature.target.typeParameters, p => visitType(p, referenceNode, symbolStack));
-            }
-            else {
-                forEach(signature.typeParameters, p => visitType(p, referenceNode, symbolStack));
-            }
+        function visitExpressionWithTypeArguments(node: ExpressionWithTypeArguments): void {
+            // TODO: handel infered type
+            // TODO: Cache the result
+            currentErrorNode = node;
+            resolver.writeTypeOfExpression(node.expression, enclosingDeclaration, TypeFormatFlags.UseTypeOfFunction, writer);
+            currentErrorNode = undefined;
 
-            forEach(signature.parameters, p => {
-                let t = resolver.getTypeOfSymbol(p);
-                visitType(t, referenceNode, symbolStack);
-            });
-            visitType(resolver.getReturnTypeOfSignature(signature), referenceNode, symbolStack);
-        }
-
-        function visitTypePart(symbol: Symbol, referenceNode: Node): void {
-            // if the symbol can be accessided by its name
-            collectDeclarations(symbol, referenceNode);
+            visitNodes(node.typeArguments);
         }
 
         function visitTypeName(node: Identifier|QualifiedName): void {
@@ -1878,6 +1803,7 @@ namespace ts {
             collectDeclarations(target, node);
         }
 
+
         function isDeclarationVisible(node: Node): boolean {
             switch (node.kind) {
                 case SyntaxKind.TypeParameter:
@@ -1954,6 +1880,7 @@ namespace ts {
             return undefined;
         }
 
+
         function collectDeclarations(symbol: Symbol, errorNode: Node): void {
             forEach(symbol.declarations, d => collectDeclaration(d, errorNode));
         }

From b010a1925e22125fcf32bdf542639172edb470ec Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Mon, 6 Jul 2015 23:24:54 -0700
Subject: [PATCH 07/57] remove old diagnostics reporting

---
 src/compiler/checker.ts            |   1 -
 src/compiler/declarationEmitter.ts | 465 +++--------------------------
 src/compiler/types.ts              |   3 +-
 3 files changed, 39 insertions(+), 430 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 97b88dd47d0dc..0e0629f4a9360 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -14181,7 +14181,6 @@ namespace ts {
                 getReturnTypeOfSignature,
                 getSignatureFromDeclaration,
                 getSignaturesOfType,
-                resolveObjectOrUnionTypeMembers
             };
         }
 
diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index 2f84e0dd5561d..43bf9613eac67 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -13,7 +13,6 @@ namespace ts {
 
     interface DeclarationEmit {
         reportedDeclarationError: boolean;
-        moduleElementDeclarationEmitInfo: ModuleElementDeclarationEmitInfo[];
         synchronousDeclarationOutput: string;
         referencePathsOutput: string;
     }
@@ -48,6 +47,7 @@ namespace ts {
         let writeTextOfNode: (sourceFile: SourceFile, node: Node) => void;
 
         let writer = createAndSetNewTextWriterWithSymbolWriter();
+        setWriter(writer);
 
         let enclosingDeclaration: Node;
         let currentSourceFile: SourceFile;
@@ -55,9 +55,6 @@ namespace ts {
         let emitJsDocComments = compilerOptions.removeComments ? function (declaration: Node) { } : writeJsDocComments;
         let emit = compilerOptions.stripInternal ? stripInternal : emitNode;
 
-        let moduleElementDeclarationEmitInfo: ModuleElementDeclarationEmitInfo[] = [];
-        let asynchronousSubModuleDeclarationEmitInfo: ModuleElementDeclarationEmitInfo[];
-
         // Contains the reference paths that needs to go in the declaration file.
         // Collecting this separately because reference paths need to be first thing in the declaration file
         // and we could be collecting these paths from multiple files into single one with --out option
@@ -95,21 +92,6 @@ namespace ts {
             }
 
             emitSourceFile(root);
-
-            // create asynchronous output for the importDeclarations
-            if (moduleElementDeclarationEmitInfo.length) {
-                let oldWriter = writer;
-                forEach(moduleElementDeclarationEmitInfo, aliasEmitInfo => {
-                    if (aliasEmitInfo.isVisible) {
-                        Debug.assert(aliasEmitInfo.node.kind === SyntaxKind.ImportDeclaration);
-                        createAndSetNewTextWriterWithSymbolWriter();
-                        Debug.assert(aliasEmitInfo.indent === 0);
-                        writeImportDeclaration(<ImportDeclaration>aliasEmitInfo.node);
-                        aliasEmitInfo.asynchronousOutput = writer.getText();
-                    }
-                });
-                setWriter(oldWriter);
-            }
         }
         else {
             // Emit references corresponding to this file
@@ -138,7 +120,6 @@ namespace ts {
 
         return {
             reportedDeclarationError,
-            moduleElementDeclarationEmitInfo,
             synchronousDeclarationOutput: writer.getText(),
             referencePathsOutput,
         };
@@ -170,7 +151,6 @@ namespace ts {
             writer.writeStringLiteral = writer.writeLiteral;
             writer.writeParameter = writer.write;
             writer.writeSymbol = writer.write;
-            setWriter(writer);
             return writer;
         }
 
@@ -183,6 +163,7 @@ namespace ts {
             decreaseIndent = newWriter.decreaseIndent;
         }
 
+<<<<<<< HEAD
         function writeAsynchronousModuleElements(nodes: Node[]) {
             let oldWriter = writer;
             forEach(nodes, declaration => {
@@ -264,6 +245,8 @@ namespace ts {
             }
         }
 
+=======
+>>>>>>> remove old diagnostics reporting
         var currentErrorNode: Node;
         function trackSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags) {
             if (currentErrorNode) {
@@ -272,8 +255,7 @@ namespace ts {
             //   handleSymbolAccessibilityError(resolver.isSymbolAccessible(symbol, enclosingDeclaration, meaning));
         }
 
-        function writeTypeOfDeclaration(declaration: AccessorDeclaration | VariableLikeDeclaration, type: TypeNode, getSymbolAccessibilityDiagnostic: GetSymbolAccessibilityDiagnostic) {
-            writer.getSymbolAccessibilityDiagnostic = getSymbolAccessibilityDiagnostic;
+        function writeTypeOfDeclaration(declaration: AccessorDeclaration | VariableLikeDeclaration, type: TypeNode) {
             write(": ");
             if (type) {
                 // Write the type
@@ -284,8 +266,7 @@ namespace ts {
             }
         }
 
-        function writeReturnTypeAtSignature(signature: SignatureDeclaration, getSymbolAccessibilityDiagnostic: GetSymbolAccessibilityDiagnostic) {
-            writer.getSymbolAccessibilityDiagnostic = getSymbolAccessibilityDiagnostic;
+        function writeReturnTypeAtSignature(signature: SignatureDeclaration) {
             write(": ");
             if (signature.type) {
                 // Write the type
@@ -328,11 +309,6 @@ namespace ts {
             }
         }
 
-        function emitTypeWithNewGetSymbolAccessibilityDiagnostic(type: TypeNode | EntityName, getSymbolAccessibilityDiagnostic: GetSymbolAccessibilityDiagnostic) {
-            writer.getSymbolAccessibilityDiagnostic = getSymbolAccessibilityDiagnostic;
-            emitType(type);
-        }
-
         function emitType(type: TypeNode | Identifier | QualifiedName) {
             switch (type.kind) {
                 case SyntaxKind.AnyKeyword:
@@ -385,6 +361,7 @@ namespace ts {
                 }
             }
 
+<<<<<<< HEAD
             function emitEntityName(entityName: EntityName | PropertyAccessExpression) {
                 let visibilityResult = resolver.isEntityNameVisible(entityName,
                     // Aliases can be written asynchronously so use correct enclosing declaration
@@ -392,6 +369,20 @@ namespace ts {
 
                 handleSymbolAccessibilityError(visibilityResult);
                 writeEntityName(entityName);
+=======
+            function emitEntityName(entityName: EntityName | Expression) {
+
+                if (entityName.kind === SyntaxKind.Identifier) {
+                    writeTextOfNode(currentSourceFile, entityName);
+                }
+                else {
+                    let left = entityName.kind === SyntaxKind.QualifiedName ? (<QualifiedName>entityName).left : (<PropertyAccessExpression>entityName).expression;
+                    let right = entityName.kind === SyntaxKind.QualifiedName ? (<QualifiedName>entityName).right : (<PropertyAccessExpression>entityName).name;
+                    emitEntityName(left);
+                    write(".");
+                    writeTextOfNode(currentSourceFile, right);
+                }
+>>>>>>> remove old diagnostics reporting
             }
 
             function emitExpressionWithTypeArguments(node: ExpressionWithTypeArguments) {
@@ -500,7 +491,6 @@ namespace ts {
                 write("declare var ");
                 write(tempVarName);
                 write(": ");
-                writer.getSymbolAccessibilityDiagnostic = getDefaultExportAccessibilityDiagnostic;
                 resolver.writeTypeOfExpression(node.expression, enclosingDeclaration, TypeFormatFlags.UseTypeOfFunction, writer);
                 write(";");
                 writeLine();
@@ -509,89 +499,8 @@ namespace ts {
             }
             write(";");
             writeLine();
-
-            // Make all the declarations visible for the export name
-            if (node.expression.kind === SyntaxKind.Identifier) {
-                let nodes = resolver.collectLinkedAliases(<Identifier>node.expression);
-
-                // write each of these declarations asynchronously
-                writeAsynchronousModuleElements(nodes);
-            }
-
-            function getDefaultExportAccessibilityDiagnostic(diagnostic: SymbolAccessiblityResult): SymbolAccessibilityDiagnostic {
-                return {
-                    diagnosticMessage: Diagnostics.Default_export_of_the_module_has_or_is_using_private_name_0,
-                    errorNode: node
-                };
-            }
         }
 
-        //function isModuleElementVisible(node: Declaration) {
-        //    return resolver.isDeclarationVisible(node);
-        //}
-
-        //function emitModuleElement(node: Node, isModuleElementVisible: boolean) {
-        //    writeModuleElement(node);
-           
-        //    if (isModuleElementVisible) {
-        //        writeModuleElement(node);
-        //    }
-        //    // Import equals declaration in internal module can become visible as part of any emit so lets make sure we add these irrespective
-        //    else if (node.kind === SyntaxKind.ImportEqualsDeclaration ||
-        //        (node.parent.kind === SyntaxKind.SourceFile && isExternalModule(currentSourceFile))) {
-        //        let isVisible: boolean;
-        //        if (asynchronousSubModuleDeclarationEmitInfo && node.parent.kind !== SyntaxKind.SourceFile) {
-        //            // Import declaration of another module that is visited async so lets put it in right spot
-        //            asynchronousSubModuleDeclarationEmitInfo.push({
-        //                node,
-        //                outputPos: writer.getTextPos(),
-        //                indent: writer.getIndent(),
-        //                isVisible
-        //            });
-        //        }
-        //        else {
-        //            if (node.kind === SyntaxKind.ImportDeclaration) {
-        //                let importDeclaration = <ImportDeclaration>node;
-        //                if (importDeclaration.importClause) {
-        //                    isVisible = (importDeclaration.importClause.name && resolver.isDeclarationVisible(importDeclaration.importClause)) ||
-        //                    isVisibleNamedBinding(importDeclaration.importClause.namedBindings);
-        //                }
-        //            }
-        //            moduleElementDeclarationEmitInfo.push({
-        //                node,
-        //                outputPos: writer.getTextPos(),
-        //                indent: writer.getIndent(),
-        //                isVisible
-        //            });
-        //        }
-        //    }
-        //}
-
-        //function writeModuleElement(node: Node) {
-        //    switch (node.kind) {
-        //        case SyntaxKind.FunctionDeclaration:
-        //            return writeFunctionDeclaration(<FunctionLikeDeclaration>node);
-        //        case SyntaxKind.VariableStatement:
-        //            return writeVariableStatement(<VariableStatement>node);
-        //        case SyntaxKind.InterfaceDeclaration:
-        //            return writeInterfaceDeclaration(<InterfaceDeclaration>node);
-        //        case SyntaxKind.ClassDeclaration:
-        //            return writeClassDeclaration(<ClassDeclaration>node);
-        //        case SyntaxKind.TypeAliasDeclaration:
-        //            return writeTypeAliasDeclaration(<TypeAliasDeclaration>node);
-        //        case SyntaxKind.EnumDeclaration:
-        //            return writeEnumDeclaration(<EnumDeclaration>node);
-        //        case SyntaxKind.ModuleDeclaration:
-        //            return writeModuleDeclaration(<ModuleDeclaration>node);
-        //        case SyntaxKind.ImportEqualsDeclaration:
-        //            return writeImportEqualsDeclaration(<ImportEqualsDeclaration>node);
-        //        case SyntaxKind.ImportDeclaration:
-        //            return writeImportDeclaration(<ImportDeclaration>node);
-        //        default:
-        //            Debug.fail("Unknown symbol kind");
-        //    }
-        //}
-
         function emitModuleElementDeclarationFlags(node: Node) {
             // If the node is parented in the current source file we need to emit export declare or just export
             if (node.parent === currentSourceFile) {
@@ -636,7 +545,7 @@ namespace ts {
             writeTextOfNode(currentSourceFile, node.name);
             write(" = ");
             if (isInternalModuleImportEqualsDeclaration(node)) {
-                emitTypeWithNewGetSymbolAccessibilityDiagnostic(<EntityName>node.moduleReference, getImportEntityNameVisibilityError);
+                emitType(<EntityName>node.moduleReference);
                 write(";");
             }
             else {
@@ -645,25 +554,6 @@ namespace ts {
                 write(");");
             }
             writer.writeLine();
-
-            function getImportEntityNameVisibilityError(symbolAccesibilityResult: SymbolAccessiblityResult): SymbolAccessibilityDiagnostic {
-                return {
-                    diagnosticMessage: Diagnostics.Import_declaration_0_is_using_private_name_1,
-                    errorNode: node,
-                    typeName: node.name
-                };
-            }
-        }
-
-        function isVisibleNamedBinding(namedBindings: NamespaceImport | NamedImports): boolean {
-            if (namedBindings) {
-                if (namedBindings.kind === SyntaxKind.NamespaceImport) {
-                    return resolver.isDeclarationVisible(<NamespaceImport>namedBindings);
-                }
-                else {
-                    return forEach((<NamedImports>namedBindings).elements, namedImport => resolver.isDeclarationVisible(namedImport));
-                }
-            }
         }
 
         function writeImportDeclaration(node: ImportDeclaration) {
@@ -681,7 +571,7 @@ namespace ts {
                 if (node.importClause.name && resolver.isDeclarationVisible(node.importClause)) {
                     writeTextOfNode(currentSourceFile, node.importClause.name);
                 }
-                if (node.importClause.namedBindings && isVisibleNamedBinding(node.importClause.namedBindings)) {
+                if (node.importClause.namedBindings) {
                     if (currentWriterPos !== writer.getTextPos()) {
                         // If the default binding was emitted, write the separated
                         write(", ");
@@ -713,12 +603,6 @@ namespace ts {
 
         function emitExportSpecifier(node: ExportSpecifier) {
             emitImportOrExportSpecifier(node);
-
-            // Make all the declarations visible for the export name
-            let nodes = resolver.collectLinkedAliases(node.propertyName || node.name);
-
-            // write each of these declarations asynchronously
-            writeAsynchronousModuleElements(nodes);
         }
 
         function emitExportDeclaration(node: ExportDeclaration) {
@@ -774,17 +658,9 @@ namespace ts {
             write("type ");
             writeTextOfNode(currentSourceFile, node.name);
             write(" = ");
-            emitTypeWithNewGetSymbolAccessibilityDiagnostic(node.type, getTypeAliasDeclarationVisibilityError);
+            emitType(node.type);
             write(";");
             writeLine();
-
-            function getTypeAliasDeclarationVisibilityError(symbolAccesibilityResult: SymbolAccessiblityResult): SymbolAccessibilityDiagnostic {
-                return {
-                    diagnosticMessage: Diagnostics.Exported_type_alias_0_has_or_is_using_private_name_1,
-                    errorNode: node.type,
-                    typeName: node.name
-                };
-            }
         }
 
         function writeEnumDeclaration(node: EnumDeclaration) {
@@ -830,68 +706,7 @@ namespace ts {
                 // If there is constraint present and this is not a type parameter of the private method emit the constraint
                 if (node.constraint && !isPrivateMethodTypeParameter(node)) {
                     write(" extends ");
-                    if (node.parent.kind === SyntaxKind.FunctionType ||
-                        node.parent.kind === SyntaxKind.ConstructorType ||
-                        (node.parent.parent && node.parent.parent.kind === SyntaxKind.TypeLiteral)) {
-                        Debug.assert(node.parent.kind === SyntaxKind.MethodDeclaration ||
-                            node.parent.kind === SyntaxKind.MethodSignature ||
-                            node.parent.kind === SyntaxKind.FunctionType ||
-                            node.parent.kind === SyntaxKind.ConstructorType ||
-                            node.parent.kind === SyntaxKind.CallSignature ||
-                            node.parent.kind === SyntaxKind.ConstructSignature);
-                        emitType(node.constraint);
-                    }
-                    else {
-                        emitTypeWithNewGetSymbolAccessibilityDiagnostic(node.constraint, getTypeParameterConstraintVisibilityError);
-                    }
-                }
-
-                function getTypeParameterConstraintVisibilityError(symbolAccesibilityResult: SymbolAccessiblityResult): SymbolAccessibilityDiagnostic {
-                    // Type parameter constraints are named by user so we should always be able to name it
-                    let diagnosticMessage: DiagnosticMessage;
-                    switch (node.parent.kind) {
-                        case SyntaxKind.ClassDeclaration:
-                            diagnosticMessage = Diagnostics.Type_parameter_0_of_exported_class_has_or_is_using_private_name_1;
-                            break;
-
-                        case SyntaxKind.InterfaceDeclaration:
-                            diagnosticMessage = Diagnostics.Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1;
-                            break;
-
-                        case SyntaxKind.ConstructSignature:
-                            diagnosticMessage = Diagnostics.Type_parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1;
-                            break;
-
-                        case SyntaxKind.CallSignature:
-                            diagnosticMessage = Diagnostics.Type_parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1;
-                            break;
-
-                        case SyntaxKind.MethodDeclaration:
-                        case SyntaxKind.MethodSignature:
-                            if (node.parent.flags & NodeFlags.Static) {
-                                diagnosticMessage = Diagnostics.Type_parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1;
-                            }
-                            else if (node.parent.parent.kind === SyntaxKind.ClassDeclaration) {
-                                diagnosticMessage = Diagnostics.Type_parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1;
-                            }
-                            else {
-                                diagnosticMessage = Diagnostics.Type_parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1;
-                            }
-                            break;
-
-                        case SyntaxKind.FunctionDeclaration:
-                            diagnosticMessage = Diagnostics.Type_parameter_0_of_exported_function_has_or_is_using_private_name_1;
-                            break;
-
-                        default:
-                            Debug.fail("This is unknown parent for type parameter: " + node.parent.kind);
-                    }
-
-                    return {
-                        diagnosticMessage,
-                        errorNode: node,
-                        typeName: node.name
-                    };
+                    emitType(node.constraint);
                 }
             }
 
@@ -910,28 +725,7 @@ namespace ts {
 
             function emitTypeOfTypeReference(node: ExpressionWithTypeArguments) {
                 if (isSupportedExpressionWithTypeArguments(node)) {
-                    emitTypeWithNewGetSymbolAccessibilityDiagnostic(node, getHeritageClauseVisibilityError);
-                }
-
-                function getHeritageClauseVisibilityError(symbolAccesibilityResult: SymbolAccessiblityResult): SymbolAccessibilityDiagnostic {
-                    let diagnosticMessage: DiagnosticMessage;
-                    // Heritage clause is written by user so it can always be named
-                    if (node.parent.parent.kind === SyntaxKind.ClassDeclaration) {
-                        // Class or Interface implemented/extended is inaccessible
-                        diagnosticMessage = isImplementsList ?
-                            Diagnostics.Implements_clause_of_exported_class_0_has_or_is_using_private_name_1 :
-                            Diagnostics.Extends_clause_of_exported_class_0_has_or_is_using_private_name_1;
-                    }
-                    else {
-                        // interface is inaccessible
-                        diagnosticMessage = Diagnostics.Extends_clause_of_exported_interface_0_has_or_is_using_private_name_1;
-                    }
-
-                    return {
-                        diagnosticMessage,
-                        errorNode: node,
-                        typeName: (<Declaration>node.parent.parent).name
-                    };
+                    emitType(node);
                 }
             }
         }
@@ -1027,54 +821,11 @@ namespace ts {
                     emitTypeOfVariableDeclarationFromTypeLiteral(node);
                 }
                 else if (!(node.flags & NodeFlags.Private)) {
-                    writeTypeOfDeclaration(node, node.type, getVariableDeclarationTypeVisibilityError);
+                    writeTypeOfDeclaration(node, node.type);
                 }
             }
             //}
 
-            function getVariableDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult: SymbolAccessiblityResult) {
-                if (node.kind === SyntaxKind.VariableDeclaration) {
-                    return symbolAccesibilityResult.errorModuleName ?
-                        symbolAccesibilityResult.accessibility === SymbolAccessibility.CannotBeNamed ?
-                            Diagnostics.Exported_variable_0_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
-                            Diagnostics.Exported_variable_0_has_or_is_using_name_1_from_private_module_2 :
-                        Diagnostics.Exported_variable_0_has_or_is_using_private_name_1;
-                }
-                // This check is to ensure we don't report error on constructor parameter property as that error would be reported during parameter emit
-                else if (node.kind === SyntaxKind.PropertyDeclaration || node.kind === SyntaxKind.PropertySignature) {
-                    // TODO(jfreeman): Deal with computed properties in error reporting.
-                    if (node.flags & NodeFlags.Static) {
-                        return symbolAccesibilityResult.errorModuleName ?
-                            symbolAccesibilityResult.accessibility === SymbolAccessibility.CannotBeNamed ?
-                                Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
-                                Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 :
-                            Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_private_name_1;
-                    }
-                    else if (node.parent.kind === SyntaxKind.ClassDeclaration) {
-                        return symbolAccesibilityResult.errorModuleName ?
-                            symbolAccesibilityResult.accessibility === SymbolAccessibility.CannotBeNamed ?
-                                Diagnostics.Public_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
-                                Diagnostics.Public_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 :
-                            Diagnostics.Public_property_0_of_exported_class_has_or_is_using_private_name_1;
-                    }
-                    else {
-                        // Interfaces cannot have types that cannot be named
-                        return symbolAccesibilityResult.errorModuleName ?
-                            Diagnostics.Property_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2 :
-                            Diagnostics.Property_0_of_exported_interface_has_or_is_using_private_name_1;
-                    }
-                }
-            }
-
-            function getVariableDeclarationTypeVisibilityError(symbolAccesibilityResult: SymbolAccessiblityResult): SymbolAccessibilityDiagnostic {
-                let diagnosticMessage = getVariableDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult);
-                return diagnosticMessage !== undefined ? {
-                    diagnosticMessage,
-                    errorNode: node,
-                    typeName: node.name
-                } : undefined;
-            }
-
             function emitBindingPattern(bindingPattern: BindingPattern) {
                 // Only select non-omitted expression from the bindingPattern's elements.
                 // We have to do this to avoid emitting trailing commas.
@@ -1091,22 +842,13 @@ namespace ts {
             }
 
             function emitBindingElement(bindingElement: BindingElement) {
-                function getBindingElementTypeVisibilityError(symbolAccesibilityResult: SymbolAccessiblityResult): SymbolAccessibilityDiagnostic {
-                    let diagnosticMessage = getVariableDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult);
-                    return diagnosticMessage !== undefined ? {
-                        diagnosticMessage,
-                        errorNode: bindingElement,
-                        typeName: bindingElement.name
-                    } : undefined;
-                }
-
                 if (bindingElement.name) {
                     if (isBindingPattern(bindingElement.name)) {
                         emitBindingPattern(<BindingPattern>bindingElement.name);
                     }
                     else {
                         writeTextOfNode(currentSourceFile, bindingElement.name);
-                        writeTypeOfDeclaration(bindingElement, /*type*/ undefined, getBindingElementTypeVisibilityError);
+                        writeTypeOfDeclaration(bindingElement, /*type*/ undefined);
                     }
                 }
             }
@@ -1122,10 +864,6 @@ namespace ts {
             }
         }
 
-        function isVariableStatementVisible(node: VariableStatement) {
-            return forEach(node.declarationList.declarations, varDeclaration => resolver.isDeclarationVisible(varDeclaration));
-        }
-
         function writeVariableStatement(node: VariableStatement) {
             emitJsDocComments(node);
             emitModuleElementDeclarationFlags(node);
@@ -1186,7 +924,7 @@ namespace ts {
                             accessorWithTypeAnnotation = anotherAccessor;
                         }
                     }
-                    writeTypeOfDeclaration(node, type, getAccessorDeclarationTypeVisibilityError);
+                    writeTypeOfDeclaration(node, type);
                 }
                 write(";");
                 writeLine();
@@ -1201,50 +939,6 @@ namespace ts {
                             : undefined;
                 }
             }
-
-            function getAccessorDeclarationTypeVisibilityError(symbolAccesibilityResult: SymbolAccessiblityResult): SymbolAccessibilityDiagnostic {
-                let diagnosticMessage: DiagnosticMessage;
-                if (accessorWithTypeAnnotation.kind === SyntaxKind.SetAccessor) {
-                    // Setters have to have type named and cannot infer it so, the type should always be named
-                    if (accessorWithTypeAnnotation.parent.flags & NodeFlags.Static) {
-                        diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
-                            Diagnostics.Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_name_1_from_private_module_2 :
-                            Diagnostics.Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_private_name_1;
-                    }
-                    else {
-                        diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
-                            Diagnostics.Parameter_0_of_public_property_setter_from_exported_class_has_or_is_using_name_1_from_private_module_2 :
-                            Diagnostics.Parameter_0_of_public_property_setter_from_exported_class_has_or_is_using_private_name_1;
-                    }
-                    return {
-                        diagnosticMessage,
-                        errorNode: <Node>accessorWithTypeAnnotation.parameters[0],
-                        // TODO(jfreeman): Investigate why we are passing node.name instead of node.parameters[0].name
-                        typeName: accessorWithTypeAnnotation.name
-                    };
-                }
-                else {
-                    if (accessorWithTypeAnnotation.flags & NodeFlags.Static) {
-                        diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
-                            symbolAccesibilityResult.accessibility === SymbolAccessibility.CannotBeNamed ?
-                                Diagnostics.Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named :
-                                Diagnostics.Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_name_0_from_private_module_1 :
-                            Diagnostics.Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_private_name_0;
-                    }
-                    else {
-                        diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
-                            symbolAccesibilityResult.accessibility === SymbolAccessibility.CannotBeNamed ?
-                                Diagnostics.Return_type_of_public_property_getter_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named :
-                                Diagnostics.Return_type_of_public_property_getter_from_exported_class_has_or_is_using_name_0_from_private_module_1 :
-                            Diagnostics.Return_type_of_public_property_getter_from_exported_class_has_or_is_using_private_name_0;
-                    }
-                    return {
-                        diagnosticMessage,
-                        errorNode: <Node>accessorWithTypeAnnotation.name,
-                        typeName: undefined
-                    };
-                }
-            }
         }
 
         function writeFunctionDeclaration(node: FunctionLikeDeclaration) {
@@ -1320,7 +1014,7 @@ namespace ts {
                 }
             }
             else if (node.kind !== SyntaxKind.Constructor && !(node.flags & NodeFlags.Private)) {
-                writeReturnTypeAtSignature(node, getReturnTypeVisibilityError);
+                writeReturnTypeAtSignature(node);
             }
 
             enclosingDeclaration = prevEnclosingDeclaration;
@@ -1329,6 +1023,7 @@ namespace ts {
                 write(";");
                 writeLine();
             }
+<<<<<<< HEAD
 
             function getReturnTypeVisibilityError(symbolAccesibilityResult: SymbolAccessiblityResult): SymbolAccessibilityDiagnostic {
                 let diagnosticMessage: DiagnosticMessage;
@@ -1395,6 +1090,8 @@ namespace ts {
                     errorNode: <Node>node.name || node
                 };
             }
+=======
+>>>>>>> remove old diagnostics reporting
         }
 
         function emitParameterDeclaration(node: ParameterDeclaration) {
@@ -1423,72 +1120,7 @@ namespace ts {
                 emitTypeOfVariableDeclarationFromTypeLiteral(node);
             }
             else if (!(node.parent.flags & NodeFlags.Private)) {
-                writeTypeOfDeclaration(node, node.type, getParameterDeclarationTypeVisibilityError);
-            }
-
-            function getParameterDeclarationTypeVisibilityError(symbolAccesibilityResult: SymbolAccessiblityResult): SymbolAccessibilityDiagnostic {
-                let diagnosticMessage: DiagnosticMessage = getParameterDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult);
-                return diagnosticMessage !== undefined ? {
-                    diagnosticMessage,
-                    errorNode: node,
-                    typeName: node.name
-                } : undefined;
-            }
-
-            function getParameterDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult: SymbolAccessiblityResult): DiagnosticMessage {
-                switch (node.parent.kind) {
-                    case SyntaxKind.Constructor:
-                        return symbolAccesibilityResult.errorModuleName ?
-                            symbolAccesibilityResult.accessibility === SymbolAccessibility.CannotBeNamed ?
-                                Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
-                                Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_private_module_2 :
-                            Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_name_1;
-
-                    case SyntaxKind.ConstructSignature:
-                        // Interfaces cannot have parameter types that cannot be named
-                        return symbolAccesibilityResult.errorModuleName ?
-                            Diagnostics.Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 :
-                            Diagnostics.Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1;
-
-                    case SyntaxKind.CallSignature:
-                        // Interfaces cannot have parameter types that cannot be named
-                        return symbolAccesibilityResult.errorModuleName ?
-                            Diagnostics.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 :
-                            Diagnostics.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1;
-
-                    case SyntaxKind.MethodDeclaration:
-                    case SyntaxKind.MethodSignature:
-                        if (node.parent.flags & NodeFlags.Static) {
-                            return symbolAccesibilityResult.errorModuleName ?
-                                symbolAccesibilityResult.accessibility === SymbolAccessibility.CannotBeNamed ?
-                                    Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
-                                    Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_private_module_2 :
-                                Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1;
-                        }
-                        else if (node.parent.parent.kind === SyntaxKind.ClassDeclaration) {
-                            return symbolAccesibilityResult.errorModuleName ?
-                                symbolAccesibilityResult.accessibility === SymbolAccessibility.CannotBeNamed ?
-                                    Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
-                                    Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_private_module_2 :
-                                Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1;
-                        }
-                        else {
-                            // Interfaces cannot have parameter types that cannot be named
-                            return symbolAccesibilityResult.errorModuleName ?
-                                Diagnostics.Parameter_0_of_method_from_exported_interface_has_or_is_using_name_1_from_private_module_2 :
-                                Diagnostics.Parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1;
-                        }
-
-                    case SyntaxKind.FunctionDeclaration:
-                        return symbolAccesibilityResult.errorModuleName ?
-                            symbolAccesibilityResult.accessibility === SymbolAccessibility.CannotBeNamed ?
-                                Diagnostics.Parameter_0_of_exported_function_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
-                                Diagnostics.Parameter_0_of_exported_function_has_or_is_using_name_1_from_private_module_2 :
-                            Diagnostics.Parameter_0_of_exported_function_has_or_is_using_private_name_1;
-
-                    default:
-                        Debug.fail("This is unknown parent for parameter: " + node.parent.kind);
-                }
+                writeTypeOfDeclaration(node, node.type);
             }
 
             function emitBindingPattern(bindingPattern: BindingPattern) {
@@ -1510,15 +1142,6 @@ namespace ts {
             }
 
             function emitBindingElement(bindingElement: BindingElement) {
-                function getBindingElementTypeVisibilityError(symbolAccesibilityResult: SymbolAccessiblityResult): SymbolAccessibilityDiagnostic {
-                    let diagnosticMessage = getParameterDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult);
-                    return diagnosticMessage !== undefined ? {
-                        diagnosticMessage,
-                        errorNode: bindingElement,
-                        typeName: bindingElement.name
-                    } : undefined;
-                }
-
                 if (bindingElement.kind === SyntaxKind.OmittedExpression) {
                     // If bindingElement is an omittedExpression (i.e. containing elision),
                     // we will emit blank space (although this may differ from users' original code,
@@ -1758,6 +1381,7 @@ namespace ts {
             else if (node.kind !== SyntaxKind.Constructor) {
                 // TODO: handel infered type
                 // TODO: Cache the result
+                let writer = createAndSetNewTextWriterWithSymbolWriter();
                 currentErrorNode = node;
                 resolver.writeReturnTypeOfSignatureDeclaration(node, enclosingDeclaration, TypeFormatFlags.UseTypeOfFunction, writer);
                 currentErrorNode = undefined;
@@ -1775,6 +1399,7 @@ namespace ts {
             else {
                 // TODO: handel infered type
                 // TODO: Cache the result
+                let writer = createAndSetNewTextWriterWithSymbolWriter();
                 currentErrorNode = node;
                 resolver.writeTypeOfDeclaration(node, enclosingDeclaration, TypeFormatFlags.UseTypeOfFunction, writer);
                 currentErrorNode = undefined;
@@ -1784,6 +1409,7 @@ namespace ts {
         function visitExpressionWithTypeArguments(node: ExpressionWithTypeArguments): void {
             // TODO: handel infered type
             // TODO: Cache the result
+            let writer = createAndSetNewTextWriterWithSymbolWriter();
             currentErrorNode = node;
             resolver.writeTypeOfExpression(node.expression, enclosingDeclaration, TypeFormatFlags.UseTypeOfFunction, writer);
             currentErrorNode = undefined;
@@ -2102,23 +1728,8 @@ namespace ts {
         // or should we just not write this file like we are doing now
         //if (!emitDeclarationResult.reportedDeclarationError) {
             let declarationOutput = emitDeclarationResult.referencePathsOutput
-                + getDeclarationOutput(emitDeclarationResult.synchronousDeclarationOutput, emitDeclarationResult.moduleElementDeclarationEmitInfo);
+                + emitDeclarationResult.synchronousDeclarationOutput;
             writeFile(host, diagnostics, removeFileExtension(jsFilePath) + ".d.ts", declarationOutput, host.getCompilerOptions().emitBOM);
         //}
-
-        function getDeclarationOutput(synchronousDeclarationOutput: string, moduleElementDeclarationEmitInfo: ModuleElementDeclarationEmitInfo[]) {
-            let appliedSyncOutputPos = 0;
-            let declarationOutput = "";
-            // apply asynchronous additions to the synchronous output
-            forEach(moduleElementDeclarationEmitInfo, aliasEmitInfo => {
-                if (aliasEmitInfo.asynchronousOutput) {
-                    declarationOutput += synchronousDeclarationOutput.substring(appliedSyncOutputPos, aliasEmitInfo.outputPos);
-                    declarationOutput += getDeclarationOutput(aliasEmitInfo.asynchronousOutput, aliasEmitInfo.subModuleElementDeclarationEmitInfo);
-                    appliedSyncOutputPos = aliasEmitInfo.outputPos;
-                }
-            });
-            declarationOutput += synchronousDeclarationOutput.substring(appliedSyncOutputPos);
-            return declarationOutput;
-        }
     }
 }
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index c82a9b9b8cee3..728e6369892ea 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -1573,7 +1573,7 @@ namespace ts {
         getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number;
         getBlockScopedVariableId(node: Identifier): number;
         getReferencedValueDeclaration(reference: Identifier): Declaration;
-        getTypeReferenceSerializationKind(node: TypeReferenceNode): TypeReferenceSerializationKind; 
+        getTypeReferenceSerializationKind(node: TypeReferenceNode): TypeReferenceSerializationKind;
         resolveName(location: Node, name: string, meaning: SymbolFlags, nameNotFoundMessage: DiagnosticMessage, nameArg: string | Identifier): Symbol;
         getSymbolAtLocation(node: Node): Symbol;
         resolveAlias(symbol: Symbol): Symbol;
@@ -1582,7 +1582,6 @@ namespace ts {
         getReturnTypeOfSignature(signature: Signature): Type;
         getSignatureFromDeclaration(declaration: SignatureDeclaration): Signature;
         getSignaturesOfType(type: Type, kind: SignatureKind): Signature[];
-        resolveObjectOrUnionTypeMembers(type: ObjectType): ResolvedType;
     }
 
     export const enum SymbolFlags {

From 4e6948f223a0c9e28e8bce3baffad4171178e214 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Mon, 6 Jul 2015 23:28:38 -0700
Subject: [PATCH 08/57] Remove isDeclarationVisible uses

---
 src/compiler/declarationEmitter.ts | 31 +++++++++++-------------------
 1 file changed, 11 insertions(+), 20 deletions(-)

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index 43bf9613eac67..71fb772cf8572 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -252,7 +252,6 @@ namespace ts {
             if (currentErrorNode) {
                 collectDeclarations(symbol, currentErrorNode);
             }
-            //   handleSymbolAccessibilityError(resolver.isSymbolAccessible(symbol, enclosingDeclaration, meaning));
         }
 
         function writeTypeOfDeclaration(declaration: AccessorDeclaration | VariableLikeDeclaration, type: TypeNode) {
@@ -277,27 +276,19 @@ namespace ts {
             }
         }
 
-        function emitLines(nodes: Node[]) {
-            for (let node of nodes) {
-                emit(node);
-            }
-        }
-
-        function emitSeparatedList(nodes: Node[], separator: string, eachNodeEmitFn: (node: Node) => void, canEmitFn?: (node: Node) => boolean) {
+        function emitSeparatedList(nodes: Node[], separator: string, eachNodeEmitFn: (node: Node) => void) {
             let currentWriterPos = writer.getTextPos();
             for (let node of nodes) {
-                if (!canEmitFn || canEmitFn(node)) {
-                    if (currentWriterPos !== writer.getTextPos()) {
-                        write(separator);
-                    }
-                    currentWriterPos = writer.getTextPos();
-                    eachNodeEmitFn(node);
+                if (currentWriterPos !== writer.getTextPos()) {
+                    write(separator);
                 }
+                currentWriterPos = writer.getTextPos();
+                eachNodeEmitFn(node);
             }
         }
 
-        function emitCommaList(nodes: Node[], eachNodeEmitFn: (node: Node) => void, canEmitFn?: (node: Node) => boolean) {
-            emitSeparatedList(nodes, ", ", eachNodeEmitFn, canEmitFn);
+        function emitCommaList(nodes: Node[], eachNodeEmitFn: (node: Node) => void) {
+            emitSeparatedList(nodes, ", ", eachNodeEmitFn);
         }
 
         function writeJsDocComments(declaration: Node) {
@@ -448,7 +439,7 @@ namespace ts {
                     writeLine();
                     increaseIndent();
                     // write members
-                    emitLines(type.members);
+                    forEach(type.members, emitNode);
                     decreaseIndent();
                 }
                 write("}");
@@ -568,7 +559,7 @@ namespace ts {
             write("import ");
             if (node.importClause) {
                 let currentWriterPos = writer.getTextPos();
-                if (node.importClause.name && resolver.isDeclarationVisible(node.importClause)) {
+                if (node.importClause.name) {
                     writeTextOfNode(currentSourceFile, node.importClause.name);
                 }
                 if (node.importClause.namedBindings) {
@@ -582,7 +573,7 @@ namespace ts {
                     }
                     else {
                         write("{ ");
-                        emitCommaList((<NamedImports>node.importClause.namedBindings).elements, emitImportOrExportSpecifier, resolver.isDeclarationVisible);
+                        emitCommaList((<NamedImports>node.importClause.namedBindings).elements, emitImportOrExportSpecifier);
                         write(" }");
                     }
                 }
@@ -876,7 +867,7 @@ namespace ts {
             else {
                 write("var ");
             }
-            emitCommaList(node.declarationList.declarations, emitVariableDeclaration/*, resolver.isDeclarationVisible*/);
+            emitCommaList(node.declarationList.declarations, emitVariableDeclaration);
             write(";");
             writeLine();
         }

From 4f1c0884be0f31ae4d50e93a6ed49ed1c7601126 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Mon, 6 Jul 2015 23:42:22 -0700
Subject: [PATCH 09/57] rename functions with write prefix to emit

---
 src/compiler/declarationEmitter.ts | 258 +++++------------------------
 1 file changed, 45 insertions(+), 213 deletions(-)

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index 71fb772cf8572..ac9ddee9ecbe2 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -52,8 +52,6 @@ namespace ts {
         let enclosingDeclaration: Node;
         let currentSourceFile: SourceFile;
         let reportedDeclarationError = false;
-        let emitJsDocComments = compilerOptions.removeComments ? function (declaration: Node) { } : writeJsDocComments;
-        let emit = compilerOptions.stripInternal ? stripInternal : emitNode;
 
         // Contains the reference paths that needs to go in the declaration file.
         // Collecting this separately because reference paths need to be first thing in the declaration file
@@ -83,7 +81,7 @@ namespace ts {
                         shouldEmitToOwnFile(referencedFile, compilerOptions) || // This is referenced file is emitting its own js file
                         !addedGlobalFileReference)) { // Or the global out file corresponding to this reference was not added
 
-                        writeReferencePath(referencedFile);
+                        emitReferencePath(referencedFile);
                         if (!isExternalModuleOrDeclarationFile(referencedFile)) {
                             addedGlobalFileReference = true;
                         }
@@ -107,7 +105,7 @@ namespace ts {
                             if (referencedFile && (isExternalModuleOrDeclarationFile(referencedFile) &&
                                 !contains(emittedReferencedFiles, referencedFile))) { // If the file reference was not already emitted
 
-                                writeReferencePath(referencedFile);
+                                emitReferencePath(referencedFile);
                                 emittedReferencedFiles.push(referencedFile);
                             }
                         });
@@ -130,17 +128,6 @@ namespace ts {
             return comment.indexOf("@internal") >= 0;
         }
 
-        function stripInternal(node: Node) {
-            if (node) {
-                let leadingCommentRanges = getLeadingCommentRanges(currentSourceFile.text, node.pos);
-                if (forEach(leadingCommentRanges, hasInternalAnnotation)) {
-                    return;
-                }
-
-                emitNode(node);
-            }
-        }
-
         function createAndSetNewTextWriterWithSymbolWriter(): EmitTextWriterWithSymbolWriter {
             let writer = <EmitTextWriterWithSymbolWriter>createTextWriter(newLine);
             writer.trackSymbol = trackSymbol;
@@ -163,90 +150,6 @@ namespace ts {
             decreaseIndent = newWriter.decreaseIndent;
         }
 
-<<<<<<< HEAD
-        function writeAsynchronousModuleElements(nodes: Node[]) {
-            let oldWriter = writer;
-            forEach(nodes, declaration => {
-                let nodeToCheck: Node;
-                if (declaration.kind === SyntaxKind.VariableDeclaration) {
-                    nodeToCheck = declaration.parent.parent;
-                } else if (declaration.kind === SyntaxKind.NamedImports || declaration.kind === SyntaxKind.ImportSpecifier || declaration.kind === SyntaxKind.ImportClause) {
-                    Debug.fail("We should be getting ImportDeclaration instead to write");
-                } else {
-                    nodeToCheck = declaration;
-                }
-
-                let moduleElementEmitInfo = forEach(moduleElementDeclarationEmitInfo, declEmitInfo => declEmitInfo.node === nodeToCheck ? declEmitInfo : undefined);
-                if (!moduleElementEmitInfo && asynchronousSubModuleDeclarationEmitInfo) {
-                    moduleElementEmitInfo = forEach(asynchronousSubModuleDeclarationEmitInfo, declEmitInfo => declEmitInfo.node === nodeToCheck ? declEmitInfo : undefined);
-                }
-
-                // If the alias was marked as not visible when we saw its declaration, we would have saved the aliasEmitInfo, but if we haven't yet visited the alias declaration
-                // then we don't need to write it at this point. We will write it when we actually see its declaration
-                // Eg.
-                // export function bar(a: foo.Foo) { }
-                // import foo = require("foo");
-                // Writing of function bar would mark alias declaration foo as visible but we haven't yet visited that declaration so do nothing,
-                // we would write alias foo declaration when we visit it since it would now be marked as visible
-                if (moduleElementEmitInfo) {
-                    if (moduleElementEmitInfo.node.kind === SyntaxKind.ImportDeclaration) {
-                        // we have to create asynchronous output only after we have collected complete information
-                        // because it is possible to enable multiple bindings as asynchronously visible
-                        moduleElementEmitInfo.isVisible = true;
-                    }
-                    else {
-                        createAndSetNewTextWriterWithSymbolWriter();
-                        for (let declarationIndent = moduleElementEmitInfo.indent; declarationIndent; declarationIndent--) {
-                            increaseIndent();
-                        }
-
-                        if (nodeToCheck.kind === SyntaxKind.ModuleDeclaration) {
-                            Debug.assert(asynchronousSubModuleDeclarationEmitInfo === undefined);
-                            asynchronousSubModuleDeclarationEmitInfo = [];
-                        }
-                        //writeModuleElement(nodeToCheck);
-                        if (nodeToCheck.kind === SyntaxKind.ModuleDeclaration) {
-                            moduleElementEmitInfo.subModuleElementDeclarationEmitInfo = asynchronousSubModuleDeclarationEmitInfo;
-                            asynchronousSubModuleDeclarationEmitInfo = undefined;
-                        }
-                        moduleElementEmitInfo.asynchronousOutput = writer.getText();
-                    }
-                }
-            });
-            setWriter(oldWriter);
-        }
-
-        function handleSymbolAccessibilityError(symbolAccesibilityResult: SymbolAccessiblityResult) {
-            if (symbolAccesibilityResult.accessibility === SymbolAccessibility.Accessible) {
-                // write the aliases
-                if (symbolAccesibilityResult && symbolAccesibilityResult.aliasesToMakeVisible) {
-                    writeAsynchronousModuleElements(symbolAccesibilityResult.aliasesToMakeVisible);
-                }
-            }
-            else {
-                // Report error
-                reportedDeclarationError = true;
-                let errorInfo = writer.getSymbolAccessibilityDiagnostic(symbolAccesibilityResult);
-                if (errorInfo) {
-                    if (errorInfo.typeName) {
-                        diagnostics.push(createDiagnosticForNode(symbolAccesibilityResult.errorNode || errorInfo.errorNode,
-                            errorInfo.diagnosticMessage,
-                            getSourceTextOfNodeFromSourceFile(currentSourceFile, errorInfo.typeName),
-                            symbolAccesibilityResult.errorSymbolName,
-                            symbolAccesibilityResult.errorModuleName));
-                    }
-                    else {
-                        diagnostics.push(createDiagnosticForNode(symbolAccesibilityResult.errorNode || errorInfo.errorNode,
-                            errorInfo.diagnosticMessage,
-                            symbolAccesibilityResult.errorSymbolName,
-                            symbolAccesibilityResult.errorModuleName));
-                    }
-                }
-            }
-        }
-
-=======
->>>>>>> remove old diagnostics reporting
         var currentErrorNode: Node;
         function trackSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags) {
             if (currentErrorNode) {
@@ -254,7 +157,7 @@ namespace ts {
             }
         }
 
-        function writeTypeOfDeclaration(declaration: AccessorDeclaration | VariableLikeDeclaration, type: TypeNode) {
+        function emitTypeOfDeclaration(declaration: AccessorDeclaration | VariableLikeDeclaration, type: TypeNode) {
             write(": ");
             if (type) {
                 // Write the type
@@ -265,7 +168,7 @@ namespace ts {
             }
         }
 
-        function writeReturnTypeAtSignature(signature: SignatureDeclaration) {
+        function emitReturnTypeAtSignature(signature: SignatureDeclaration) {
             write(": ");
             if (signature.type) {
                 // Write the type
@@ -291,12 +194,14 @@ namespace ts {
             emitSeparatedList(nodes, ", ", eachNodeEmitFn);
         }
 
-        function writeJsDocComments(declaration: Node) {
-            if (declaration) {
-                let jsDocComments = getJsDocComments(declaration, currentSourceFile);
-                emitNewLineBeforeLeadingComments(currentSourceFile, writer, declaration, jsDocComments);
-                // jsDoc comments are emitted at /*leading comment1 */space/*leading comment*/space
-                emitComments(currentSourceFile, writer, jsDocComments, /*trailingSeparator*/ true, newLine, writeCommentRange);
+        function emitJsDocComments(declaration: Node) {
+            if (!compilerOptions.removeComments) {
+                if (declaration) {
+                    let jsDocComments = getJsDocComments(declaration, currentSourceFile);
+                    emitNewLineBeforeLeadingComments(currentSourceFile, writer, declaration, jsDocComments);
+                    // jsDoc comments are emitted at /*leading comment1 */space/*leading comment*/space
+                    emitComments(currentSourceFile, writer, jsDocComments, /*trailingSeparator*/ true, newLine, writeCommentRange);
+                }
             }
         }
 
@@ -352,15 +257,6 @@ namespace ts {
                 }
             }
 
-<<<<<<< HEAD
-            function emitEntityName(entityName: EntityName | PropertyAccessExpression) {
-                let visibilityResult = resolver.isEntityNameVisible(entityName,
-                    // Aliases can be written asynchronously so use correct enclosing declaration
-                    entityName.parent.kind === SyntaxKind.ImportEqualsDeclaration ? entityName.parent : enclosingDeclaration);
-
-                handleSymbolAccessibilityError(visibilityResult);
-                writeEntityName(entityName);
-=======
             function emitEntityName(entityName: EntityName | Expression) {
 
                 if (entityName.kind === SyntaxKind.Identifier) {
@@ -373,7 +269,6 @@ namespace ts {
                     write(".");
                     writeTextOfNode(currentSourceFile, right);
                 }
->>>>>>> remove old diagnostics reporting
             }
 
             function emitExpressionWithTypeArguments(node: ExpressionWithTypeArguments) {
@@ -449,7 +344,6 @@ namespace ts {
         function emitSourceFile(node: SourceFile) {
             currentSourceFile = node;
             enclosingDeclaration = node;
-            //            emitLines(node.statements);
             emitSourceFileDeclarations(node);
         }
 
@@ -525,8 +419,8 @@ namespace ts {
             }
         }
 
-        function writeImportEqualsDeclaration(node: ImportEqualsDeclaration) {
-            // note usage of writer. methods instead of aliases created, just to make sure we are using
+        function emitImportEqualsDeclaration(node: ImportEqualsDeclaration) {
+            // note usage of writer. methods instead of aliases created, just to make sure we are using 
             // correct writer especially to handle asynchronous alias writing
             emitJsDocComments(node);
             if (node.flags & NodeFlags.Export) {
@@ -547,7 +441,7 @@ namespace ts {
             writer.writeLine();
         }
 
-        function writeImportDeclaration(node: ImportDeclaration) {
+        function emitImportDeclaration(node: ImportDeclaration) {
             if (!node.importClause && !(node.flags & NodeFlags.Export)) {
                 // do not write non-exported import declarations that don't have import clauses
                 return;
@@ -615,7 +509,7 @@ namespace ts {
             writer.writeLine();
         }
 
-        function writeModuleDeclaration(node: ModuleDeclaration) {
+        function emitModuleDeclaration(node: ModuleDeclaration) {
             emitJsDocComments(node);
             emitModuleElementDeclarationFlags(node);
             if (node.flags & NodeFlags.Namespace) {
@@ -643,7 +537,7 @@ namespace ts {
             enclosingDeclaration = prevEnclosingDeclaration;
         }
 
-        function writeTypeAliasDeclaration(node: TypeAliasDeclaration) {
+        function emitTypeAliasDeclaration(node: TypeAliasDeclaration) {
             emitJsDocComments(node);
             emitModuleElementDeclarationFlags(node);
             write("type ");
@@ -654,7 +548,7 @@ namespace ts {
             writeLine();
         }
 
-        function writeEnumDeclaration(node: EnumDeclaration) {
+        function emitEnumDeclaration(node: EnumDeclaration) {
             emitJsDocComments(node);
             emitModuleElementDeclarationFlags(node);
             if (isConst(node)) {
@@ -721,7 +615,7 @@ namespace ts {
             }
         }
 
-        function writeClassDeclaration(node: ClassDeclaration) {
+        function emitClassDeclaration(node: ClassDeclaration) {
             function emitParameterProperties(constructorDeclaration: ConstructorDeclaration) {
                 if (constructorDeclaration) {
                     forEach(constructorDeclaration.parameters, param => {
@@ -760,7 +654,7 @@ namespace ts {
             enclosingDeclaration = prevEnclosingDeclaration;
         }
 
-        function writeInterfaceDeclaration(node: InterfaceDeclaration) {
+        function emitInterfaceDeclaration(node: InterfaceDeclaration) {
             emitJsDocComments(node);
             emitModuleElementDeclarationFlags(node);
             write("interface ");
@@ -812,7 +706,7 @@ namespace ts {
                     emitTypeOfVariableDeclarationFromTypeLiteral(node);
                 }
                 else if (!(node.flags & NodeFlags.Private)) {
-                    writeTypeOfDeclaration(node, node.type);
+                    emitTypeOfDeclaration(node, node.type);
                 }
             }
             //}
@@ -839,7 +733,7 @@ namespace ts {
                     }
                     else {
                         writeTextOfNode(currentSourceFile, bindingElement.name);
-                        writeTypeOfDeclaration(bindingElement, /*type*/ undefined);
+                        emitTypeOfDeclaration(bindingElement, /*type*/ undefined);
                     }
                 }
             }
@@ -855,7 +749,7 @@ namespace ts {
             }
         }
 
-        function writeVariableStatement(node: VariableStatement) {
+        function emitVariableStatement(node: VariableStatement) {
             emitJsDocComments(node);
             emitModuleElementDeclarationFlags(node);
             if (isLet(node.declarationList)) {
@@ -915,7 +809,7 @@ namespace ts {
                             accessorWithTypeAnnotation = anotherAccessor;
                         }
                     }
-                    writeTypeOfDeclaration(node, type);
+                    emitTypeOfDeclaration(node, type);
                 }
                 write(";");
                 writeLine();
@@ -932,7 +826,7 @@ namespace ts {
             }
         }
 
-        function writeFunctionDeclaration(node: FunctionLikeDeclaration) {
+        function emitFunctionDeclaration(node: FunctionLikeDeclaration) {
             if (hasDynamicName(node)) {
                 return;
             }
@@ -1005,7 +899,7 @@ namespace ts {
                 }
             }
             else if (node.kind !== SyntaxKind.Constructor && !(node.flags & NodeFlags.Private)) {
-                writeReturnTypeAtSignature(node);
+                emitReturnTypeAtSignature(node);
             }
 
             enclosingDeclaration = prevEnclosingDeclaration;
@@ -1014,75 +908,6 @@ namespace ts {
                 write(";");
                 writeLine();
             }
-<<<<<<< HEAD
-
-            function getReturnTypeVisibilityError(symbolAccesibilityResult: SymbolAccessiblityResult): SymbolAccessibilityDiagnostic {
-                let diagnosticMessage: DiagnosticMessage;
-                switch (node.kind) {
-                    case SyntaxKind.ConstructSignature:
-                        // Interfaces cannot have return types that cannot be named
-                        diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
-                            Diagnostics.Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 :
-                            Diagnostics.Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_0;
-                        break;
-
-                    case SyntaxKind.CallSignature:
-                        // Interfaces cannot have return types that cannot be named
-                        diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
-                            Diagnostics.Return_type_of_call_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 :
-                            Diagnostics.Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_name_0;
-                        break;
-
-                    case SyntaxKind.IndexSignature:
-                        // Interfaces cannot have return types that cannot be named
-                        diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
-                            Diagnostics.Return_type_of_index_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 :
-                            Diagnostics.Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_name_0;
-                        break;
-
-                    case SyntaxKind.MethodDeclaration:
-                    case SyntaxKind.MethodSignature:
-                        if (node.flags & NodeFlags.Static) {
-                            diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
-                                symbolAccesibilityResult.accessibility === SymbolAccessibility.CannotBeNamed ?
-                                    Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named :
-                                    Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_private_module_1 :
-                                Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_name_0;
-                        }
-                        else if (node.parent.kind === SyntaxKind.ClassDeclaration) {
-                            diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
-                                symbolAccesibilityResult.accessibility === SymbolAccessibility.CannotBeNamed ?
-                                    Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named :
-                                    Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_private_module_1 :
-                                Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_private_name_0;
-                        }
-                        else {
-                            // Interfaces cannot have return types that cannot be named
-                            diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
-                                Diagnostics.Return_type_of_method_from_exported_interface_has_or_is_using_name_0_from_private_module_1 :
-                                Diagnostics.Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0;
-                        }
-                        break;
-
-                    case SyntaxKind.FunctionDeclaration:
-                        diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
-                            symbolAccesibilityResult.accessibility === SymbolAccessibility.CannotBeNamed ?
-                                Diagnostics.Return_type_of_exported_function_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named :
-                                Diagnostics.Return_type_of_exported_function_has_or_is_using_name_0_from_private_module_1 :
-                            Diagnostics.Return_type_of_exported_function_has_or_is_using_private_name_0;
-                        break;
-
-                    default:
-                        Debug.fail("This is unknown kind for signature: " + node.kind);
-                }
-
-                return {
-                    diagnosticMessage,
-                    errorNode: <Node>node.name || node
-                };
-            }
-=======
->>>>>>> remove old diagnostics reporting
         }
 
         function emitParameterDeclaration(node: ParameterDeclaration) {
@@ -1111,7 +936,7 @@ namespace ts {
                 emitTypeOfVariableDeclarationFromTypeLiteral(node);
             }
             else if (!(node.parent.flags & NodeFlags.Private)) {
-                writeTypeOfDeclaration(node, node.type);
+                emitTypeOfDeclaration(node, node.type);
             }
 
             function emitBindingPattern(bindingPattern: BindingPattern) {
@@ -1184,36 +1009,43 @@ namespace ts {
         }
 
         function emitNode(node: Node) {
+            if (compilerOptions.stripInternal) {
+                let leadingCommentRanges = getLeadingCommentRanges(currentSourceFile.text, node.pos);
+                if (forEach(leadingCommentRanges, hasInternalAnnotation)) {
+                    return;
+                }
+            }
+
             switch (node.kind) {
                 case SyntaxKind.FunctionDeclaration:
-                    return writeFunctionDeclaration(<FunctionLikeDeclaration>node);
+                    return emitFunctionDeclaration(<FunctionLikeDeclaration>node);
 
                 case SyntaxKind.VariableStatement:
-                    return writeVariableStatement(<VariableStatement>node);
+                    return emitVariableStatement(<VariableStatement>node);
                 case SyntaxKind.VariableDeclaration:
                     return writeVariableDeclaration(<VariableDeclaration>node);
 
                 case SyntaxKind.InterfaceDeclaration:
-                    return writeInterfaceDeclaration(<InterfaceDeclaration>node);
+                    return emitInterfaceDeclaration(<InterfaceDeclaration>node);
                 case SyntaxKind.ClassDeclaration:
-                    return writeClassDeclaration(<ClassDeclaration>node);
+                    return emitClassDeclaration(<ClassDeclaration>node);
                 case SyntaxKind.TypeAliasDeclaration:
-                    return writeTypeAliasDeclaration(<TypeAliasDeclaration>node);
+                    return emitTypeAliasDeclaration(<TypeAliasDeclaration>node);
                 case SyntaxKind.EnumDeclaration:
-                    return writeEnumDeclaration(<EnumDeclaration>node);
+                    return emitEnumDeclaration(<EnumDeclaration>node);
                 case SyntaxKind.ModuleDeclaration:
-                    return writeModuleDeclaration(<ModuleDeclaration>node);
+                    return emitModuleDeclaration(<ModuleDeclaration>node);
                 case SyntaxKind.ImportEqualsDeclaration:
-                    return writeImportEqualsDeclaration(<ImportEqualsDeclaration>node);
+                    return emitImportEqualsDeclaration(<ImportEqualsDeclaration>node);
                 case SyntaxKind.ImportDeclaration:
-                    return writeImportDeclaration(<ImportDeclaration>node);
+                    return emitImportDeclaration(<ImportDeclaration>node);
 
                 case SyntaxKind.ExportDeclaration:
                     return emitExportDeclaration(<ExportDeclaration>node);
                 case SyntaxKind.Constructor:
                 case SyntaxKind.MethodDeclaration:
                 case SyntaxKind.MethodSignature:
-                    return writeFunctionDeclaration(<FunctionLikeDeclaration>node);
+                    return emitFunctionDeclaration(<FunctionLikeDeclaration>node);
                 case SyntaxKind.ConstructSignature:
                 case SyntaxKind.CallSignature:
                 case SyntaxKind.IndexSignature:
@@ -1233,7 +1065,7 @@ namespace ts {
             }
         }
 
-        function writeReferencePath(referencedFile: SourceFile) {
+        function emitReferencePath(referencedFile: SourceFile) {
             let declFileName = referencedFile.flags & NodeFlags.DeclarationFile
                 ? referencedFile.fileName // Declaration file, use declaration file name
                 : shouldEmitToOwnFile(referencedFile, compilerOptions)

From ccba2968de99fc3a1d4fa74adaf09e4394a00c59 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Mon, 6 Jul 2015 23:50:41 -0700
Subject: [PATCH 10/57] clean up

---
 src/compiler/declarationEmitter.ts | 24 ++++++++----------------
 1 file changed, 8 insertions(+), 16 deletions(-)

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index ac9ddee9ecbe2..dc2e9a9b994ff 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -17,16 +17,7 @@ namespace ts {
         referencePathsOutput: string;
     }
 
-    type GetSymbolAccessibilityDiagnostic = (symbolAccesibilityResult: SymbolAccessiblityResult) => SymbolAccessibilityDiagnostic;
-
     interface EmitTextWriterWithSymbolWriter extends EmitTextWriter, SymbolWriter {
-        getSymbolAccessibilityDiagnostic: GetSymbolAccessibilityDiagnostic;
-    }
-
-    interface SymbolAccessibilityDiagnostic {
-        errorNode: Node;
-        diagnosticMessage: DiagnosticMessage;
-        typeName?: DeclarationName;
     }
 
     export function getDeclarationDiagnostics(host: EmitHost, resolver: EmitResolver, targetSourceFile: SourceFile): Diagnostic[] {
@@ -46,7 +37,7 @@ namespace ts {
         let decreaseIndent: () => void;
         let writeTextOfNode: (sourceFile: SourceFile, node: Node) => void;
 
-        let writer = createAndSetNewTextWriterWithSymbolWriter();
+        let writer = createNewTextWriterWithSymbolWriter();
         setWriter(writer);
 
         let enclosingDeclaration: Node;
@@ -128,7 +119,7 @@ namespace ts {
             return comment.indexOf("@internal") >= 0;
         }
 
-        function createAndSetNewTextWriterWithSymbolWriter(): EmitTextWriterWithSymbolWriter {
+        function createNewTextWriterWithSymbolWriter(): EmitTextWriterWithSymbolWriter {
             let writer = <EmitTextWriterWithSymbolWriter>createTextWriter(newLine);
             writer.trackSymbol = trackSymbol;
             writer.writeKeyword = writer.write;
@@ -767,7 +758,7 @@ namespace ts {
         }
 
         // TODO: we only should have either statement or declaration
-        function writeVariableDeclaration(node: VariableDeclaration) {
+        function emitVariableDeclarationWithoutStatement(node: VariableDeclaration) {
             emitJsDocComments(node);
             emitModuleElementDeclarationFlags(node);
             var declarationList = node.parent;
@@ -1023,7 +1014,7 @@ namespace ts {
                 case SyntaxKind.VariableStatement:
                     return emitVariableStatement(<VariableStatement>node);
                 case SyntaxKind.VariableDeclaration:
-                    return writeVariableDeclaration(<VariableDeclaration>node);
+                    return emitVariableDeclarationWithoutStatement(<VariableDeclaration>node);
 
                 case SyntaxKind.InterfaceDeclaration:
                     return emitInterfaceDeclaration(<InterfaceDeclaration>node);
@@ -1204,7 +1195,7 @@ namespace ts {
             else if (node.kind !== SyntaxKind.Constructor) {
                 // TODO: handel infered type
                 // TODO: Cache the result
-                let writer = createAndSetNewTextWriterWithSymbolWriter();
+                let writer = createNewTextWriterWithSymbolWriter();
                 currentErrorNode = node;
                 resolver.writeReturnTypeOfSignatureDeclaration(node, enclosingDeclaration, TypeFormatFlags.UseTypeOfFunction, writer);
                 currentErrorNode = undefined;
@@ -1222,7 +1213,7 @@ namespace ts {
             else {
                 // TODO: handel infered type
                 // TODO: Cache the result
-                let writer = createAndSetNewTextWriterWithSymbolWriter();
+                let writer = createNewTextWriterWithSymbolWriter();
                 currentErrorNode = node;
                 resolver.writeTypeOfDeclaration(node, enclosingDeclaration, TypeFormatFlags.UseTypeOfFunction, writer);
                 currentErrorNode = undefined;
@@ -1232,7 +1223,7 @@ namespace ts {
         function visitExpressionWithTypeArguments(node: ExpressionWithTypeArguments): void {
             // TODO: handel infered type
             // TODO: Cache the result
-            let writer = createAndSetNewTextWriterWithSymbolWriter();
+            let writer = createNewTextWriterWithSymbolWriter();
             currentErrorNode = node;
             resolver.writeTypeOfExpression(node.expression, enclosingDeclaration, TypeFormatFlags.UseTypeOfFunction, writer);
             currentErrorNode = undefined;
@@ -1363,6 +1354,7 @@ namespace ts {
             Debug.assert(referencedDeclaration.name && referencedDeclaration.name.kind === SyntaxKind.Identifier);
             let referencedDeclarationName = (<Identifier>referencedDeclaration.name).text;
 
+            reportedDeclarationError = true;
 
             referencedDeclarationName = "---" + referencedDeclarationName +"---";
             let container = errorNode;

From e05b983e9c79e4d5ef8f1d2b09ca8a3e5906ef46 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Tue, 7 Jul 2015 01:08:37 -0700
Subject: [PATCH 11/57] Handel visibility correctelly

---
 src/compiler/declarationEmitter.ts | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index dc2e9a9b994ff..42f3debfab9fb 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -143,9 +143,9 @@ namespace ts {
 
         var currentErrorNode: Node;
         function trackSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags) {
-            if (currentErrorNode) {
-                collectDeclarations(symbol, currentErrorNode);
-            }
+            //if (currentErrorNode) {
+            //    collectDeclarations(symbol, currentErrorNode);
+            //}
         }
 
         function emitTypeOfDeclaration(declaration: AccessorDeclaration | VariableLikeDeclaration, type: TypeNode) {
@@ -1075,6 +1075,8 @@ namespace ts {
 
 
         function visitNode(node: Node): void {
+            if (!node) return;
+
             switch (node.kind) {
                 // import/export aliases
                 case SyntaxKind.ExportDeclaration:
@@ -1272,12 +1274,17 @@ namespace ts {
                 case SyntaxKind.InterfaceDeclaration:
                 case SyntaxKind.ModuleDeclaration:
                 case SyntaxKind.TypeAliasDeclaration:
-                    // TODO: handel ambient context
-                    return (node.flags & NodeFlags.Export) !== 0;
+                    if (node.parent.kind === SyntaxKind.SourceFile && !isExternalModule(<SourceFile>node.parent)) {
+                        return true;
+                    }
+                    else {
+                        // TODO: handel ambient context
+                        return (node.flags & NodeFlags.Export) !== 0;
+                    }
 
                 case SyntaxKind.VariableDeclaration:
                     // TODO: do we need this
-                    return (node.parent.parent.flags & NodeFlags.Export) !== 0;
+                    return isDeclarationVisible(node.parent.parent);
             }
 
             return false;

From f33e4221f66e4075e5234ad513a98fc94cab326f Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Tue, 7 Jul 2015 01:13:13 -0700
Subject: [PATCH 12/57] handel internals when collecting declarations

---
 src/compiler/declarationEmitter.ts | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index 42f3debfab9fb..276fef20ec14c 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -119,6 +119,10 @@ namespace ts {
             return comment.indexOf("@internal") >= 0;
         }
 
+        function isInternal(node: Node) {
+            return forEach(getLeadingCommentRanges(currentSourceFile.text, node.pos), hasInternalAnnotation)
+        }
+
         function createNewTextWriterWithSymbolWriter(): EmitTextWriterWithSymbolWriter {
             let writer = <EmitTextWriterWithSymbolWriter>createTextWriter(newLine);
             writer.trackSymbol = trackSymbol;
@@ -1000,11 +1004,8 @@ namespace ts {
         }
 
         function emitNode(node: Node) {
-            if (compilerOptions.stripInternal) {
-                let leadingCommentRanges = getLeadingCommentRanges(currentSourceFile.text, node.pos);
-                if (forEach(leadingCommentRanges, hasInternalAnnotation)) {
-                    return;
-                }
+            if (compilerOptions.stripInternal && isInternal(node)) {
+                return;
             }
 
             switch (node.kind) {
@@ -1247,6 +1248,10 @@ namespace ts {
 
 
         function isDeclarationVisible(node: Node): boolean {
+            if (compilerOptions.stripInternal && isInternal(node)) {
+                return false;
+            }
+
             switch (node.kind) {
                 case SyntaxKind.TypeParameter:
                 case SyntaxKind.Parameter:
@@ -1263,7 +1268,6 @@ namespace ts {
                 case SyntaxKind.EnumMember:
                 case SyntaxKind.ExportAssignment:
                 case SyntaxKind.ExportDeclaration:
-                    // TODO: filter on @internal
                     return true;
 
                 case SyntaxKind.VariableStatement:

From 820d77d3c8e8768f2f561cccb12f9fd02a40ba9d Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Tue, 7 Jul 2015 12:42:58 -0700
Subject: [PATCH 13/57] Wire trackSymbol to show errors correctelly

---
 src/compiler/checker.ts            | 11 +++--------
 src/compiler/declarationEmitter.ts | 15 +++++++++------
 2 files changed, 12 insertions(+), 14 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 0e0629f4a9360..fca7fa3a2790d 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -1527,14 +1527,6 @@ namespace ts {
                     appendSymbolNameOnly(symbol, writer);
                 }
 
-                // Let the writer know we just wrote out a symbol.  The declaration emitter writer uses
-                // this to determine if an import it has previously seen (and not written out) needs
-                // to be written to the file once the walk of the tree is complete.
-                //
-                // NOTE(cyrusn): This approach feels somewhat unfortunate.  A simple pass over the tree
-                // up front (for example, during checking) could determine if we need to emit the imports
-                // and we could then access that data during declaration emit.
-                writer.trackSymbol(symbol, enclosingDeclaration, meaning);
                 function walkSymbol(symbol: Symbol, meaning: SymbolFlags): void {
                     if (symbol) {
                         let accessibleSymbolChain = getAccessibleSymbolChain(symbol, enclosingDeclaration, meaning, !!(flags & SymbolFormatFlags.UseOnlyExternalAliasing));
@@ -1598,6 +1590,7 @@ namespace ts {
                         writeTypeReference(<TypeReference>type, flags);
                     }
                     else if (type.flags & (TypeFlags.Class | TypeFlags.Interface | TypeFlags.Enum | TypeFlags.TypeParameter)) {
+                        writer.trackSymbol(type.symbol);
                         // The specified symbol flags need to be reinterpreted as type flags
                         buildSymbolDisplay(type.symbol, writer, enclosingDeclaration, SymbolFlags.Type, SymbolFormatFlags.None, flags);
                     }
@@ -1641,6 +1634,7 @@ namespace ts {
                     // Unnamed function expressions, arrow functions, and unnamed class expressions have reserved names that
                     // we don't want to display
                     if (!isReservedMemberName(symbol.name)) {
+                        writer.trackSymbol(symbol);
                         buildSymbolDisplay(symbol, writer, enclosingDeclaration, SymbolFlags.Type);
                     }
                     if (pos < end) {
@@ -1761,6 +1755,7 @@ namespace ts {
                 function writeTypeofSymbol(type: ObjectType, typeFormatFlags?: TypeFormatFlags) {
                     writeKeyword(writer, SyntaxKind.TypeOfKeyword);
                     writeSpace(writer);
+                    writer.trackSymbol(type.symbol);
                     buildSymbolDisplay(type.symbol, writer, enclosingDeclaration, SymbolFlags.Value, SymbolFormatFlags.None, typeFormatFlags);
                 }
 
diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index 276fef20ec14c..de3314c1ad3e2 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -147,9 +147,9 @@ namespace ts {
 
         var currentErrorNode: Node;
         function trackSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags) {
-            //if (currentErrorNode) {
-            //    collectDeclarations(symbol, currentErrorNode);
-            //}
+            if (currentErrorNode) {
+                collectDeclarations(symbol, currentErrorNode);
+            }
         }
 
         function emitTypeOfDeclaration(declaration: AccessorDeclaration | VariableLikeDeclaration, type: TypeNode) {
@@ -1199,9 +1199,10 @@ namespace ts {
                 // TODO: handel infered type
                 // TODO: Cache the result
                 let writer = createNewTextWriterWithSymbolWriter();
+                let previousErrorNode = currentErrorNode;
                 currentErrorNode = node;
                 resolver.writeReturnTypeOfSignatureDeclaration(node, enclosingDeclaration, TypeFormatFlags.UseTypeOfFunction, writer);
-                currentErrorNode = undefined;
+                currentErrorNode = previousErrorNode;
             }
         }
 
@@ -1217,9 +1218,10 @@ namespace ts {
                 // TODO: handel infered type
                 // TODO: Cache the result
                 let writer = createNewTextWriterWithSymbolWriter();
+                let previousErrorNode = currentErrorNode;
                 currentErrorNode = node;
                 resolver.writeTypeOfDeclaration(node, enclosingDeclaration, TypeFormatFlags.UseTypeOfFunction, writer);
-                currentErrorNode = undefined;
+                currentErrorNode = previousErrorNode;
             }
         }
 
@@ -1227,9 +1229,10 @@ namespace ts {
             // TODO: handel infered type
             // TODO: Cache the result
             let writer = createNewTextWriterWithSymbolWriter();
+            let previousErrorNode = currentErrorNode;
             currentErrorNode = node;
             resolver.writeTypeOfExpression(node.expression, enclosingDeclaration, TypeFormatFlags.UseTypeOfFunction, writer);
-            currentErrorNode = undefined;
+            currentErrorNode = previousErrorNode;
 
             visitNodes(node.typeArguments);
         }

From 655104ee72d11e9ca803d983cd65f93e2f85562b Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Tue, 7 Jul 2015 12:43:21 -0700
Subject: [PATCH 14/57] Disable internal check for now untill all code is fixed

---
 src/compiler/declarationEmitter.ts | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index de3314c1ad3e2..35bf53c3870b8 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -1252,7 +1252,10 @@ namespace ts {
 
         function isDeclarationVisible(node: Node): boolean {
             if (compilerOptions.stripInternal && isInternal(node)) {
-                return false;
+                // TODO: this is the correct place for this check, enable this 
+                // after updating the code to make internal on local declarations instead
+                // of containers
+                //return false;
             }
 
             switch (node.kind) {

From 7718b2244669051baa1797880df16fb5d2559269 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Tue, 7 Jul 2015 12:44:53 -0700
Subject: [PATCH 15/57] use custom indexOf instead of array.prototype.indexOf
 to allow running on ES3

---
 src/compiler/checker.ts | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index fca7fa3a2790d..c18bed30ebcca 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -371,8 +371,7 @@ namespace ts {
             }
 
             let sourceFiles = host.getSourceFiles();
-            return sourceFiles.indexOf(file1) <= sourceFiles.indexOf(file2);
-        }
+            return indexOf(sourceFiles, file1) <= indexOf(sourceFiles, file2);
        }
 
         // Resolve a given name for a given meaning at a given location. An error is reported if the name was not found and
         // the nameNotFoundMessage argument is not undefined. Returns the resolved symbol, or undefined if no symbol with

From 86c9578c984cfc78942863a64740c2be74ae1f43 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Tue, 7 Jul 2015 14:08:54 -0700
Subject: [PATCH 16/57] Accept symbol baselines

---
 tests/baselines/reference/2dArrays.symbols    |    1 +
 ...nctionWithTheSameNameAndCommonRoot.symbols |    1 +
 .../reference/ArrowFunction4.symbols          |    1 +
 ...dNonExportedFunctionThatShareAName.symbols |    2 +
 ...bleAndNonExportedVarThatShareAName.symbols |    2 +
 tests/baselines/reference/ES5For-of10.symbols |    1 +
 tests/baselines/reference/ES5For-of9.symbols  |    1 +
 ...sHeritageListMemberTypeAnnotations.symbols |    2 +
 ...sibleTypeInTypeParameterConstraint.symbols |    2 +
 ...InParameterAndReturnTypeAnnotation.symbols |    1 +
 ...ibleTypesInParameterTypeAnnotation.symbols |    1 +
 ...essibleTypesInReturnTypeAnnotation.symbols |    1 +
 ...sHeritageListMemberTypeAnnotations.symbols |    2 +
 ...sibleTypeInTypeParameterConstraint.symbols |    2 +
 ...ccessibleTypesOnItsExportedMembers.symbols |    1 +
 ...ssibleTypesInMemberTypeAnnotations.symbols |    2 +
 ...WithAccessibleTypeInTypeAnnotation.symbols |    1 +
 ...thInaccessibleTypeInTypeAnnotation.symbols |    2 +
 ...WithSameNameAndDifferentCommonRoot.symbols |    2 +
 ...AndNonExportedClassesOfTheSameName.symbols |    1 +
 ...dNonExportedLocalVarsOfTheSameName.symbols |    3 +
 ...hTheSameNameAndDifferentCommonRoot.symbols |    2 +
 ...esWithTheSameNameAndSameCommonRoot.symbols |    3 +
 .../reference/accessorWithES5.symbols         |    2 +
 ...dditionOperatorWithAnyAndEveryType.symbols |    2 +
 ...tionOperatorWithStringAndEveryType.symbols |    1 +
 .../aliasUsageInFunctionExpression.symbols    |    2 +
 .../aliasUsageInGenericFunction.symbols       |    2 +
 .../aliasUsageInObjectLiteral.symbols         |    4 +
 .../aliasUsageInOrExpression.symbols          |    2 +
 .../reference/aliasUsedAsNameValue.symbols    |    1 +
 .../amdImportNotAsPrimaryExpression.symbols   |    1 +
 tests/baselines/reference/anonterface.symbols |    1 +
 .../anonymousClassExpression1.symbols         |    1 +
 .../anyInferenceAnonymousFunctions.symbols    |    8 +
 ...gumentsUsedInObjectLiteralProperty.symbols |    2 +
 .../reference/arrayBestCommonTypes.symbols    |   30 +
 ...ayBindingPatternOmittedExpressions.symbols |    1 +
 .../reference/arrayConcatMap.symbols          |    3 +
 .../arrayLiteralTypeInference.symbols         |    4 +
 ...LiteralWithMultipleBestCommonTypes.symbols |    8 +
 .../baselines/reference/arrayLiterals.symbols |    4 +
 .../reference/arrayLiterals2ES5.symbols       |    1 +
 .../reference/arrayLiterals2ES6.symbols       |    1 +
 .../reference/arrayOfFunctionTypes3.symbols   |    2 +
 tests/baselines/reference/arrayconcat.symbols |    1 +
 .../arrowFunctionExpressions.symbols          |   36 +
 ...rrowFunctionInExpressionStatement1.symbols |    3 +-
 ...rrowFunctionInExpressionStatement2.symbols |    1 +
 ...rrowFunctionWithObjectLiteralBody1.symbols |    2 +
 ...rrowFunctionWithObjectLiteralBody2.symbols |    2 +
 ...rrowFunctionWithObjectLiteralBody3.symbols |    2 +
 ...rrowFunctionWithObjectLiteralBody4.symbols |    2 +
 ...rrowFunctionWithObjectLiteralBody5.symbols |    8 +
 ...rrowFunctionWithObjectLiteralBody6.symbols |    8 +
 .../reference/asiInES6Classes.symbols         |    1 +
 .../asiPreventsParsingAsNamespace04.symbols   |    1 +
 tests/baselines/reference/assign1.symbols     |    1 +
 .../reference/assignEveryTypeToAny.symbols    |    2 +
 .../reference/assignToPrototype1.symbols      |    1 +
 .../assignmentCompatForEnums.symbols          |    1 +
 .../assignmentCompatWithObjectMembers.symbols |    4 +
 ...assignmentCompatWithObjectMembers2.symbols |    2 +
 ...assignmentCompatWithObjectMembers3.symbols |    2 +
 ...ompatWithObjectMembersNumericNames.symbols |    2 +
 .../assignmentCompatability1.symbols          |    2 +
 .../assignmentCompatability2.symbols          |    1 +
 .../assignmentCompatability3.symbols          |    2 +
 .../assignmentCompatability4.symbols          |    1 +
 .../assignmentCompatability5.symbols          |    2 +
 .../assignmentCompatability6.symbols          |    2 +
 .../assignmentCompatability7.symbols          |    2 +
 .../assignmentCompatability8.symbols          |    1 +
 .../assignmentCompatability9.symbols          |    1 +
 ...tedTypeBracketAccessIndexSignature.symbols |    2 +
 ...ntedTypeBracketNamedPropertyAccess.symbols |    2 +
 .../reference/badOverloadError.symbols        |    1 +
 .../reference/badThisBinding.symbols          |    2 +
 ...CommonTypeOfConditionalExpressions.symbols |    7 +
 ...bestCommonTypeWithContextualTyping.symbols |    1 +
 .../reference/binaryIntegerLiteral.symbols    |    2 +
 .../reference/binaryIntegerLiteralES6.symbols |    2 +
 .../bitwiseNotOperatorWithBooleanType.symbols |    1 +
 .../bitwiseNotOperatorWithNumberType.symbols  |    3 +
 .../bitwiseNotOperatorWithStringType.symbols  |    3 +
 ...nericFunctionWithZeroTypeArguments.symbols |    1 +
 ...thoutReturnTypeAnnotationInference.symbols |    1 +
 ...llSignaturesWithOptionalParameters.symbols |    5 +
 .../reference/callbacksDontShareTypes.symbols |    3 +
 .../reference/captureThisInSuperCall.symbols  |    2 +
 .../castExpressionParentheses.symbols         |    3 +
 tests/baselines/reference/castTest.symbols    |    3 +
 ...dSpecializationToObjectTypeLiteral.symbols |    2 +
 .../reference/classExpression.symbols         |    4 +
 .../reference/classExpression1.symbols        |    1 +
 .../reference/classExpression2.symbols        |    1 +
 .../reference/classExpression3.symbols        |    3 +
 .../reference/classExpression4.symbols        |    1 +
 .../reference/classExpressionES61.symbols     |    1 +
 .../reference/classExpressionES62.symbols     |    1 +
 .../reference/classExpressionES63.symbols     |    3 +
 .../reference/classExpressionTest1.symbols    |    1 +
 .../reference/classExpressionTest2.symbols    |    2 +
 ...hResolutionOfNamespaceOfSameName01.symbols |    1 +
 ...assExpressionWithStaticProperties1.symbols |    1 +
 ...assExpressionWithStaticProperties2.symbols |    1 +
 ...ExpressionWithStaticPropertiesES61.symbols |    1 +
 ...ExpressionWithStaticPropertiesES62.symbols |    1 +
 ...MemberInitializerWithLamdaScoping5.symbols |    1 +
 .../reference/classWithEmptyBody.symbols      |    4 +
 .../classWithProtectedProperty.symbols        |    2 +
 .../reference/classWithPublicProperty.symbols |    2 +
 ...llisionRestParameterArrowFunctions.symbols |    4 +
 ...peratorWithSecondOperandObjectType.symbols |    4 +
 .../reference/commentInMethodCall.symbols     |    1 +
 .../commentOnSimpleArrowFunctionBody1.symbols |    1 +
 .../commentsBeforeFunctionExpression1.symbols |    2 +
 .../reference/commentsFunction.symbols        |    7 +
 .../reference/commentsInterface.symbols       |    2 +
 .../commentsOnObjectLiteral3.symbols          |    2 +
 .../commentsOnObjectLiteral4.symbols          |    1 +
 .../commentsPropertySignature1.symbols        |    1 +
 .../reference/commentsVarDecl.symbols         |    1 +
 ...mmonJSImportNotAsPrimaryExpression.symbols |    1 +
 .../complexClassRelationships.symbols         |    1 +
 ...AdditionAssignmentLHSCanBeAssigned.symbols |    2 +
 .../computedPropertyNames10_ES5.symbols       |    1 +
 .../computedPropertyNames10_ES6.symbols       |    1 +
 .../computedPropertyNames11_ES5.symbols       |    1 +
 .../computedPropertyNames11_ES6.symbols       |    1 +
 .../computedPropertyNames18_ES5.symbols       |    1 +
 .../computedPropertyNames18_ES6.symbols       |    1 +
 .../computedPropertyNames1_ES5.symbols        |    1 +
 .../computedPropertyNames1_ES6.symbols        |    1 +
 .../computedPropertyNames20_ES5.symbols       |    1 +
 .../computedPropertyNames20_ES6.symbols       |    1 +
 .../computedPropertyNames22_ES5.symbols       |    1 +
 .../computedPropertyNames22_ES6.symbols       |    1 +
 .../computedPropertyNames25_ES5.symbols       |    1 +
 .../computedPropertyNames25_ES6.symbols       |    1 +
 .../computedPropertyNames28_ES5.symbols       |    1 +
 .../computedPropertyNames28_ES6.symbols       |    1 +
 .../computedPropertyNames29_ES5.symbols       |    3 +
 .../computedPropertyNames29_ES6.symbols       |    3 +
 .../computedPropertyNames31_ES5.symbols       |    3 +
 .../computedPropertyNames31_ES6.symbols       |    3 +
 .../computedPropertyNames33_ES5.symbols       |    1 +
 .../computedPropertyNames33_ES6.symbols       |    1 +
 .../computedPropertyNames46_ES5.symbols       |    1 +
 .../computedPropertyNames46_ES6.symbols       |    1 +
 .../computedPropertyNames47_ES5.symbols       |    1 +
 .../computedPropertyNames47_ES6.symbols       |    1 +
 .../computedPropertyNames48_ES5.symbols       |    3 +
 .../computedPropertyNames48_ES6.symbols       |    3 +
 .../computedPropertyNames4_ES5.symbols        |    1 +
 .../computedPropertyNames4_ES6.symbols        |    1 +
 .../computedPropertyNames7_ES5.symbols        |    1 +
 .../computedPropertyNames7_ES6.symbols        |    1 +
 ...edPropertyNamesContextualType1_ES5.symbols |    2 +
 ...edPropertyNamesContextualType1_ES6.symbols |    2 +
 ...edPropertyNamesContextualType2_ES5.symbols |    2 +
 ...edPropertyNamesContextualType2_ES6.symbols |    2 +
 ...edPropertyNamesContextualType3_ES5.symbols |    2 +
 ...edPropertyNamesContextualType3_ES6.symbols |    2 +
 ...edPropertyNamesContextualType4_ES5.symbols |    1 +
 ...edPropertyNamesContextualType4_ES6.symbols |    1 +
 ...edPropertyNamesContextualType5_ES5.symbols |    1 +
 ...edPropertyNamesContextualType5_ES6.symbols |    1 +
 ...edPropertyNamesContextualType6_ES5.symbols |    3 +
 ...edPropertyNamesContextualType6_ES6.symbols |    3 +
 ...edPropertyNamesContextualType7_ES5.symbols |    3 +
 ...edPropertyNamesContextualType7_ES6.symbols |    3 +
 ...dPropertyNamesDeclarationEmit5_ES5.symbols |    1 +
 ...dPropertyNamesDeclarationEmit5_ES6.symbols |    1 +
 ...omputedPropertyNamesSourceMap2_ES5.symbols |    1 +
 ...omputedPropertyNamesSourceMap2_ES6.symbols |    1 +
 .../reference/conditionalExpressions2.symbols |    3 +
 ...ionalOperatorConditionIsObjectType.symbols |   12 +
 ...onditionalOperatorWithIdenticalBCT.symbols |   20 +
 ...verloadsCausedByOverloadResolution.symbols |    2 +
 .../constEnumPropertyAccess1.symbols          |    2 +
 ...straintSatisfactionWithEmptyObject.symbols |    8 +
 .../contextualSignatureInstantiation1.symbols |    2 +
 .../contextualSignatureInstantiation2.symbols |    3 +
 .../reference/contextualTypeAny.symbols       |    1 +
 .../contextualTypeAppliedToVarArgs.symbols    |    2 +
 .../contextualTypeArrayReturnType.symbols     |    4 +
 ...ualTypeWithUnionTypeCallSignatures.symbols |    5 +
 ...alTypeWithUnionTypeIndexSignatures.symbols |   18 +
 ...contextualTypeWithUnionTypeMembers.symbols |   37 +
 .../reference/contextualTyping1.symbols       |    1 +
 .../reference/contextualTyping10.symbols      |    2 +
 .../reference/contextualTyping12.symbols      |    2 +
 .../reference/contextualTyping13.symbols      |    1 +
 .../reference/contextualTyping14.symbols      |    1 +
 .../reference/contextualTyping15.symbols      |    1 +
 .../reference/contextualTyping16.symbols      |    2 +
 .../reference/contextualTyping17.symbols      |    2 +
 .../reference/contextualTyping18.symbols      |    2 +
 .../reference/contextualTyping19.symbols      |    3 +
 .../reference/contextualTyping2.symbols       |    1 +
 .../reference/contextualTyping20.symbols      |    3 +
 .../reference/contextualTyping22.symbols      |    2 +
 .../reference/contextualTyping23.symbols      |    1 +
 .../reference/contextualTyping25.symbols      |    1 +
 .../reference/contextualTyping26.symbols      |    1 +
 .../reference/contextualTyping27.symbols      |    1 +
 .../reference/contextualTyping3.symbols       |    1 +
 .../reference/contextualTyping32.symbols      |    2 +
 .../reference/contextualTyping34.symbols      |    1 +
 .../reference/contextualTyping35.symbols      |    1 +
 .../reference/contextualTyping36.symbols      |    2 +
 .../reference/contextualTyping37.symbols      |    2 +
 .../reference/contextualTyping38.symbols      |    1 +
 .../reference/contextualTyping4.symbols       |    1 +
 .../reference/contextualTyping40.symbols      |    1 +
 .../reference/contextualTyping6.symbols       |    2 +
 .../reference/contextualTyping7.symbols       |    1 +
 .../reference/contextualTyping8.symbols       |    1 +
 .../reference/contextualTyping9.symbols       |    2 +
 .../contextualTypingArrayOfLambdas.symbols    |    3 +
 ...xtualTypingOfConditionalExpression.symbols |    4 +
 ...pingOfLambdaWithMultipleSignatures.symbols |    1 +
 ...ingOfLambdaWithMultipleSignatures2.symbols |    1 +
 ...ingTwoInstancesOfSameTypeParameter.symbols |    2 +
 ...gWithGenericAndNonGenericSignature.symbols |    2 +
 ...ntextualTypingWithGenericSignature.symbols |    1 +
 ...ionExpressionsAndReturnAnnotations.symbols |    3 +
 .../contextuallyTypingOrOperator.symbols      |   10 +
 .../contextuallyTypingOrOperator2.symbols     |    6 +
 tests/baselines/reference/covariance1.symbols |    2 +
 .../reference/crashInResolveInterface.symbols |    1 +
 .../baselines/reference/debuggerEmit.symbols  |    1 +
 ...eAssignmentInObjectLiteralProperty.symbols |    3 +
 .../reference/declFileRegressionTests.symbols |    2 +
 ...arametersOfFunctionAndFunctionType.symbols |    1 +
 .../declFileTypeAnnotationArrayType.symbols   |    2 +
 .../declFileTypeAnnotationParenType.symbols   |    4 +
 .../declFileTypeAnnotationTupleType.symbols   |    1 +
 .../declFileTypeAnnotationUnionType.symbols   |    2 +
 ...AnnotationVisibilityErrorAccessors.symbols |  182 ++
 ...VisibilityErrorParameterOfFunction.symbols |   95 +
 .../reference/declFileTypeofFunction.symbols  |    2 +
 .../declFileTypeofInAnonymousType.symbols     |    6 +
 tests/baselines/reference/declInput3.symbols  |    1 +
 .../declarationEmitDefaultExport7.symbols     |    7 +
 .../declarationEmitDestructuring4.symbols     |    1 +
 ...tionEmitDestructuringArrayPattern2.symbols |    3 +
 ...tDestructuringObjectLiteralPattern.symbols |   11 +
 ...DestructuringObjectLiteralPattern1.symbols |    7 +
 ...DestructuringObjectLiteralPattern2.symbols |    4 +
 ...ationEmitDestructuringPrivacyError.symbols |   13 +
 ...InstantiateModulesInFunctionBodies.symbols |    2 +
 .../decrementOperatorWithAnyOtherType.symbols |    1 +
 .../reference/defaultIndexProps1.symbols      |    1 +
 .../reference/defaultIndexProps2.symbols      |    1 +
 .../deleteOperatorWithBooleanType.symbols     |    1 +
 .../deleteOperatorWithNumberType.symbols      |    3 +
 .../deleteOperatorWithStringType.symbols      |    3 +
 .../reference/derivedClasses.symbols          |    2 +
 ...ddenBaseCallViaSuperPropertyAccess.symbols |    3 +
 ...ectBindingPatternAndAssignment1ES5.symbols |   15 +
 ...ectBindingPatternAndAssignment1ES6.symbols |   15 +
 ...structuringVariableDeclaration1ES5.symbols |   15 +
 ...structuringVariableDeclaration1ES6.symbols |   15 +
 ...tachedCommentAtStartOfConstructor1.symbols |    1 +
 ...tachedCommentAtStartOfConstructor2.symbols |    1 +
 ...hedCommentAtStartOfLambdaFunction1.symbols |    1 +
 ...hedCommentAtStartOfLambdaFunction2.symbols |    1 +
 ...nAtObjectLiteralPropertyAssignment.symbols |    2 +
 .../reference/doWhileBreakStatements.symbols  |    1 +
 .../doWhileContinueStatements.symbols         |    1 +
 .../reference/dottedSymbolResolution1.symbols |    1 +
 .../reference/downlevelLetConst12.symbols     |    2 +
 .../reference/downlevelLetConst13.symbols     |    4 +
 .../reference/downlevelLetConst14.symbols     |    4 +
 .../reference/downlevelLetConst15.symbols     |    6 +
 ...plicateOverloadInTypeAugmentation1.symbols |    1 +
 .../reference/emitArrowFunction.symbols       |    6 +
 .../reference/emitArrowFunctionAsIs.symbols   |    3 +
 .../emitArrowFunctionAsIsES6.symbols          |    3 +
 .../reference/emitArrowFunctionES6.symbols    |   17 +
 .../emitArrowFunctionThisCapturing.symbols    |    3 +
 .../emitArrowFunctionThisCapturingES6.symbols |    3 +
 ...owFunctionWhenUsingArguments01_ES6.symbols |    8 +
 ...owFunctionWhenUsingArguments02_ES6.symbols |    1 +
 ...owFunctionWhenUsingArguments03_ES6.symbols |    1 +
 ...owFunctionWhenUsingArguments04_ES6.symbols |    1 +
 ...owFunctionWhenUsingArguments05_ES6.symbols |    1 +
 ...owFunctionWhenUsingArguments06_ES6.symbols |    2 +
 ...owFunctionWhenUsingArguments07_ES6.symbols |    2 +
 ...tArrowFunctionWhenUsingArguments08.symbols |    2 +
 ...owFunctionWhenUsingArguments08_ES6.symbols |    2 +
 ...owFunctionWhenUsingArguments09_ES6.symbols |    2 +
 ...owFunctionWhenUsingArguments10_ES6.symbols |    2 +
 ...owFunctionWhenUsingArguments11_ES6.symbols |    2 +
 ...tArrowFunctionWhenUsingArguments13.symbols |    2 +
 ...owFunctionWhenUsingArguments13_ES6.symbols |    2 +
 ...owFunctionWhenUsingArguments14_ES6.symbols |    1 +
 ...owFunctionWhenUsingArguments15_ES6.symbols |    1 +
 ...owFunctionWhenUsingArguments16_ES6.symbols |    1 +
 ...owFunctionWhenUsingArguments17_ES6.symbols |    2 +
 ...owFunctionWhenUsingArguments18_ES6.symbols |    2 +
 ...owFunctionWhenUsingArguments19_ES6.symbols |    1 +
 .../reference/emitArrowFunctionsAsIs.symbols  |    3 +
 .../emitArrowFunctionsAsIsES6.symbols         |    3 +
 ...ssDeclarationWithSuperMethodCall01.symbols |    1 +
 ...efaultParametersFunctionExpression.symbols |    7 +
 ...ultParametersFunctionExpressionES6.symbols |    7 +
 ...tDefaultParametersFunctionProperty.symbols |    1 +
 ...faultParametersFunctionPropertyES6.symbols |    1 +
 ...itRestParametersFunctionExpression.symbols |    4 +
 ...estParametersFunctionExpressionES6.symbols |    4 +
 ...emitRestParametersFunctionProperty.symbols |    1 +
 ...tRestParametersFunctionPropertyES6.symbols |    1 +
 tests/baselines/reference/emptyExpr.symbols   |    3 +-
 ...ptyObjectBindingPatternParameter04.symbols |    1 +
 tests/baselines/reference/enumIndexer.symbols |    3 +
 .../baselines/reference/es6ClassTest5.symbols |    1 +
 .../baselines/reference/es6ClassTest8.symbols |    1 +
 .../reference/escapedIdentifiers.symbols      |    4 +
 ...pedReservedCompilerNamedIdentifier.symbols |    6 +
 ...ryTypeWithAnnotationAndInitializer.symbols |    3 +
 .../everyTypeWithInitializer.symbols          |    2 +
 .../exportAssignmentMergedInterface.symbols   |    1 +
 ...exportAssignmentWithoutIdentifier1.symbols |    1 +
 .../exportImportNonInstantiatedModule.symbols |    1 +
 .../reference/exportedVariable1.symbols       |    1 +
 ...ingClassFromAliasAndUsageInIndexer.symbols |    1 +
 .../baselines/reference/fatArrowSelf.symbols  |    1 +
 .../reference/fatArrowfunctionAsType.symbols  |    1 +
 .../reference/fatarrowfunctions.symbols       |   22 +
 ...nctionsInFunctionParameterDefaults.symbols |    1 +
 .../fatarrowfunctionsInFunctions.symbols      |    3 +
 tests/baselines/reference/for-of18.symbols    |    2 +
 tests/baselines/reference/for-of19.symbols    |    2 +
 tests/baselines/reference/for-of20.symbols    |    2 +
 tests/baselines/reference/for-of21.symbols    |    2 +
 tests/baselines/reference/for-of22.symbols    |    2 +
 tests/baselines/reference/for-of23.symbols    |    2 +
 tests/baselines/reference/for-of41.symbols    |    2 +
 tests/baselines/reference/for-of42.symbols    |    1 +
 .../reference/forBreakStatements.symbols      |    1 +
 .../reference/forContinueStatements.symbols   |    1 +
 .../reference/forInBreakStatements.symbols    |   12 +
 .../reference/forInContinueStatements.symbols |   12 +
 .../baselines/reference/forStatements.symbols |    3 +
 .../forStatementsMultipleValidDecl.symbols    |    7 +
 tests/baselines/reference/funcdecl.symbols    |    2 +
 .../reference/functionAssignmentError.symbols |    2 +
 .../functionConstraintSatisfaction.symbols    |    8 +
 .../functionConstraintSatisfaction3.symbols   |    6 +
 ...ExpressionAndLambdaMatchesFunction.symbols |    2 +
 ...unctionExpressionContextualTyping1.symbols |   12 +
 .../functionExpressionReturningItself.symbols |    1 +
 ...thResolutionOfTypeNamedArguments01.symbols |    1 +
 ...onWithResolutionOfTypeOfSameName01.symbols |    1 +
 ...onWithResolutionOfTypeOfSameName02.symbols |    1 +
 .../reference/functionImplementations.symbols |   20 +
 .../reference/functionLiteral.symbols         |    2 +
 .../functionLiteralForOverloads.symbols       |    4 +
 .../reference/functionOverloads14.symbols     |    1 +
 .../reference/functionOverloads24.symbols     |    1 +
 .../reference/functionOverloads35.symbols     |    1 +
 .../reference/functionOverloads36.symbols     |    1 +
 .../reference/functionOverloads38.symbols     |    1 +
 .../reference/functionOverloads39.symbols     |    1 +
 .../reference/functionOverloads42.symbols     |    1 +
 ...AnyReturnTypeAndNoReturnExpression.symbols |    2 +
 .../generatedContextualTyping.symbols         |  368 +++
 .../reference/generatorES6_3.symbols          |    1 +
 .../reference/generatorES6_4.symbols          |    1 +
 .../reference/generatorTypeCheck26.symbols    |    3 +
 .../reference/generatorTypeCheck27.symbols    |    3 +
 .../reference/generatorTypeCheck28.symbols    |    3 +
 .../reference/generatorTypeCheck29.symbols    |    3 +
 .../reference/generatorTypeCheck30.symbols    |    3 +
 .../reference/generatorTypeCheck41.symbols    |    1 +
 .../reference/generatorTypeCheck42.symbols    |    1 +
 .../reference/generatorTypeCheck43.symbols    |    1 +
 .../reference/generatorTypeCheck44.symbols    |    1 +
 .../reference/generatorTypeCheck45.symbols    |    3 +
 .../reference/generatorTypeCheck46.symbols    |    5 +
 .../baselines/reference/genericArray1.symbols |    1 +
 .../genericBaseClassLiteralProperty2.symbols  |    1 +
 .../genericCallWithObjectTypeArgs2.symbols    |    4 +
 ...lWithObjectTypeArgsAndConstraints2.symbols |    5 +
 ...thOverloadedFunctionTypedArguments.symbols |    8 +
 .../genericCallbacksAndClassHierarchy.symbols |    2 +
 ...ericContextualTypingSpecialization.symbols |    1 +
 .../genericFunctionHasFreshTypeArgs.symbols   |    2 +
 .../reference/genericFunctions2.symbols       |    1 +
 ...icFunctionsWithOptionalParameters3.symbols |    6 +
 .../reference/genericInference1.symbols       |    1 +
 .../reference/genericInference2.symbols       |    1 +
 .../genericInterfaceTypeCall.symbols          |    2 +
 .../genericMethodOverspecialization.symbols   |    3 +
 .../genericObjectLitReturnType.symbols        |    1 +
 .../genericParameterAssignability1.symbols    |    1 +
 .../reference/genericTypeAliases.symbols      |   10 +
 .../reference/genericTypeAssertions3.symbols  |    2 +
 .../genericTypeParameterEquivalence2.symbols  |    4 +
 ...ricWithIndexerOfTypeParameterType1.symbols |    1 +
 .../genericsAndHigherOrderFunctions.symbols   |    6 +
 .../reference/getterSetterNonAccessor.symbols |    2 +
 .../reference/globalThisCapture.symbols       |    1 +
 .../heterogeneousArrayLiterals.symbols        |   56 +
 .../reference/ifDoWhileStatements.symbols     |   15 +
 .../implicitAnyAnyReturningFunction.symbols   |    2 +
 .../reference/importAliasIdentifiers.symbols  |    3 +
 .../reference/importInTypePosition.symbols    |    1 +
 .../reference/importStatements.symbols        |    1 +
 .../reference/inOperatorWithFunction.symbols  |    2 +
 .../inOperatorWithValidOperands.symbols       |    1 +
 .../incrementOperatorWithAnyOtherType.symbols |    1 +
 .../indexSignaturesInferentialTyping.symbols  |    4 +
 tests/baselines/reference/indexer.symbols     |    3 +
 tests/baselines/reference/indexer2.symbols    |    1 +
 tests/baselines/reference/indexer3.symbols    |    1 +
 tests/baselines/reference/indexerA.symbols    |    3 +
 .../reference/inferSecondaryParameter.symbols |    3 +
 .../inferenceFromParameterlessLambda.symbols  |    2 +
 ...erentialTypingObjectLiteralMethod1.symbols |    2 +
 ...erentialTypingObjectLiteralMethod2.symbols |    2 +
 ...entialTypingWithFunctionTypeNested.symbols |    2 +
 ...WithFunctionTypeSyntacticScenarios.symbols |    2 +
 ...tedFunctionAssignmentCompatibility.symbols |    2 +
 ...initializePropertiesWithRenamedLet.symbols |    8 +
 .../reference/innerBoundLambdaEmit.symbols    |    1 +
 .../reference/instantiatedModule.symbols      |    1 +
 tests/baselines/reference/interface0.symbols  |    1 +
 .../reference/interfaceContextualType.symbols |    4 +
 .../interfaceWithPropertyOfEveryType.symbols  |    6 +
 .../reference/invalidUndefinedValues.symbols  |    1 +
 tests/baselines/reference/ipromise2.symbols   |    1 +
 tests/baselines/reference/ipromise3.symbols   |    1 +
 tests/baselines/reference/ipromise4.symbols   |    3 +
 .../reference/iterableArrayPattern1.symbols   |    2 +
 .../reference/iterableArrayPattern11.symbols  |    2 +
 .../reference/iterableArrayPattern12.symbols  |    2 +
 .../reference/iterableArrayPattern13.symbols  |    2 +
 .../reference/iterableArrayPattern2.symbols   |    2 +
 .../reference/iterableArrayPattern3.symbols   |    2 +
 .../reference/iterableArrayPattern4.symbols   |    2 +
 .../reference/iterableArrayPattern9.symbols   |    2 +
 .../iterableContextualTyping1.symbols         |    1 +
 .../reference/iteratorSpreadInArray.symbols   |    2 +
 .../reference/iteratorSpreadInArray2.symbols  |    4 +
 .../reference/iteratorSpreadInArray3.symbols  |    2 +
 .../reference/iteratorSpreadInArray4.symbols  |    2 +
 .../reference/iteratorSpreadInArray7.symbols  |    2 +
 .../reference/iteratorSpreadInCall11.symbols  |    2 +
 .../reference/iteratorSpreadInCall12.symbols  |    4 +
 .../reference/iteratorSpreadInCall3.symbols   |    2 +
 .../reference/iteratorSpreadInCall5.symbols   |    4 +
 .../reference/jsxReactTestSuite.symbols       |    1 +
 .../baselines/reference/keywordField.symbols  |    2 +
 .../baselines/reference/lambdaASIEmit.symbols |    1 +
 .../reference/lambdaExpression.symbols        |    4 +
 .../reference/letDeclarations-es5.symbols     |    1 +
 .../reference/letDeclarations.symbols         |    1 +
 .../reference/letInNonStrictMode.symbols      |    1 +
 tests/baselines/reference/localTypes1.symbols |    2 +
 tests/baselines/reference/localTypes5.symbols |    1 +
 .../logicalNotOperatorWithBooleanType.symbols |    1 +
 .../logicalNotOperatorWithNumberType.symbols  |    3 +
 .../logicalNotOperatorWithStringType.symbols  |    3 +
 ...calOrExpressionIsContextuallyTyped.symbols |    2 +
 ...OrExpressionIsNotContextuallyTyped.symbols |    1 +
 ...ogicalOrOperatorWithTypeParameters.symbols |    1 +
 tests/baselines/reference/m7Bugs.symbols      |    3 +
 .../reference/mergedDeclarations1.symbols     |    1 +
 .../methodContainingLocalFunction.symbols     |    2 +
 tests/baselines/reference/missingSelf.symbols |    1 +
 .../reference/modFunctionCrash.symbols        |    1 +
 .../moduleWithStatementsOfEveryKind.symbols   |    4 +
 .../reference/multiCallOverloads.symbols      |    4 +
 .../reference/multiImportExport.symbols       |    1 +
 ...ameCollisionsInPropertyAssignments.symbols |    1 +
 ...nExpressionAssignedToClassProperty.symbols |    1 +
 .../namedFunctionExpressionCall.symbols       |    2 +
 .../namedFunctionExpressionInModule.symbols   |    1 +
 .../negateOperatorWithAnyOtherType.symbols    |    2 +
 .../negateOperatorWithBooleanType.symbols     |    1 +
 .../negateOperatorWithNumberType.symbols      |    3 +
 .../negateOperatorWithStringType.symbols      |    3 +
 .../baselines/reference/nestedModules.symbols |    1 +
 .../reference/nestedRecursiveLambda.symbols   |    8 +
 tests/baselines/reference/nestedSelf.symbols  |    1 +
 ...sionThisExpressionAndClassInGlobal.symbols |    1 +
 ...ExpressionAndLocalVarInConstructor.symbols |    6 +
 ...hisExpressionAndLocalVarInFunction.symbols |    1 +
 ...nThisExpressionAndLocalVarInLambda.symbols |    4 +
 ...nThisExpressionAndLocalVarInMethod.symbols |    8 +
 ...hisExpressionAndLocalVarInProperty.symbols |    6 +
 ...lisionThisExpressionAndVarInGlobal.symbols |    1 +
 ...ExpressionInFunctionAndVarInGlobal.symbols |    1 +
 ...citAnyFunctionExpressionAssignment.symbols |    2 +
 ...nContextuallyTypesFunctionParamter.symbols |    1 +
 .../noImplicitAnyIndexingSuppressed.symbols   |    4 +
 .../reference/nonInstantiatedModule.symbols   |    1 +
 .../reference/nonIterableRestElement1.symbols |    1 +
 .../reference/nonIterableRestElement2.symbols |    1 +
 tests/baselines/reference/null.symbols        |    1 +
 ...lIsSubtypeOfEverythingButUndefined.symbols |    8 +
 .../numericIndexerConstraint4.symbols         |    1 +
 .../reference/numericIndexingResults.symbols  |    2 +
 ...BindingPatternKeywordIdentifiers05.symbols |    1 +
 ...BindingPatternKeywordIdentifiers06.symbols |    1 +
 .../baselines/reference/objectIndexer.symbols |    1 +
 .../reference/objectLitGetterSetter.symbols   |    4 +
 .../reference/objectLiteral1.symbols          |    1 +
 .../reference/objectLiteral2.symbols          |    1 +
 .../objectLiteralArraySpecialization.symbols  |    3 +
 .../objectLiteralContextualTyping.symbols     |    5 +
 .../objectLiteralIndexerNoImplicitAny.symbols |    1 +
 .../reference/objectLiteralIndexers.symbols   |    3 +
 .../objectLiteralShorthandProperties.symbols  |    3 +
 ...teralShorthandPropertiesAssignment.symbols |    4 +
 ...alShorthandPropertiesAssignmentES6.symbols |    4 +
 ...bjectLiteralShorthandPropertiesES6.symbols |    3 +
 ...horthandPropertiesFunctionArgument.symbols |    2 +
 ...teralShorthandPropertiesWithModule.symbols |    1 +
 ...alShorthandPropertiesWithModuleES6.symbols |    1 +
 .../reference/objectLiteralWidened.symbols    |    3 +
 .../objectTypeHidingMembersOfObject.symbols   |    2 +
 .../objectTypePropertyAccess.symbols          |    1 +
 .../objectTypeWithNumericProperty.symbols     |    1 +
 ...TypeWithStringNamedNumericProperty.symbols |    1 +
 ...ngNamedPropertyOfIllegalCharacters.symbols |    1 +
 .../reference/objectTypesIdentity.symbols     |    1 +
 .../reference/objectTypesIdentity2.symbols    |    1 +
 ...ectTypesIdentityWithCallSignatures.symbols |    1 +
 ...ctTypesIdentityWithCallSignatures2.symbols |    1 +
 ...CallSignaturesDifferingParamCounts.symbols |    1 +
 ...ityWithCallSignaturesWithOverloads.symbols |    1 +
 ...esIdentityWithConstructSignatures2.symbols |    1 +
 ...ructSignaturesDifferingParamCounts.symbols |    1 +
 ...sIdentityWithGenericCallSignatures.symbols |    1 +
 ...IdentityWithGenericCallSignatures2.symbols |    1 +
 ...llSignaturesDifferingByConstraints.symbols |    1 +
 ...allSignaturesDifferingByReturnType.symbols |    1 +
 ...llSignaturesDifferingByReturnType2.symbols |    1 +
 ...aturesDifferingTypeParameterCounts.symbols |    1 +
 ...naturesDifferingTypeParameterNames.symbols |    1 +
 ...enericCallSignaturesOptionalParams.symbols |    1 +
 ...nericCallSignaturesOptionalParams2.symbols |    1 +
 ...nericCallSignaturesOptionalParams3.symbols |    1 +
 ...ctSignaturesDifferingByConstraints.symbols |    1 +
 ...uctSignaturesDifferingByReturnType.symbols |    1 +
 ...ctSignaturesDifferingByReturnType2.symbols |    1 +
 ...aturesDifferingTypeParameterCounts.symbols |    1 +
 ...naturesDifferingTypeParameterNames.symbols |    1 +
 ...cConstructSignaturesOptionalParams.symbols |    1 +
 ...ConstructSignaturesOptionalParams2.symbols |    1 +
 ...ConstructSignaturesOptionalParams3.symbols |    1 +
 ...tTypesIdentityWithNumericIndexers1.symbols |    1 +
 ...tTypesIdentityWithNumericIndexers2.symbols |    1 +
 ...tTypesIdentityWithNumericIndexers3.symbols |    1 +
 ...objectTypesIdentityWithOptionality.symbols |    1 +
 .../objectTypesIdentityWithPrivates.symbols   |    1 +
 .../objectTypesIdentityWithPublics.symbols    |    1 +
 ...ectTypesIdentityWithStringIndexers.symbols |    1 +
 ...ctTypesIdentityWithStringIndexers2.symbols |    1 +
 .../reference/octalIntegerLiteral.symbols     |    2 +
 .../reference/octalIntegerLiteralES6.symbols  |    2 +
 .../optionalAccessorsInInterface1.symbols     |    6 +
 ...BindingAcrossDeclarationBoundaries.symbols |    3 +
 ...indingAcrossDeclarationBoundaries2.symbols |    3 +
 ...overloadResolutionOverNonCTLambdas.symbols |    2 +
 ...erloadResolutionOverNonCTObjectLit.symbols |    2 +
 ...acksWithDifferingOptionalityOnArgs.symbols |    2 +
 .../parametersWithNoAnnotationAreAny.symbols  |    6 +
 .../parenthesizedContexualTyping1.symbols     |   30 +
 .../parenthesizedContexualTyping2.symbols     |   30 +
 .../parenthesizedContexualTyping3.symbols     |   13 +
 .../reference/parserAccessors4.symbols        |    1 +
 .../parserFunctionPropertyAssignment1.symbols |    1 +
 .../parserFunctionPropertyAssignment2.symbols |    1 +
 .../parserFunctionPropertyAssignment3.symbols |    1 +
 .../parserFunctionPropertyAssignment4.symbols |    1 +
 .../parserKeywordsAsIdentifierName1.symbols   |    1 +
 .../reference/parserObjectLiterals1.symbols   |    1 +
 .../reference/parserX_ArrowFunction4.symbols  |    1 +
 .../plusOperatorWithBooleanType.symbols       |    1 +
 .../plusOperatorWithNumberType.symbols        |    3 +
 .../plusOperatorWithStringType.symbols        |    3 +
 .../prespecializedGenericMembers1.symbols     |    1 +
 .../reference/privacyAccessorDeclFile.symbols | 2217 +++++++++++++++++
 .../privacyCannotNameAccessorDeclFile.symbols |  319 +++
 .../privacyCannotNameVarTypeDeclFile.symbols  |  315 +++
 ...acyCheckAnonymousFunctionParameter.symbols |    1 +
 .../privacyClassExtendsClauseDeclFile.symbols |  177 ++
 ...ivacyClassImplementsClauseDeclFile.symbols |  169 ++
 ...ionCannotNameParameterTypeDeclFile.symbols |  483 ++++
 ...nctionCannotNameReturnTypeDeclFile.symbols |  386 +++
 .../privacyFunctionParameterDeclFile.symbols  | 1968 +++++++++++++++
 ...vacyInterfaceExtendsClauseDeclFile.symbols |  169 ++
 ...lInternalReferenceImportWithExport.symbols |  510 ++++
 ...lInternalReferenceImportWithExport.symbols |  297 +++
 .../reference/promiseChaining.symbols         |    3 +
 tests/baselines/reference/promiseTest.symbols |    1 +
 .../reference/promiseTypeInference.symbols    |    1 +
 .../promiseVoidErrorCallback.symbols          |   15 +
 ...propagationOfPromiseInitialization.symbols |    2 +
 ...cessOnTypeParameterWithConstraints.symbols |    2 +
 ...essOnTypeParameterWithConstraints2.symbols |    2 +
 ...sOnTypeParameterWithoutConstraints.symbols |    2 +
 .../propertyNameWithoutTypeAnnotation.symbols |    1 +
 ...ClassPropertyAccessibleWithinClass.symbols |    7 +
 .../protoAsIndexInIndexExpression.symbols     |    3 +
 .../reference/quotedPropertyName3.symbols     |    1 +
 tests/baselines/reference/recur1.symbols      |    2 +
 .../reference/recursiveInitializer.symbols    |    1 +
 .../reference/recursiveObjectLiteral.symbols  |    1 +
 .../baselines/reference/reservedWords.symbols |    2 +
 .../reference/returnStatement1.symbols        |    1 +
 .../reference/returnStatements.symbols        |    1 +
 .../returnTypeParameterWithModules.symbols    |    1 +
 .../reference/selfInCallback.symbols          |    1 +
 .../baselines/reference/selfInLambdas.symbols |    6 +
 ...arameterReferencedInObjectLiteral1.symbols |    3 +
 ...onstructorAndCapturedThisStatement.symbols |    1 +
 ...ceMapValidationFunctionExpressions.symbols |    2 +
 ...lidationFunctionPropertyAssignment.symbols |    1 +
 ...eMapWithMultipleFilesWithCopyright.symbols |    1 +
 ...alizationsShouldNotAffectEachOther.symbols |    2 +
 .../specializedInheritedConstructors1.symbols |    2 +
 .../strictModeUseContextualKeyword.symbols    |    1 +
 .../reference/stringIndexingResults.symbols   |    1 +
 ...ngLiteralObjectLiteralDeclaration1.symbols |    1 +
 ...lPropertyNameWithLineContinuation1.symbols |    1 +
 .../stringNamedPropertyAccess.symbols         |    1 +
 .../reference/stringPropCodeGen.symbols       |    3 +
 tests/baselines/reference/structural1.symbols |    1 +
 .../subtypingWithCallSignatures.symbols       |    4 +
 .../subtypingWithCallSignatures2.symbols      |   38 +
 .../subtypingWithCallSignatures3.symbols      |   26 +
 .../subtypingWithCallSignatures4.symbols      |   20 +
 ...typingWithObjectMembersOptionality.symbols |    2 +
 .../subtypingWithOptionalProperties.symbols   |    1 +
 .../reference/superAccessInFatArrow1.symbols  |    1 +
 ...uperCallParameterContextualTyping1.symbols |    1 +
 ...uperCallParameterContextualTyping3.symbols |    2 +
 .../reference/switchBreakStatements.symbols   |    1 +
 .../reference/switchStatements.symbols        |   11 +
 .../reference/symbolDeclarationEmit10.symbols |    1 +
 .../reference/symbolDeclarationEmit8.symbols  |    1 +
 .../reference/symbolDeclarationEmit9.symbols  |    1 +
 .../reference/symbolProperty1.symbols         |    1 +
 .../reference/symbolProperty18.symbols        |    1 +
 .../reference/symbolProperty19.symbols        |   15 +
 .../reference/symbolProperty2.symbols         |    1 +
 .../reference/symbolProperty20.symbols        |    8 +
 .../reference/symbolProperty21.symbols        |    1 +
 .../reference/symbolProperty22.symbols        |    8 +
 .../reference/symbolProperty27.symbols        |    1 +
 .../reference/symbolProperty28.symbols        |    1 +
 .../reference/symbolProperty4.symbols         |    1 +
 .../reference/symbolProperty5.symbols         |    1 +
 .../reference/symbolProperty55.symbols        |    1 +
 .../reference/symbolProperty56.symbols        |    1 +
 .../reference/symbolProperty57.symbols        |    1 +
 .../baselines/reference/symbolType11.symbols  |    1 +
 .../reference/systemModule13.symbols          |    2 +
 .../baselines/reference/systemModule8.symbols |    2 +
 .../taggedTemplateContextualTyping1.symbols   |    7 +
 .../taggedTemplateContextualTyping2.symbols   |    4 +
 .../reference/targetTypeArgs.symbols          |    7 +
 .../reference/targetTypeCalls.symbols         |   10 +
 .../reference/targetTypeObjectLiteral.symbols |    2 +
 .../targetTypeObjectLiteralToAny.symbols      |    2 +
 .../reference/targetTypingOnFunctions.symbols |    2 +
 .../templateStringInArrowFunction.symbols     |    1 +
 .../templateStringInArrowFunctionES6.symbols  |    1 +
 ...templateStringInFunctionExpression.symbols |    1 +
 ...plateStringInFunctionExpressionES6.symbols |    1 +
 .../templateStringInInOperator.symbols        |    1 +
 .../templateStringInInOperatorES6.symbols     |    1 +
 ...templateStringInPropertyAssignment.symbols |    1 +
 ...plateStringInPropertyAssignmentES6.symbols |    1 +
 ...ateStringWithEmbeddedArrowFunction.symbols |    1 +
 ...StringWithEmbeddedArrowFunctionES6.symbols |    1 +
 ...ringWithEmbeddedFunctionExpression.symbols |    1 +
 ...gWithEmbeddedFunctionExpressionES6.symbols |    1 +
 ...mplateStringWithEmbeddedInOperator.symbols |    1 +
 ...ateStringWithEmbeddedInOperatorES6.symbols |    1 +
 ...ateStringWithEmbeddedObjectLiteral.symbols |    1 +
 ...StringWithEmbeddedObjectLiteralES6.symbols |    1 +
 .../ternaryExpressionSourceMap.symbols        |    2 +
 .../baselines/reference/thisBinding2.symbols  |    5 +
 .../baselines/reference/thisCapture1.symbols  |    1 +
 .../thisExpressionInIndexExpression.symbols   |    1 +
 .../thisExpressionOfGenericObject.symbols     |    1 +
 .../reference/thisInInnerFunctions.symbols    |    4 +
 .../baselines/reference/thisInLambda.symbols  |    3 +
 .../reference/thisInObjectLiterals.symbols    |    2 +
 .../thisInPropertyBoundDeclarations.symbols   |   28 +
 ...ncedInFunctionInsideArrowFunction1.symbols |    4 +
 .../throwInEnclosingStatements.symbols        |    3 +
 .../reference/throwStatements.symbols         |    6 +
 ...entsInGenericFunctionTypedArgument.symbols |    2 +
 .../reference/topLevelLambda2.symbols         |    1 +
 .../reference/topLevelLambda3.symbols         |    1 +
 .../reference/topLevelLambda4.symbols         |    1 +
 .../reference/trailingCommasES3.symbols       |    4 +
 .../reference/trailingCommasES5.symbols       |    4 +
 tests/baselines/reference/tsxEmit1.symbols    |    4 +
 .../tsxGenericArrowFunctionParsing.symbols    |    2 +
 .../reference/tsxInArrowFunction.symbols      |    4 +
 .../baselines/reference/tsxReactEmit1.symbols |   20 +
 .../baselines/reference/tsxTypeErrors.symbols |    2 +
 ...tationBestCommonTypeInArrayLiteral.symbols |    4 +
 .../reference/typeArgInference.symbols        |    1 +
 .../typeArgInferenceWithNull.symbols          |    4 +
 ...typeArgumentsInFunctionExpressions.symbols |    2 +
 .../reference/typeGuardFunction.symbols       |    2 +
 .../reference/typeGuardsDefeat.symbols        |    2 +
 .../reference/typeGuardsInFunction.symbols    |    2 +
 ...typeGuardsInFunctionAndModuleBlock.symbols |    5 +
 .../reference/typeGuardsObjectMethods.symbols |    1 +
 .../reference/typeInferenceFixEarly.symbols   |    1 +
 .../typeInferenceReturnTypeCallback.symbols   |    1 +
 .../typeInferenceWithTypeAnnotation.symbols   |    1 +
 .../reference/typeLiteralCallback.symbols     |    2 +
 .../typeOfThisInFunctionExpression.symbols    |    6 +
 ...ypeParameterConstraintTransitively.symbols |    8 +
 ...peParameterConstraintTransitively2.symbols |    7 +
 ...erCompatibilityAccrossDeclarations.symbols |    4 +
 ...typeParameterFixingWithConstraints.symbols |    3 +
 ...ixingWithContextSensitiveArguments.symbols |    3 +
 ...xingWithContextSensitiveArguments4.symbols |    2 +
 ...xingWithContextSensitiveArguments5.symbols |    2 +
 ...peParametersAvailableInNestedScope.symbols |    1 +
 tests/baselines/reference/typeVal.symbols     |    1 +
 .../reference/typeofInterface.symbols         |    1 +
 .../typeofOperatorWithBooleanType.symbols     |    2 +
 .../typeofOperatorWithNumberType.symbols      |    4 +
 .../typeofOperatorWithStringType.symbols      |    4 +
 .../typesWithOptionalProperty.symbols         |    4 +
 .../reference/uncaughtCompilerError1.symbols  |    2 +
 .../undefinedArgumentInference.symbols        |    1 +
 .../reference/underscoreTest1.symbols         |   75 +
 .../untypedArgumentInLambdaExpression.symbols |    1 +
 .../reference/unusedImportDeclaration.symbols |    1 +
 .../validMultipleVariableDeclarations.symbols |    7 +
 .../reference/validUseOfThisInSuper.symbols   |    1 +
 .../reference/varArgParamTypeCheck.symbols    |    5 +
 .../varInFunctionInVarInitializer.symbols     |    1 +
 tests/baselines/reference/vardecl.symbols     |    2 +
 .../reference/variableDeclarator1.symbols     |    1 +
 .../voidFunctionAssignmentCompat.symbols      |   14 +
 .../voidOperatorWithBooleanType.symbols       |    1 +
 .../voidOperatorWithNumberType.symbols        |    3 +
 .../voidOperatorWithStringType.symbols        |    3 +
 .../reference/whileBreakStatements.symbols    |    1 +
 .../reference/whileContinueStatements.symbols |    1 +
 .../baselines/reference/widenedTypes1.symbols |    3 +
 .../reference/withImportDecl.symbols          |    3 +
 .../wrappedAndRecursiveConstraints3.symbols   |    3 +
 760 files changed, 9898 insertions(+), 2 deletions(-)
 create mode 100644 tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.symbols
 create mode 100644 tests/baselines/reference/declFileTypeAnnotationVisibilityErrorParameterOfFunction.symbols
 create mode 100644 tests/baselines/reference/declarationEmitDefaultExport7.symbols
 create mode 100644 tests/baselines/reference/declarationEmitDestructuringPrivacyError.symbols
 create mode 100644 tests/baselines/reference/privacyAccessorDeclFile.symbols
 create mode 100644 tests/baselines/reference/privacyCannotNameAccessorDeclFile.symbols
 create mode 100644 tests/baselines/reference/privacyCannotNameVarTypeDeclFile.symbols
 create mode 100644 tests/baselines/reference/privacyClassExtendsClauseDeclFile.symbols
 create mode 100644 tests/baselines/reference/privacyClassImplementsClauseDeclFile.symbols
 create mode 100644 tests/baselines/reference/privacyFunctionCannotNameParameterTypeDeclFile.symbols
 create mode 100644 tests/baselines/reference/privacyFunctionCannotNameReturnTypeDeclFile.symbols
 create mode 100644 tests/baselines/reference/privacyFunctionParameterDeclFile.symbols
 create mode 100644 tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.symbols
 create mode 100644 tests/baselines/reference/privacyLocalInternalReferenceImportWithExport.symbols
 create mode 100644 tests/baselines/reference/privacyTopLevelInternalReferenceImportWithExport.symbols

diff --git a/tests/baselines/reference/2dArrays.symbols b/tests/baselines/reference/2dArrays.symbols
index c069f2dae8c9d..a1123888f4f93 100644
--- a/tests/baselines/reference/2dArrays.symbols
+++ b/tests/baselines/reference/2dArrays.symbols
@@ -30,6 +30,7 @@ class Board {
 >this : Symbol(Board, Decl(2dArrays.ts, 5, 1))
 >ships : Symbol(ships, Decl(2dArrays.ts, 7, 13))
 >every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
+>function (val) { return val.isSunk; } : Symbol((Anonymous function), Decl(2dArrays.ts, 12, 32))
 >val : Symbol(val, Decl(2dArrays.ts, 12, 42))
 >val.isSunk : Symbol(Ship.isSunk, Decl(2dArrays.ts, 3, 12))
 >val : Symbol(val, Decl(2dArrays.ts, 12, 42))
diff --git a/tests/baselines/reference/AmbientModuleAndNonAmbientFunctionWithTheSameNameAndCommonRoot.symbols b/tests/baselines/reference/AmbientModuleAndNonAmbientFunctionWithTheSameNameAndCommonRoot.symbols
index ccb8662712faa..c5fca19c76f18 100644
--- a/tests/baselines/reference/AmbientModuleAndNonAmbientFunctionWithTheSameNameAndCommonRoot.symbols
+++ b/tests/baselines/reference/AmbientModuleAndNonAmbientFunctionWithTheSameNameAndCommonRoot.symbols
@@ -13,6 +13,7 @@ function Point() {
 >Point : Symbol(Point, Decl(module.d.ts, 0, 0), Decl(function.ts, 0, 0))
 
     return { x: 0, y: 0 };
+>{ x: 0, y: 0 } : Symbol(, Decl(function.ts, 1, 10))
 >x : Symbol(x, Decl(function.ts, 1, 12))
 >y : Symbol(y, Decl(function.ts, 1, 18))
 }
diff --git a/tests/baselines/reference/ArrowFunction4.symbols b/tests/baselines/reference/ArrowFunction4.symbols
index cd19b8cdac9d1..70abc1151373d 100644
--- a/tests/baselines/reference/ArrowFunction4.symbols
+++ b/tests/baselines/reference/ArrowFunction4.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrowFunctions/ArrowFunction4.ts ===
 var v = (a, b) => {
 >v : Symbol(v, Decl(ArrowFunction4.ts, 0, 3))
+>(a, b) => {   } : Symbol((Anonymous function), Decl(ArrowFunction4.ts, 0, 7))
 >a : Symbol(a, Decl(ArrowFunction4.ts, 0, 9))
 >b : Symbol(b, Decl(ArrowFunction4.ts, 0, 11))
    
diff --git a/tests/baselines/reference/ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.symbols b/tests/baselines/reference/ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.symbols
index 1c75c33a278ff..e006b55595243 100644
--- a/tests/baselines/reference/ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.symbols
+++ b/tests/baselines/reference/ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.symbols
@@ -9,6 +9,7 @@ class Point {
     static Origin(): Point { return { x: 0, y: 0 }; }
 >Origin : Symbol(Point.Origin, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 1, 55))
 >Point : Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 0, 0), Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 4, 1))
+>{ x: 0, y: 0 } : Symbol(, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 3, 35))
 >x : Symbol(x, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 3, 37))
 >y : Symbol(y, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 3, 43))
 }
@@ -34,6 +35,7 @@ module A {
         static Origin(): Point { return { x: 0, y: 0 }; }
 >Origin : Symbol(Point.Origin, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 13, 59))
 >Point : Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 11, 10), Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 16, 5))
+>{ x: 0, y: 0 } : Symbol(, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 15, 39))
 >x : Symbol(x, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 15, 41))
 >y : Symbol(y, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 15, 47))
     }
diff --git a/tests/baselines/reference/ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.symbols b/tests/baselines/reference/ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.symbols
index 046b92fd6eed6..56c0f0d589188 100644
--- a/tests/baselines/reference/ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.symbols
+++ b/tests/baselines/reference/ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.symbols
@@ -9,6 +9,7 @@ class Point {
     static Origin: Point = { x: 0, y: 0 };
 >Origin : Symbol(Point.Origin, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 1, 55))
 >Point : Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 0, 0), Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 4, 1))
+>{ x: 0, y: 0 } : Symbol(, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 3, 26))
 >x : Symbol(x, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 3, 28))
 >y : Symbol(y, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 3, 34))
 }
@@ -34,6 +35,7 @@ module A {
         static Origin: Point = { x: 0, y: 0 };
 >Origin : Symbol(Point.Origin, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 13, 59))
 >Point : Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 11, 10), Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 16, 5))
+>{ x: 0, y: 0 } : Symbol(, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 15, 30))
 >x : Symbol(x, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 15, 32))
 >y : Symbol(y, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 15, 38))
     }
diff --git a/tests/baselines/reference/ES5For-of10.symbols b/tests/baselines/reference/ES5For-of10.symbols
index 302db0a5ec7a6..7bb66d0ab083a 100644
--- a/tests/baselines/reference/ES5For-of10.symbols
+++ b/tests/baselines/reference/ES5For-of10.symbols
@@ -3,6 +3,7 @@ function foo() {
 >foo : Symbol(foo, Decl(ES5For-of10.ts, 0, 0))
 
     return { x: 0 };
+>{ x: 0 } : Symbol(, Decl(ES5For-of10.ts, 1, 10))
 >x : Symbol(x, Decl(ES5For-of10.ts, 1, 12))
 }
 for (foo().x of []) {
diff --git a/tests/baselines/reference/ES5For-of9.symbols b/tests/baselines/reference/ES5For-of9.symbols
index 426a5442ecbd5..7712a10d3b1af 100644
--- a/tests/baselines/reference/ES5For-of9.symbols
+++ b/tests/baselines/reference/ES5For-of9.symbols
@@ -3,6 +3,7 @@ function foo() {
 >foo : Symbol(foo, Decl(ES5For-of9.ts, 0, 0))
 
     return { x: 0 };
+>{ x: 0 } : Symbol(, Decl(ES5For-of9.ts, 1, 10))
 >x : Symbol(x, Decl(ES5For-of9.ts, 1, 12))
 }
 for (foo().x of []) {
diff --git a/tests/baselines/reference/ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.symbols b/tests/baselines/reference/ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.symbols
index 2802e6aa3921e..df8cdce648191 100644
--- a/tests/baselines/reference/ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.symbols
+++ b/tests/baselines/reference/ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.symbols
@@ -15,6 +15,7 @@ module A {
     export var Origin: Point = { x: 0, y: 0 };
 >Origin : Symbol(Origin, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 14))
 >Point : Symbol(Point, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 0, 10))
+>{ x: 0, y: 0 } : Symbol(, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 30))
 >x : Symbol(x, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 32))
 >y : Symbol(y, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 38))
 
@@ -29,6 +30,7 @@ module A {
     export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
 >Origin3d : Symbol(Origin3d, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 14))
 >Point3d : Symbol(Point3d, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 46))
+>{ x: 0, y: 0, z: 0 } : Symbol(, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 34))
 >x : Symbol(x, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 36))
 >y : Symbol(y, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 42))
 >z : Symbol(z, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 48))
diff --git a/tests/baselines/reference/ExportClassWithInaccessibleTypeInTypeParameterConstraint.symbols b/tests/baselines/reference/ExportClassWithInaccessibleTypeInTypeParameterConstraint.symbols
index e1044bd2442d9..69bd69c8eab2b 100644
--- a/tests/baselines/reference/ExportClassWithInaccessibleTypeInTypeParameterConstraint.symbols
+++ b/tests/baselines/reference/ExportClassWithInaccessibleTypeInTypeParameterConstraint.symbols
@@ -15,6 +15,7 @@ module A {
     export var Origin: Point = { x: 0, y: 0 };
 >Origin : Symbol(Origin, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 14))
 >Point : Symbol(Point, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 0, 10))
+>{ x: 0, y: 0 } : Symbol(, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 30))
 >x : Symbol(x, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 32))
 >y : Symbol(y, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 38))
 
@@ -29,6 +30,7 @@ module A {
     export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
 >Origin3d : Symbol(Origin3d, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 14))
 >Point3d : Symbol(Point3d, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 46))
+>{ x: 0, y: 0, z: 0 } : Symbol(, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 34))
 >x : Symbol(x, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 36))
 >y : Symbol(y, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 42))
 >z : Symbol(z, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 48))
diff --git a/tests/baselines/reference/ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.symbols b/tests/baselines/reference/ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.symbols
index 37b6da18c375c..dd8bec1e65308 100644
--- a/tests/baselines/reference/ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.symbols
+++ b/tests/baselines/reference/ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.symbols
@@ -30,6 +30,7 @@ module A {
 
         return new Line({ x: 0, y: 0 }, p);
 >Line : Symbol(Line, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 5, 5))
+>{ x: 0, y: 0 } : Symbol(, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 12, 24))
 >x : Symbol(x, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 12, 25))
 >y : Symbol(y, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 12, 31))
 >p : Symbol(p, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 11, 31))
diff --git a/tests/baselines/reference/ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.symbols b/tests/baselines/reference/ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.symbols
index 41993ebf48fef..fa99b4f38a149 100644
--- a/tests/baselines/reference/ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.symbols
+++ b/tests/baselines/reference/ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.symbols
@@ -30,6 +30,7 @@ module A {
 
         return new Line({ x: 0, y: 0 }, p);
 >Line : Symbol(Line, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 5, 5))
+>{ x: 0, y: 0 } : Symbol(, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 12, 24))
 >x : Symbol(x, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 12, 25))
 >y : Symbol(y, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 12, 31))
 >p : Symbol(p, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 11, 31))
diff --git a/tests/baselines/reference/ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.symbols b/tests/baselines/reference/ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.symbols
index 77d5721579515..54835e551ffeb 100644
--- a/tests/baselines/reference/ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.symbols
+++ b/tests/baselines/reference/ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.symbols
@@ -30,6 +30,7 @@ module A {
 
         return new Line({ x: 0, y: 0 }, p);
 >Line : Symbol(Line, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 5, 5))
+>{ x: 0, y: 0 } : Symbol(, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 12, 24))
 >x : Symbol(x, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 12, 25))
 >y : Symbol(y, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 12, 31))
 >p : Symbol(p, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 11, 31))
diff --git a/tests/baselines/reference/ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.symbols b/tests/baselines/reference/ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.symbols
index 31b978c85f934..eaa42d6fbaac3 100644
--- a/tests/baselines/reference/ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.symbols
+++ b/tests/baselines/reference/ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.symbols
@@ -15,6 +15,7 @@ module A {
     export var Origin: Point = { x: 0, y: 0 };
 >Origin : Symbol(Origin, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 14))
 >Point : Symbol(Point, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 0, 10))
+>{ x: 0, y: 0 } : Symbol(, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 30))
 >x : Symbol(x, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 32))
 >y : Symbol(y, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 38))
 
@@ -29,6 +30,7 @@ module A {
     export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
 >Origin3d : Symbol(Origin3d, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 14))
 >Point3d : Symbol(Point3d, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 46))
+>{ x: 0, y: 0, z: 0 } : Symbol(, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 34))
 >x : Symbol(x, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 36))
 >y : Symbol(y, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 42))
 >z : Symbol(z, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 48))
diff --git a/tests/baselines/reference/ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.symbols b/tests/baselines/reference/ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.symbols
index 7ee70a0c77bbe..169f5ff240679 100644
--- a/tests/baselines/reference/ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.symbols
+++ b/tests/baselines/reference/ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.symbols
@@ -15,6 +15,7 @@ module A {
     export var Origin: Point = { x: 0, y: 0 };
 >Origin : Symbol(Origin, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 14))
 >Point : Symbol(Point, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 0, 10))
+>{ x: 0, y: 0 } : Symbol(, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 30))
 >x : Symbol(x, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 32))
 >y : Symbol(y, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 38))
 
@@ -29,6 +30,7 @@ module A {
     export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
 >Origin3d : Symbol(Origin3d, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 14))
 >Point3d : Symbol(Point3d, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 46))
+>{ x: 0, y: 0, z: 0 } : Symbol(, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 34))
 >x : Symbol(x, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 36))
 >y : Symbol(y, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 42))
 >z : Symbol(z, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 48))
diff --git a/tests/baselines/reference/ExportModuleWithAccessibleTypesOnItsExportedMembers.symbols b/tests/baselines/reference/ExportModuleWithAccessibleTypesOnItsExportedMembers.symbols
index acf6a1caef4c8..a6ba88fb27c6a 100644
--- a/tests/baselines/reference/ExportModuleWithAccessibleTypesOnItsExportedMembers.symbols
+++ b/tests/baselines/reference/ExportModuleWithAccessibleTypesOnItsExportedMembers.symbols
@@ -36,6 +36,7 @@ module A {
 
                 return new Line({ x: 0, y: 0 }, p);
 >Line : Symbol(Line, Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts, 7, 51))
+>{ x: 0, y: 0 } : Symbol(, Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts, 15, 32))
 >x : Symbol(x, Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts, 15, 33))
 >y : Symbol(y, Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts, 15, 39))
 >p : Symbol(p, Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts, 14, 30))
diff --git a/tests/baselines/reference/ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.symbols b/tests/baselines/reference/ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.symbols
index dccc613aca931..2e7410e19a45c 100644
--- a/tests/baselines/reference/ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.symbols
+++ b/tests/baselines/reference/ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.symbols
@@ -13,11 +13,13 @@ module A {
     export var Origin: Point = { x: 0, y: 0 };
 >Origin : Symbol(Origin, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 6, 14))
 >Point : Symbol(Point, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 0, 10))
+>{ x: 0, y: 0 } : Symbol(, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 6, 30))
 >x : Symbol(x, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 6, 32))
 >y : Symbol(y, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 6, 38))
 
     export var Unity = { start: new Point(0, 0), end: new Point(1, 0) };
 >Unity : Symbol(Unity, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 8, 14))
+>{ start: new Point(0, 0), end: new Point(1, 0) } : Symbol(, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 8, 22))
 >start : Symbol(start, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 8, 24))
 >Point : Symbol(Point, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 0, 10))
 >end : Symbol(end, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 8, 48))
diff --git a/tests/baselines/reference/ExportVariableWithAccessibleTypeInTypeAnnotation.symbols b/tests/baselines/reference/ExportVariableWithAccessibleTypeInTypeAnnotation.symbols
index 55ba5fd0cf348..600bcc08a2d80 100644
--- a/tests/baselines/reference/ExportVariableWithAccessibleTypeInTypeAnnotation.symbols
+++ b/tests/baselines/reference/ExportVariableWithAccessibleTypeInTypeAnnotation.symbols
@@ -16,6 +16,7 @@ module A {
     export var Origin: Point = { x: 0, y: 0 };
 >Origin : Symbol(Origin, Decl(ExportVariableWithAccessibleTypeInTypeAnnotation.ts, 8, 14))
 >Point : Symbol(Point, Decl(ExportVariableWithAccessibleTypeInTypeAnnotation.ts, 0, 10))
+>{ x: 0, y: 0 } : Symbol(, Decl(ExportVariableWithAccessibleTypeInTypeAnnotation.ts, 8, 30))
 >x : Symbol(x, Decl(ExportVariableWithAccessibleTypeInTypeAnnotation.ts, 8, 32))
 >y : Symbol(y, Decl(ExportVariableWithAccessibleTypeInTypeAnnotation.ts, 8, 38))
 }
diff --git a/tests/baselines/reference/ExportVariableWithInaccessibleTypeInTypeAnnotation.symbols b/tests/baselines/reference/ExportVariableWithInaccessibleTypeInTypeAnnotation.symbols
index ac43ccea789a3..b1b8bb2e97f22 100644
--- a/tests/baselines/reference/ExportVariableWithInaccessibleTypeInTypeAnnotation.symbols
+++ b/tests/baselines/reference/ExportVariableWithInaccessibleTypeInTypeAnnotation.symbols
@@ -16,6 +16,7 @@ module A {
     export var Origin: Point = { x: 0, y: 0 };
 >Origin : Symbol(Origin, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 8, 14))
 >Point : Symbol(Point, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 0, 10))
+>{ x: 0, y: 0 } : Symbol(, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 8, 30))
 >x : Symbol(x, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 8, 32))
 >y : Symbol(y, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 8, 38))
 
@@ -31,6 +32,7 @@ module A {
     export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
 >Origin3d : Symbol(Origin3d, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 15, 14))
 >Point3d : Symbol(Point3d, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 8, 46))
+>{ x: 0, y: 0, z: 0 } : Symbol(, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 15, 34))
 >x : Symbol(x, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 15, 36))
 >y : Symbol(y, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 15, 42))
 >z : Symbol(z, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 15, 48))
diff --git a/tests/baselines/reference/FunctionAndModuleWithSameNameAndDifferentCommonRoot.symbols b/tests/baselines/reference/FunctionAndModuleWithSameNameAndDifferentCommonRoot.symbols
index 96963246d26d9..090eadfa60b3b 100644
--- a/tests/baselines/reference/FunctionAndModuleWithSameNameAndDifferentCommonRoot.symbols
+++ b/tests/baselines/reference/FunctionAndModuleWithSameNameAndDifferentCommonRoot.symbols
@@ -6,6 +6,7 @@ module A {
 >Point : Symbol(Point, Decl(function.ts, 0, 10))
 
         return { x: 0, y: 0 };
+>{ x: 0, y: 0 } : Symbol(, Decl(function.ts, 2, 14))
 >x : Symbol(x, Decl(function.ts, 2, 16))
 >y : Symbol(y, Decl(function.ts, 2, 22))
     }
@@ -20,6 +21,7 @@ module B {
 
         export var Origin = { x: 0, y: 0 };
 >Origin : Symbol(Origin, Decl(module.ts, 2, 18))
+>{ x: 0, y: 0 } : Symbol(, Decl(module.ts, 2, 27))
 >x : Symbol(x, Decl(module.ts, 2, 29))
 >y : Symbol(y, Decl(module.ts, 2, 35))
     }
diff --git a/tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.symbols b/tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.symbols
index c9e2c124e9d0a..45ca47dfc375c 100644
--- a/tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.symbols
+++ b/tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.symbols
@@ -26,6 +26,7 @@ module A {
 >Point : Symbol(Point, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 0, 10))
 
             return { x: p.x, y: p.y };
+>{ x: p.x, y: p.y } : Symbol(, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 10, 18))
 >x : Symbol(x, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 10, 20))
 >p.x : Symbol(Point.x, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 1, 24))
 >p : Symbol(p, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 9, 23))
diff --git a/tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedLocalVarsOfTheSameName.symbols b/tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedLocalVarsOfTheSameName.symbols
index b7402952dff61..8135100bfae4b 100644
--- a/tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedLocalVarsOfTheSameName.symbols
+++ b/tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedLocalVarsOfTheSameName.symbols
@@ -23,6 +23,7 @@ module A {
 >T : Symbol(T, Decl(part1.ts, 7, 31))
 
             return { x: p.y, y: p.x };
+>{ x: p.y, y: p.x } : Symbol(, Decl(part1.ts, 8, 18))
 >x : Symbol(x, Decl(part1.ts, 8, 20))
 >p.y : Symbol(Point.y, Decl(part1.ts, 2, 18))
 >p : Symbol(p, Decl(part1.ts, 7, 48))
@@ -36,6 +37,7 @@ module A {
     export var Origin: Point = { x: 0, y: 0 };
 >Origin : Symbol(Origin, Decl(part1.ts, 11, 14))
 >Point : Symbol(Point, Decl(part1.ts, 0, 10))
+>{ x: 0, y: 0 } : Symbol(, Decl(part1.ts, 11, 30))
 >x : Symbol(x, Decl(part1.ts, 11, 32))
 >y : Symbol(y, Decl(part1.ts, 11, 38))
 }
@@ -114,6 +116,7 @@ var p = new A.Utils.Plane(o, { x: 1, y: 1 });
 >Utils : Symbol(A.Utils, Decl(part1.ts, 4, 5), Decl(part2.ts, 2, 31))
 >Plane : Symbol(A.Utils.Plane, Decl(part2.ts, 4, 25))
 >o : Symbol(o, Decl(part3.ts, 2, 3), Decl(part3.ts, 3, 3), Decl(part3.ts, 4, 3), Decl(part3.ts, 5, 3))
+>{ x: 1, y: 1 } : Symbol(, Decl(part3.ts, 9, 28))
 >x : Symbol(x, Decl(part3.ts, 9, 30))
 >y : Symbol(y, Decl(part3.ts, 9, 36))
 
diff --git a/tests/baselines/reference/TwoInternalModulesWithTheSameNameAndDifferentCommonRoot.symbols b/tests/baselines/reference/TwoInternalModulesWithTheSameNameAndDifferentCommonRoot.symbols
index 5c533273fa68e..b71ceddd77575 100644
--- a/tests/baselines/reference/TwoInternalModulesWithTheSameNameAndDifferentCommonRoot.symbols
+++ b/tests/baselines/reference/TwoInternalModulesWithTheSameNameAndDifferentCommonRoot.symbols
@@ -26,6 +26,7 @@ module Root {
 >T : Symbol(T, Decl(part1.ts, 8, 35))
 
                 return { x: p.y, y: p.x };
+>{ x: p.y, y: p.x } : Symbol(, Decl(part1.ts, 9, 22))
 >x : Symbol(x, Decl(part1.ts, 9, 24))
 >p.y : Symbol(Point.y, Decl(part1.ts, 3, 22))
 >p : Symbol(p, Decl(part1.ts, 8, 52))
@@ -52,6 +53,7 @@ module otherRoot {
 >Root : Symbol(Root, Decl(part1.ts, 0, 0))
 >A : Symbol(Root.A, Decl(part1.ts, 0, 13))
 >Point : Symbol(Root.A.Point, Decl(part1.ts, 1, 21))
+>{ x: 0, y: 0 } : Symbol(, Decl(part2.ts, 3, 41))
 >x : Symbol(x, Decl(part2.ts, 3, 43))
 >y : Symbol(y, Decl(part2.ts, 3, 49))
 
diff --git a/tests/baselines/reference/TwoInternalModulesWithTheSameNameAndSameCommonRoot.symbols b/tests/baselines/reference/TwoInternalModulesWithTheSameNameAndSameCommonRoot.symbols
index 34abd4ecd65d5..d334b85a91db0 100644
--- a/tests/baselines/reference/TwoInternalModulesWithTheSameNameAndSameCommonRoot.symbols
+++ b/tests/baselines/reference/TwoInternalModulesWithTheSameNameAndSameCommonRoot.symbols
@@ -23,6 +23,7 @@ module A {
 >T : Symbol(T, Decl(part1.ts, 7, 31))
 
             return { x: p.y, y: p.x };
+>{ x: p.y, y: p.x } : Symbol(, Decl(part1.ts, 8, 18))
 >x : Symbol(x, Decl(part1.ts, 8, 20))
 >p.y : Symbol(Point.y, Decl(part1.ts, 2, 18))
 >p : Symbol(p, Decl(part1.ts, 7, 48))
@@ -42,6 +43,7 @@ module A {
     export var Origin: Point = { x: 0, y: 0 };
 >Origin : Symbol(Origin, Decl(part2.ts, 1, 14))
 >Point : Symbol(Point, Decl(part1.ts, 0, 10))
+>{ x: 0, y: 0 } : Symbol(, Decl(part2.ts, 1, 30))
 >x : Symbol(x, Decl(part2.ts, 1, 32))
 >y : Symbol(y, Decl(part2.ts, 1, 38))
 
@@ -111,6 +113,7 @@ var p = new A.Utils.Plane(o, { x: 1, y: 1 });
 >Utils : Symbol(A.Utils, Decl(part1.ts, 4, 5), Decl(part2.ts, 1, 46))
 >Plane : Symbol(A.Utils.Plane, Decl(part2.ts, 3, 25))
 >o : Symbol(o, Decl(part3.ts, 2, 3), Decl(part3.ts, 3, 3), Decl(part3.ts, 4, 3), Decl(part3.ts, 5, 3))
+>{ x: 1, y: 1 } : Symbol(, Decl(part3.ts, 9, 28))
 >x : Symbol(x, Decl(part3.ts, 9, 30))
 >y : Symbol(y, Decl(part3.ts, 9, 36))
 
diff --git a/tests/baselines/reference/accessorWithES5.symbols b/tests/baselines/reference/accessorWithES5.symbols
index dccbd8180bb5d..a1529ee1797dc 100644
--- a/tests/baselines/reference/accessorWithES5.symbols
+++ b/tests/baselines/reference/accessorWithES5.symbols
@@ -21,6 +21,7 @@ class D {
 
 var x = {
 >x : Symbol(x, Decl(accessorWithES5.ts, 12, 3))
+>{    get a() { return 1 }} : Symbol(, Decl(accessorWithES5.ts, 12, 7))
 
     get a() { return 1 }
 >a : Symbol(a, Decl(accessorWithES5.ts, 12, 9))
@@ -28,6 +29,7 @@ var x = {
 
 var y = {
 >y : Symbol(y, Decl(accessorWithES5.ts, 16, 3))
+>{    set b(v) { }} : Symbol(, Decl(accessorWithES5.ts, 16, 7))
 
     set b(v) { }
 >b : Symbol(b, Decl(accessorWithES5.ts, 16, 9))
diff --git a/tests/baselines/reference/additionOperatorWithAnyAndEveryType.symbols b/tests/baselines/reference/additionOperatorWithAnyAndEveryType.symbols
index eff45630aae8e..0ad3373bde4f8 100644
--- a/tests/baselines/reference/additionOperatorWithAnyAndEveryType.symbols
+++ b/tests/baselines/reference/additionOperatorWithAnyAndEveryType.symbols
@@ -133,11 +133,13 @@ var r18 = a + 123;
 var r19 = a + { a: '' };
 >r19 : Symbol(r19, Decl(additionOperatorWithAnyAndEveryType.ts, 37, 3))
 >a : Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 8, 3))
+>{ a: '' } : Symbol(, Decl(additionOperatorWithAnyAndEveryType.ts, 37, 13))
 >a : Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 37, 15))
 
 var r20 = a + ((a: string) => { return a });
 >r20 : Symbol(r20, Decl(additionOperatorWithAnyAndEveryType.ts, 38, 3))
 >a : Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 8, 3))
+>(a: string) => { return a } : Symbol((Anonymous function), Decl(additionOperatorWithAnyAndEveryType.ts, 38, 15))
 >a : Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 38, 16))
 >a : Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 38, 16))
 
diff --git a/tests/baselines/reference/additionOperatorWithStringAndEveryType.symbols b/tests/baselines/reference/additionOperatorWithStringAndEveryType.symbols
index 0fb0f428716b4..1b8a1c5d50acc 100644
--- a/tests/baselines/reference/additionOperatorWithStringAndEveryType.symbols
+++ b/tests/baselines/reference/additionOperatorWithStringAndEveryType.symbols
@@ -128,6 +128,7 @@ var r18 = x + 0;
 var r19 = x + { a: '' };
 >r19 : Symbol(r19, Decl(additionOperatorWithStringAndEveryType.ts, 36, 3))
 >x : Symbol(x, Decl(additionOperatorWithStringAndEveryType.ts, 10, 3))
+>{ a: '' } : Symbol(, Decl(additionOperatorWithStringAndEveryType.ts, 36, 13))
 >a : Symbol(a, Decl(additionOperatorWithStringAndEveryType.ts, 36, 15))
 
 var r20 = x + [];
diff --git a/tests/baselines/reference/aliasUsageInFunctionExpression.symbols b/tests/baselines/reference/aliasUsageInFunctionExpression.symbols
index 2afb6be55c557..8f12b3d3390af 100644
--- a/tests/baselines/reference/aliasUsageInFunctionExpression.symbols
+++ b/tests/baselines/reference/aliasUsageInFunctionExpression.symbols
@@ -16,12 +16,14 @@ interface IHasVisualizationModel {
 }
 var f = (x: IHasVisualizationModel) => x;
 >f : Symbol(f, Decl(aliasUsageInFunctionExpression_main.ts, 5, 3))
+>(x: IHasVisualizationModel) => x : Symbol((Anonymous function), Decl(aliasUsageInFunctionExpression_main.ts, 5, 7))
 >x : Symbol(x, Decl(aliasUsageInFunctionExpression_main.ts, 5, 9))
 >IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInFunctionExpression_main.ts, 1, 67))
 >x : Symbol(x, Decl(aliasUsageInFunctionExpression_main.ts, 5, 9))
 
 f = (x) => moduleA;
 >f : Symbol(f, Decl(aliasUsageInFunctionExpression_main.ts, 5, 3))
+>(x) => moduleA : Symbol((Anonymous function), Decl(aliasUsageInFunctionExpression_main.ts, 6, 3))
 >x : Symbol(x, Decl(aliasUsageInFunctionExpression_main.ts, 6, 5))
 >moduleA : Symbol(moduleA, Decl(aliasUsageInFunctionExpression_main.ts, 0, 69))
 
diff --git a/tests/baselines/reference/aliasUsageInGenericFunction.symbols b/tests/baselines/reference/aliasUsageInGenericFunction.symbols
index 3f001e8bd1a98..bf67e5d8ad8f3 100644
--- a/tests/baselines/reference/aliasUsageInGenericFunction.symbols
+++ b/tests/baselines/reference/aliasUsageInGenericFunction.symbols
@@ -28,12 +28,14 @@ function foo<T extends { a: IHasVisualizationModel }>(x: T) {
 var r = foo({ a: moduleA });
 >r : Symbol(r, Decl(aliasUsageInGenericFunction_main.ts, 8, 3))
 >foo : Symbol(foo, Decl(aliasUsageInGenericFunction_main.ts, 4, 1))
+>{ a: moduleA } : Symbol(, Decl(aliasUsageInGenericFunction_main.ts, 8, 12))
 >a : Symbol(a, Decl(aliasUsageInGenericFunction_main.ts, 8, 13))
 >moduleA : Symbol(moduleA, Decl(aliasUsageInGenericFunction_main.ts, 0, 66))
 
 var r2 = foo({ a: <IHasVisualizationModel>null });
 >r2 : Symbol(r2, Decl(aliasUsageInGenericFunction_main.ts, 9, 3))
 >foo : Symbol(foo, Decl(aliasUsageInGenericFunction_main.ts, 4, 1))
+>{ a: <IHasVisualizationModel>null } : Symbol(, Decl(aliasUsageInGenericFunction_main.ts, 9, 13))
 >a : Symbol(a, Decl(aliasUsageInGenericFunction_main.ts, 9, 14))
 >IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInGenericFunction_main.ts, 1, 64))
 
diff --git a/tests/baselines/reference/aliasUsageInObjectLiteral.symbols b/tests/baselines/reference/aliasUsageInObjectLiteral.symbols
index a508e9fafc173..8b18f768285c1 100644
--- a/tests/baselines/reference/aliasUsageInObjectLiteral.symbols
+++ b/tests/baselines/reference/aliasUsageInObjectLiteral.symbols
@@ -18,6 +18,7 @@ var a: { x: typeof moduleA } = { x: moduleA };
 >a : Symbol(a, Decl(aliasUsageInObjectLiteral_main.ts, 5, 3))
 >x : Symbol(x, Decl(aliasUsageInObjectLiteral_main.ts, 5, 8))
 >moduleA : Symbol(moduleA, Decl(aliasUsageInObjectLiteral_main.ts, 0, 64))
+>{ x: moduleA } : Symbol(, Decl(aliasUsageInObjectLiteral_main.ts, 5, 30))
 >x : Symbol(x, Decl(aliasUsageInObjectLiteral_main.ts, 5, 32))
 >moduleA : Symbol(moduleA, Decl(aliasUsageInObjectLiteral_main.ts, 0, 64))
 
@@ -25,6 +26,7 @@ var b: { x: IHasVisualizationModel } = { x: moduleA };
 >b : Symbol(b, Decl(aliasUsageInObjectLiteral_main.ts, 6, 3))
 >x : Symbol(x, Decl(aliasUsageInObjectLiteral_main.ts, 6, 8))
 >IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInObjectLiteral_main.ts, 1, 62))
+>{ x: moduleA } : Symbol(, Decl(aliasUsageInObjectLiteral_main.ts, 6, 38))
 >x : Symbol(x, Decl(aliasUsageInObjectLiteral_main.ts, 6, 40))
 >moduleA : Symbol(moduleA, Decl(aliasUsageInObjectLiteral_main.ts, 0, 64))
 
@@ -33,7 +35,9 @@ var c: { y: { z: IHasVisualizationModel } } = { y: { z: moduleA } };
 >y : Symbol(y, Decl(aliasUsageInObjectLiteral_main.ts, 7, 8))
 >z : Symbol(z, Decl(aliasUsageInObjectLiteral_main.ts, 7, 13))
 >IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInObjectLiteral_main.ts, 1, 62))
+>{ y: { z: moduleA } } : Symbol(, Decl(aliasUsageInObjectLiteral_main.ts, 7, 45))
 >y : Symbol(y, Decl(aliasUsageInObjectLiteral_main.ts, 7, 47))
+>{ z: moduleA } : Symbol(, Decl(aliasUsageInObjectLiteral_main.ts, 7, 50))
 >z : Symbol(z, Decl(aliasUsageInObjectLiteral_main.ts, 7, 52))
 >moduleA : Symbol(moduleA, Decl(aliasUsageInObjectLiteral_main.ts, 0, 64))
 
diff --git a/tests/baselines/reference/aliasUsageInOrExpression.symbols b/tests/baselines/reference/aliasUsageInOrExpression.symbols
index adfba01a1190c..2e628b6960850 100644
--- a/tests/baselines/reference/aliasUsageInOrExpression.symbols
+++ b/tests/baselines/reference/aliasUsageInOrExpression.symbols
@@ -41,6 +41,7 @@ var e: { x: IHasVisualizationModel } = <{ x: IHasVisualizationModel }>null || {
 >IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInOrExpression_main.ts, 1, 61))
 >x : Symbol(x, Decl(aliasUsageInOrExpression_main.ts, 9, 41))
 >IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInOrExpression_main.ts, 1, 61))
+>{ x: moduleA } : Symbol(, Decl(aliasUsageInOrExpression_main.ts, 9, 77))
 >x : Symbol(x, Decl(aliasUsageInOrExpression_main.ts, 9, 79))
 >moduleA : Symbol(moduleA, Decl(aliasUsageInOrExpression_main.ts, 0, 63))
 
@@ -50,6 +51,7 @@ var f: { x: IHasVisualizationModel } = <{ x: IHasVisualizationModel }>null ? { x
 >IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInOrExpression_main.ts, 1, 61))
 >x : Symbol(x, Decl(aliasUsageInOrExpression_main.ts, 10, 41))
 >IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInOrExpression_main.ts, 1, 61))
+>{ x: moduleA } : Symbol(, Decl(aliasUsageInOrExpression_main.ts, 10, 76))
 >x : Symbol(x, Decl(aliasUsageInOrExpression_main.ts, 10, 78))
 >moduleA : Symbol(moduleA, Decl(aliasUsageInOrExpression_main.ts, 0, 63))
 
diff --git a/tests/baselines/reference/aliasUsedAsNameValue.symbols b/tests/baselines/reference/aliasUsedAsNameValue.symbols
index a816e2b2c63e6..62e36c6c9076b 100644
--- a/tests/baselines/reference/aliasUsedAsNameValue.symbols
+++ b/tests/baselines/reference/aliasUsedAsNameValue.symbols
@@ -9,6 +9,7 @@ import b = require("aliasUsedAsNameValue_1");
  
 export var a = function () {
 >a : Symbol(a, Decl(aliasUsedAsNameValue_2.ts, 5, 10))
+>function () {    //var x = mod.id; // TODO needed hack that mod is loaded    b.b(mod);} : Symbol((Anonymous function), Decl(aliasUsedAsNameValue_2.ts, 5, 14))
 
     //var x = mod.id; // TODO needed hack that mod is loaded
     b.b(mod);
diff --git a/tests/baselines/reference/amdImportNotAsPrimaryExpression.symbols b/tests/baselines/reference/amdImportNotAsPrimaryExpression.symbols
index 68a852c6165aa..8748a877c0323 100644
--- a/tests/baselines/reference/amdImportNotAsPrimaryExpression.symbols
+++ b/tests/baselines/reference/amdImportNotAsPrimaryExpression.symbols
@@ -18,6 +18,7 @@ var x: foo.C1 = <{m1: number}>{};
 >foo : Symbol(foo, Decl(foo_1.ts, 0, 0))
 >C1 : Symbol(foo.C1, Decl(foo_0.ts, 0, 0))
 >m1 : Symbol(m1, Decl(foo_1.ts, 4, 18))
+>{} : Symbol(, Decl(foo_1.ts, 4, 30))
 
 var y: typeof foo.C1.s1 = false;
 >y : Symbol(y, Decl(foo_1.ts, 5, 3))
diff --git a/tests/baselines/reference/anonterface.symbols b/tests/baselines/reference/anonterface.symbols
index fccd48043cf01..ee3a9a6737c20 100644
--- a/tests/baselines/reference/anonterface.symbols
+++ b/tests/baselines/reference/anonterface.symbols
@@ -28,6 +28,7 @@ c.m(function(n) { return "hello: "+n; },18);
 >c.m : Symbol(M.C.m, Decl(anonterface.ts, 1, 20))
 >c : Symbol(c, Decl(anonterface.ts, 8, 3))
 >m : Symbol(M.C.m, Decl(anonterface.ts, 1, 20))
+>function(n) { return "hello: "+n; } : Symbol((Anonymous function), Decl(anonterface.ts, 9, 4))
 >n : Symbol(n, Decl(anonterface.ts, 9, 13))
 >n : Symbol(n, Decl(anonterface.ts, 9, 13))
 
diff --git a/tests/baselines/reference/anonymousClassExpression1.symbols b/tests/baselines/reference/anonymousClassExpression1.symbols
index 114bfc96097a2..25d7b9a1e0af5 100644
--- a/tests/baselines/reference/anonymousClassExpression1.symbols
+++ b/tests/baselines/reference/anonymousClassExpression1.symbols
@@ -3,4 +3,5 @@ function f() {
 >f : Symbol(f, Decl(anonymousClassExpression1.ts, 0, 0))
 
     return typeof class {} === "function";
+>class {} : Symbol((Anonymous class), Decl(anonymousClassExpression1.ts, 1, 17))
 }
diff --git a/tests/baselines/reference/anyInferenceAnonymousFunctions.symbols b/tests/baselines/reference/anyInferenceAnonymousFunctions.symbols
index daf7947e69437..8e3d27d33bfdb 100644
--- a/tests/baselines/reference/anyInferenceAnonymousFunctions.symbols
+++ b/tests/baselines/reference/anyInferenceAnonymousFunctions.symbols
@@ -6,11 +6,13 @@ paired.reduce(function (a1, a2) {
 >paired.reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120))
 >paired : Symbol(paired, Decl(anyInferenceAnonymousFunctions.ts, 0, 3))
 >reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120))
+>function (a1, a2) {    return a1.concat({});} : Symbol((Anonymous function), Decl(anyInferenceAnonymousFunctions.ts, 2, 14))
 >a1 : Symbol(a1, Decl(anyInferenceAnonymousFunctions.ts, 2, 24))
 >a2 : Symbol(a2, Decl(anyInferenceAnonymousFunctions.ts, 2, 27))
 
     return a1.concat({});
 >a1 : Symbol(a1, Decl(anyInferenceAnonymousFunctions.ts, 2, 24))
+>{} : Symbol(, Decl(anyInferenceAnonymousFunctions.ts, 4, 21))
 
 } , []);
 
@@ -18,11 +20,13 @@ paired.reduce((b1, b2) => {
 >paired.reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120))
 >paired : Symbol(paired, Decl(anyInferenceAnonymousFunctions.ts, 0, 3))
 >reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120))
+>(b1, b2) => {    return b1.concat({});} : Symbol((Anonymous function), Decl(anyInferenceAnonymousFunctions.ts, 8, 14))
 >b1 : Symbol(b1, Decl(anyInferenceAnonymousFunctions.ts, 8, 15))
 >b2 : Symbol(b2, Decl(anyInferenceAnonymousFunctions.ts, 8, 18))
 
     return b1.concat({});
 >b1 : Symbol(b1, Decl(anyInferenceAnonymousFunctions.ts, 8, 15))
+>{} : Symbol(, Decl(anyInferenceAnonymousFunctions.ts, 10, 21))
 
 } , []);
 
@@ -30,14 +34,17 @@ paired.reduce((b3, b4) => b3.concat({}), []);
 >paired.reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120))
 >paired : Symbol(paired, Decl(anyInferenceAnonymousFunctions.ts, 0, 3))
 >reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120))
+>(b3, b4) => b3.concat({}) : Symbol((Anonymous function), Decl(anyInferenceAnonymousFunctions.ts, 13, 14))
 >b3 : Symbol(b3, Decl(anyInferenceAnonymousFunctions.ts, 13, 15))
 >b4 : Symbol(b4, Decl(anyInferenceAnonymousFunctions.ts, 13, 18))
 >b3 : Symbol(b3, Decl(anyInferenceAnonymousFunctions.ts, 13, 15))
+>{} : Symbol(, Decl(anyInferenceAnonymousFunctions.ts, 13, 36))
 
 paired.map((c1) => c1.count);
 >paired.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
 >paired : Symbol(paired, Decl(anyInferenceAnonymousFunctions.ts, 0, 3))
 >map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>(c1) => c1.count : Symbol((Anonymous function), Decl(anyInferenceAnonymousFunctions.ts, 15, 11))
 >c1 : Symbol(c1, Decl(anyInferenceAnonymousFunctions.ts, 15, 12))
 >c1 : Symbol(c1, Decl(anyInferenceAnonymousFunctions.ts, 15, 12))
 
@@ -45,6 +52,7 @@ paired.map(function (c2) { return c2.count; });
 >paired.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
 >paired : Symbol(paired, Decl(anyInferenceAnonymousFunctions.ts, 0, 3))
 >map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>function (c2) { return c2.count; } : Symbol((Anonymous function), Decl(anyInferenceAnonymousFunctions.ts, 16, 11))
 >c2 : Symbol(c2, Decl(anyInferenceAnonymousFunctions.ts, 16, 21))
 >c2 : Symbol(c2, Decl(anyInferenceAnonymousFunctions.ts, 16, 21))
 
diff --git a/tests/baselines/reference/argumentsUsedInObjectLiteralProperty.symbols b/tests/baselines/reference/argumentsUsedInObjectLiteralProperty.symbols
index 1c3b54ef427e2..0da8f2dd87856 100644
--- a/tests/baselines/reference/argumentsUsedInObjectLiteralProperty.symbols
+++ b/tests/baselines/reference/argumentsUsedInObjectLiteralProperty.symbols
@@ -8,6 +8,8 @@ class A {
 >selectedValue : Symbol(selectedValue, Decl(argumentsUsedInObjectLiteralProperty.ts, 1, 63))
 
         return {
+>{            selectedValue: arguments.length        } : Symbol(, Decl(argumentsUsedInObjectLiteralProperty.ts, 2, 14))
+
             selectedValue: arguments.length
 >selectedValue : Symbol(selectedValue, Decl(argumentsUsedInObjectLiteralProperty.ts, 2, 16))
 >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, 272, 25))
diff --git a/tests/baselines/reference/arrayBestCommonTypes.symbols b/tests/baselines/reference/arrayBestCommonTypes.symbols
index c4b42f66991ab..03d5c0b342e66 100644
--- a/tests/baselines/reference/arrayBestCommonTypes.symbols
+++ b/tests/baselines/reference/arrayBestCommonTypes.symbols
@@ -121,9 +121,11 @@ module EmptyTypes {
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 31, 21))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 31, 32))
 >base : Symbol(base, Decl(arrayBestCommonTypes.ts, 1, 23))
+>{ x: 7, y: new derived() } : Symbol(, Decl(arrayBestCommonTypes.ts, 31, 49))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 31, 50))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 31, 56))
 >derived : Symbol(derived, Decl(arrayBestCommonTypes.ts, 3, 36))
+>{ x: 5, y: new base() } : Symbol(, Decl(arrayBestCommonTypes.ts, 31, 76))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 31, 78))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 31, 84))
 >base : Symbol(base, Decl(arrayBestCommonTypes.ts, 1, 23))
@@ -133,9 +135,11 @@ module EmptyTypes {
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 32, 21))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 32, 33))
 >base : Symbol(base, Decl(arrayBestCommonTypes.ts, 1, 23))
+>{ x: true, y: new derived() } : Symbol(, Decl(arrayBestCommonTypes.ts, 32, 50))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 32, 51))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 32, 60))
 >derived : Symbol(derived, Decl(arrayBestCommonTypes.ts, 3, 36))
+>{ x: false, y: new base() } : Symbol(, Decl(arrayBestCommonTypes.ts, 32, 80))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 32, 82))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 32, 92))
 >base : Symbol(base, Decl(arrayBestCommonTypes.ts, 1, 23))
@@ -145,10 +149,12 @@ module EmptyTypes {
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 33, 21))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 33, 32))
 >base : Symbol(base, Decl(arrayBestCommonTypes.ts, 1, 23))
+>{ x: undefined, y: new base() } : Symbol(, Decl(arrayBestCommonTypes.ts, 33, 49))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 33, 50))
 >undefined : Symbol(undefined)
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 33, 64))
 >base : Symbol(base, Decl(arrayBestCommonTypes.ts, 1, 23))
+>{ x: '', y: new derived() } : Symbol(, Decl(arrayBestCommonTypes.ts, 33, 81))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 33, 83))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 33, 90))
 >derived : Symbol(derived, Decl(arrayBestCommonTypes.ts, 3, 36))
@@ -159,31 +165,40 @@ module EmptyTypes {
             // Order matters here so test all the variants
             var a1 = [{ x: 0, y: 'a' }, { x: 'a', y: 'a' }, { x: anyObj, y: 'a' }];
 >a1 : Symbol(a1, Decl(arrayBestCommonTypes.ts, 37, 15))
+>{ x: 0, y: 'a' } : Symbol(, Decl(arrayBestCommonTypes.ts, 37, 22))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 37, 23))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 37, 29))
+>{ x: 'a', y: 'a' } : Symbol(, Decl(arrayBestCommonTypes.ts, 37, 39))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 37, 41))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 37, 49))
+>{ x: anyObj, y: 'a' } : Symbol(, Decl(arrayBestCommonTypes.ts, 37, 59))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 37, 61))
 >anyObj : Symbol(anyObj, Decl(arrayBestCommonTypes.ts, 35, 15))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 37, 72))
 
             var a2 = [{ x: anyObj, y: 'a' }, { x: 0, y: 'a' }, { x: 'a', y: 'a' }];
 >a2 : Symbol(a2, Decl(arrayBestCommonTypes.ts, 38, 15))
+>{ x: anyObj, y: 'a' } : Symbol(, Decl(arrayBestCommonTypes.ts, 38, 22))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 38, 23))
 >anyObj : Symbol(anyObj, Decl(arrayBestCommonTypes.ts, 35, 15))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 38, 34))
+>{ x: 0, y: 'a' } : Symbol(, Decl(arrayBestCommonTypes.ts, 38, 44))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 38, 46))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 38, 52))
+>{ x: 'a', y: 'a' } : Symbol(, Decl(arrayBestCommonTypes.ts, 38, 62))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 38, 64))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 38, 72))
 
             var a3 = [{ x: 0, y: 'a' }, { x: anyObj, y: 'a' }, { x: 'a', y: 'a' }];
 >a3 : Symbol(a3, Decl(arrayBestCommonTypes.ts, 39, 15))
+>{ x: 0, y: 'a' } : Symbol(, Decl(arrayBestCommonTypes.ts, 39, 22))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 39, 23))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 39, 29))
+>{ x: anyObj, y: 'a' } : Symbol(, Decl(arrayBestCommonTypes.ts, 39, 39))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 39, 41))
 >anyObj : Symbol(anyObj, Decl(arrayBestCommonTypes.ts, 35, 15))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 39, 52))
+>{ x: 'a', y: 'a' } : Symbol(, Decl(arrayBestCommonTypes.ts, 39, 62))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 39, 64))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 39, 72))
 
@@ -354,9 +369,11 @@ module NonEmptyTypes {
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 84, 21))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 84, 32))
 >base : Symbol(base, Decl(arrayBestCommonTypes.ts, 54, 34))
+>{ x: 7, y: new derived() } : Symbol(, Decl(arrayBestCommonTypes.ts, 84, 49))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 84, 50))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 84, 56))
 >derived : Symbol(derived, Decl(arrayBestCommonTypes.ts, 56, 58))
+>{ x: 5, y: new base() } : Symbol(, Decl(arrayBestCommonTypes.ts, 84, 76))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 84, 78))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 84, 84))
 >base : Symbol(base, Decl(arrayBestCommonTypes.ts, 54, 34))
@@ -366,9 +383,11 @@ module NonEmptyTypes {
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 85, 21))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 85, 33))
 >base : Symbol(base, Decl(arrayBestCommonTypes.ts, 54, 34))
+>{ x: true, y: new derived() } : Symbol(, Decl(arrayBestCommonTypes.ts, 85, 50))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 85, 51))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 85, 60))
 >derived : Symbol(derived, Decl(arrayBestCommonTypes.ts, 56, 58))
+>{ x: false, y: new base() } : Symbol(, Decl(arrayBestCommonTypes.ts, 85, 80))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 85, 82))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 85, 92))
 >base : Symbol(base, Decl(arrayBestCommonTypes.ts, 54, 34))
@@ -378,10 +397,12 @@ module NonEmptyTypes {
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 86, 21))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 86, 32))
 >base : Symbol(base, Decl(arrayBestCommonTypes.ts, 54, 34))
+>{ x: undefined, y: new base() } : Symbol(, Decl(arrayBestCommonTypes.ts, 86, 49))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 86, 50))
 >undefined : Symbol(undefined)
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 86, 64))
 >base : Symbol(base, Decl(arrayBestCommonTypes.ts, 54, 34))
+>{ x: '', y: new derived() } : Symbol(, Decl(arrayBestCommonTypes.ts, 86, 81))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 86, 83))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 86, 90))
 >derived : Symbol(derived, Decl(arrayBestCommonTypes.ts, 56, 58))
@@ -392,31 +413,40 @@ module NonEmptyTypes {
             // Order matters here so test all the variants
             var a1 = [{ x: 0, y: 'a' }, { x: 'a', y: 'a' }, { x: anyObj, y: 'a' }];
 >a1 : Symbol(a1, Decl(arrayBestCommonTypes.ts, 90, 15))
+>{ x: 0, y: 'a' } : Symbol(, Decl(arrayBestCommonTypes.ts, 90, 22))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 90, 23))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 90, 29))
+>{ x: 'a', y: 'a' } : Symbol(, Decl(arrayBestCommonTypes.ts, 90, 39))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 90, 41))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 90, 49))
+>{ x: anyObj, y: 'a' } : Symbol(, Decl(arrayBestCommonTypes.ts, 90, 59))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 90, 61))
 >anyObj : Symbol(anyObj, Decl(arrayBestCommonTypes.ts, 88, 15))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 90, 72))
 
             var a2 = [{ x: anyObj, y: 'a' }, { x: 0, y: 'a' }, { x: 'a', y: 'a' }];
 >a2 : Symbol(a2, Decl(arrayBestCommonTypes.ts, 91, 15))
+>{ x: anyObj, y: 'a' } : Symbol(, Decl(arrayBestCommonTypes.ts, 91, 22))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 91, 23))
 >anyObj : Symbol(anyObj, Decl(arrayBestCommonTypes.ts, 88, 15))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 91, 34))
+>{ x: 0, y: 'a' } : Symbol(, Decl(arrayBestCommonTypes.ts, 91, 44))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 91, 46))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 91, 52))
+>{ x: 'a', y: 'a' } : Symbol(, Decl(arrayBestCommonTypes.ts, 91, 62))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 91, 64))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 91, 72))
 
             var a3 = [{ x: 0, y: 'a' }, { x: anyObj, y: 'a' }, { x: 'a', y: 'a' }];
 >a3 : Symbol(a3, Decl(arrayBestCommonTypes.ts, 92, 15))
+>{ x: 0, y: 'a' } : Symbol(, Decl(arrayBestCommonTypes.ts, 92, 22))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 92, 23))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 92, 29))
+>{ x: anyObj, y: 'a' } : Symbol(, Decl(arrayBestCommonTypes.ts, 92, 39))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 92, 41))
 >anyObj : Symbol(anyObj, Decl(arrayBestCommonTypes.ts, 88, 15))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 92, 52))
+>{ x: 'a', y: 'a' } : Symbol(, Decl(arrayBestCommonTypes.ts, 92, 62))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 92, 64))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 92, 72))
 
diff --git a/tests/baselines/reference/arrayBindingPatternOmittedExpressions.symbols b/tests/baselines/reference/arrayBindingPatternOmittedExpressions.symbols
index 41d04ee623a05..e506d62e60fae 100644
--- a/tests/baselines/reference/arrayBindingPatternOmittedExpressions.symbols
+++ b/tests/baselines/reference/arrayBindingPatternOmittedExpressions.symbols
@@ -11,6 +11,7 @@ var results: string[];
 
     let x = {
 >x : Symbol(x, Decl(arrayBindingPatternOmittedExpressions.ts, 5, 7))
+>{        a,        b    } : Symbol(, Decl(arrayBindingPatternOmittedExpressions.ts, 5, 11))
 
         a,
 >a : Symbol(a, Decl(arrayBindingPatternOmittedExpressions.ts, 5, 13))
diff --git a/tests/baselines/reference/arrayConcatMap.symbols b/tests/baselines/reference/arrayConcatMap.symbols
index 1ff4bc3bff56c..e6ecc2a9432da 100644
--- a/tests/baselines/reference/arrayConcatMap.symbols
+++ b/tests/baselines/reference/arrayConcatMap.symbols
@@ -4,11 +4,14 @@ var x = [].concat([{ a: 1 }], [{ a: 2 }])
 >[].concat([{ a: 1 }], [{ a: 2 }])          .map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
 >[].concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
 >concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
+>{ a: 1 } : Symbol(, Decl(arrayConcatMap.ts, 0, 19))
 >a : Symbol(a, Decl(arrayConcatMap.ts, 0, 20))
+>{ a: 2 } : Symbol(, Decl(arrayConcatMap.ts, 0, 31))
 >a : Symbol(a, Decl(arrayConcatMap.ts, 0, 32))
 
           .map(b => b.a);
 >map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>b => b.a : Symbol((Anonymous function), Decl(arrayConcatMap.ts, 1, 15))
 >b : Symbol(b, Decl(arrayConcatMap.ts, 1, 15))
 >b : Symbol(b, Decl(arrayConcatMap.ts, 1, 15))
 
diff --git a/tests/baselines/reference/arrayLiteralTypeInference.symbols b/tests/baselines/reference/arrayLiteralTypeInference.symbols
index 005cb57f6c402..ff5d62c2f3450 100644
--- a/tests/baselines/reference/arrayLiteralTypeInference.symbols
+++ b/tests/baselines/reference/arrayLiteralTypeInference.symbols
@@ -27,10 +27,12 @@ var x1: Action[] = [
 >Action : Symbol(Action, Decl(arrayLiteralTypeInference.ts, 0, 0))
 
     { id: 2, trueness: false },
+>{ id: 2, trueness: false } : Symbol(, Decl(arrayLiteralTypeInference.ts, 12, 20))
 >id : Symbol(id, Decl(arrayLiteralTypeInference.ts, 13, 5))
 >trueness : Symbol(trueness, Decl(arrayLiteralTypeInference.ts, 13, 12))
 
     { id: 3, name: "three" }
+>{ id: 3, name: "three" } : Symbol(, Decl(arrayLiteralTypeInference.ts, 13, 31))
 >id : Symbol(id, Decl(arrayLiteralTypeInference.ts, 14, 5))
 >name : Symbol(name, Decl(arrayLiteralTypeInference.ts, 14, 12))
 
@@ -69,10 +71,12 @@ var z1: { id: number }[] =
 
     [
         { id: 2, trueness: false },
+>{ id: 2, trueness: false } : Symbol(, Decl(arrayLiteralTypeInference.ts, 29, 5))
 >id : Symbol(id, Decl(arrayLiteralTypeInference.ts, 30, 9))
 >trueness : Symbol(trueness, Decl(arrayLiteralTypeInference.ts, 30, 16))
 
         { id: 3, name: "three" }
+>{ id: 3, name: "three" } : Symbol(, Decl(arrayLiteralTypeInference.ts, 30, 35))
 >id : Symbol(id, Decl(arrayLiteralTypeInference.ts, 31, 9))
 >name : Symbol(name, Decl(arrayLiteralTypeInference.ts, 31, 16))
 
diff --git a/tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.symbols b/tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.symbols
index 071596c9af1e0..cb01e8fbb718b 100644
--- a/tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.symbols
+++ b/tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.symbols
@@ -34,30 +34,38 @@ var cs = [a, b, c]; // { x: number; y?: number };[]
 
 var ds = [(x: Object) => 1, (x: string) => 2]; // { (x:Object) => number }[]
 >ds : Symbol(ds, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 10, 3))
+>(x: Object) => 1 : Symbol((Anonymous function), Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 10, 10))
 >x : Symbol(x, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 10, 11))
 >Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>(x: string) => 2 : Symbol((Anonymous function), Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 10, 27))
 >x : Symbol(x, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 10, 29))
 
 var es = [(x: string) => 2, (x: Object) => 1]; // { (x:string) => number }[]
 >es : Symbol(es, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 11, 3))
+>(x: string) => 2 : Symbol((Anonymous function), Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 11, 10))
 >x : Symbol(x, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 11, 11))
+>(x: Object) => 1 : Symbol((Anonymous function), Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 11, 27))
 >x : Symbol(x, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 11, 29))
 >Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
 
 var fs = [(a: { x: number; y?: number }) => 1, (b: { x: number; z?: number }) => 2]; // (a: { x: number; y?: number }) => number[]
 >fs : Symbol(fs, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 12, 3))
+>(a: { x: number; y?: number }) => 1 : Symbol((Anonymous function), Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 12, 10))
 >a : Symbol(a, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 12, 11))
 >x : Symbol(x, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 12, 15))
 >y : Symbol(y, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 12, 26))
+>(b: { x: number; z?: number }) => 2 : Symbol((Anonymous function), Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 12, 46))
 >b : Symbol(b, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 12, 48))
 >x : Symbol(x, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 12, 52))
 >z : Symbol(z, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 12, 63))
 
 var gs = [(b: { x: number; z?: number }) => 2, (a: { x: number; y?: number }) => 1]; // (b: { x: number; z?: number }) => number[]
 >gs : Symbol(gs, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 13, 3))
+>(b: { x: number; z?: number }) => 2 : Symbol((Anonymous function), Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 13, 10))
 >b : Symbol(b, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 13, 11))
 >x : Symbol(x, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 13, 15))
 >z : Symbol(z, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 13, 26))
+>(a: { x: number; y?: number }) => 1 : Symbol((Anonymous function), Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 13, 46))
 >a : Symbol(a, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 13, 48))
 >x : Symbol(x, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 13, 52))
 >y : Symbol(y, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 13, 63))
diff --git a/tests/baselines/reference/arrayLiterals.symbols b/tests/baselines/reference/arrayLiterals.symbols
index b338e7ff6e6c5..cb8b309307527 100644
--- a/tests/baselines/reference/arrayLiterals.symbols
+++ b/tests/baselines/reference/arrayLiterals.symbols
@@ -47,18 +47,22 @@ var context1: { [n: number]: { a: string; b: number; }; } = [{ a: '', b: 0, c: '
 >n : Symbol(n, Decl(arrayLiterals.ts, 23, 17))
 >a : Symbol(a, Decl(arrayLiterals.ts, 23, 30))
 >b : Symbol(b, Decl(arrayLiterals.ts, 23, 41))
+>{ a: '', b: 0, c: '' } : Symbol(, Decl(arrayLiterals.ts, 23, 61))
 >a : Symbol(a, Decl(arrayLiterals.ts, 23, 62))
 >b : Symbol(b, Decl(arrayLiterals.ts, 23, 69))
 >c : Symbol(c, Decl(arrayLiterals.ts, 23, 75))
+>{ a: "", b: 3, c: 0 } : Symbol(, Decl(arrayLiterals.ts, 23, 84))
 >a : Symbol(a, Decl(arrayLiterals.ts, 23, 86))
 >b : Symbol(b, Decl(arrayLiterals.ts, 23, 93))
 >c : Symbol(c, Decl(arrayLiterals.ts, 23, 99))
 
 var context2 = [{ a: '', b: 0, c: '' }, { a: "", b: 3, c: 0 }];
 >context2 : Symbol(context2, Decl(arrayLiterals.ts, 24, 3))
+>{ a: '', b: 0, c: '' } : Symbol(, Decl(arrayLiterals.ts, 24, 16))
 >a : Symbol(a, Decl(arrayLiterals.ts, 24, 17))
 >b : Symbol(b, Decl(arrayLiterals.ts, 24, 24))
 >c : Symbol(c, Decl(arrayLiterals.ts, 24, 30))
+>{ a: "", b: 3, c: 0 } : Symbol(, Decl(arrayLiterals.ts, 24, 39))
 >a : Symbol(a, Decl(arrayLiterals.ts, 24, 41))
 >b : Symbol(b, Decl(arrayLiterals.ts, 24, 48))
 >c : Symbol(c, Decl(arrayLiterals.ts, 24, 54))
diff --git a/tests/baselines/reference/arrayLiterals2ES5.symbols b/tests/baselines/reference/arrayLiterals2ES5.symbols
index c69b79de2724d..baaacdda2764f 100644
--- a/tests/baselines/reference/arrayLiterals2ES5.symbols
+++ b/tests/baselines/reference/arrayLiterals2ES5.symbols
@@ -24,6 +24,7 @@ var a3 = [,, ...a0]
 
 var a4 = [() => 1, ];
 >a4 : Symbol(a4, Decl(arrayLiterals2ES5.ts, 13, 3))
+>() => 1 : Symbol((Anonymous function), Decl(arrayLiterals2ES5.ts, 13, 10))
 
 var a5 = [...a0, , ]
 >a5 : Symbol(a5, Decl(arrayLiterals2ES5.ts, 14, 3))
diff --git a/tests/baselines/reference/arrayLiterals2ES6.symbols b/tests/baselines/reference/arrayLiterals2ES6.symbols
index faf0b13073815..c95ffffd3c95f 100644
--- a/tests/baselines/reference/arrayLiterals2ES6.symbols
+++ b/tests/baselines/reference/arrayLiterals2ES6.symbols
@@ -24,6 +24,7 @@ var a3 = [, , ...a0]
 
 var a4 = [() => 1, ];
 >a4 : Symbol(a4, Decl(arrayLiterals2ES6.ts, 13, 3))
+>() => 1 : Symbol((Anonymous function), Decl(arrayLiterals2ES6.ts, 13, 10))
 
 var a5 = [...a0, , ]
 >a5 : Symbol(a5, Decl(arrayLiterals2ES6.ts, 14, 3))
diff --git a/tests/baselines/reference/arrayOfFunctionTypes3.symbols b/tests/baselines/reference/arrayOfFunctionTypes3.symbols
index d26effeb5b77b..f2bf4a72e0022 100644
--- a/tests/baselines/reference/arrayOfFunctionTypes3.symbols
+++ b/tests/baselines/reference/arrayOfFunctionTypes3.symbols
@@ -3,6 +3,8 @@
 
 var x = [() => 1, () => { }];
 >x : Symbol(x, Decl(arrayOfFunctionTypes3.ts, 2, 3))
+>() => 1 : Symbol((Anonymous function), Decl(arrayOfFunctionTypes3.ts, 2, 9))
+>() => { } : Symbol((Anonymous function), Decl(arrayOfFunctionTypes3.ts, 2, 17))
 
 var r2 = x[0]();
 >r2 : Symbol(r2, Decl(arrayOfFunctionTypes3.ts, 3, 3))
diff --git a/tests/baselines/reference/arrayconcat.symbols b/tests/baselines/reference/arrayconcat.symbols
index 64e63d7c2ecc0..ac87eb46a3202 100644
--- a/tests/baselines/reference/arrayconcat.symbols
+++ b/tests/baselines/reference/arrayconcat.symbols
@@ -44,6 +44,7 @@ class parser {
 >this : Symbol(parser, Decl(arrayconcat.ts, 8, 1))
 >options : Symbol(options, Decl(arrayconcat.ts, 10, 14))
 >sort : Symbol(Array.sort, Decl(lib.d.ts, 1054, 45))
+>function(a, b) {            var aName = a.name.toLowerCase();            var bName = b.name.toLowerCase();            if (aName > bName) {                return 1;            } else if (aName < bName) {                return -1;            } else {                return 0;            }        } : Symbol((Anonymous function), Decl(arrayconcat.ts, 14, 35))
 >a : Symbol(a, Decl(arrayconcat.ts, 14, 44))
 >b : Symbol(b, Decl(arrayconcat.ts, 14, 46))
 
diff --git a/tests/baselines/reference/arrowFunctionExpressions.symbols b/tests/baselines/reference/arrowFunctionExpressions.symbols
index 28945e1179f63..4ade530993569 100644
--- a/tests/baselines/reference/arrowFunctionExpressions.symbols
+++ b/tests/baselines/reference/arrowFunctionExpressions.symbols
@@ -2,6 +2,7 @@
 // ArrowFormalParameters => AssignmentExpression is equivalent to ArrowFormalParameters => { return AssignmentExpression; }
 var a = (p: string) => p.length;
 >a : Symbol(a, Decl(arrowFunctionExpressions.ts, 1, 3), Decl(arrowFunctionExpressions.ts, 2, 3))
+>(p: string) => p.length : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 1, 7))
 >p : Symbol(p, Decl(arrowFunctionExpressions.ts, 1, 9))
 >p.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >p : Symbol(p, Decl(arrowFunctionExpressions.ts, 1, 9))
@@ -9,6 +10,7 @@ var a = (p: string) => p.length;
 
 var a = (p: string) => { return p.length; }
 >a : Symbol(a, Decl(arrowFunctionExpressions.ts, 1, 3), Decl(arrowFunctionExpressions.ts, 2, 3))
+>(p: string) => { return p.length; } : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 2, 7))
 >p : Symbol(p, Decl(arrowFunctionExpressions.ts, 2, 9))
 >p.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >p : Symbol(p, Decl(arrowFunctionExpressions.ts, 2, 9))
@@ -17,10 +19,12 @@ var a = (p: string) => { return p.length; }
 // Identifier => Block is equivalent to(Identifier) => Block
 var b = j => { return 0; }
 >b : Symbol(b, Decl(arrowFunctionExpressions.ts, 5, 3), Decl(arrowFunctionExpressions.ts, 6, 3))
+>j => { return 0; } : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 5, 7))
 >j : Symbol(j, Decl(arrowFunctionExpressions.ts, 5, 7))
 
 var b = (j) => { return 0; }
 >b : Symbol(b, Decl(arrowFunctionExpressions.ts, 5, 3), Decl(arrowFunctionExpressions.ts, 6, 3))
+>(j) => { return 0; } : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 6, 7))
 >j : Symbol(j, Decl(arrowFunctionExpressions.ts, 6, 9))
 
 // Identifier => AssignmentExpression is equivalent to(Identifier) => AssignmentExpression
@@ -29,12 +33,14 @@ var c: number;
 
 var d = n => c = n;
 >d : Symbol(d, Decl(arrowFunctionExpressions.ts, 10, 3), Decl(arrowFunctionExpressions.ts, 11, 3), Decl(arrowFunctionExpressions.ts, 12, 3))
+>n => c = n : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 10, 7))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 10, 7))
 >c : Symbol(c, Decl(arrowFunctionExpressions.ts, 9, 3))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 10, 7))
 
 var d = (n) => c = n;
 >d : Symbol(d, Decl(arrowFunctionExpressions.ts, 10, 3), Decl(arrowFunctionExpressions.ts, 11, 3), Decl(arrowFunctionExpressions.ts, 12, 3))
+>(n) => c = n : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 11, 7))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 11, 9))
 >c : Symbol(c, Decl(arrowFunctionExpressions.ts, 9, 3))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 11, 9))
@@ -46,43 +52,54 @@ var d: (n: any) => any;
 // Binding patterns in arrow functions
 var p1 = ([a]) => { };
 >p1 : Symbol(p1, Decl(arrowFunctionExpressions.ts, 15, 3))
+>([a]) => { } : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 15, 8))
 >a : Symbol(a, Decl(arrowFunctionExpressions.ts, 15, 11))
 
 var p2 = ([...a]) => { };
 >p2 : Symbol(p2, Decl(arrowFunctionExpressions.ts, 16, 3))
+>([...a]) => { } : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 16, 8))
 >a : Symbol(a, Decl(arrowFunctionExpressions.ts, 16, 11))
 
 var p3 = ([, a]) => { };
 >p3 : Symbol(p3, Decl(arrowFunctionExpressions.ts, 17, 3))
+>([, a]) => { } : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 17, 8))
 >a : Symbol(a, Decl(arrowFunctionExpressions.ts, 17, 12))
 
 var p4 = ([, ...a]) => { };
 >p4 : Symbol(p4, Decl(arrowFunctionExpressions.ts, 18, 3))
+>([, ...a]) => { } : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 18, 8))
 >a : Symbol(a, Decl(arrowFunctionExpressions.ts, 18, 12))
 
 var p5 = ([a = 1]) => { };
 >p5 : Symbol(p5, Decl(arrowFunctionExpressions.ts, 19, 3))
+>([a = 1]) => { } : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 19, 8))
 >a : Symbol(a, Decl(arrowFunctionExpressions.ts, 19, 11))
 
 var p6 = ({ a }) => { };
 >p6 : Symbol(p6, Decl(arrowFunctionExpressions.ts, 20, 3))
+>({ a }) => { } : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 20, 8))
 >a : Symbol(a, Decl(arrowFunctionExpressions.ts, 20, 11))
 
 var p7 = ({ a: { b } }) => { };
 >p7 : Symbol(p7, Decl(arrowFunctionExpressions.ts, 21, 3))
+>({ a: { b } }) => { } : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 21, 8))
 >b : Symbol(b, Decl(arrowFunctionExpressions.ts, 21, 16))
 
 var p8 = ({ a = 1 }) => { };
 >p8 : Symbol(p8, Decl(arrowFunctionExpressions.ts, 22, 3))
+>({ a = 1 }) => { } : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 22, 8))
 >a : Symbol(a, Decl(arrowFunctionExpressions.ts, 22, 11))
 
 var p9 = ({ a: { b = 1 } = { b: 1 } }) => { };
 >p9 : Symbol(p9, Decl(arrowFunctionExpressions.ts, 23, 3))
+>({ a: { b = 1 } = { b: 1 } }) => { } : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 23, 8))
 >b : Symbol(b, Decl(arrowFunctionExpressions.ts, 23, 16))
+>{ b: 1 } : Symbol(, Decl(arrowFunctionExpressions.ts, 23, 26))
 >b : Symbol(b, Decl(arrowFunctionExpressions.ts, 23, 28))
 
 var p10 = ([{ value, done }]) => { };
 >p10 : Symbol(p10, Decl(arrowFunctionExpressions.ts, 24, 3))
+>([{ value, done }]) => { } : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 24, 9))
 >value : Symbol(value, Decl(arrowFunctionExpressions.ts, 24, 13))
 >done : Symbol(done, Decl(arrowFunctionExpressions.ts, 24, 20))
 
@@ -93,11 +110,13 @@ class MyClass {
 
     m = (n) => n + 1;
 >m : Symbol(m, Decl(arrowFunctionExpressions.ts, 28, 15))
+>(n) => n + 1 : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 29, 7))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 29, 9))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 29, 9))
 
     p = (n) => n && this;
 >p : Symbol(p, Decl(arrowFunctionExpressions.ts, 29, 21))
+>(n) => n && this : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 30, 7))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 30, 9))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 30, 9))
 >this : Symbol(MyClass, Decl(arrowFunctionExpressions.ts, 24, 37))
@@ -107,11 +126,13 @@ class MyClass {
 
         var m = (n) => n + 1;
 >m : Symbol(m, Decl(arrowFunctionExpressions.ts, 33, 11))
+>(n) => n + 1 : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 33, 15))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 33, 17))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 33, 17))
 
         var p = (n) => n && this;
 >p : Symbol(p, Decl(arrowFunctionExpressions.ts, 34, 11))
+>(n) => n && this : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 34, 15))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 34, 17))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 34, 17))
 >this : Symbol(MyClass, Decl(arrowFunctionExpressions.ts, 24, 37))
@@ -121,7 +142,11 @@ class MyClass {
 // Arrow function used in arrow function
 var arrrr = () => (m: number) => () => (n: number) => m + n;
 >arrrr : Symbol(arrrr, Decl(arrowFunctionExpressions.ts, 39, 3))
+>() => (m: number) => () => (n: number) => m + n : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 39, 11))
+>(m: number) => () => (n: number) => m + n : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 39, 17))
 >m : Symbol(m, Decl(arrowFunctionExpressions.ts, 39, 19))
+>() => (n: number) => m + n : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 39, 32))
+>(n: number) => m + n : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 39, 38))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 39, 40))
 >m : Symbol(m, Decl(arrowFunctionExpressions.ts, 39, 19))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 39, 40))
@@ -139,7 +164,9 @@ function someFn() {
 
     var arr = (n: number) => (p: number) => p * n;
 >arr : Symbol(arr, Decl(arrowFunctionExpressions.ts, 45, 7))
+>(n: number) => (p: number) => p * n : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 45, 13))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 45, 15))
+>(p: number) => p * n : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 45, 28))
 >p : Symbol(p, Decl(arrowFunctionExpressions.ts, 45, 30))
 >p : Symbol(p, Decl(arrowFunctionExpressions.ts, 45, 30))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 45, 15))
@@ -156,6 +183,7 @@ function someOtherFn() {
 
     var arr = (n: number) => '' + n;
 >arr : Symbol(arr, Decl(arrowFunctionExpressions.ts, 51, 7))
+>(n: number) => '' + n : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 51, 13))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 51, 15))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 51, 15))
 
@@ -174,6 +202,7 @@ function outerFn() {
 
         var arrowFn = () => { };
 >arrowFn : Symbol(arrowFn, Decl(arrowFunctionExpressions.ts, 58, 11))
+>() => { } : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 58, 21))
 
         var p = arrowFn();
 >p : Symbol(p, Decl(arrowFunctionExpressions.ts, 59, 11), Decl(arrowFunctionExpressions.ts, 60, 11))
@@ -187,6 +216,7 @@ function outerFn() {
 // Arrow function used in nested function in arrow function
 var f = (n: string) => {
 >f : Symbol(f, Decl(arrowFunctionExpressions.ts, 65, 3))
+>(n: string) => {    function fn(x: number) {        return () => n + x;    }    return fn(4);} : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 65, 7))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 65, 9))
 
     function fn(x: number) {
@@ -194,6 +224,7 @@ var f = (n: string) => {
 >x : Symbol(x, Decl(arrowFunctionExpressions.ts, 66, 16))
 
         return () => n + x;
+>() => n + x : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 67, 14))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 65, 9))
 >x : Symbol(x, Decl(arrowFunctionExpressions.ts, 66, 16))
     }
@@ -214,12 +245,14 @@ function someOuterFn() {
 
     var arr = (n: string) => {
 >arr : Symbol(arr, Decl(arrowFunctionExpressions.ts, 77, 7))
+>(n: string) => {        function innerFn() {            return () => n.length;        }        return innerFn;    } : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 77, 13))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 77, 15))
 
         function innerFn() {
 >innerFn : Symbol(innerFn, Decl(arrowFunctionExpressions.ts, 77, 30))
 
             return () => n.length;
+>() => n.length : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 79, 18))
 >n.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 77, 15))
 >length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
@@ -246,17 +279,20 @@ function tryCatchFn() {
     try {
         var x = () => this;
 >x : Symbol(x, Decl(arrowFunctionExpressions.ts, 91, 11))
+>() => this : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 91, 15))
 
     } catch (e) {
 >e : Symbol(e, Decl(arrowFunctionExpressions.ts, 92, 13))
 
         var t = () => e + this;
 >t : Symbol(t, Decl(arrowFunctionExpressions.ts, 93, 11))
+>() => e + this : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 93, 15))
 >e : Symbol(e, Decl(arrowFunctionExpressions.ts, 92, 13))
 
     } finally {
         var m = () => this + '';
 >m : Symbol(m, Decl(arrowFunctionExpressions.ts, 95, 11))
+>() => this + '' : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 95, 15))
     }
 }
 
diff --git a/tests/baselines/reference/arrowFunctionInExpressionStatement1.symbols b/tests/baselines/reference/arrowFunctionInExpressionStatement1.symbols
index 690ff3500c8ee..71b1c40082454 100644
--- a/tests/baselines/reference/arrowFunctionInExpressionStatement1.symbols
+++ b/tests/baselines/reference/arrowFunctionInExpressionStatement1.symbols
@@ -1,3 +1,4 @@
 === tests/cases/compiler/arrowFunctionInExpressionStatement1.ts ===
 () => 0;
-No type information for this code.
\ No newline at end of file
+>() => 0 : Symbol((Anonymous function), Decl(arrowFunctionInExpressionStatement1.ts, 0, 0))
+
diff --git a/tests/baselines/reference/arrowFunctionInExpressionStatement2.symbols b/tests/baselines/reference/arrowFunctionInExpressionStatement2.symbols
index c9bbfde997418..4578a253dd484 100644
--- a/tests/baselines/reference/arrowFunctionInExpressionStatement2.symbols
+++ b/tests/baselines/reference/arrowFunctionInExpressionStatement2.symbols
@@ -3,4 +3,5 @@ module M {
 >M : Symbol(M, Decl(arrowFunctionInExpressionStatement2.ts, 0, 0))
 
     () => 0;
+>() => 0 : Symbol((Anonymous function), Decl(arrowFunctionInExpressionStatement2.ts, 0, 10))
 }
diff --git a/tests/baselines/reference/arrowFunctionWithObjectLiteralBody1.symbols b/tests/baselines/reference/arrowFunctionWithObjectLiteralBody1.symbols
index b4f68e045fe54..6df9ee96795bf 100644
--- a/tests/baselines/reference/arrowFunctionWithObjectLiteralBody1.symbols
+++ b/tests/baselines/reference/arrowFunctionWithObjectLiteralBody1.symbols
@@ -1,5 +1,7 @@
 === tests/cases/compiler/arrowFunctionWithObjectLiteralBody1.ts ===
 var v = a => <any>{}
 >v : Symbol(v, Decl(arrowFunctionWithObjectLiteralBody1.ts, 0, 3))
+>a => <any>{} : Symbol((Anonymous function), Decl(arrowFunctionWithObjectLiteralBody1.ts, 0, 7))
 >a : Symbol(a, Decl(arrowFunctionWithObjectLiteralBody1.ts, 0, 7))
+>{} : Symbol(, Decl(arrowFunctionWithObjectLiteralBody1.ts, 0, 18))
 
diff --git a/tests/baselines/reference/arrowFunctionWithObjectLiteralBody2.symbols b/tests/baselines/reference/arrowFunctionWithObjectLiteralBody2.symbols
index 1f8b83a23f158..092f79bc962bf 100644
--- a/tests/baselines/reference/arrowFunctionWithObjectLiteralBody2.symbols
+++ b/tests/baselines/reference/arrowFunctionWithObjectLiteralBody2.symbols
@@ -1,5 +1,7 @@
 === tests/cases/compiler/arrowFunctionWithObjectLiteralBody2.ts ===
 var v = a => <any><any>{}
 >v : Symbol(v, Decl(arrowFunctionWithObjectLiteralBody2.ts, 0, 3))
+>a => <any><any>{} : Symbol((Anonymous function), Decl(arrowFunctionWithObjectLiteralBody2.ts, 0, 7))
 >a : Symbol(a, Decl(arrowFunctionWithObjectLiteralBody2.ts, 0, 7))
+>{} : Symbol(, Decl(arrowFunctionWithObjectLiteralBody2.ts, 0, 23))
 
diff --git a/tests/baselines/reference/arrowFunctionWithObjectLiteralBody3.symbols b/tests/baselines/reference/arrowFunctionWithObjectLiteralBody3.symbols
index 92122d16fc993..7d7c06e8a7a98 100644
--- a/tests/baselines/reference/arrowFunctionWithObjectLiteralBody3.symbols
+++ b/tests/baselines/reference/arrowFunctionWithObjectLiteralBody3.symbols
@@ -1,5 +1,7 @@
 === tests/cases/compiler/arrowFunctionWithObjectLiteralBody3.ts ===
 var v = a => <any>{}
 >v : Symbol(v, Decl(arrowFunctionWithObjectLiteralBody3.ts, 0, 3))
+>a => <any>{} : Symbol((Anonymous function), Decl(arrowFunctionWithObjectLiteralBody3.ts, 0, 7))
 >a : Symbol(a, Decl(arrowFunctionWithObjectLiteralBody3.ts, 0, 7))
+>{} : Symbol(, Decl(arrowFunctionWithObjectLiteralBody3.ts, 0, 18))
 
diff --git a/tests/baselines/reference/arrowFunctionWithObjectLiteralBody4.symbols b/tests/baselines/reference/arrowFunctionWithObjectLiteralBody4.symbols
index 74a6b6a2b9d0e..c33c65df9a912 100644
--- a/tests/baselines/reference/arrowFunctionWithObjectLiteralBody4.symbols
+++ b/tests/baselines/reference/arrowFunctionWithObjectLiteralBody4.symbols
@@ -1,5 +1,7 @@
 === tests/cases/compiler/arrowFunctionWithObjectLiteralBody4.ts ===
 var v = a => <any><any>{}
 >v : Symbol(v, Decl(arrowFunctionWithObjectLiteralBody4.ts, 0, 3))
+>a => <any><any>{} : Symbol((Anonymous function), Decl(arrowFunctionWithObjectLiteralBody4.ts, 0, 7))
 >a : Symbol(a, Decl(arrowFunctionWithObjectLiteralBody4.ts, 0, 7))
+>{} : Symbol(, Decl(arrowFunctionWithObjectLiteralBody4.ts, 0, 23))
 
diff --git a/tests/baselines/reference/arrowFunctionWithObjectLiteralBody5.symbols b/tests/baselines/reference/arrowFunctionWithObjectLiteralBody5.symbols
index c1d1cf40d9096..ff74ff4744b84 100644
--- a/tests/baselines/reference/arrowFunctionWithObjectLiteralBody5.symbols
+++ b/tests/baselines/reference/arrowFunctionWithObjectLiteralBody5.symbols
@@ -1,24 +1,32 @@
 === tests/cases/compiler/arrowFunctionWithObjectLiteralBody5.ts ===
 var a = () => <Error>{ name: "foo", message: "bar" };      
 >a : Symbol(a, Decl(arrowFunctionWithObjectLiteralBody5.ts, 0, 3))
+>() => <Error>{ name: "foo", message: "bar" } : Symbol((Anonymous function), Decl(arrowFunctionWithObjectLiteralBody5.ts, 0, 7))
 >Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11))
+>{ name: "foo", message: "bar" } : Symbol(, Decl(arrowFunctionWithObjectLiteralBody5.ts, 0, 21))
 >name : Symbol(name, Decl(arrowFunctionWithObjectLiteralBody5.ts, 0, 22))
 >message : Symbol(message, Decl(arrowFunctionWithObjectLiteralBody5.ts, 0, 35))
 
 var b = () => (<Error>{ name: "foo", message: "bar" });    
 >b : Symbol(b, Decl(arrowFunctionWithObjectLiteralBody5.ts, 2, 3))
+>() => (<Error>{ name: "foo", message: "bar" }) : Symbol((Anonymous function), Decl(arrowFunctionWithObjectLiteralBody5.ts, 2, 7))
 >Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11))
+>{ name: "foo", message: "bar" } : Symbol(, Decl(arrowFunctionWithObjectLiteralBody5.ts, 2, 22))
 >name : Symbol(name, Decl(arrowFunctionWithObjectLiteralBody5.ts, 2, 23))
 >message : Symbol(message, Decl(arrowFunctionWithObjectLiteralBody5.ts, 2, 36))
 
 var c = () => ({ name: "foo", message: "bar" });           
 >c : Symbol(c, Decl(arrowFunctionWithObjectLiteralBody5.ts, 4, 3))
+>() => ({ name: "foo", message: "bar" }) : Symbol((Anonymous function), Decl(arrowFunctionWithObjectLiteralBody5.ts, 4, 7))
+>{ name: "foo", message: "bar" } : Symbol(, Decl(arrowFunctionWithObjectLiteralBody5.ts, 4, 15))
 >name : Symbol(name, Decl(arrowFunctionWithObjectLiteralBody5.ts, 4, 16))
 >message : Symbol(message, Decl(arrowFunctionWithObjectLiteralBody5.ts, 4, 29))
 
 var d = () => ((<Error>({ name: "foo", message: "bar" })));
 >d : Symbol(d, Decl(arrowFunctionWithObjectLiteralBody5.ts, 6, 3))
+>() => ((<Error>({ name: "foo", message: "bar" }))) : Symbol((Anonymous function), Decl(arrowFunctionWithObjectLiteralBody5.ts, 6, 7))
 >Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11))
+>{ name: "foo", message: "bar" } : Symbol(, Decl(arrowFunctionWithObjectLiteralBody5.ts, 6, 24))
 >name : Symbol(name, Decl(arrowFunctionWithObjectLiteralBody5.ts, 6, 25))
 >message : Symbol(message, Decl(arrowFunctionWithObjectLiteralBody5.ts, 6, 38))
 
diff --git a/tests/baselines/reference/arrowFunctionWithObjectLiteralBody6.symbols b/tests/baselines/reference/arrowFunctionWithObjectLiteralBody6.symbols
index 80530cde01629..f57005868b461 100644
--- a/tests/baselines/reference/arrowFunctionWithObjectLiteralBody6.symbols
+++ b/tests/baselines/reference/arrowFunctionWithObjectLiteralBody6.symbols
@@ -1,24 +1,32 @@
 === tests/cases/compiler/arrowFunctionWithObjectLiteralBody6.ts ===
 var a = () => <Error>{ name: "foo", message: "bar" };      
 >a : Symbol(a, Decl(arrowFunctionWithObjectLiteralBody6.ts, 0, 3))
+>() => <Error>{ name: "foo", message: "bar" } : Symbol((Anonymous function), Decl(arrowFunctionWithObjectLiteralBody6.ts, 0, 7))
 >Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11))
+>{ name: "foo", message: "bar" } : Symbol(, Decl(arrowFunctionWithObjectLiteralBody6.ts, 0, 21))
 >name : Symbol(name, Decl(arrowFunctionWithObjectLiteralBody6.ts, 0, 22))
 >message : Symbol(message, Decl(arrowFunctionWithObjectLiteralBody6.ts, 0, 35))
 
 var b = () => (<Error>{ name: "foo", message: "bar" });    
 >b : Symbol(b, Decl(arrowFunctionWithObjectLiteralBody6.ts, 2, 3))
+>() => (<Error>{ name: "foo", message: "bar" }) : Symbol((Anonymous function), Decl(arrowFunctionWithObjectLiteralBody6.ts, 2, 7))
 >Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11))
+>{ name: "foo", message: "bar" } : Symbol(, Decl(arrowFunctionWithObjectLiteralBody6.ts, 2, 22))
 >name : Symbol(name, Decl(arrowFunctionWithObjectLiteralBody6.ts, 2, 23))
 >message : Symbol(message, Decl(arrowFunctionWithObjectLiteralBody6.ts, 2, 36))
 
 var c = () => ({ name: "foo", message: "bar" });           
 >c : Symbol(c, Decl(arrowFunctionWithObjectLiteralBody6.ts, 4, 3))
+>() => ({ name: "foo", message: "bar" }) : Symbol((Anonymous function), Decl(arrowFunctionWithObjectLiteralBody6.ts, 4, 7))
+>{ name: "foo", message: "bar" } : Symbol(, Decl(arrowFunctionWithObjectLiteralBody6.ts, 4, 15))
 >name : Symbol(name, Decl(arrowFunctionWithObjectLiteralBody6.ts, 4, 16))
 >message : Symbol(message, Decl(arrowFunctionWithObjectLiteralBody6.ts, 4, 29))
 
 var d = () => ((<Error>({ name: "foo", message: "bar" })));
 >d : Symbol(d, Decl(arrowFunctionWithObjectLiteralBody6.ts, 6, 3))
+>() => ((<Error>({ name: "foo", message: "bar" }))) : Symbol((Anonymous function), Decl(arrowFunctionWithObjectLiteralBody6.ts, 6, 7))
 >Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11))
+>{ name: "foo", message: "bar" } : Symbol(, Decl(arrowFunctionWithObjectLiteralBody6.ts, 6, 24))
 >name : Symbol(name, Decl(arrowFunctionWithObjectLiteralBody6.ts, 6, 25))
 >message : Symbol(message, Decl(arrowFunctionWithObjectLiteralBody6.ts, 6, 38))
 
diff --git a/tests/baselines/reference/asiInES6Classes.symbols b/tests/baselines/reference/asiInES6Classes.symbols
index e6af356008d0a..d59ca0eb52210 100644
--- a/tests/baselines/reference/asiInES6Classes.symbols
+++ b/tests/baselines/reference/asiInES6Classes.symbols
@@ -6,6 +6,7 @@ class Foo {
 
     defaults = {
 >defaults : Symbol(defaults, Decl(asiInES6Classes.ts, 0, 11))
+>{        done: false    } : Symbol(, Decl(asiInES6Classes.ts, 4, 14))
 
         done: false
 >done : Symbol(done, Decl(asiInES6Classes.ts, 4, 16))
diff --git a/tests/baselines/reference/asiPreventsParsingAsNamespace04.symbols b/tests/baselines/reference/asiPreventsParsingAsNamespace04.symbols
index 60d1f8fcc48ff..557048ed2d644 100644
--- a/tests/baselines/reference/asiPreventsParsingAsNamespace04.symbols
+++ b/tests/baselines/reference/asiPreventsParsingAsNamespace04.symbols
@@ -5,4 +5,5 @@ let module = 10;
 
 module in {}
 >module : Symbol(module, Decl(asiPreventsParsingAsNamespace04.ts, 1, 3))
+>{} : Symbol(, Decl(asiPreventsParsingAsNamespace04.ts, 2, 9))
 
diff --git a/tests/baselines/reference/assign1.symbols b/tests/baselines/reference/assign1.symbols
index f434da7267023..98b2e0123dfcd 100644
--- a/tests/baselines/reference/assign1.symbols
+++ b/tests/baselines/reference/assign1.symbols
@@ -15,6 +15,7 @@ module M {
     var x:I={salt:2,pepper:0};
 >x : Symbol(x, Decl(assign1.ts, 6, 7))
 >I : Symbol(I, Decl(assign1.ts, 0, 10))
+>{salt:2,pepper:0} : Symbol(, Decl(assign1.ts, 6, 12))
 >salt : Symbol(salt, Decl(assign1.ts, 6, 13))
 >pepper : Symbol(pepper, Decl(assign1.ts, 6, 20))
 }
diff --git a/tests/baselines/reference/assignEveryTypeToAny.symbols b/tests/baselines/reference/assignEveryTypeToAny.symbols
index 145e19664fd92..8e43f9fb77950 100644
--- a/tests/baselines/reference/assignEveryTypeToAny.symbols
+++ b/tests/baselines/reference/assignEveryTypeToAny.symbols
@@ -119,10 +119,12 @@ x = i;
 
 x = { f() { return 1; } }
 >x : Symbol(x, Decl(assignEveryTypeToAny.ts, 2, 3))
+>{ f() { return 1; } } : Symbol(, Decl(assignEveryTypeToAny.ts, 49, 3))
 >f : Symbol(f, Decl(assignEveryTypeToAny.ts, 49, 5))
 
 x = { f<T>(x: T) { return x; } }
 >x : Symbol(x, Decl(assignEveryTypeToAny.ts, 2, 3))
+>{ f<T>(x: T) { return x; } } : Symbol(, Decl(assignEveryTypeToAny.ts, 50, 3))
 >f : Symbol(f, Decl(assignEveryTypeToAny.ts, 50, 5))
 >T : Symbol(T, Decl(assignEveryTypeToAny.ts, 50, 8))
 >x : Symbol(x, Decl(assignEveryTypeToAny.ts, 50, 11))
diff --git a/tests/baselines/reference/assignToPrototype1.symbols b/tests/baselines/reference/assignToPrototype1.symbols
index ddb8e915043d9..08da73e3e868d 100644
--- a/tests/baselines/reference/assignToPrototype1.symbols
+++ b/tests/baselines/reference/assignToPrototype1.symbols
@@ -14,6 +14,7 @@ Point.prototype.add = function(dx, dy) {
 >Point : Symbol(Point, Decl(assignToPrototype1.ts, 0, 0))
 >prototype : Symbol(Point.prototype)
 >add : Symbol(Point.add, Decl(assignToPrototype1.ts, 0, 21))
+>function(dx, dy) {} : Symbol((Anonymous function), Decl(assignToPrototype1.ts, 4, 21))
 >dx : Symbol(dx, Decl(assignToPrototype1.ts, 4, 31))
 >dy : Symbol(dy, Decl(assignToPrototype1.ts, 4, 34))
 
diff --git a/tests/baselines/reference/assignmentCompatForEnums.symbols b/tests/baselines/reference/assignmentCompatForEnums.symbols
index 510c08e61f692..33b484e734b20 100644
--- a/tests/baselines/reference/assignmentCompatForEnums.symbols
+++ b/tests/baselines/reference/assignmentCompatForEnums.symbols
@@ -6,6 +6,7 @@ enum TokenType { One, Two };
 
 var list = {};
 >list : Symbol(list, Decl(assignmentCompatForEnums.ts, 2, 3))
+>{} : Symbol(, Decl(assignmentCompatForEnums.ts, 2, 10))
 
 
 function returnType(): TokenType { return null; }
diff --git a/tests/baselines/reference/assignmentCompatWithObjectMembers.symbols b/tests/baselines/reference/assignmentCompatWithObjectMembers.symbols
index 181c4db641a12..e7a040e4ca755 100644
--- a/tests/baselines/reference/assignmentCompatWithObjectMembers.symbols
+++ b/tests/baselines/reference/assignmentCompatWithObjectMembers.symbols
@@ -47,10 +47,12 @@ module SimpleTypes {
 
     var a2 = { foo: '' };
 >a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembers.ts, 17, 7))
+>{ foo: '' } : Symbol(, Decl(assignmentCompatWithObjectMembers.ts, 17, 12))
 >foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers.ts, 17, 14))
 
     var b2 = { foo: '' };
 >b2 : Symbol(b2, Decl(assignmentCompatWithObjectMembers.ts, 18, 7))
+>{ foo: '' } : Symbol(, Decl(assignmentCompatWithObjectMembers.ts, 18, 12))
 >foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers.ts, 18, 14))
 
     s = t;
@@ -181,11 +183,13 @@ module ObjectTypes {
 
     var a2 = { foo: a2 };
 >a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembers.ts, 58, 7))
+>{ foo: a2 } : Symbol(, Decl(assignmentCompatWithObjectMembers.ts, 58, 12))
 >foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers.ts, 58, 14))
 >a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembers.ts, 58, 7))
 
     var b2 = { foo: b2 };
 >b2 : Symbol(b2, Decl(assignmentCompatWithObjectMembers.ts, 59, 7))
+>{ foo: b2 } : Symbol(, Decl(assignmentCompatWithObjectMembers.ts, 59, 12))
 >foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers.ts, 59, 14))
 >b2 : Symbol(b2, Decl(assignmentCompatWithObjectMembers.ts, 59, 7))
 
diff --git a/tests/baselines/reference/assignmentCompatWithObjectMembers2.symbols b/tests/baselines/reference/assignmentCompatWithObjectMembers2.symbols
index ab3301c5e93e7..20de0bffa9c0e 100644
--- a/tests/baselines/reference/assignmentCompatWithObjectMembers2.symbols
+++ b/tests/baselines/reference/assignmentCompatWithObjectMembers2.symbols
@@ -48,10 +48,12 @@ var b: { foo: string; baz?: string }
 
 var a2 = { foo: '' };
 >a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembers2.ts, 16, 3))
+>{ foo: '' } : Symbol(, Decl(assignmentCompatWithObjectMembers2.ts, 16, 8))
 >foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers2.ts, 16, 10))
 
 var b2 = { foo: '' };
 >b2 : Symbol(b2, Decl(assignmentCompatWithObjectMembers2.ts, 17, 3))
+>{ foo: '' } : Symbol(, Decl(assignmentCompatWithObjectMembers2.ts, 17, 8))
 >foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers2.ts, 17, 10))
 
 s = t;
diff --git a/tests/baselines/reference/assignmentCompatWithObjectMembers3.symbols b/tests/baselines/reference/assignmentCompatWithObjectMembers3.symbols
index 861d38530bbbf..631630e5b1cd7 100644
--- a/tests/baselines/reference/assignmentCompatWithObjectMembers3.symbols
+++ b/tests/baselines/reference/assignmentCompatWithObjectMembers3.symbols
@@ -51,11 +51,13 @@ var b: { foo: string; baz?: string }
 var a2: S2 = { foo: '' };
 >a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembers3.ts, 16, 3))
 >S2 : Symbol(S2, Decl(assignmentCompatWithObjectMembers3.ts, 6, 9))
+>{ foo: '' } : Symbol(, Decl(assignmentCompatWithObjectMembers3.ts, 16, 12))
 >foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers3.ts, 16, 14))
 
 var b2: T2 = { foo: '' };
 >b2 : Symbol(b2, Decl(assignmentCompatWithObjectMembers3.ts, 17, 3))
 >T2 : Symbol(T2, Decl(assignmentCompatWithObjectMembers3.ts, 8, 42))
+>{ foo: '' } : Symbol(, Decl(assignmentCompatWithObjectMembers3.ts, 17, 12))
 >foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers3.ts, 17, 14))
 
 s = t;
diff --git a/tests/baselines/reference/assignmentCompatWithObjectMembersNumericNames.symbols b/tests/baselines/reference/assignmentCompatWithObjectMembersNumericNames.symbols
index e01bcee21c050..0a8089c8ac908 100644
--- a/tests/baselines/reference/assignmentCompatWithObjectMembersNumericNames.symbols
+++ b/tests/baselines/reference/assignmentCompatWithObjectMembersNumericNames.symbols
@@ -42,9 +42,11 @@ var b: { 1.0: string; baz?: string }
 
 var a2 = { 1.0: '' };
 >a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembersNumericNames.ts, 16, 3))
+>{ 1.0: '' } : Symbol(, Decl(assignmentCompatWithObjectMembersNumericNames.ts, 16, 8))
 
 var b2 = { 1: '' };
 >b2 : Symbol(b2, Decl(assignmentCompatWithObjectMembersNumericNames.ts, 17, 3))
+>{ 1: '' } : Symbol(, Decl(assignmentCompatWithObjectMembersNumericNames.ts, 17, 8))
 
 s = t;
 >s : Symbol(s, Decl(assignmentCompatWithObjectMembersNumericNames.ts, 5, 3))
diff --git a/tests/baselines/reference/assignmentCompatability1.symbols b/tests/baselines/reference/assignmentCompatability1.symbols
index 07d3cf4c0298d..8ccb6468cc01c 100644
--- a/tests/baselines/reference/assignmentCompatability1.symbols
+++ b/tests/baselines/reference/assignmentCompatability1.symbols
@@ -12,6 +12,7 @@ module __test1__ {
 >U : Symbol(U, Decl(assignmentCompatability1.ts, 1, 54))
 >obj4 : Symbol(obj4, Decl(assignmentCompatability1.ts, 1, 83))
 >interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability1.ts, 0, 18))
+>{ one: 1 } : Symbol(, Decl(assignmentCompatability1.ts, 1, 137))
 >one : Symbol(one, Decl(assignmentCompatability1.ts, 1, 139))
 
     export var __val__obj4 = obj4;
@@ -23,6 +24,7 @@ module __test2__ {
 
     export var aa = {};;
 >aa : Symbol(aa, Decl(assignmentCompatability1.ts, 5, 14))
+>{} : Symbol(, Decl(assignmentCompatability1.ts, 5, 19))
 
     export var __val__aa = aa;
 >__val__aa : Symbol(__val__aa, Decl(assignmentCompatability1.ts, 6, 14))
diff --git a/tests/baselines/reference/assignmentCompatability2.symbols b/tests/baselines/reference/assignmentCompatability2.symbols
index 1ed6dd3c6396a..180815c0f92fa 100644
--- a/tests/baselines/reference/assignmentCompatability2.symbols
+++ b/tests/baselines/reference/assignmentCompatability2.symbols
@@ -12,6 +12,7 @@ module __test1__ {
 >U : Symbol(U, Decl(assignmentCompatability2.ts, 1, 54))
 >obj4 : Symbol(obj4, Decl(assignmentCompatability2.ts, 1, 83))
 >interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability2.ts, 0, 18))
+>{ one: 1 } : Symbol(, Decl(assignmentCompatability2.ts, 1, 137))
 >one : Symbol(one, Decl(assignmentCompatability2.ts, 1, 139))
 
     export var __val__obj4 = obj4;
diff --git a/tests/baselines/reference/assignmentCompatability3.symbols b/tests/baselines/reference/assignmentCompatability3.symbols
index c31d69e2f1287..15eb2cc991a20 100644
--- a/tests/baselines/reference/assignmentCompatability3.symbols
+++ b/tests/baselines/reference/assignmentCompatability3.symbols
@@ -12,6 +12,7 @@ module __test1__ {
 >U : Symbol(U, Decl(assignmentCompatability3.ts, 1, 54))
 >obj4 : Symbol(obj4, Decl(assignmentCompatability3.ts, 1, 83))
 >interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability3.ts, 0, 18))
+>{ one: 1 } : Symbol(, Decl(assignmentCompatability3.ts, 1, 137))
 >one : Symbol(one, Decl(assignmentCompatability3.ts, 1, 139))
 
     export var __val__obj4 = obj4;
@@ -23,6 +24,7 @@ module __test2__ {
 
     export var obj = {one: 1};
 >obj : Symbol(obj, Decl(assignmentCompatability3.ts, 5, 14))
+>{one: 1} : Symbol(, Decl(assignmentCompatability3.ts, 5, 20))
 >one : Symbol(one, Decl(assignmentCompatability3.ts, 5, 22))
 
     export var __val__obj = obj;
diff --git a/tests/baselines/reference/assignmentCompatability4.symbols b/tests/baselines/reference/assignmentCompatability4.symbols
index fe5e4a32deeb4..e0d6d011ceb18 100644
--- a/tests/baselines/reference/assignmentCompatability4.symbols
+++ b/tests/baselines/reference/assignmentCompatability4.symbols
@@ -12,6 +12,7 @@ module __test1__ {
 >U : Symbol(U, Decl(assignmentCompatability4.ts, 1, 54))
 >obj4 : Symbol(obj4, Decl(assignmentCompatability4.ts, 1, 83))
 >interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability4.ts, 0, 18))
+>{ one: 1 } : Symbol(, Decl(assignmentCompatability4.ts, 1, 137))
 >one : Symbol(one, Decl(assignmentCompatability4.ts, 1, 139))
 
     export var __val__obj4 = obj4;
diff --git a/tests/baselines/reference/assignmentCompatability5.symbols b/tests/baselines/reference/assignmentCompatability5.symbols
index 15885d078923e..a727e9d796091 100644
--- a/tests/baselines/reference/assignmentCompatability5.symbols
+++ b/tests/baselines/reference/assignmentCompatability5.symbols
@@ -12,6 +12,7 @@ module __test1__ {
 >U : Symbol(U, Decl(assignmentCompatability5.ts, 1, 54))
 >obj4 : Symbol(obj4, Decl(assignmentCompatability5.ts, 1, 83))
 >interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability5.ts, 0, 18))
+>{ one: 1 } : Symbol(, Decl(assignmentCompatability5.ts, 1, 137))
 >one : Symbol(one, Decl(assignmentCompatability5.ts, 1, 139))
 
     export var __val__obj4 = obj4;
@@ -28,6 +29,7 @@ module __test2__ {
 >T : Symbol(T, Decl(assignmentCompatability5.ts, 5, 52))
 >obj1 : Symbol(obj1, Decl(assignmentCompatability5.ts, 5, 86))
 >interfaceOne : Symbol(interfaceOne, Decl(assignmentCompatability5.ts, 4, 18))
+>{ one: 1 } : Symbol(, Decl(assignmentCompatability5.ts, 5, 115))
 >one : Symbol(one, Decl(assignmentCompatability5.ts, 5, 117))
 
     export var __val__obj1 = obj1;
diff --git a/tests/baselines/reference/assignmentCompatability6.symbols b/tests/baselines/reference/assignmentCompatability6.symbols
index 4ddacd5cd8c82..40bea435bc726 100644
--- a/tests/baselines/reference/assignmentCompatability6.symbols
+++ b/tests/baselines/reference/assignmentCompatability6.symbols
@@ -12,6 +12,7 @@ module __test1__ {
 >U : Symbol(U, Decl(assignmentCompatability6.ts, 1, 54))
 >obj4 : Symbol(obj4, Decl(assignmentCompatability6.ts, 1, 83))
 >interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability6.ts, 0, 18))
+>{ one: 1 } : Symbol(, Decl(assignmentCompatability6.ts, 1, 137))
 >one : Symbol(one, Decl(assignmentCompatability6.ts, 1, 139))
 
     export var __val__obj4 = obj4;
@@ -28,6 +29,7 @@ module __test2__ {
 >T : Symbol(T, Decl(assignmentCompatability6.ts, 5, 52))
 >obj3 : Symbol(obj3, Decl(assignmentCompatability6.ts, 5, 86))
 >interfaceWithOptional : Symbol(interfaceWithOptional, Decl(assignmentCompatability6.ts, 4, 18))
+>{ } : Symbol(, Decl(assignmentCompatability6.ts, 5, 124))
 
     export var __val__obj3 = obj3;
 >__val__obj3 : Symbol(__val__obj3, Decl(assignmentCompatability6.ts, 6, 14))
diff --git a/tests/baselines/reference/assignmentCompatability7.symbols b/tests/baselines/reference/assignmentCompatability7.symbols
index 32a5be9f87f9c..e21e602170cb8 100644
--- a/tests/baselines/reference/assignmentCompatability7.symbols
+++ b/tests/baselines/reference/assignmentCompatability7.symbols
@@ -12,6 +12,7 @@ module __test1__ {
 >U : Symbol(U, Decl(assignmentCompatability7.ts, 1, 54))
 >obj4 : Symbol(obj4, Decl(assignmentCompatability7.ts, 1, 83))
 >interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability7.ts, 0, 18))
+>{ one: 1 } : Symbol(, Decl(assignmentCompatability7.ts, 1, 137))
 >one : Symbol(one, Decl(assignmentCompatability7.ts, 1, 139))
 
     export var __val__obj4 = obj4;
@@ -31,6 +32,7 @@ module __test2__ {
 >U : Symbol(U, Decl(assignmentCompatability7.ts, 5, 54))
 >obj4 : Symbol(obj4, Decl(assignmentCompatability7.ts, 5, 83))
 >interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability7.ts, 4, 18))
+>{ one: 1 } : Symbol(, Decl(assignmentCompatability7.ts, 5, 137))
 >one : Symbol(one, Decl(assignmentCompatability7.ts, 5, 139))
 
     export var __val__obj4 = obj4;
diff --git a/tests/baselines/reference/assignmentCompatability8.symbols b/tests/baselines/reference/assignmentCompatability8.symbols
index ba30e4fee9415..8440fffd1c434 100644
--- a/tests/baselines/reference/assignmentCompatability8.symbols
+++ b/tests/baselines/reference/assignmentCompatability8.symbols
@@ -12,6 +12,7 @@ module __test1__ {
 >U : Symbol(U, Decl(assignmentCompatability8.ts, 1, 54))
 >obj4 : Symbol(obj4, Decl(assignmentCompatability8.ts, 1, 83))
 >interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability8.ts, 0, 18))
+>{ one: 1 } : Symbol(, Decl(assignmentCompatability8.ts, 1, 137))
 >one : Symbol(one, Decl(assignmentCompatability8.ts, 1, 139))
 
     export var __val__obj4 = obj4;
diff --git a/tests/baselines/reference/assignmentCompatability9.symbols b/tests/baselines/reference/assignmentCompatability9.symbols
index 7c49da7fea2f1..a104205be7970 100644
--- a/tests/baselines/reference/assignmentCompatability9.symbols
+++ b/tests/baselines/reference/assignmentCompatability9.symbols
@@ -12,6 +12,7 @@ module __test1__ {
 >U : Symbol(U, Decl(assignmentCompatability9.ts, 1, 54))
 >obj4 : Symbol(obj4, Decl(assignmentCompatability9.ts, 1, 83))
 >interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability9.ts, 0, 18))
+>{ one: 1 } : Symbol(, Decl(assignmentCompatability9.ts, 1, 137))
 >one : Symbol(one, Decl(assignmentCompatability9.ts, 1, 139))
 
     export var __val__obj4 = obj4;
diff --git a/tests/baselines/reference/augmentedTypeBracketAccessIndexSignature.symbols b/tests/baselines/reference/augmentedTypeBracketAccessIndexSignature.symbols
index 81c8b13d207dd..28030536a88e9 100644
--- a/tests/baselines/reference/augmentedTypeBracketAccessIndexSignature.symbols
+++ b/tests/baselines/reference/augmentedTypeBracketAccessIndexSignature.symbols
@@ -25,7 +25,9 @@ interface Function {
 
 var a = {}[0]; // Should be Foo
 >a : Symbol(a, Decl(augmentedTypeBracketAccessIndexSignature.ts, 11, 3))
+>{} : Symbol(, Decl(augmentedTypeBracketAccessIndexSignature.ts, 11, 7))
 
 var b = (() => { })[0]; // Should be Bar
 >b : Symbol(b, Decl(augmentedTypeBracketAccessIndexSignature.ts, 12, 3))
+>() => { } : Symbol((Anonymous function), Decl(augmentedTypeBracketAccessIndexSignature.ts, 12, 9))
 
diff --git a/tests/baselines/reference/augmentedTypeBracketNamedPropertyAccess.symbols b/tests/baselines/reference/augmentedTypeBracketNamedPropertyAccess.symbols
index cc9c2ba62ef3f..3d6392660f466 100644
--- a/tests/baselines/reference/augmentedTypeBracketNamedPropertyAccess.symbols
+++ b/tests/baselines/reference/augmentedTypeBracketNamedPropertyAccess.symbols
@@ -13,9 +13,11 @@ interface Function {
 }
 var o = {};
 >o : Symbol(o, Decl(augmentedTypeBracketNamedPropertyAccess.ts, 6, 3))
+>{} : Symbol(, Decl(augmentedTypeBracketNamedPropertyAccess.ts, 6, 7))
 
 var f = function () { };
 >f : Symbol(f, Decl(augmentedTypeBracketNamedPropertyAccess.ts, 7, 3))
+>function () { } : Symbol((Anonymous function), Decl(augmentedTypeBracketNamedPropertyAccess.ts, 7, 7))
 
 var r1 = o['data']; // Should be number
 >r1 : Symbol(r1, Decl(augmentedTypeBracketNamedPropertyAccess.ts, 9, 3))
diff --git a/tests/baselines/reference/badOverloadError.symbols b/tests/baselines/reference/badOverloadError.symbols
index 86c0a332f8ff1..43cd3a3846137 100644
--- a/tests/baselines/reference/badOverloadError.symbols
+++ b/tests/baselines/reference/badOverloadError.symbols
@@ -5,5 +5,6 @@ function method() {
     var dictionary = <{ [index: string]: string; }>{};
 >dictionary : Symbol(dictionary, Decl(badOverloadError.ts, 1, 7))
 >index : Symbol(index, Decl(badOverloadError.ts, 1, 25))
+>{} : Symbol(, Decl(badOverloadError.ts, 1, 51))
 }
 
diff --git a/tests/baselines/reference/badThisBinding.symbols b/tests/baselines/reference/badThisBinding.symbols
index c1ca8d1f48137..23d4c281955b2 100644
--- a/tests/baselines/reference/badThisBinding.symbols
+++ b/tests/baselines/reference/badThisBinding.symbols
@@ -13,9 +13,11 @@ class Greeter {
     constructor() {
 		foo(() => {
 >foo : Symbol(foo, Decl(badThisBinding.ts, 0, 0))
+>() => {            bar(() => {                var x = this;			});		} : Symbol((Anonymous function), Decl(badThisBinding.ts, 5, 6))
 
             bar(() => {
 >bar : Symbol(bar, Decl(badThisBinding.ts, 0, 33))
+>() => {                var x = this;			} : Symbol((Anonymous function), Decl(badThisBinding.ts, 6, 16))
 
                 var x = this;
 >x : Symbol(x, Decl(badThisBinding.ts, 7, 19))
diff --git a/tests/baselines/reference/bestCommonTypeOfConditionalExpressions.symbols b/tests/baselines/reference/bestCommonTypeOfConditionalExpressions.symbols
index e6b6def094457..b5916bd2ee341 100644
--- a/tests/baselines/reference/bestCommonTypeOfConditionalExpressions.symbols
+++ b/tests/baselines/reference/bestCommonTypeOfConditionalExpressions.symbols
@@ -43,6 +43,7 @@ var r = true ? 1 : 2;
 
 var r3 = true ? 1 : {};
 >r3 : Symbol(r3, Decl(bestCommonTypeOfConditionalExpressions.ts, 14, 3))
+>{} : Symbol(, Decl(bestCommonTypeOfConditionalExpressions.ts, 14, 19))
 
 var r4 = true ? a : b; // typeof a
 >r4 : Symbol(r4, Decl(bestCommonTypeOfConditionalExpressions.ts, 15, 3))
@@ -56,7 +57,9 @@ var r5 = true ? b : a; // typeof b
 
 var r6 = true ? (x: number) => { } : (x: Object) => { }; // returns number => void
 >r6 : Symbol(r6, Decl(bestCommonTypeOfConditionalExpressions.ts, 17, 3))
+>(x: number) => { } : Symbol((Anonymous function), Decl(bestCommonTypeOfConditionalExpressions.ts, 17, 15))
 >x : Symbol(x, Decl(bestCommonTypeOfConditionalExpressions.ts, 17, 17))
+>(x: Object) => { } : Symbol((Anonymous function), Decl(bestCommonTypeOfConditionalExpressions.ts, 17, 36))
 >x : Symbol(x, Decl(bestCommonTypeOfConditionalExpressions.ts, 17, 38))
 >Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
 
@@ -64,14 +67,18 @@ var r7: (x: Object) => void = true ? (x: number) => { } : (x: Object) => { };
 >r7 : Symbol(r7, Decl(bestCommonTypeOfConditionalExpressions.ts, 18, 3))
 >x : Symbol(x, Decl(bestCommonTypeOfConditionalExpressions.ts, 18, 9))
 >Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>(x: number) => { } : Symbol((Anonymous function), Decl(bestCommonTypeOfConditionalExpressions.ts, 18, 36))
 >x : Symbol(x, Decl(bestCommonTypeOfConditionalExpressions.ts, 18, 38))
+>(x: Object) => { } : Symbol((Anonymous function), Decl(bestCommonTypeOfConditionalExpressions.ts, 18, 57))
 >x : Symbol(x, Decl(bestCommonTypeOfConditionalExpressions.ts, 18, 59))
 >Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
 
 var r8 = true ? (x: Object) => { } : (x: number) => { }; // returns Object => void
 >r8 : Symbol(r8, Decl(bestCommonTypeOfConditionalExpressions.ts, 19, 3))
+>(x: Object) => { } : Symbol((Anonymous function), Decl(bestCommonTypeOfConditionalExpressions.ts, 19, 15))
 >x : Symbol(x, Decl(bestCommonTypeOfConditionalExpressions.ts, 19, 17))
 >Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>(x: number) => { } : Symbol((Anonymous function), Decl(bestCommonTypeOfConditionalExpressions.ts, 19, 36))
 >x : Symbol(x, Decl(bestCommonTypeOfConditionalExpressions.ts, 19, 38))
 
 var r10: Base = true ? derived : derived2; // no error since we use the contextual type in BCT
diff --git a/tests/baselines/reference/bestCommonTypeWithContextualTyping.symbols b/tests/baselines/reference/bestCommonTypeWithContextualTyping.symbols
index cfa5310bd3c97..fb169d3eda0fb 100644
--- a/tests/baselines/reference/bestCommonTypeWithContextualTyping.symbols
+++ b/tests/baselines/reference/bestCommonTypeWithContextualTyping.symbols
@@ -35,6 +35,7 @@ var obj: { [s: string]: Contextual } = { s: e }; // { s: Ellement; [s: string]:
 >obj : Symbol(obj, Decl(bestCommonTypeWithContextualTyping.ts, 16, 3))
 >s : Symbol(s, Decl(bestCommonTypeWithContextualTyping.ts, 16, 12))
 >Contextual : Symbol(Contextual, Decl(bestCommonTypeWithContextualTyping.ts, 0, 0))
+>{ s: e } : Symbol(, Decl(bestCommonTypeWithContextualTyping.ts, 16, 38))
 >s : Symbol(s, Decl(bestCommonTypeWithContextualTyping.ts, 16, 40))
 >e : Symbol(e, Decl(bestCommonTypeWithContextualTyping.ts, 10, 3))
 
diff --git a/tests/baselines/reference/binaryIntegerLiteral.symbols b/tests/baselines/reference/binaryIntegerLiteral.symbols
index 31e28819657b0..25a48c0cdd6f0 100644
--- a/tests/baselines/reference/binaryIntegerLiteral.symbols
+++ b/tests/baselines/reference/binaryIntegerLiteral.symbols
@@ -13,6 +13,7 @@ var bin4 = 0B1111111111111111111111111111111111111111111111111111111111111111111
 
 var obj1 = {
 >obj1 : Symbol(obj1, Decl(binaryIntegerLiteral.ts, 5, 3))
+>{    0b11010: "Hello",    a: bin1,    bin1,    b: 0b11010,    0B111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111101001010100000010111110001111111111: true,} : Symbol(, Decl(binaryIntegerLiteral.ts, 5, 10))
 
     0b11010: "Hello",
     a: bin1,
@@ -30,6 +31,7 @@ var obj1 = {
 
 var obj2 = {
 >obj2 : Symbol(obj2, Decl(binaryIntegerLiteral.ts, 13, 3))
+>{    0B11010: "World",    a: bin2,    bin2,    b: 0B11010,    0B11111111111111111111111111111111111111111111111101001010100000010111110001111111111: false,} : Symbol(, Decl(binaryIntegerLiteral.ts, 13, 10))
 
     0B11010: "World",
     a: bin2,
diff --git a/tests/baselines/reference/binaryIntegerLiteralES6.symbols b/tests/baselines/reference/binaryIntegerLiteralES6.symbols
index 4fb7aaff82dcf..48ea403f81b3a 100644
--- a/tests/baselines/reference/binaryIntegerLiteralES6.symbols
+++ b/tests/baselines/reference/binaryIntegerLiteralES6.symbols
@@ -13,6 +13,7 @@ var bin4 = 0B1111111111111111111111111111111111111111111111111111111111111111111
 
 var obj1 = {
 >obj1 : Symbol(obj1, Decl(binaryIntegerLiteralES6.ts, 5, 3))
+>{    0b11010: "Hello",    a: bin1,    bin1,    b: 0b11010,    0B111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111101001010100000010111110001111111111: true,} : Symbol(, Decl(binaryIntegerLiteralES6.ts, 5, 10))
 
     0b11010: "Hello",
     a: bin1,
@@ -30,6 +31,7 @@ var obj1 = {
 
 var obj2 = {
 >obj2 : Symbol(obj2, Decl(binaryIntegerLiteralES6.ts, 13, 3))
+>{    0B11010: "World",    a: bin2,    bin2,    b: 0B11010,    0B11111111111111111111111111111111111111111111111101001010100000010111110001111111111: false,} : Symbol(, Decl(binaryIntegerLiteralES6.ts, 13, 10))
 
     0B11010: "World",
     a: bin2,
diff --git a/tests/baselines/reference/bitwiseNotOperatorWithBooleanType.symbols b/tests/baselines/reference/bitwiseNotOperatorWithBooleanType.symbols
index d6a29a11980a6..e93a939997f89 100644
--- a/tests/baselines/reference/bitwiseNotOperatorWithBooleanType.symbols
+++ b/tests/baselines/reference/bitwiseNotOperatorWithBooleanType.symbols
@@ -37,6 +37,7 @@ var ResultIsNumber2 = ~true;
 
 var ResultIsNumber3 = ~{ x: true, y: false };
 >ResultIsNumber3 : Symbol(ResultIsNumber3, Decl(bitwiseNotOperatorWithBooleanType.ts, 20, 3))
+>{ x: true, y: false } : Symbol(, Decl(bitwiseNotOperatorWithBooleanType.ts, 20, 23))
 >x : Symbol(x, Decl(bitwiseNotOperatorWithBooleanType.ts, 20, 24))
 >y : Symbol(y, Decl(bitwiseNotOperatorWithBooleanType.ts, 20, 33))
 
diff --git a/tests/baselines/reference/bitwiseNotOperatorWithNumberType.symbols b/tests/baselines/reference/bitwiseNotOperatorWithNumberType.symbols
index 2cb37660135eb..9c5c5ba6665c7 100644
--- a/tests/baselines/reference/bitwiseNotOperatorWithNumberType.symbols
+++ b/tests/baselines/reference/bitwiseNotOperatorWithNumberType.symbols
@@ -44,13 +44,16 @@ var ResultIsNumber3 = ~1;
 
 var ResultIsNumber4 = ~{ x: 1, y: 2};
 >ResultIsNumber4 : Symbol(ResultIsNumber4, Decl(bitwiseNotOperatorWithNumberType.ts, 22, 3))
+>{ x: 1, y: 2} : Symbol(, Decl(bitwiseNotOperatorWithNumberType.ts, 22, 23))
 >x : Symbol(x, Decl(bitwiseNotOperatorWithNumberType.ts, 22, 24))
 >y : Symbol(y, Decl(bitwiseNotOperatorWithNumberType.ts, 22, 30))
 
 var ResultIsNumber5 = ~{ x: 1, y: (n: number) => { return n; } };
 >ResultIsNumber5 : Symbol(ResultIsNumber5, Decl(bitwiseNotOperatorWithNumberType.ts, 23, 3))
+>{ x: 1, y: (n: number) => { return n; } } : Symbol(, Decl(bitwiseNotOperatorWithNumberType.ts, 23, 23))
 >x : Symbol(x, Decl(bitwiseNotOperatorWithNumberType.ts, 23, 24))
 >y : Symbol(y, Decl(bitwiseNotOperatorWithNumberType.ts, 23, 30))
+>(n: number) => { return n; } : Symbol((Anonymous function), Decl(bitwiseNotOperatorWithNumberType.ts, 23, 33))
 >n : Symbol(n, Decl(bitwiseNotOperatorWithNumberType.ts, 23, 35))
 >n : Symbol(n, Decl(bitwiseNotOperatorWithNumberType.ts, 23, 35))
 
diff --git a/tests/baselines/reference/bitwiseNotOperatorWithStringType.symbols b/tests/baselines/reference/bitwiseNotOperatorWithStringType.symbols
index 1e2d28f51c20d..f0fddda8b3bf4 100644
--- a/tests/baselines/reference/bitwiseNotOperatorWithStringType.symbols
+++ b/tests/baselines/reference/bitwiseNotOperatorWithStringType.symbols
@@ -44,13 +44,16 @@ var ResultIsNumber3 = ~"";
 
 var ResultIsNumber4 = ~{ x: "", y: "" };
 >ResultIsNumber4 : Symbol(ResultIsNumber4, Decl(bitwiseNotOperatorWithStringType.ts, 22, 3))
+>{ x: "", y: "" } : Symbol(, Decl(bitwiseNotOperatorWithStringType.ts, 22, 23))
 >x : Symbol(x, Decl(bitwiseNotOperatorWithStringType.ts, 22, 24))
 >y : Symbol(y, Decl(bitwiseNotOperatorWithStringType.ts, 22, 31))
 
 var ResultIsNumber5 = ~{ x: "", y: (s: string) => { return s; } };
 >ResultIsNumber5 : Symbol(ResultIsNumber5, Decl(bitwiseNotOperatorWithStringType.ts, 23, 3))
+>{ x: "", y: (s: string) => { return s; } } : Symbol(, Decl(bitwiseNotOperatorWithStringType.ts, 23, 23))
 >x : Symbol(x, Decl(bitwiseNotOperatorWithStringType.ts, 23, 24))
 >y : Symbol(y, Decl(bitwiseNotOperatorWithStringType.ts, 23, 31))
+>(s: string) => { return s; } : Symbol((Anonymous function), Decl(bitwiseNotOperatorWithStringType.ts, 23, 34))
 >s : Symbol(s, Decl(bitwiseNotOperatorWithStringType.ts, 23, 36))
 >s : Symbol(s, Decl(bitwiseNotOperatorWithStringType.ts, 23, 36))
 
diff --git a/tests/baselines/reference/callGenericFunctionWithZeroTypeArguments.symbols b/tests/baselines/reference/callGenericFunctionWithZeroTypeArguments.symbols
index 107650c530eed..c141bb80f23df 100644
--- a/tests/baselines/reference/callGenericFunctionWithZeroTypeArguments.symbols
+++ b/tests/baselines/reference/callGenericFunctionWithZeroTypeArguments.symbols
@@ -14,6 +14,7 @@ var r = f(1);
 
 var f2 = <T>(x: T): T => { return null; }
 >f2 : Symbol(f2, Decl(callGenericFunctionWithZeroTypeArguments.ts, 5, 3))
+><T>(x: T): T => { return null; } : Symbol((Anonymous function), Decl(callGenericFunctionWithZeroTypeArguments.ts, 5, 8))
 >T : Symbol(T, Decl(callGenericFunctionWithZeroTypeArguments.ts, 5, 10))
 >x : Symbol(x, Decl(callGenericFunctionWithZeroTypeArguments.ts, 5, 13))
 >T : Symbol(T, Decl(callGenericFunctionWithZeroTypeArguments.ts, 5, 10))
diff --git a/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.symbols b/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.symbols
index 1c5a6786ab707..be1bdba158800 100644
--- a/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.symbols
+++ b/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.symbols
@@ -97,6 +97,7 @@ function foo8(x: number) {
 >x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 50, 14))
 
     return { x: x };
+>{ x: x } : Symbol(, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 51, 10))
 >x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 51, 12))
 >x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 50, 14))
 }
diff --git a/tests/baselines/reference/callSignaturesWithOptionalParameters.symbols b/tests/baselines/reference/callSignaturesWithOptionalParameters.symbols
index 542bd425fb121..914420002e174 100644
--- a/tests/baselines/reference/callSignaturesWithOptionalParameters.symbols
+++ b/tests/baselines/reference/callSignaturesWithOptionalParameters.symbols
@@ -7,11 +7,13 @@ function foo(x?: number) { }
 
 var f = function foo(x?: number) { }
 >f : Symbol(f, Decl(callSignaturesWithOptionalParameters.ts, 3, 3))
+>function foo(x?: number) { } : Symbol(foo, Decl(callSignaturesWithOptionalParameters.ts, 3, 7))
 >foo : Symbol(foo, Decl(callSignaturesWithOptionalParameters.ts, 3, 7))
 >x : Symbol(x, Decl(callSignaturesWithOptionalParameters.ts, 3, 21))
 
 var f2 = (x: number, y?: number) => { }
 >f2 : Symbol(f2, Decl(callSignaturesWithOptionalParameters.ts, 4, 3))
+>(x: number, y?: number) => { } : Symbol((Anonymous function), Decl(callSignaturesWithOptionalParameters.ts, 4, 8))
 >x : Symbol(x, Decl(callSignaturesWithOptionalParameters.ts, 4, 10))
 >y : Symbol(y, Decl(callSignaturesWithOptionalParameters.ts, 4, 20))
 
@@ -116,6 +118,7 @@ a.foo(1);
 
 var b = {
 >b : Symbol(b, Decl(callSignaturesWithOptionalParameters.ts, 42, 3))
+>{    foo(x?: number) { },    a: function foo(x: number, y?: number) { },    b: (x?: number) => { }} : Symbol(, Decl(callSignaturesWithOptionalParameters.ts, 42, 7))
 
     foo(x?: number) { },
 >foo : Symbol(foo, Decl(callSignaturesWithOptionalParameters.ts, 42, 9))
@@ -123,12 +126,14 @@ var b = {
 
     a: function foo(x: number, y?: number) { },
 >a : Symbol(a, Decl(callSignaturesWithOptionalParameters.ts, 43, 24))
+>function foo(x: number, y?: number) { } : Symbol(foo, Decl(callSignaturesWithOptionalParameters.ts, 44, 6))
 >foo : Symbol(foo, Decl(callSignaturesWithOptionalParameters.ts, 44, 6))
 >x : Symbol(x, Decl(callSignaturesWithOptionalParameters.ts, 44, 20))
 >y : Symbol(y, Decl(callSignaturesWithOptionalParameters.ts, 44, 30))
 
     b: (x?: number) => { }
 >b : Symbol(b, Decl(callSignaturesWithOptionalParameters.ts, 44, 47))
+>(x?: number) => { } : Symbol((Anonymous function), Decl(callSignaturesWithOptionalParameters.ts, 45, 6))
 >x : Symbol(x, Decl(callSignaturesWithOptionalParameters.ts, 45, 8))
 }
 
diff --git a/tests/baselines/reference/callbacksDontShareTypes.symbols b/tests/baselines/reference/callbacksDontShareTypes.symbols
index 80a5f234d383e..ee84869c72853 100644
--- a/tests/baselines/reference/callbacksDontShareTypes.symbols
+++ b/tests/baselines/reference/callbacksDontShareTypes.symbols
@@ -55,6 +55,7 @@ var c2: Collection<number>;
 
 var rf1 = (x: number) => { return x.toFixed() };
 >rf1 : Symbol(rf1, Decl(callbacksDontShareTypes.ts, 13, 3))
+>(x: number) => { return x.toFixed() } : Symbol((Anonymous function), Decl(callbacksDontShareTypes.ts, 13, 9))
 >x : Symbol(x, Decl(callbacksDontShareTypes.ts, 13, 11))
 >x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
 >x : Symbol(x, Decl(callbacksDontShareTypes.ts, 13, 11))
@@ -66,6 +67,7 @@ var r1a = _.map(c2, (x) => { return x.toFixed() });
 >_ : Symbol(_, Decl(callbacksDontShareTypes.ts, 10, 3))
 >map : Symbol(Combinators.map, Decl(callbacksDontShareTypes.ts, 5, 23), Decl(callbacksDontShareTypes.ts, 6, 63))
 >c2 : Symbol(c2, Decl(callbacksDontShareTypes.ts, 11, 3))
+>(x) => { return x.toFixed() } : Symbol((Anonymous function), Decl(callbacksDontShareTypes.ts, 14, 19))
 >x : Symbol(x, Decl(callbacksDontShareTypes.ts, 14, 21))
 >x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
 >x : Symbol(x, Decl(callbacksDontShareTypes.ts, 14, 21))
@@ -85,6 +87,7 @@ var r5a = _.map<number, string>(c2, (x) => { return x.toFixed() });
 >_ : Symbol(_, Decl(callbacksDontShareTypes.ts, 10, 3))
 >map : Symbol(Combinators.map, Decl(callbacksDontShareTypes.ts, 5, 23), Decl(callbacksDontShareTypes.ts, 6, 63))
 >c2 : Symbol(c2, Decl(callbacksDontShareTypes.ts, 11, 3))
+>(x) => { return x.toFixed() } : Symbol((Anonymous function), Decl(callbacksDontShareTypes.ts, 16, 35))
 >x : Symbol(x, Decl(callbacksDontShareTypes.ts, 16, 37))
 >x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
 >x : Symbol(x, Decl(callbacksDontShareTypes.ts, 16, 37))
diff --git a/tests/baselines/reference/captureThisInSuperCall.symbols b/tests/baselines/reference/captureThisInSuperCall.symbols
index bf1fd151b3c49..88f41d4365f19 100644
--- a/tests/baselines/reference/captureThisInSuperCall.symbols
+++ b/tests/baselines/reference/captureThisInSuperCall.symbols
@@ -12,7 +12,9 @@ class B extends A {
 
     constructor() { super({ test: () => this.someMethod()}); } 
 >super : Symbol(A, Decl(captureThisInSuperCall.ts, 0, 0))
+>{ test: () => this.someMethod()} : Symbol(, Decl(captureThisInSuperCall.ts, 5, 26))
 >test : Symbol(test, Decl(captureThisInSuperCall.ts, 5, 27))
+>() => this.someMethod() : Symbol((Anonymous function), Decl(captureThisInSuperCall.ts, 5, 33))
 >this.someMethod : Symbol(someMethod, Decl(captureThisInSuperCall.ts, 5, 62))
 >this : Symbol(B, Decl(captureThisInSuperCall.ts, 2, 1))
 >someMethod : Symbol(someMethod, Decl(captureThisInSuperCall.ts, 5, 62))
diff --git a/tests/baselines/reference/castExpressionParentheses.symbols b/tests/baselines/reference/castExpressionParentheses.symbols
index 7bc8169e40fe9..c21b34c1e8154 100644
--- a/tests/baselines/reference/castExpressionParentheses.symbols
+++ b/tests/baselines/reference/castExpressionParentheses.symbols
@@ -5,6 +5,7 @@ declare var a;
 // parentheses should be omitted
 // literals
 (<any>{a:0});  
+>{a:0} : Symbol(, Decl(castExpressionParentheses.ts, 4, 6))
 >a : Symbol(a, Decl(castExpressionParentheses.ts, 4, 7))
 
 (<any>[1,3,]); 
@@ -49,9 +50,11 @@ new (<any>A());
 >A : Symbol(A, Decl(castExpressionParentheses.ts, 21, 11))
 
 (<Tany>()=> {})();
+><Tany>()=> {} : Symbol((Anonymous function), Decl(castExpressionParentheses.ts, 28, 1))
 >Tany : Symbol(Tany, Decl(castExpressionParentheses.ts, 28, 2))
 
 (<any>function foo() { })();
+>function foo() { } : Symbol(foo, Decl(castExpressionParentheses.ts, 29, 6))
 >foo : Symbol(foo, Decl(castExpressionParentheses.ts, 29, 6))
 
 (<any><number><any>-A).x; 
diff --git a/tests/baselines/reference/castTest.symbols b/tests/baselines/reference/castTest.symbols
index e0bf154820e52..fe2027627b24a 100644
--- a/tests/baselines/reference/castTest.symbols
+++ b/tests/baselines/reference/castTest.symbols
@@ -57,6 +57,7 @@ declare class Point
 var p_cast = <Point> ({
 >p_cast : Symbol(p_cast, Decl(castTest.ts, 22, 3))
 >Point : Symbol(Point, Decl(castTest.ts, 11, 37))
+>{    x: 0,    y: 0,    add: function(dx, dy) {        return new Point(this.x + dx, this.y + dy);    },    mult: function(p) { return p; }} : Symbol(, Decl(castTest.ts, 22, 22))
 
     x: 0,
 >x : Symbol(x, Decl(castTest.ts, 22, 23))
@@ -66,6 +67,7 @@ var p_cast = <Point> ({
 
     add: function(dx, dy) {
 >add : Symbol(add, Decl(castTest.ts, 24, 9))
+>function(dx, dy) {        return new Point(this.x + dx, this.y + dy);    } : Symbol((Anonymous function), Decl(castTest.ts, 25, 8))
 >dx : Symbol(dx, Decl(castTest.ts, 25, 18))
 >dy : Symbol(dy, Decl(castTest.ts, 25, 21))
 
@@ -77,6 +79,7 @@ var p_cast = <Point> ({
     },
     mult: function(p) { return p; }
 >mult : Symbol(mult, Decl(castTest.ts, 27, 6))
+>function(p) { return p; } : Symbol((Anonymous function), Decl(castTest.ts, 28, 9))
 >p : Symbol(p, Decl(castTest.ts, 28, 19))
 >p : Symbol(p, Decl(castTest.ts, 28, 19))
 
diff --git a/tests/baselines/reference/chainedSpecializationToObjectTypeLiteral.symbols b/tests/baselines/reference/chainedSpecializationToObjectTypeLiteral.symbols
index 5eb563d3ef615..194ed5d574e10 100644
--- a/tests/baselines/reference/chainedSpecializationToObjectTypeLiteral.symbols
+++ b/tests/baselines/reference/chainedSpecializationToObjectTypeLiteral.symbols
@@ -50,6 +50,7 @@ var s2 = s.groupBy(s => s.length);
 >s.groupBy : Symbol(Sequence.groupBy, Decl(chainedSpecializationToObjectTypeLiteral.ts, 3, 57))
 >s : Symbol(s, Decl(chainedSpecializationToObjectTypeLiteral.ts, 7, 3))
 >groupBy : Symbol(Sequence.groupBy, Decl(chainedSpecializationToObjectTypeLiteral.ts, 3, 57))
+>s => s.length : Symbol((Anonymous function), Decl(chainedSpecializationToObjectTypeLiteral.ts, 8, 19))
 >s : Symbol(s, Decl(chainedSpecializationToObjectTypeLiteral.ts, 8, 19))
 >s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >s : Symbol(s, Decl(chainedSpecializationToObjectTypeLiteral.ts, 8, 19))
@@ -60,6 +61,7 @@ var s3 = s2.each(x => { x.key /* Type is K, should be number */ });
 >s2.each : Symbol(Sequence.each, Decl(chainedSpecializationToObjectTypeLiteral.ts, 0, 23))
 >s2 : Symbol(s2, Decl(chainedSpecializationToObjectTypeLiteral.ts, 8, 3))
 >each : Symbol(Sequence.each, Decl(chainedSpecializationToObjectTypeLiteral.ts, 0, 23))
+>x => { x.key /* Type is K, should be number */ } : Symbol((Anonymous function), Decl(chainedSpecializationToObjectTypeLiteral.ts, 9, 17))
 >x : Symbol(x, Decl(chainedSpecializationToObjectTypeLiteral.ts, 9, 17))
 >x.key : Symbol(key, Decl(chainedSpecializationToObjectTypeLiteral.ts, 4, 56))
 >x : Symbol(x, Decl(chainedSpecializationToObjectTypeLiteral.ts, 9, 17))
diff --git a/tests/baselines/reference/classExpression.symbols b/tests/baselines/reference/classExpression.symbols
index f4d4423649983..131659fe9244e 100644
--- a/tests/baselines/reference/classExpression.symbols
+++ b/tests/baselines/reference/classExpression.symbols
@@ -1,14 +1,17 @@
 === tests/cases/conformance/classes/classExpression.ts ===
 var x = class C {
 >x : Symbol(x, Decl(classExpression.ts, 0, 3))
+>class C {} : Symbol(C, Decl(classExpression.ts, 0, 7))
 >C : Symbol(C, Decl(classExpression.ts, 0, 7))
 }
 
 var y = {
 >y : Symbol(y, Decl(classExpression.ts, 3, 3))
+>{    foo: class C2 {    }} : Symbol(, Decl(classExpression.ts, 3, 7))
 
     foo: class C2 {
 >foo : Symbol(foo, Decl(classExpression.ts, 3, 9))
+>class C2 {    } : Symbol(C2, Decl(classExpression.ts, 4, 8))
 >C2 : Symbol(C2, Decl(classExpression.ts, 4, 8))
     }
 }
@@ -18,6 +21,7 @@ module M {
 
     var z = class C4 {
 >z : Symbol(z, Decl(classExpression.ts, 9, 7))
+>class C4 {    } : Symbol(C4, Decl(classExpression.ts, 9, 11))
 >C4 : Symbol(C4, Decl(classExpression.ts, 9, 11))
     }
 }
diff --git a/tests/baselines/reference/classExpression1.symbols b/tests/baselines/reference/classExpression1.symbols
index 8d3bad269b4f4..719ee3971f4b6 100644
--- a/tests/baselines/reference/classExpression1.symbols
+++ b/tests/baselines/reference/classExpression1.symbols
@@ -1,5 +1,6 @@
 === tests/cases/conformance/classes/classExpressions/classExpression1.ts ===
 var v = class C {};
 >v : Symbol(v, Decl(classExpression1.ts, 0, 3))
+>class C {} : Symbol(C, Decl(classExpression1.ts, 0, 7))
 >C : Symbol(C, Decl(classExpression1.ts, 0, 7))
 
diff --git a/tests/baselines/reference/classExpression2.symbols b/tests/baselines/reference/classExpression2.symbols
index 11c78a2cad2b0..a82fb2eef3a8c 100644
--- a/tests/baselines/reference/classExpression2.symbols
+++ b/tests/baselines/reference/classExpression2.symbols
@@ -4,6 +4,7 @@ class D { }
 
 var v = class C extends D {};
 >v : Symbol(v, Decl(classExpression2.ts, 1, 3))
+>class C extends D {} : Symbol(C, Decl(classExpression2.ts, 1, 7))
 >C : Symbol(C, Decl(classExpression2.ts, 1, 7))
 >D : Symbol(D, Decl(classExpression2.ts, 0, 0))
 
diff --git a/tests/baselines/reference/classExpression3.symbols b/tests/baselines/reference/classExpression3.symbols
index bc1b263a00044..1fe7d3362b6d8 100644
--- a/tests/baselines/reference/classExpression3.symbols
+++ b/tests/baselines/reference/classExpression3.symbols
@@ -1,6 +1,9 @@
 === tests/cases/conformance/classes/classExpressions/classExpression3.ts ===
 let C = class extends class extends class { a = 1 } { b = 2 } { c = 3 };
 >C : Symbol(C, Decl(classExpression3.ts, 0, 3))
+>class extends class extends class { a = 1 } { b = 2 } { c = 3 } : Symbol((Anonymous class), Decl(classExpression3.ts, 0, 7))
+>class extends class { a = 1 } { b = 2 } : Symbol((Anonymous class), Decl(classExpression3.ts, 0, 21))
+>class { a = 1 } : Symbol((Anonymous class), Decl(classExpression3.ts, 0, 35))
 >a : Symbol((Anonymous class).a, Decl(classExpression3.ts, 0, 43))
 >b : Symbol((Anonymous class).b, Decl(classExpression3.ts, 0, 53))
 >c : Symbol((Anonymous class).c, Decl(classExpression3.ts, 0, 63))
diff --git a/tests/baselines/reference/classExpression4.symbols b/tests/baselines/reference/classExpression4.symbols
index 4df5302cecc56..34cd362f5f6d4 100644
--- a/tests/baselines/reference/classExpression4.symbols
+++ b/tests/baselines/reference/classExpression4.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/classes/classExpressions/classExpression4.ts ===
 let C = class {
 >C : Symbol(C, Decl(classExpression4.ts, 0, 3))
+>class {    foo() {        return new C();    }} : Symbol((Anonymous class), Decl(classExpression4.ts, 0, 7))
 
     foo() {
 >foo : Symbol((Anonymous class).foo, Decl(classExpression4.ts, 0, 15))
diff --git a/tests/baselines/reference/classExpressionES61.symbols b/tests/baselines/reference/classExpressionES61.symbols
index 1f49229fbc738..7a8cf95402b16 100644
--- a/tests/baselines/reference/classExpressionES61.symbols
+++ b/tests/baselines/reference/classExpressionES61.symbols
@@ -1,5 +1,6 @@
 === tests/cases/conformance/es6/classExpressions/classExpressionES61.ts ===
 var v = class C {};
 >v : Symbol(v, Decl(classExpressionES61.ts, 0, 3))
+>class C {} : Symbol(C, Decl(classExpressionES61.ts, 0, 7))
 >C : Symbol(C, Decl(classExpressionES61.ts, 0, 7))
 
diff --git a/tests/baselines/reference/classExpressionES62.symbols b/tests/baselines/reference/classExpressionES62.symbols
index 18e1a48ca30d7..aa612d33e0b89 100644
--- a/tests/baselines/reference/classExpressionES62.symbols
+++ b/tests/baselines/reference/classExpressionES62.symbols
@@ -4,6 +4,7 @@ class D { }
 
 var v = class C extends D {};
 >v : Symbol(v, Decl(classExpressionES62.ts, 1, 3))
+>class C extends D {} : Symbol(C, Decl(classExpressionES62.ts, 1, 7))
 >C : Symbol(C, Decl(classExpressionES62.ts, 1, 7))
 >D : Symbol(D, Decl(classExpressionES62.ts, 0, 0))
 
diff --git a/tests/baselines/reference/classExpressionES63.symbols b/tests/baselines/reference/classExpressionES63.symbols
index 4e52d5ee9ddc1..4ea70feb3bf78 100644
--- a/tests/baselines/reference/classExpressionES63.symbols
+++ b/tests/baselines/reference/classExpressionES63.symbols
@@ -1,6 +1,9 @@
 === tests/cases/conformance/es6/classExpressions/classExpressionES63.ts ===
 let C = class extends class extends class { a = 1 } { b = 2 } { c = 3 };
 >C : Symbol(C, Decl(classExpressionES63.ts, 0, 3))
+>class extends class extends class { a = 1 } { b = 2 } { c = 3 } : Symbol((Anonymous class), Decl(classExpressionES63.ts, 0, 7))
+>class extends class { a = 1 } { b = 2 } : Symbol((Anonymous class), Decl(classExpressionES63.ts, 0, 21))
+>class { a = 1 } : Symbol((Anonymous class), Decl(classExpressionES63.ts, 0, 35))
 >a : Symbol((Anonymous class).a, Decl(classExpressionES63.ts, 0, 43))
 >b : Symbol((Anonymous class).b, Decl(classExpressionES63.ts, 0, 53))
 >c : Symbol((Anonymous class).c, Decl(classExpressionES63.ts, 0, 63))
diff --git a/tests/baselines/reference/classExpressionTest1.symbols b/tests/baselines/reference/classExpressionTest1.symbols
index 684ee3028957d..96a5f48dda264 100644
--- a/tests/baselines/reference/classExpressionTest1.symbols
+++ b/tests/baselines/reference/classExpressionTest1.symbols
@@ -19,6 +19,7 @@ function M() {
 >X : Symbol(X, Decl(classExpressionTest1.ts, 1, 12))
 
             return { t, x };
+>{ t, x } : Symbol(, Decl(classExpressionTest1.ts, 5, 18))
 >t : Symbol(t, Decl(classExpressionTest1.ts, 5, 20))
 >x : Symbol(x, Decl(classExpressionTest1.ts, 5, 23))
         }
diff --git a/tests/baselines/reference/classExpressionTest2.symbols b/tests/baselines/reference/classExpressionTest2.symbols
index 62143cf0b9f08..0fbfb11544662 100644
--- a/tests/baselines/reference/classExpressionTest2.symbols
+++ b/tests/baselines/reference/classExpressionTest2.symbols
@@ -4,6 +4,7 @@ function M() {
 
     var m = class C<X> {
 >m : Symbol(m, Decl(classExpressionTest2.ts, 1, 7))
+>class C<X> {        f<T>() {            var t: T;            var x: X;            return { t, x };        }    } : Symbol(C, Decl(classExpressionTest2.ts, 1, 11))
 >C : Symbol(C, Decl(classExpressionTest2.ts, 1, 11))
 >X : Symbol(X, Decl(classExpressionTest2.ts, 1, 20))
 
@@ -20,6 +21,7 @@ function M() {
 >X : Symbol(X, Decl(classExpressionTest2.ts, 1, 20))
 
             return { t, x };
+>{ t, x } : Symbol(, Decl(classExpressionTest2.ts, 5, 18))
 >t : Symbol(t, Decl(classExpressionTest2.ts, 5, 20))
 >x : Symbol(x, Decl(classExpressionTest2.ts, 5, 23))
         }
diff --git a/tests/baselines/reference/classExpressionWithResolutionOfNamespaceOfSameName01.symbols b/tests/baselines/reference/classExpressionWithResolutionOfNamespaceOfSameName01.symbols
index fcd4f0388db3e..0db0c1df64d29 100644
--- a/tests/baselines/reference/classExpressionWithResolutionOfNamespaceOfSameName01.symbols
+++ b/tests/baselines/reference/classExpressionWithResolutionOfNamespaceOfSameName01.symbols
@@ -9,6 +9,7 @@ namespace C {
 
 var x = class C {
 >x : Symbol(x, Decl(classExpressionWithResolutionOfNamespaceOfSameName01.ts, 5, 3))
+>class C {    prop: C.type;} : Symbol(C, Decl(classExpressionWithResolutionOfNamespaceOfSameName01.ts, 5, 7))
 >C : Symbol(C, Decl(classExpressionWithResolutionOfNamespaceOfSameName01.ts, 5, 7))
 
     prop: C.type;
diff --git a/tests/baselines/reference/classExpressionWithStaticProperties1.symbols b/tests/baselines/reference/classExpressionWithStaticProperties1.symbols
index d4c811daebec3..f73ca19352112 100644
--- a/tests/baselines/reference/classExpressionWithStaticProperties1.symbols
+++ b/tests/baselines/reference/classExpressionWithStaticProperties1.symbols
@@ -1,6 +1,7 @@
 === tests/cases/compiler/classExpressionWithStaticProperties1.ts ===
 var v = class C { static a = 1; static b = 2 };
 >v : Symbol(v, Decl(classExpressionWithStaticProperties1.ts, 0, 3))
+>class C { static a = 1; static b = 2 } : Symbol(C, Decl(classExpressionWithStaticProperties1.ts, 0, 7))
 >C : Symbol(C, Decl(classExpressionWithStaticProperties1.ts, 0, 7))
 >a : Symbol(C.a, Decl(classExpressionWithStaticProperties1.ts, 0, 17))
 >b : Symbol(C.b, Decl(classExpressionWithStaticProperties1.ts, 0, 31))
diff --git a/tests/baselines/reference/classExpressionWithStaticProperties2.symbols b/tests/baselines/reference/classExpressionWithStaticProperties2.symbols
index 480123a1c3bfb..8f6ef450318a0 100644
--- a/tests/baselines/reference/classExpressionWithStaticProperties2.symbols
+++ b/tests/baselines/reference/classExpressionWithStaticProperties2.symbols
@@ -1,6 +1,7 @@
 === tests/cases/compiler/classExpressionWithStaticProperties2.ts ===
 var v = class C { static a = 1; static b };
 >v : Symbol(v, Decl(classExpressionWithStaticProperties2.ts, 0, 3))
+>class C { static a = 1; static b } : Symbol(C, Decl(classExpressionWithStaticProperties2.ts, 0, 7))
 >C : Symbol(C, Decl(classExpressionWithStaticProperties2.ts, 0, 7))
 >a : Symbol(C.a, Decl(classExpressionWithStaticProperties2.ts, 0, 17))
 >b : Symbol(C.b, Decl(classExpressionWithStaticProperties2.ts, 0, 31))
diff --git a/tests/baselines/reference/classExpressionWithStaticPropertiesES61.symbols b/tests/baselines/reference/classExpressionWithStaticPropertiesES61.symbols
index c5f53e19bffb1..7c48d34b981d8 100644
--- a/tests/baselines/reference/classExpressionWithStaticPropertiesES61.symbols
+++ b/tests/baselines/reference/classExpressionWithStaticPropertiesES61.symbols
@@ -1,6 +1,7 @@
 === tests/cases/compiler/classExpressionWithStaticPropertiesES61.ts ===
 var v = class C { static a = 1; static b = 2 };
 >v : Symbol(v, Decl(classExpressionWithStaticPropertiesES61.ts, 0, 3))
+>class C { static a = 1; static b = 2 } : Symbol(C, Decl(classExpressionWithStaticPropertiesES61.ts, 0, 7))
 >C : Symbol(C, Decl(classExpressionWithStaticPropertiesES61.ts, 0, 7))
 >a : Symbol(C.a, Decl(classExpressionWithStaticPropertiesES61.ts, 0, 17))
 >b : Symbol(C.b, Decl(classExpressionWithStaticPropertiesES61.ts, 0, 31))
diff --git a/tests/baselines/reference/classExpressionWithStaticPropertiesES62.symbols b/tests/baselines/reference/classExpressionWithStaticPropertiesES62.symbols
index be57a289f533b..3de3d399ecad8 100644
--- a/tests/baselines/reference/classExpressionWithStaticPropertiesES62.symbols
+++ b/tests/baselines/reference/classExpressionWithStaticPropertiesES62.symbols
@@ -1,6 +1,7 @@
 === tests/cases/compiler/classExpressionWithStaticPropertiesES62.ts ===
 var v = class C { static a = 1; static b };
 >v : Symbol(v, Decl(classExpressionWithStaticPropertiesES62.ts, 0, 3))
+>class C { static a = 1; static b } : Symbol(C, Decl(classExpressionWithStaticPropertiesES62.ts, 0, 7))
 >C : Symbol(C, Decl(classExpressionWithStaticPropertiesES62.ts, 0, 7))
 >a : Symbol(C.a, Decl(classExpressionWithStaticPropertiesES62.ts, 0, 17))
 >b : Symbol(C.b, Decl(classExpressionWithStaticPropertiesES62.ts, 0, 31))
diff --git a/tests/baselines/reference/classMemberInitializerWithLamdaScoping5.symbols b/tests/baselines/reference/classMemberInitializerWithLamdaScoping5.symbols
index 585bae5b3c347..76f349ecc7553 100644
--- a/tests/baselines/reference/classMemberInitializerWithLamdaScoping5.symbols
+++ b/tests/baselines/reference/classMemberInitializerWithLamdaScoping5.symbols
@@ -17,6 +17,7 @@ class Greeter {
 
     messageHandler = (message: string) => {
 >messageHandler : Symbol(messageHandler, Decl(classMemberInitializerWithLamdaScoping5.ts, 5, 5))
+>(message: string) => {        console.log(message); // This shouldnt be error    } : Symbol((Anonymous function), Decl(classMemberInitializerWithLamdaScoping5.ts, 7, 20))
 >message : Symbol(message, Decl(classMemberInitializerWithLamdaScoping5.ts, 7, 22))
 
         console.log(message); // This shouldnt be error
diff --git a/tests/baselines/reference/classWithEmptyBody.symbols b/tests/baselines/reference/classWithEmptyBody.symbols
index e08b0fe03af17..2dbd2a42926c8 100644
--- a/tests/baselines/reference/classWithEmptyBody.symbols
+++ b/tests/baselines/reference/classWithEmptyBody.symbols
@@ -16,10 +16,12 @@ c = 1;
 
 c = { foo: '' }
 >c : Symbol(c, Decl(classWithEmptyBody.ts, 3, 3))
+>{ foo: '' } : Symbol(, Decl(classWithEmptyBody.ts, 6, 3))
 >foo : Symbol(foo, Decl(classWithEmptyBody.ts, 6, 5))
 
 c = () => { }
 >c : Symbol(c, Decl(classWithEmptyBody.ts, 3, 3))
+>() => { } : Symbol((Anonymous function), Decl(classWithEmptyBody.ts, 7, 3))
 
 class D {
 >D : Symbol(D, Decl(classWithEmptyBody.ts, 7, 13))
@@ -42,8 +44,10 @@ d = 1;
 
 d = { foo: '' }
 >d : Symbol(d, Decl(classWithEmptyBody.ts, 15, 3))
+>{ foo: '' } : Symbol(, Decl(classWithEmptyBody.ts, 18, 3))
 >foo : Symbol(foo, Decl(classWithEmptyBody.ts, 18, 5))
 
 d = () => { }
 >d : Symbol(d, Decl(classWithEmptyBody.ts, 15, 3))
+>() => { } : Symbol((Anonymous function), Decl(classWithEmptyBody.ts, 19, 3))
 
diff --git a/tests/baselines/reference/classWithProtectedProperty.symbols b/tests/baselines/reference/classWithProtectedProperty.symbols
index 017233081b25c..e71b5d6e2c949 100644
--- a/tests/baselines/reference/classWithProtectedProperty.symbols
+++ b/tests/baselines/reference/classWithProtectedProperty.symbols
@@ -18,6 +18,7 @@ class C {
 
     protected d = () => '';
 >d : Symbol(d, Decl(classWithProtectedProperty.ts, 6, 31))
+>() => '' : Symbol((Anonymous function), Decl(classWithProtectedProperty.ts, 7, 17))
 
     protected static e;
 >e : Symbol(C.e, Decl(classWithProtectedProperty.ts, 7, 27))
@@ -27,6 +28,7 @@ class C {
 
     protected static g = () => '';
 >g : Symbol(C.g, Decl(classWithProtectedProperty.ts, 9, 38))
+>() => '' : Symbol((Anonymous function), Decl(classWithProtectedProperty.ts, 10, 24))
 }
 
 class D extends C {
diff --git a/tests/baselines/reference/classWithPublicProperty.symbols b/tests/baselines/reference/classWithPublicProperty.symbols
index 0e3aa272e5d3f..9e461a0c7c69a 100644
--- a/tests/baselines/reference/classWithPublicProperty.symbols
+++ b/tests/baselines/reference/classWithPublicProperty.symbols
@@ -16,6 +16,7 @@ class C {
 
     public d = () => '';
 >d : Symbol(d, Decl(classWithPublicProperty.ts, 4, 28))
+>() => '' : Symbol((Anonymous function), Decl(classWithPublicProperty.ts, 5, 14))
 
     public static e;
 >e : Symbol(C.e, Decl(classWithPublicProperty.ts, 5, 24))
@@ -25,6 +26,7 @@ class C {
 
     public static g = () => '';
 >g : Symbol(C.g, Decl(classWithPublicProperty.ts, 7, 35))
+>() => '' : Symbol((Anonymous function), Decl(classWithPublicProperty.ts, 8, 21))
 }
 
 // all of these are valid
diff --git a/tests/baselines/reference/collisionRestParameterArrowFunctions.symbols b/tests/baselines/reference/collisionRestParameterArrowFunctions.symbols
index 9a44f92b1f511..c1fc705a8ad9d 100644
--- a/tests/baselines/reference/collisionRestParameterArrowFunctions.symbols
+++ b/tests/baselines/reference/collisionRestParameterArrowFunctions.symbols
@@ -1,6 +1,7 @@
 === tests/cases/compiler/collisionRestParameterArrowFunctions.ts ===
 var f1 = (_i: number, ...restParameters) => { //_i is error
 >f1 : Symbol(f1, Decl(collisionRestParameterArrowFunctions.ts, 0, 3))
+>(_i: number, ...restParameters) => { //_i is error    var _i = 10; // no error} : Symbol((Anonymous function), Decl(collisionRestParameterArrowFunctions.ts, 0, 8))
 >_i : Symbol(_i, Decl(collisionRestParameterArrowFunctions.ts, 0, 10), Decl(collisionRestParameterArrowFunctions.ts, 1, 7))
 >restParameters : Symbol(restParameters, Decl(collisionRestParameterArrowFunctions.ts, 0, 21))
 
@@ -9,6 +10,7 @@ var f1 = (_i: number, ...restParameters) => { //_i is error
 }
 var f1NoError = (_i: number) => { // no error
 >f1NoError : Symbol(f1NoError, Decl(collisionRestParameterArrowFunctions.ts, 3, 3))
+>(_i: number) => { // no error    var _i = 10; // no error} : Symbol((Anonymous function), Decl(collisionRestParameterArrowFunctions.ts, 3, 15))
 >_i : Symbol(_i, Decl(collisionRestParameterArrowFunctions.ts, 3, 17), Decl(collisionRestParameterArrowFunctions.ts, 4, 7))
 
     var _i = 10; // no error
@@ -17,6 +19,7 @@ var f1NoError = (_i: number) => { // no error
 
 var f2 = (...restParameters) => {
 >f2 : Symbol(f2, Decl(collisionRestParameterArrowFunctions.ts, 7, 3))
+>(...restParameters) => {    var _i = 10; // No Error} : Symbol((Anonymous function), Decl(collisionRestParameterArrowFunctions.ts, 7, 8))
 >restParameters : Symbol(restParameters, Decl(collisionRestParameterArrowFunctions.ts, 7, 10))
 
     var _i = 10; // No Error
@@ -24,6 +27,7 @@ var f2 = (...restParameters) => {
 }
 var f2NoError = () => {
 >f2NoError : Symbol(f2NoError, Decl(collisionRestParameterArrowFunctions.ts, 10, 3))
+>() => {    var _i = 10; // no error} : Symbol((Anonymous function), Decl(collisionRestParameterArrowFunctions.ts, 10, 15))
 
     var _i = 10; // no error
 >_i : Symbol(_i, Decl(collisionRestParameterArrowFunctions.ts, 11, 7))
diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.symbols b/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.symbols
index 42f24f77d5061..54baebcf26f3b 100644
--- a/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.symbols
+++ b/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.symbols
@@ -78,6 +78,8 @@ ANY = null, OBJECT
 >OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3))
 
 true, {}
+>{} : Symbol(, Decl(commaOperatorWithSecondOperandObjectType.ts, 27, 5))
+
 !BOOLEAN, []
 >BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandObjectType.ts, 1, 3))
 
@@ -101,10 +103,12 @@ var resultIsObject7 = (ANY = null, OBJECT);
 
 var resultIsObject8 = (true, {});
 >resultIsObject8 : Symbol(resultIsObject8, Decl(commaOperatorWithSecondOperandObjectType.ts, 34, 3))
+>{} : Symbol(, Decl(commaOperatorWithSecondOperandObjectType.ts, 34, 28))
 
 var resultIsObject9 = (!BOOLEAN, { a: 1, b: "s" });
 >resultIsObject9 : Symbol(resultIsObject9, Decl(commaOperatorWithSecondOperandObjectType.ts, 35, 3))
 >BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandObjectType.ts, 1, 3))
+>{ a: 1, b: "s" } : Symbol(, Decl(commaOperatorWithSecondOperandObjectType.ts, 35, 32))
 >a : Symbol(a, Decl(commaOperatorWithSecondOperandObjectType.ts, 35, 34))
 >b : Symbol(b, Decl(commaOperatorWithSecondOperandObjectType.ts, 35, 40))
 
diff --git a/tests/baselines/reference/commentInMethodCall.symbols b/tests/baselines/reference/commentInMethodCall.symbols
index ff286983e23a0..47caf88f31f17 100644
--- a/tests/baselines/reference/commentInMethodCall.symbols
+++ b/tests/baselines/reference/commentInMethodCall.symbols
@@ -9,4 +9,5 @@ s.map(// do something
 >map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
 
     function () { });
+>function () { } : Symbol((Anonymous function), Decl(commentInMethodCall.ts, 2, 6))
 
diff --git a/tests/baselines/reference/commentOnSimpleArrowFunctionBody1.symbols b/tests/baselines/reference/commentOnSimpleArrowFunctionBody1.symbols
index efbcb08496dc5..31657df746a8c 100644
--- a/tests/baselines/reference/commentOnSimpleArrowFunctionBody1.symbols
+++ b/tests/baselines/reference/commentOnSimpleArrowFunctionBody1.symbols
@@ -7,6 +7,7 @@ function Foo(x: any)
  
 Foo(() =>
 >Foo : Symbol(Foo, Decl(commentOnSimpleArrowFunctionBody1.ts, 0, 0))
+>() =>    // do something    127 : Symbol((Anonymous function), Decl(commentOnSimpleArrowFunctionBody1.ts, 4, 4))
 
     // do something
     127);
diff --git a/tests/baselines/reference/commentsBeforeFunctionExpression1.symbols b/tests/baselines/reference/commentsBeforeFunctionExpression1.symbols
index adeea60711e27..d0622bebe78b7 100644
--- a/tests/baselines/reference/commentsBeforeFunctionExpression1.symbols
+++ b/tests/baselines/reference/commentsBeforeFunctionExpression1.symbols
@@ -1,9 +1,11 @@
 === tests/cases/compiler/commentsBeforeFunctionExpression1.ts ===
 var v = {
 >v : Symbol(v, Decl(commentsBeforeFunctionExpression1.ts, 0, 3))
+>{    f: /**own f*/ (a) => 0} : Symbol(, Decl(commentsBeforeFunctionExpression1.ts, 0, 7))
 
     f: /**own f*/ (a) => 0
 >f : Symbol(f, Decl(commentsBeforeFunctionExpression1.ts, 0, 9))
+>(a) => 0 : Symbol((Anonymous function), Decl(commentsBeforeFunctionExpression1.ts, 1, 6))
 >a : Symbol(a, Decl(commentsBeforeFunctionExpression1.ts, 1, 19))
 }
 
diff --git a/tests/baselines/reference/commentsFunction.symbols b/tests/baselines/reference/commentsFunction.symbols
index dfc68eb6743e1..53d6f1a6613e6 100644
--- a/tests/baselines/reference/commentsFunction.symbols
+++ b/tests/baselines/reference/commentsFunction.symbols
@@ -30,6 +30,7 @@ fooWithParameters("a", 10);
  */
 var fooFunc = function FooFunctionValue(/** fooFunctionValue param */ b: string) {
 >fooFunc : Symbol(fooFunc, Decl(commentsFunction.ts, 15, 3))
+>function FooFunctionValue(/** fooFunctionValue param */ b: string) {    return b;} : Symbol(FooFunctionValue, Decl(commentsFunction.ts, 15, 13))
 >FooFunctionValue : Symbol(FooFunctionValue, Decl(commentsFunction.ts, 15, 13))
 >b : Symbol(b, Decl(commentsFunction.ts, 15, 40))
 
@@ -40,6 +41,7 @@ var fooFunc = function FooFunctionValue(/** fooFunctionValue param */ b: string)
 /// lamdaFoo var comment
 var lambdaFoo = /** this is lambda comment*/ (/**param a*/a: number, /**param b*/b: number) => a + b;
 >lambdaFoo : Symbol(lambdaFoo, Decl(commentsFunction.ts, 20, 3))
+>(/**param a*/a: number, /**param b*/b: number) => a + b : Symbol((Anonymous function), Decl(commentsFunction.ts, 20, 15))
 >a : Symbol(a, Decl(commentsFunction.ts, 20, 46))
 >b : Symbol(b, Decl(commentsFunction.ts, 20, 68))
 >a : Symbol(a, Decl(commentsFunction.ts, 20, 46))
@@ -47,6 +49,7 @@ var lambdaFoo = /** this is lambda comment*/ (/**param a*/a: number, /**param b*
 
 var lambddaNoVarComment = /** this is lambda multiplication*/ (/**param a*/a: number, /**param b*/b: number) => a * b;
 >lambddaNoVarComment : Symbol(lambddaNoVarComment, Decl(commentsFunction.ts, 21, 3))
+>(/**param a*/a: number, /**param b*/b: number) => a * b : Symbol((Anonymous function), Decl(commentsFunction.ts, 21, 25))
 >a : Symbol(a, Decl(commentsFunction.ts, 21, 63))
 >b : Symbol(b, Decl(commentsFunction.ts, 21, 85))
 >a : Symbol(a, Decl(commentsFunction.ts, 21, 63))
@@ -79,13 +82,17 @@ function blah3(a: string // trailing commen single line
 
 lambdaFoo = (a, b) => a * b; // This is trailing comment
 >lambdaFoo : Symbol(lambdaFoo, Decl(commentsFunction.ts, 20, 3))
+>(a, b) => a * b : Symbol((Anonymous function), Decl(commentsFunction.ts, 36, 11))
 >a : Symbol(a, Decl(commentsFunction.ts, 36, 13))
 >b : Symbol(b, Decl(commentsFunction.ts, 36, 15))
 >a : Symbol(a, Decl(commentsFunction.ts, 36, 13))
 >b : Symbol(b, Decl(commentsFunction.ts, 36, 15))
 
 /*leading comment*/() => 0; // Needs to be wrapped in parens to be a valid expression (not declaration)
+>() => 0 : Symbol((Anonymous function), Decl(commentsFunction.ts, 36, 28))
+
 /*leading comment*/(() => 0); //trailing comment
+>() => 0 : Symbol((Anonymous function), Decl(commentsFunction.ts, 39, 20))
 
 function blah4(/*1*/a: string/*2*/,/*3*/b: string/*4*/) {
 >blah4 : Symbol(blah4, Decl(commentsFunction.ts, 39, 29))
diff --git a/tests/baselines/reference/commentsInterface.symbols b/tests/baselines/reference/commentsInterface.symbols
index 78d89989ed186..fe957ee4f8041 100644
--- a/tests/baselines/reference/commentsInterface.symbols
+++ b/tests/baselines/reference/commentsInterface.symbols
@@ -179,9 +179,11 @@ var i3_i: i3;
 
 i3_i = {
 >i3_i : Symbol(i3_i, Decl(commentsInterface.ts, 54, 3))
+>{    f: /**own f*/ (/**i3_i a*/a: number) => "Hello" + a,    l: this.f,    /** own x*/    x: this.f(10),    nc_x: this.l(this.x),    nc_f: this.f,    nc_l: this.l} : Symbol(, Decl(commentsInterface.ts, 55, 6))
 
     f: /**own f*/ (/**i3_i a*/a: number) => "Hello" + a,
 >f : Symbol(f, Decl(commentsInterface.ts, 55, 8))
+>(/**i3_i a*/a: number) => "Hello" + a : Symbol((Anonymous function), Decl(commentsInterface.ts, 56, 6))
 >a : Symbol(a, Decl(commentsInterface.ts, 56, 19))
 >a : Symbol(a, Decl(commentsInterface.ts, 56, 19))
 
diff --git a/tests/baselines/reference/commentsOnObjectLiteral3.symbols b/tests/baselines/reference/commentsOnObjectLiteral3.symbols
index 3d58fe2d6d7eb..0612853f4b1ee 100644
--- a/tests/baselines/reference/commentsOnObjectLiteral3.symbols
+++ b/tests/baselines/reference/commentsOnObjectLiteral3.symbols
@@ -2,6 +2,7 @@
 
 var v = {
 >v : Symbol(v, Decl(commentsOnObjectLiteral3.ts, 1, 3))
+>{ //property prop: 1 /* multiple trailing comments */ /*trailing comments*/, //property func: function () { }, //PropertyName + CallSignature func1() { }, //getter get a() {  return this.prop; } /*trailing 1*/, //setter set a(value) {  this.prop = value; } // trailing 2} : Symbol(, Decl(commentsOnObjectLiteral3.ts, 1, 7))
 
  //property
  prop: 1 /* multiple trailing comments */ /*trailing comments*/,
@@ -10,6 +11,7 @@ var v = {
  //property
  func: function () {
 >func : Symbol(func, Decl(commentsOnObjectLiteral3.ts, 3, 64))
+>function () { } : Symbol((Anonymous function), Decl(commentsOnObjectLiteral3.ts, 5, 6))
 
  },
  //PropertyName + CallSignature
diff --git a/tests/baselines/reference/commentsOnObjectLiteral4.symbols b/tests/baselines/reference/commentsOnObjectLiteral4.symbols
index c1762cb75c8e8..b9236e7a760de 100644
--- a/tests/baselines/reference/commentsOnObjectLiteral4.symbols
+++ b/tests/baselines/reference/commentsOnObjectLiteral4.symbols
@@ -2,6 +2,7 @@
 
 var v = {
 >v : Symbol(v, Decl(commentsOnObjectLiteral4.ts, 1, 3))
+>{ /**  * @type {number}  */ get bar(): number {  return this._bar; }} : Symbol(, Decl(commentsOnObjectLiteral4.ts, 1, 7))
 
  /**
   * @type {number}
diff --git a/tests/baselines/reference/commentsPropertySignature1.symbols b/tests/baselines/reference/commentsPropertySignature1.symbols
index 2e97f70187152..45419ed3cbf1e 100644
--- a/tests/baselines/reference/commentsPropertySignature1.symbols
+++ b/tests/baselines/reference/commentsPropertySignature1.symbols
@@ -1,6 +1,7 @@
 === tests/cases/compiler/commentsPropertySignature1.ts ===
 var a = {
 >a : Symbol(a, Decl(commentsPropertySignature1.ts, 0, 3))
+>{    /** own x*/    x: 0} : Symbol(, Decl(commentsPropertySignature1.ts, 0, 7))
 
     /** own x*/
     x: 0
diff --git a/tests/baselines/reference/commentsVarDecl.symbols b/tests/baselines/reference/commentsVarDecl.symbols
index d2ec3d4edcdfd..b606e689f5e31 100644
--- a/tests/baselines/reference/commentsVarDecl.symbols
+++ b/tests/baselines/reference/commentsVarDecl.symbols
@@ -48,6 +48,7 @@ var yy =
 /** comment2 */
 var z = /** lambda comment */ (x: number, y: number) => x + y;
 >z : Symbol(z, Decl(commentsVarDecl.ts, 35, 3))
+>(x: number, y: number) => x + y : Symbol((Anonymous function), Decl(commentsVarDecl.ts, 35, 7))
 >x : Symbol(x, Decl(commentsVarDecl.ts, 35, 31))
 >y : Symbol(y, Decl(commentsVarDecl.ts, 35, 41))
 >x : Symbol(x, Decl(commentsVarDecl.ts, 35, 31))
diff --git a/tests/baselines/reference/commonJSImportNotAsPrimaryExpression.symbols b/tests/baselines/reference/commonJSImportNotAsPrimaryExpression.symbols
index 68a852c6165aa..8748a877c0323 100644
--- a/tests/baselines/reference/commonJSImportNotAsPrimaryExpression.symbols
+++ b/tests/baselines/reference/commonJSImportNotAsPrimaryExpression.symbols
@@ -18,6 +18,7 @@ var x: foo.C1 = <{m1: number}>{};
 >foo : Symbol(foo, Decl(foo_1.ts, 0, 0))
 >C1 : Symbol(foo.C1, Decl(foo_0.ts, 0, 0))
 >m1 : Symbol(m1, Decl(foo_1.ts, 4, 18))
+>{} : Symbol(, Decl(foo_1.ts, 4, 30))
 
 var y: typeof foo.C1.s1 = false;
 >y : Symbol(y, Decl(foo_1.ts, 5, 3))
diff --git a/tests/baselines/reference/complexClassRelationships.symbols b/tests/baselines/reference/complexClassRelationships.symbols
index 533c5171cf8b5..df591cef6b13b 100644
--- a/tests/baselines/reference/complexClassRelationships.symbols
+++ b/tests/baselines/reference/complexClassRelationships.symbols
@@ -26,6 +26,7 @@ class BaseCollection<T extends Base> {
 >T : Symbol(T, Decl(complexClassRelationships.ts, 7, 21))
 
         (item: Thing) => { return [item.Components]; };
+>(item: Thing) => { return [item.Components]; } : Symbol((Anonymous function), Decl(complexClassRelationships.ts, 8, 29))
 >item : Symbol(item, Decl(complexClassRelationships.ts, 9, 9))
 >Thing : Symbol(Thing, Decl(complexClassRelationships.ts, 14, 1))
 >item.Components : Symbol(Thing.Components, Decl(complexClassRelationships.ts, 16, 13))
diff --git a/tests/baselines/reference/compoundAdditionAssignmentLHSCanBeAssigned.symbols b/tests/baselines/reference/compoundAdditionAssignmentLHSCanBeAssigned.symbols
index cb2a0975e0ba0..983ac8c025300 100644
--- a/tests/baselines/reference/compoundAdditionAssignmentLHSCanBeAssigned.symbols
+++ b/tests/baselines/reference/compoundAdditionAssignmentLHSCanBeAssigned.symbols
@@ -38,6 +38,7 @@ x1 += E.a;
 
 x1 += {};
 >x1 : Symbol(x1, Decl(compoundAdditionAssignmentLHSCanBeAssigned.ts, 5, 3))
+>{} : Symbol(, Decl(compoundAdditionAssignmentLHSCanBeAssigned.ts, 12, 5))
 
 x1 += null;
 >x1 : Symbol(x1, Decl(compoundAdditionAssignmentLHSCanBeAssigned.ts, 5, 3))
@@ -74,6 +75,7 @@ x2 += E.a;
 
 x2 += {};
 >x2 : Symbol(x2, Decl(compoundAdditionAssignmentLHSCanBeAssigned.ts, 16, 3))
+>{} : Symbol(, Decl(compoundAdditionAssignmentLHSCanBeAssigned.ts, 23, 5))
 
 x2 += null;
 >x2 : Symbol(x2, Decl(compoundAdditionAssignmentLHSCanBeAssigned.ts, 16, 3))
diff --git a/tests/baselines/reference/computedPropertyNames10_ES5.symbols b/tests/baselines/reference/computedPropertyNames10_ES5.symbols
index 17d1f7ca11757..7bc820fa278b4 100644
--- a/tests/baselines/reference/computedPropertyNames10_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNames10_ES5.symbols
@@ -10,6 +10,7 @@ var a: any;
 
 var v = {
 >v : Symbol(v, Decl(computedPropertyNames10_ES5.ts, 3, 3))
+>{    [s]() { },    [n]() { },    [s + s]() { },    [s + n]() { },    [+s]() { },    [""]() { },    [0]() { },    [a]() { },    [<any>true]() { },    [`hello bye`]() { },    [`hello ${a} bye`]() { }} : Symbol(, Decl(computedPropertyNames10_ES5.ts, 3, 7))
 
     [s]() { },
 >s : Symbol(s, Decl(computedPropertyNames10_ES5.ts, 0, 3))
diff --git a/tests/baselines/reference/computedPropertyNames10_ES6.symbols b/tests/baselines/reference/computedPropertyNames10_ES6.symbols
index 4141b7872089c..7c1a49bbcfb00 100644
--- a/tests/baselines/reference/computedPropertyNames10_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNames10_ES6.symbols
@@ -10,6 +10,7 @@ var a: any;
 
 var v = {
 >v : Symbol(v, Decl(computedPropertyNames10_ES6.ts, 3, 3))
+>{    [s]() { },    [n]() { },    [s + s]() { },    [s + n]() { },    [+s]() { },    [""]() { },    [0]() { },    [a]() { },    [<any>true]() { },    [`hello bye`]() { },    [`hello ${a} bye`]() { }} : Symbol(, Decl(computedPropertyNames10_ES6.ts, 3, 7))
 
     [s]() { },
 >s : Symbol(s, Decl(computedPropertyNames10_ES6.ts, 0, 3))
diff --git a/tests/baselines/reference/computedPropertyNames11_ES5.symbols b/tests/baselines/reference/computedPropertyNames11_ES5.symbols
index 34326273e595a..b97586bb5b2b9 100644
--- a/tests/baselines/reference/computedPropertyNames11_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNames11_ES5.symbols
@@ -10,6 +10,7 @@ var a: any;
 
 var v = {
 >v : Symbol(v, Decl(computedPropertyNames11_ES5.ts, 3, 3))
+>{    get [s]() { return 0; },    set [n](v) { },    get [s + s]() { return 0; },    set [s + n](v) { },    get [+s]() { return 0; },    set [""](v) { },    get [0]() { return 0; },    set [a](v) { },    get [<any>true]() { return 0; },    set [`hello bye`](v) { },    get [`hello ${a} bye`]() { return 0; }} : Symbol(, Decl(computedPropertyNames11_ES5.ts, 3, 7))
 
     get [s]() { return 0; },
 >s : Symbol(s, Decl(computedPropertyNames11_ES5.ts, 0, 3))
diff --git a/tests/baselines/reference/computedPropertyNames11_ES6.symbols b/tests/baselines/reference/computedPropertyNames11_ES6.symbols
index 73503eb2758eb..1c77030981b67 100644
--- a/tests/baselines/reference/computedPropertyNames11_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNames11_ES6.symbols
@@ -10,6 +10,7 @@ var a: any;
 
 var v = {
 >v : Symbol(v, Decl(computedPropertyNames11_ES6.ts, 3, 3))
+>{    get [s]() { return 0; },    set [n](v) { },    get [s + s]() { return 0; },    set [s + n](v) { },    get [+s]() { return 0; },    set [""](v) { },    get [0]() { return 0; },    set [a](v) { },    get [<any>true]() { return 0; },    set [`hello bye`](v) { },    get [`hello ${a} bye`]() { return 0; }} : Symbol(, Decl(computedPropertyNames11_ES6.ts, 3, 7))
 
     get [s]() { return 0; },
 >s : Symbol(s, Decl(computedPropertyNames11_ES6.ts, 0, 3))
diff --git a/tests/baselines/reference/computedPropertyNames18_ES5.symbols b/tests/baselines/reference/computedPropertyNames18_ES5.symbols
index 86d706bc44c18..26ff3afcb5730 100644
--- a/tests/baselines/reference/computedPropertyNames18_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNames18_ES5.symbols
@@ -4,6 +4,7 @@ function foo() {
 
     var obj = {
 >obj : Symbol(obj, Decl(computedPropertyNames18_ES5.ts, 1, 7))
+>{        [this.bar]: 0    } : Symbol(, Decl(computedPropertyNames18_ES5.ts, 1, 13))
 
         [this.bar]: 0
     }
diff --git a/tests/baselines/reference/computedPropertyNames18_ES6.symbols b/tests/baselines/reference/computedPropertyNames18_ES6.symbols
index c530d1e811fd5..20b461c2b1fac 100644
--- a/tests/baselines/reference/computedPropertyNames18_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNames18_ES6.symbols
@@ -4,6 +4,7 @@ function foo() {
 
     var obj = {
 >obj : Symbol(obj, Decl(computedPropertyNames18_ES6.ts, 1, 7))
+>{        [this.bar]: 0    } : Symbol(, Decl(computedPropertyNames18_ES6.ts, 1, 13))
 
         [this.bar]: 0
     }
diff --git a/tests/baselines/reference/computedPropertyNames1_ES5.symbols b/tests/baselines/reference/computedPropertyNames1_ES5.symbols
index 2bc11580c7899..6441781a33f9e 100644
--- a/tests/baselines/reference/computedPropertyNames1_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNames1_ES5.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/computedProperties/computedPropertyNames1_ES5.ts ===
 var v = {
 >v : Symbol(v, Decl(computedPropertyNames1_ES5.ts, 0, 3))
+>{    get [0 + 1]() { return 0 },    set [0 + 1](v: string) { } //No error} : Symbol(, Decl(computedPropertyNames1_ES5.ts, 0, 7))
 
     get [0 + 1]() { return 0 },
     set [0 + 1](v: string) { } //No error
diff --git a/tests/baselines/reference/computedPropertyNames1_ES6.symbols b/tests/baselines/reference/computedPropertyNames1_ES6.symbols
index 5a1708b927dee..8713a059541c8 100644
--- a/tests/baselines/reference/computedPropertyNames1_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNames1_ES6.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/computedProperties/computedPropertyNames1_ES6.ts ===
 var v = {
 >v : Symbol(v, Decl(computedPropertyNames1_ES6.ts, 0, 3))
+>{    get [0 + 1]() { return 0 },    set [0 + 1](v: string) { } //No error} : Symbol(, Decl(computedPropertyNames1_ES6.ts, 0, 7))
 
     get [0 + 1]() { return 0 },
     set [0 + 1](v: string) { } //No error
diff --git a/tests/baselines/reference/computedPropertyNames20_ES5.symbols b/tests/baselines/reference/computedPropertyNames20_ES5.symbols
index 2ab61faa707cb..e5686053dbcb5 100644
--- a/tests/baselines/reference/computedPropertyNames20_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNames20_ES5.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/computedProperties/computedPropertyNames20_ES5.ts ===
 var obj = {
 >obj : Symbol(obj, Decl(computedPropertyNames20_ES5.ts, 0, 3))
+>{    [this.bar]: 0} : Symbol(, Decl(computedPropertyNames20_ES5.ts, 0, 9))
 
     [this.bar]: 0
 }
diff --git a/tests/baselines/reference/computedPropertyNames20_ES6.symbols b/tests/baselines/reference/computedPropertyNames20_ES6.symbols
index f7ab8c84def49..f472336289b8c 100644
--- a/tests/baselines/reference/computedPropertyNames20_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNames20_ES6.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/computedProperties/computedPropertyNames20_ES6.ts ===
 var obj = {
 >obj : Symbol(obj, Decl(computedPropertyNames20_ES6.ts, 0, 3))
+>{    [this.bar]: 0} : Symbol(, Decl(computedPropertyNames20_ES6.ts, 0, 9))
 
     [this.bar]: 0
 }
diff --git a/tests/baselines/reference/computedPropertyNames22_ES5.symbols b/tests/baselines/reference/computedPropertyNames22_ES5.symbols
index a1e08e5f48739..e254f9539020a 100644
--- a/tests/baselines/reference/computedPropertyNames22_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNames22_ES5.symbols
@@ -7,6 +7,7 @@ class C {
 
         var obj = {
 >obj : Symbol(obj, Decl(computedPropertyNames22_ES5.ts, 2, 11))
+>{            [this.bar()]() { }        } : Symbol(, Decl(computedPropertyNames22_ES5.ts, 2, 17))
 
             [this.bar()]() { }
 >this.bar : Symbol(bar, Decl(computedPropertyNames22_ES5.ts, 0, 9))
diff --git a/tests/baselines/reference/computedPropertyNames22_ES6.symbols b/tests/baselines/reference/computedPropertyNames22_ES6.symbols
index 5940bfb4cfb70..ba49cb664354a 100644
--- a/tests/baselines/reference/computedPropertyNames22_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNames22_ES6.symbols
@@ -7,6 +7,7 @@ class C {
 
         var obj = {
 >obj : Symbol(obj, Decl(computedPropertyNames22_ES6.ts, 2, 11))
+>{            [this.bar()]() { }        } : Symbol(, Decl(computedPropertyNames22_ES6.ts, 2, 17))
 
             [this.bar()]() { }
 >this.bar : Symbol(bar, Decl(computedPropertyNames22_ES6.ts, 0, 9))
diff --git a/tests/baselines/reference/computedPropertyNames25_ES5.symbols b/tests/baselines/reference/computedPropertyNames25_ES5.symbols
index e11753857cc11..ae0f91f0261da 100644
--- a/tests/baselines/reference/computedPropertyNames25_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNames25_ES5.symbols
@@ -17,6 +17,7 @@ class C extends Base {
 
         var obj = {
 >obj : Symbol(obj, Decl(computedPropertyNames25_ES5.ts, 7, 11))
+>{            [super.bar()]() { }        } : Symbol(, Decl(computedPropertyNames25_ES5.ts, 7, 17))
 
             [super.bar()]() { }
 >super.bar : Symbol(Base.bar, Decl(computedPropertyNames25_ES5.ts, 0, 12))
diff --git a/tests/baselines/reference/computedPropertyNames25_ES6.symbols b/tests/baselines/reference/computedPropertyNames25_ES6.symbols
index 8eb7393c6ac26..b78e0126aaca3 100644
--- a/tests/baselines/reference/computedPropertyNames25_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNames25_ES6.symbols
@@ -17,6 +17,7 @@ class C extends Base {
 
         var obj = {
 >obj : Symbol(obj, Decl(computedPropertyNames25_ES6.ts, 7, 11))
+>{            [super.bar()]() { }        } : Symbol(, Decl(computedPropertyNames25_ES6.ts, 7, 17))
 
             [super.bar()]() { }
 >super.bar : Symbol(Base.bar, Decl(computedPropertyNames25_ES6.ts, 0, 12))
diff --git a/tests/baselines/reference/computedPropertyNames28_ES5.symbols b/tests/baselines/reference/computedPropertyNames28_ES5.symbols
index 2934c3d040194..0036b0c7fc123 100644
--- a/tests/baselines/reference/computedPropertyNames28_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNames28_ES5.symbols
@@ -12,6 +12,7 @@ class C extends Base {
 
         var obj = {
 >obj : Symbol(obj, Decl(computedPropertyNames28_ES5.ts, 5, 11))
+>{            [(super(), "prop")]() { }        } : Symbol(, Decl(computedPropertyNames28_ES5.ts, 5, 17))
 
             [(super(), "prop")]() { }
 >super : Symbol(Base, Decl(computedPropertyNames28_ES5.ts, 0, 0))
diff --git a/tests/baselines/reference/computedPropertyNames28_ES6.symbols b/tests/baselines/reference/computedPropertyNames28_ES6.symbols
index 6824f62e2a595..d50641da5dcea 100644
--- a/tests/baselines/reference/computedPropertyNames28_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNames28_ES6.symbols
@@ -12,6 +12,7 @@ class C extends Base {
 
         var obj = {
 >obj : Symbol(obj, Decl(computedPropertyNames28_ES6.ts, 5, 11))
+>{            [(super(), "prop")]() { }        } : Symbol(, Decl(computedPropertyNames28_ES6.ts, 5, 17))
 
             [(super(), "prop")]() { }
 >super : Symbol(Base, Decl(computedPropertyNames28_ES6.ts, 0, 0))
diff --git a/tests/baselines/reference/computedPropertyNames29_ES5.symbols b/tests/baselines/reference/computedPropertyNames29_ES5.symbols
index c33a7390ce80d..21a15057fca64 100644
--- a/tests/baselines/reference/computedPropertyNames29_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNames29_ES5.symbols
@@ -6,8 +6,11 @@ class C {
 >bar : Symbol(bar, Decl(computedPropertyNames29_ES5.ts, 0, 9))
 
         () => {
+>() => {            var obj = {                [this.bar()]() { } // needs capture            };        } : Symbol((Anonymous function), Decl(computedPropertyNames29_ES5.ts, 1, 11))
+
             var obj = {
 >obj : Symbol(obj, Decl(computedPropertyNames29_ES5.ts, 3, 15))
+>{                [this.bar()]() { } // needs capture            } : Symbol(, Decl(computedPropertyNames29_ES5.ts, 3, 21))
 
                 [this.bar()]() { } // needs capture
 >this.bar : Symbol(bar, Decl(computedPropertyNames29_ES5.ts, 0, 9))
diff --git a/tests/baselines/reference/computedPropertyNames29_ES6.symbols b/tests/baselines/reference/computedPropertyNames29_ES6.symbols
index 41631ea63bba7..e7a47e6760e64 100644
--- a/tests/baselines/reference/computedPropertyNames29_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNames29_ES6.symbols
@@ -6,8 +6,11 @@ class C {
 >bar : Symbol(bar, Decl(computedPropertyNames29_ES6.ts, 0, 9))
 
         () => {
+>() => {            var obj = {                [this.bar()]() { } // needs capture            };        } : Symbol((Anonymous function), Decl(computedPropertyNames29_ES6.ts, 1, 11))
+
             var obj = {
 >obj : Symbol(obj, Decl(computedPropertyNames29_ES6.ts, 3, 15))
+>{                [this.bar()]() { } // needs capture            } : Symbol(, Decl(computedPropertyNames29_ES6.ts, 3, 21))
 
                 [this.bar()]() { } // needs capture
 >this.bar : Symbol(bar, Decl(computedPropertyNames29_ES6.ts, 0, 9))
diff --git a/tests/baselines/reference/computedPropertyNames31_ES5.symbols b/tests/baselines/reference/computedPropertyNames31_ES5.symbols
index 82a6acb286c95..65a83821ca061 100644
--- a/tests/baselines/reference/computedPropertyNames31_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNames31_ES5.symbols
@@ -16,8 +16,11 @@ class C extends Base {
 >foo : Symbol(foo, Decl(computedPropertyNames31_ES5.ts, 5, 22))
 
         () => {
+>() => {            var obj = {                [super.bar()]() { } // needs capture            };        } : Symbol((Anonymous function), Decl(computedPropertyNames31_ES5.ts, 6, 11))
+
             var obj = {
 >obj : Symbol(obj, Decl(computedPropertyNames31_ES5.ts, 8, 15))
+>{                [super.bar()]() { } // needs capture            } : Symbol(, Decl(computedPropertyNames31_ES5.ts, 8, 21))
 
                 [super.bar()]() { } // needs capture
 >super.bar : Symbol(Base.bar, Decl(computedPropertyNames31_ES5.ts, 0, 12))
diff --git a/tests/baselines/reference/computedPropertyNames31_ES6.symbols b/tests/baselines/reference/computedPropertyNames31_ES6.symbols
index 778293bbb885c..d85e042c54755 100644
--- a/tests/baselines/reference/computedPropertyNames31_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNames31_ES6.symbols
@@ -16,8 +16,11 @@ class C extends Base {
 >foo : Symbol(foo, Decl(computedPropertyNames31_ES6.ts, 5, 22))
 
         () => {
+>() => {            var obj = {                [super.bar()]() { } // needs capture            };        } : Symbol((Anonymous function), Decl(computedPropertyNames31_ES6.ts, 6, 11))
+
             var obj = {
 >obj : Symbol(obj, Decl(computedPropertyNames31_ES6.ts, 8, 15))
+>{                [super.bar()]() { } // needs capture            } : Symbol(, Decl(computedPropertyNames31_ES6.ts, 8, 21))
 
                 [super.bar()]() { } // needs capture
 >super.bar : Symbol(Base.bar, Decl(computedPropertyNames31_ES6.ts, 0, 12))
diff --git a/tests/baselines/reference/computedPropertyNames33_ES5.symbols b/tests/baselines/reference/computedPropertyNames33_ES5.symbols
index ae6dd01e7bc9d..4bb334d155615 100644
--- a/tests/baselines/reference/computedPropertyNames33_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNames33_ES5.symbols
@@ -12,6 +12,7 @@ class C<T> {
 
         var obj = {
 >obj : Symbol(obj, Decl(computedPropertyNames33_ES5.ts, 3, 11))
+>{            [foo<T>()]() { }        } : Symbol(, Decl(computedPropertyNames33_ES5.ts, 3, 17))
 
             [foo<T>()]() { }
 >foo : Symbol(foo, Decl(computedPropertyNames33_ES5.ts, 0, 0))
diff --git a/tests/baselines/reference/computedPropertyNames33_ES6.symbols b/tests/baselines/reference/computedPropertyNames33_ES6.symbols
index cf0b3abde9633..64c8a00a4684c 100644
--- a/tests/baselines/reference/computedPropertyNames33_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNames33_ES6.symbols
@@ -12,6 +12,7 @@ class C<T> {
 
         var obj = {
 >obj : Symbol(obj, Decl(computedPropertyNames33_ES6.ts, 3, 11))
+>{            [foo<T>()]() { }        } : Symbol(, Decl(computedPropertyNames33_ES6.ts, 3, 17))
 
             [foo<T>()]() { }
 >foo : Symbol(foo, Decl(computedPropertyNames33_ES6.ts, 0, 0))
diff --git a/tests/baselines/reference/computedPropertyNames46_ES5.symbols b/tests/baselines/reference/computedPropertyNames46_ES5.symbols
index 10a7cf0b528b7..d103724e722e4 100644
--- a/tests/baselines/reference/computedPropertyNames46_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNames46_ES5.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/computedProperties/computedPropertyNames46_ES5.ts ===
 var o = {
 >o : Symbol(o, Decl(computedPropertyNames46_ES5.ts, 0, 3))
+>{    ["" || 0]: 0} : Symbol(, Decl(computedPropertyNames46_ES5.ts, 0, 7))
 
     ["" || 0]: 0
 };
diff --git a/tests/baselines/reference/computedPropertyNames46_ES6.symbols b/tests/baselines/reference/computedPropertyNames46_ES6.symbols
index 3028eb8e225e0..6bf06442d9c52 100644
--- a/tests/baselines/reference/computedPropertyNames46_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNames46_ES6.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/computedProperties/computedPropertyNames46_ES6.ts ===
 var o = {
 >o : Symbol(o, Decl(computedPropertyNames46_ES6.ts, 0, 3))
+>{    ["" || 0]: 0} : Symbol(, Decl(computedPropertyNames46_ES6.ts, 0, 7))
 
     ["" || 0]: 0
 };
diff --git a/tests/baselines/reference/computedPropertyNames47_ES5.symbols b/tests/baselines/reference/computedPropertyNames47_ES5.symbols
index c124850e5a614..5345933a3372a 100644
--- a/tests/baselines/reference/computedPropertyNames47_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNames47_ES5.symbols
@@ -9,6 +9,7 @@ enum E2 { x }
 
 var o = {
 >o : Symbol(o, Decl(computedPropertyNames47_ES5.ts, 2, 3))
+>{    [E1.x || E2.x]: 0} : Symbol(, Decl(computedPropertyNames47_ES5.ts, 2, 7))
 
     [E1.x || E2.x]: 0
 >E1.x : Symbol(E1.x, Decl(computedPropertyNames47_ES5.ts, 0, 9))
diff --git a/tests/baselines/reference/computedPropertyNames47_ES6.symbols b/tests/baselines/reference/computedPropertyNames47_ES6.symbols
index ec0850d5b139a..f66d92def1fd5 100644
--- a/tests/baselines/reference/computedPropertyNames47_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNames47_ES6.symbols
@@ -9,6 +9,7 @@ enum E2 { x }
 
 var o = {
 >o : Symbol(o, Decl(computedPropertyNames47_ES6.ts, 2, 3))
+>{    [E1.x || E2.x]: 0} : Symbol(, Decl(computedPropertyNames47_ES6.ts, 2, 7))
 
     [E1.x || E2.x]: 0
 >E1.x : Symbol(E1.x, Decl(computedPropertyNames47_ES6.ts, 0, 9))
diff --git a/tests/baselines/reference/computedPropertyNames48_ES5.symbols b/tests/baselines/reference/computedPropertyNames48_ES5.symbols
index 14f7cc6352de9..30dba22c873b0 100644
--- a/tests/baselines/reference/computedPropertyNames48_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNames48_ES5.symbols
@@ -16,6 +16,7 @@ var a: any;
 
 extractIndexer({
 >extractIndexer : Symbol(extractIndexer, Decl(computedPropertyNames48_ES5.ts, 0, 0))
+>{    [a]: ""} : Symbol(, Decl(computedPropertyNames48_ES5.ts, 6, 15))
 
     [a]: ""
 >a : Symbol(a, Decl(computedPropertyNames48_ES5.ts, 4, 3))
@@ -24,6 +25,7 @@ extractIndexer({
 
 extractIndexer({
 >extractIndexer : Symbol(extractIndexer, Decl(computedPropertyNames48_ES5.ts, 0, 0))
+>{    [E.x]: ""} : Symbol(, Decl(computedPropertyNames48_ES5.ts, 10, 15))
 
     [E.x]: ""
 >E.x : Symbol(E.x, Decl(computedPropertyNames48_ES5.ts, 2, 8))
@@ -34,6 +36,7 @@ extractIndexer({
 
 extractIndexer({
 >extractIndexer : Symbol(extractIndexer, Decl(computedPropertyNames48_ES5.ts, 0, 0))
+>{    ["" || 0]: ""} : Symbol(, Decl(computedPropertyNames48_ES5.ts, 14, 15))
 
     ["" || 0]: ""
 }); // Should return any (widened form of undefined)
diff --git a/tests/baselines/reference/computedPropertyNames48_ES6.symbols b/tests/baselines/reference/computedPropertyNames48_ES6.symbols
index 5d63c9f495db3..dd4d253fe1ffc 100644
--- a/tests/baselines/reference/computedPropertyNames48_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNames48_ES6.symbols
@@ -16,6 +16,7 @@ var a: any;
 
 extractIndexer({
 >extractIndexer : Symbol(extractIndexer, Decl(computedPropertyNames48_ES6.ts, 0, 0))
+>{    [a]: ""} : Symbol(, Decl(computedPropertyNames48_ES6.ts, 6, 15))
 
     [a]: ""
 >a : Symbol(a, Decl(computedPropertyNames48_ES6.ts, 4, 3))
@@ -24,6 +25,7 @@ extractIndexer({
 
 extractIndexer({
 >extractIndexer : Symbol(extractIndexer, Decl(computedPropertyNames48_ES6.ts, 0, 0))
+>{    [E.x]: ""} : Symbol(, Decl(computedPropertyNames48_ES6.ts, 10, 15))
 
     [E.x]: ""
 >E.x : Symbol(E.x, Decl(computedPropertyNames48_ES6.ts, 2, 8))
@@ -34,6 +36,7 @@ extractIndexer({
 
 extractIndexer({
 >extractIndexer : Symbol(extractIndexer, Decl(computedPropertyNames48_ES6.ts, 0, 0))
+>{    ["" || 0]: ""} : Symbol(, Decl(computedPropertyNames48_ES6.ts, 14, 15))
 
     ["" || 0]: ""
 }); // Should return any (widened form of undefined)
diff --git a/tests/baselines/reference/computedPropertyNames4_ES5.symbols b/tests/baselines/reference/computedPropertyNames4_ES5.symbols
index be2014862864c..d0511ec8ec2ea 100644
--- a/tests/baselines/reference/computedPropertyNames4_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNames4_ES5.symbols
@@ -10,6 +10,7 @@ var a: any;
 
 var v = {
 >v : Symbol(v, Decl(computedPropertyNames4_ES5.ts, 3, 3))
+>{    [s]: 0,    [n]: n,    [s + s]: 1,    [s + n]: 2,    [+s]: s,    [""]: 0,    [0]: 0,    [a]: 1,    [<any>true]: 0,    [`hello bye`]: 0,    [`hello ${a} bye`]: 0} : Symbol(, Decl(computedPropertyNames4_ES5.ts, 3, 7))
 
     [s]: 0,
 >s : Symbol(s, Decl(computedPropertyNames4_ES5.ts, 0, 3))
diff --git a/tests/baselines/reference/computedPropertyNames4_ES6.symbols b/tests/baselines/reference/computedPropertyNames4_ES6.symbols
index b531a1b3d2844..1096c4a0b93da 100644
--- a/tests/baselines/reference/computedPropertyNames4_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNames4_ES6.symbols
@@ -10,6 +10,7 @@ var a: any;
 
 var v = {
 >v : Symbol(v, Decl(computedPropertyNames4_ES6.ts, 3, 3))
+>{    [s]: 0,    [n]: n,    [s + s]: 1,    [s + n]: 2,    [+s]: s,    [""]: 0,    [0]: 0,    [a]: 1,    [<any>true]: 0,    [`hello bye`]: 0,    [`hello ${a} bye`]: 0} : Symbol(, Decl(computedPropertyNames4_ES6.ts, 3, 7))
 
     [s]: 0,
 >s : Symbol(s, Decl(computedPropertyNames4_ES6.ts, 0, 3))
diff --git a/tests/baselines/reference/computedPropertyNames7_ES5.symbols b/tests/baselines/reference/computedPropertyNames7_ES5.symbols
index 7f5e7c0fd461a..26a4905708b74 100644
--- a/tests/baselines/reference/computedPropertyNames7_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNames7_ES5.symbols
@@ -7,6 +7,7 @@ enum E {
 }
 var v = {
 >v : Symbol(v, Decl(computedPropertyNames7_ES5.ts, 3, 3))
+>{    [E.member]: 0} : Symbol(, Decl(computedPropertyNames7_ES5.ts, 3, 7))
 
     [E.member]: 0
 >E.member : Symbol(E.member, Decl(computedPropertyNames7_ES5.ts, 0, 8))
diff --git a/tests/baselines/reference/computedPropertyNames7_ES6.symbols b/tests/baselines/reference/computedPropertyNames7_ES6.symbols
index b008d47a8438a..f93cf1f1b4d77 100644
--- a/tests/baselines/reference/computedPropertyNames7_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNames7_ES6.symbols
@@ -7,6 +7,7 @@ enum E {
 }
 var v = {
 >v : Symbol(v, Decl(computedPropertyNames7_ES6.ts, 3, 3))
+>{    [E.member]: 0} : Symbol(, Decl(computedPropertyNames7_ES6.ts, 3, 7))
 
     [E.member]: 0
 >E.member : Symbol(E.member, Decl(computedPropertyNames7_ES6.ts, 0, 8))
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType1_ES5.symbols b/tests/baselines/reference/computedPropertyNamesContextualType1_ES5.symbols
index a99a38997256f..fc798c000a8d3 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType1_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNamesContextualType1_ES5.symbols
@@ -14,6 +14,7 @@ interface I {
 var o: I = {
 >o : Symbol(o, Decl(computedPropertyNamesContextualType1_ES5.ts, 5, 3))
 >I : Symbol(I, Decl(computedPropertyNamesContextualType1_ES5.ts, 0, 0))
+>{    ["" + 0](y) { return y.length; },    ["" + 1]: y => y.length} : Symbol(, Decl(computedPropertyNamesContextualType1_ES5.ts, 5, 10))
 
     ["" + 0](y) { return y.length; },
 >y : Symbol(y, Decl(computedPropertyNamesContextualType1_ES5.ts, 6, 13))
@@ -22,6 +23,7 @@ var o: I = {
 >length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 
     ["" + 1]: y => y.length
+>y => y.length : Symbol((Anonymous function), Decl(computedPropertyNamesContextualType1_ES5.ts, 7, 13))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType1_ES5.ts, 7, 13))
 >y.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType1_ES5.ts, 7, 13))
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType1_ES6.symbols b/tests/baselines/reference/computedPropertyNamesContextualType1_ES6.symbols
index e386b8e9efa94..1af11451cb390 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType1_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNamesContextualType1_ES6.symbols
@@ -14,6 +14,7 @@ interface I {
 var o: I = {
 >o : Symbol(o, Decl(computedPropertyNamesContextualType1_ES6.ts, 5, 3))
 >I : Symbol(I, Decl(computedPropertyNamesContextualType1_ES6.ts, 0, 0))
+>{    ["" + 0](y) { return y.length; },    ["" + 1]: y => y.length} : Symbol(, Decl(computedPropertyNamesContextualType1_ES6.ts, 5, 10))
 
     ["" + 0](y) { return y.length; },
 >y : Symbol(y, Decl(computedPropertyNamesContextualType1_ES6.ts, 6, 13))
@@ -22,6 +23,7 @@ var o: I = {
 >length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 
     ["" + 1]: y => y.length
+>y => y.length : Symbol((Anonymous function), Decl(computedPropertyNamesContextualType1_ES6.ts, 7, 13))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType1_ES6.ts, 7, 13))
 >y.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType1_ES6.ts, 7, 13))
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType2_ES5.symbols b/tests/baselines/reference/computedPropertyNamesContextualType2_ES5.symbols
index fcd89e032e646..13eb10f816095 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType2_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNamesContextualType2_ES5.symbols
@@ -14,6 +14,7 @@ interface I {
 var o: I = {
 >o : Symbol(o, Decl(computedPropertyNamesContextualType2_ES5.ts, 5, 3))
 >I : Symbol(I, Decl(computedPropertyNamesContextualType2_ES5.ts, 0, 0))
+>{    [+"foo"](y) { return y.length; },    [+"bar"]: y => y.length} : Symbol(, Decl(computedPropertyNamesContextualType2_ES5.ts, 5, 10))
 
     [+"foo"](y) { return y.length; },
 >y : Symbol(y, Decl(computedPropertyNamesContextualType2_ES5.ts, 6, 13))
@@ -22,6 +23,7 @@ var o: I = {
 >length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 
     [+"bar"]: y => y.length
+>y => y.length : Symbol((Anonymous function), Decl(computedPropertyNamesContextualType2_ES5.ts, 7, 13))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType2_ES5.ts, 7, 13))
 >y.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType2_ES5.ts, 7, 13))
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType2_ES6.symbols b/tests/baselines/reference/computedPropertyNamesContextualType2_ES6.symbols
index ce6be5194c055..4554b1d8ecf4d 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType2_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNamesContextualType2_ES6.symbols
@@ -14,6 +14,7 @@ interface I {
 var o: I = {
 >o : Symbol(o, Decl(computedPropertyNamesContextualType2_ES6.ts, 5, 3))
 >I : Symbol(I, Decl(computedPropertyNamesContextualType2_ES6.ts, 0, 0))
+>{    [+"foo"](y) { return y.length; },    [+"bar"]: y => y.length} : Symbol(, Decl(computedPropertyNamesContextualType2_ES6.ts, 5, 10))
 
     [+"foo"](y) { return y.length; },
 >y : Symbol(y, Decl(computedPropertyNamesContextualType2_ES6.ts, 6, 13))
@@ -22,6 +23,7 @@ var o: I = {
 >length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 
     [+"bar"]: y => y.length
+>y => y.length : Symbol((Anonymous function), Decl(computedPropertyNamesContextualType2_ES6.ts, 7, 13))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType2_ES6.ts, 7, 13))
 >y.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType2_ES6.ts, 7, 13))
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType3_ES5.symbols b/tests/baselines/reference/computedPropertyNamesContextualType3_ES5.symbols
index d73c9c186d4b4..a7a4daef68f49 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType3_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNamesContextualType3_ES5.symbols
@@ -10,6 +10,7 @@ interface I {
 var o: I = {
 >o : Symbol(o, Decl(computedPropertyNamesContextualType3_ES5.ts, 4, 3))
 >I : Symbol(I, Decl(computedPropertyNamesContextualType3_ES5.ts, 0, 0))
+>{    [+"foo"](y) { return y.length; },    [+"bar"]: y => y.length} : Symbol(, Decl(computedPropertyNamesContextualType3_ES5.ts, 4, 10))
 
     [+"foo"](y) { return y.length; },
 >y : Symbol(y, Decl(computedPropertyNamesContextualType3_ES5.ts, 5, 13))
@@ -18,6 +19,7 @@ var o: I = {
 >length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 
     [+"bar"]: y => y.length
+>y => y.length : Symbol((Anonymous function), Decl(computedPropertyNamesContextualType3_ES5.ts, 6, 13))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType3_ES5.ts, 6, 13))
 >y.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType3_ES5.ts, 6, 13))
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType3_ES6.symbols b/tests/baselines/reference/computedPropertyNamesContextualType3_ES6.symbols
index 48e93ee62f971..ebc20976575de 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType3_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNamesContextualType3_ES6.symbols
@@ -10,6 +10,7 @@ interface I {
 var o: I = {
 >o : Symbol(o, Decl(computedPropertyNamesContextualType3_ES6.ts, 4, 3))
 >I : Symbol(I, Decl(computedPropertyNamesContextualType3_ES6.ts, 0, 0))
+>{    [+"foo"](y) { return y.length; },    [+"bar"]: y => y.length} : Symbol(, Decl(computedPropertyNamesContextualType3_ES6.ts, 4, 10))
 
     [+"foo"](y) { return y.length; },
 >y : Symbol(y, Decl(computedPropertyNamesContextualType3_ES6.ts, 5, 13))
@@ -18,6 +19,7 @@ var o: I = {
 >length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 
     [+"bar"]: y => y.length
+>y => y.length : Symbol((Anonymous function), Decl(computedPropertyNamesContextualType3_ES6.ts, 6, 13))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType3_ES6.ts, 6, 13))
 >y.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType3_ES6.ts, 6, 13))
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType4_ES5.symbols b/tests/baselines/reference/computedPropertyNamesContextualType4_ES5.symbols
index f6f19f3fd61e0..7441cd39039de 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType4_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNamesContextualType4_ES5.symbols
@@ -12,6 +12,7 @@ interface I {
 var o: I = {
 >o : Symbol(o, Decl(computedPropertyNamesContextualType4_ES5.ts, 5, 3))
 >I : Symbol(I, Decl(computedPropertyNamesContextualType4_ES5.ts, 0, 0))
+>{    [""+"foo"]: "",    [""+"bar"]: 0} : Symbol(, Decl(computedPropertyNamesContextualType4_ES5.ts, 5, 10))
 
     [""+"foo"]: "",
     [""+"bar"]: 0
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType4_ES6.symbols b/tests/baselines/reference/computedPropertyNamesContextualType4_ES6.symbols
index 184a561425cce..5884b2b60e0e3 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType4_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNamesContextualType4_ES6.symbols
@@ -12,6 +12,7 @@ interface I {
 var o: I = {
 >o : Symbol(o, Decl(computedPropertyNamesContextualType4_ES6.ts, 5, 3))
 >I : Symbol(I, Decl(computedPropertyNamesContextualType4_ES6.ts, 0, 0))
+>{    [""+"foo"]: "",    [""+"bar"]: 0} : Symbol(, Decl(computedPropertyNamesContextualType4_ES6.ts, 5, 10))
 
     [""+"foo"]: "",
     [""+"bar"]: 0
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType5_ES5.symbols b/tests/baselines/reference/computedPropertyNamesContextualType5_ES5.symbols
index e93cf3f94a1c7..309f0068449db 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType5_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNamesContextualType5_ES5.symbols
@@ -12,6 +12,7 @@ interface I {
 var o: I = {
 >o : Symbol(o, Decl(computedPropertyNamesContextualType5_ES5.ts, 5, 3))
 >I : Symbol(I, Decl(computedPropertyNamesContextualType5_ES5.ts, 0, 0))
+>{    [+"foo"]: "",    [+"bar"]: 0} : Symbol(, Decl(computedPropertyNamesContextualType5_ES5.ts, 5, 10))
 
     [+"foo"]: "",
     [+"bar"]: 0
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType5_ES6.symbols b/tests/baselines/reference/computedPropertyNamesContextualType5_ES6.symbols
index 46212968874ae..689abee2e6206 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType5_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNamesContextualType5_ES6.symbols
@@ -12,6 +12,7 @@ interface I {
 var o: I = {
 >o : Symbol(o, Decl(computedPropertyNamesContextualType5_ES6.ts, 5, 3))
 >I : Symbol(I, Decl(computedPropertyNamesContextualType5_ES6.ts, 0, 0))
+>{    [+"foo"]: "",    [+"bar"]: 0} : Symbol(, Decl(computedPropertyNamesContextualType5_ES6.ts, 5, 10))
 
     [+"foo"]: "",
     [+"bar"]: 0
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType6_ES5.symbols b/tests/baselines/reference/computedPropertyNamesContextualType6_ES5.symbols
index fb303b1f8b371..a4c0516c959a4 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType6_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNamesContextualType6_ES5.symbols
@@ -18,11 +18,14 @@ declare function foo<T>(obj: I<T>): T
 
 foo({
 >foo : Symbol(foo, Decl(computedPropertyNamesContextualType6_ES5.ts, 2, 1))
+>{    p: "",    0: () => { },    ["hi" + "bye"]: true,    [0 + 1]: 0,    [+"hi"]: [0]} : Symbol(, Decl(computedPropertyNamesContextualType6_ES5.ts, 6, 4))
 
     p: "",
 >p : Symbol(p, Decl(computedPropertyNamesContextualType6_ES5.ts, 6, 5))
 
     0: () => { },
+>() => { } : Symbol((Anonymous function), Decl(computedPropertyNamesContextualType6_ES5.ts, 8, 6))
+
     ["hi" + "bye"]: true,
     [0 + 1]: 0,
     [+"hi"]: [0]
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType6_ES6.symbols b/tests/baselines/reference/computedPropertyNamesContextualType6_ES6.symbols
index b3e371447e200..8e20b6dd344cf 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType6_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNamesContextualType6_ES6.symbols
@@ -18,11 +18,14 @@ declare function foo<T>(obj: I<T>): T
 
 foo({
 >foo : Symbol(foo, Decl(computedPropertyNamesContextualType6_ES6.ts, 2, 1))
+>{    p: "",    0: () => { },    ["hi" + "bye"]: true,    [0 + 1]: 0,    [+"hi"]: [0]} : Symbol(, Decl(computedPropertyNamesContextualType6_ES6.ts, 6, 4))
 
     p: "",
 >p : Symbol(p, Decl(computedPropertyNamesContextualType6_ES6.ts, 6, 5))
 
     0: () => { },
+>() => { } : Symbol((Anonymous function), Decl(computedPropertyNamesContextualType6_ES6.ts, 8, 6))
+
     ["hi" + "bye"]: true,
     [0 + 1]: 0,
     [+"hi"]: [0]
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType7_ES5.symbols b/tests/baselines/reference/computedPropertyNamesContextualType7_ES5.symbols
index 22e4cf2b45b4e..7c930d33aba4f 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType7_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNamesContextualType7_ES5.symbols
@@ -18,11 +18,14 @@ declare function foo<T>(obj: I<T>): T
 
 foo({
 >foo : Symbol(foo, Decl(computedPropertyNamesContextualType7_ES5.ts, 2, 1))
+>{    p: "",    0: () => { },    ["hi" + "bye"]: true,    [0 + 1]: 0,    [+"hi"]: [0]} : Symbol(, Decl(computedPropertyNamesContextualType7_ES5.ts, 6, 4))
 
     p: "",
 >p : Symbol(p, Decl(computedPropertyNamesContextualType7_ES5.ts, 6, 5))
 
     0: () => { },
+>() => { } : Symbol((Anonymous function), Decl(computedPropertyNamesContextualType7_ES5.ts, 8, 6))
+
     ["hi" + "bye"]: true,
     [0 + 1]: 0,
     [+"hi"]: [0]
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType7_ES6.symbols b/tests/baselines/reference/computedPropertyNamesContextualType7_ES6.symbols
index 7f33ebf58ad7e..c83adf9484344 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType7_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNamesContextualType7_ES6.symbols
@@ -18,11 +18,14 @@ declare function foo<T>(obj: I<T>): T
 
 foo({
 >foo : Symbol(foo, Decl(computedPropertyNamesContextualType7_ES6.ts, 2, 1))
+>{    p: "",    0: () => { },    ["hi" + "bye"]: true,    [0 + 1]: 0,    [+"hi"]: [0]} : Symbol(, Decl(computedPropertyNamesContextualType7_ES6.ts, 6, 4))
 
     p: "",
 >p : Symbol(p, Decl(computedPropertyNamesContextualType7_ES6.ts, 6, 5))
 
     0: () => { },
+>() => { } : Symbol((Anonymous function), Decl(computedPropertyNamesContextualType7_ES6.ts, 8, 6))
+
     ["hi" + "bye"]: true,
     [0 + 1]: 0,
     [+"hi"]: [0]
diff --git a/tests/baselines/reference/computedPropertyNamesDeclarationEmit5_ES5.symbols b/tests/baselines/reference/computedPropertyNamesDeclarationEmit5_ES5.symbols
index 8d40d4c86c0c1..65c62ad7656e0 100644
--- a/tests/baselines/reference/computedPropertyNamesDeclarationEmit5_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNamesDeclarationEmit5_ES5.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/computedProperties/computedPropertyNamesDeclarationEmit5_ES5.ts ===
 var v = {
 >v : Symbol(v, Decl(computedPropertyNamesDeclarationEmit5_ES5.ts, 0, 3))
+>{    ["" + ""]: 0,    ["" + ""]() { },    get ["" + ""]() { return 0; },    set ["" + ""](x) { }} : Symbol(, Decl(computedPropertyNamesDeclarationEmit5_ES5.ts, 0, 7))
 
     ["" + ""]: 0,
     ["" + ""]() { },
diff --git a/tests/baselines/reference/computedPropertyNamesDeclarationEmit5_ES6.symbols b/tests/baselines/reference/computedPropertyNamesDeclarationEmit5_ES6.symbols
index e9a7b4b28abbb..28dabbc42b1ea 100644
--- a/tests/baselines/reference/computedPropertyNamesDeclarationEmit5_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNamesDeclarationEmit5_ES6.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/computedProperties/computedPropertyNamesDeclarationEmit5_ES6.ts ===
 var v = {
 >v : Symbol(v, Decl(computedPropertyNamesDeclarationEmit5_ES6.ts, 0, 3))
+>{    ["" + ""]: 0,    ["" + ""]() { },    get ["" + ""]() { return 0; },    set ["" + ""](x) { }} : Symbol(, Decl(computedPropertyNamesDeclarationEmit5_ES6.ts, 0, 7))
 
     ["" + ""]: 0,
     ["" + ""]() { },
diff --git a/tests/baselines/reference/computedPropertyNamesSourceMap2_ES5.symbols b/tests/baselines/reference/computedPropertyNamesSourceMap2_ES5.symbols
index b9a389da6360a..c2e12786494fc 100644
--- a/tests/baselines/reference/computedPropertyNamesSourceMap2_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNamesSourceMap2_ES5.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/computedProperties/computedPropertyNamesSourceMap2_ES5.ts ===
 var v = {
 >v : Symbol(v, Decl(computedPropertyNamesSourceMap2_ES5.ts, 0, 3))
+>{    ["hello"]() {        debugger;    }} : Symbol(, Decl(computedPropertyNamesSourceMap2_ES5.ts, 0, 7))
 
     ["hello"]() {
         debugger;
diff --git a/tests/baselines/reference/computedPropertyNamesSourceMap2_ES6.symbols b/tests/baselines/reference/computedPropertyNamesSourceMap2_ES6.symbols
index 6c9d1e1d5fd34..f4ea7cce4de14 100644
--- a/tests/baselines/reference/computedPropertyNamesSourceMap2_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNamesSourceMap2_ES6.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/computedProperties/computedPropertyNamesSourceMap2_ES6.ts ===
 var v = {
 >v : Symbol(v, Decl(computedPropertyNamesSourceMap2_ES6.ts, 0, 3))
+>{    ["hello"]() {        debugger;    }} : Symbol(, Decl(computedPropertyNamesSourceMap2_ES6.ts, 0, 7))
 
     ["hello"]() {
         debugger;
diff --git a/tests/baselines/reference/conditionalExpressions2.symbols b/tests/baselines/reference/conditionalExpressions2.symbols
index 63c8b41747756..fab59c38fd5f2 100644
--- a/tests/baselines/reference/conditionalExpressions2.symbols
+++ b/tests/baselines/reference/conditionalExpressions2.symbols
@@ -21,13 +21,16 @@ var f = false ? null : undefined;
 
 var g = true ? {g:5} : null;
 >g : Symbol(g, Decl(conditionalExpressions2.ts, 6, 3))
+>{g:5} : Symbol(, Decl(conditionalExpressions2.ts, 6, 14))
 >g : Symbol(g, Decl(conditionalExpressions2.ts, 6, 16))
 
 var h = [{h:5}, null];
 >h : Symbol(h, Decl(conditionalExpressions2.ts, 7, 3))
+>{h:5} : Symbol(, Decl(conditionalExpressions2.ts, 7, 9))
 >h : Symbol(h, Decl(conditionalExpressions2.ts, 7, 10))
 
 function i() { if (true) { return { x: 5 }; } else { return null; } }
 >i : Symbol(i, Decl(conditionalExpressions2.ts, 7, 22))
+>{ x: 5 } : Symbol(, Decl(conditionalExpressions2.ts, 8, 33))
 >x : Symbol(x, Decl(conditionalExpressions2.ts, 8, 35))
 
diff --git a/tests/baselines/reference/conditionalOperatorConditionIsObjectType.symbols b/tests/baselines/reference/conditionalOperatorConditionIsObjectType.symbols
index 41f00e53b2627..9a09246d54b31 100644
--- a/tests/baselines/reference/conditionalOperatorConditionIsObjectType.symbols
+++ b/tests/baselines/reference/conditionalOperatorConditionIsObjectType.symbols
@@ -76,6 +76,7 @@ condObject ? exprString1 : exprBoolean1; // union
 
 //Cond is an object type literal
 ((a: string) => a.length) ? exprAny1 : exprAny2;
+>(a: string) => a.length : Symbol((Anonymous function), Decl(conditionalOperatorConditionIsObjectType.ts, 27, 1))
 >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 27, 2))
 >a.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 27, 2))
@@ -84,6 +85,7 @@ condObject ? exprString1 : exprBoolean1; // union
 >exprAny2 : Symbol(exprAny2, Decl(conditionalOperatorConditionIsObjectType.ts, 9, 3))
 
 ((a: string) => a.length) ? exprBoolean1 : exprBoolean2;
+>(a: string) => a.length : Symbol((Anonymous function), Decl(conditionalOperatorConditionIsObjectType.ts, 28, 1))
 >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 28, 2))
 >a.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 28, 2))
@@ -92,22 +94,26 @@ condObject ? exprString1 : exprBoolean1; // union
 >exprBoolean2 : Symbol(exprBoolean2, Decl(conditionalOperatorConditionIsObjectType.ts, 10, 3))
 
 ({}) ? exprNumber1 : exprNumber2;
+>{} : Symbol(, Decl(conditionalOperatorConditionIsObjectType.ts, 29, 1))
 >exprNumber1 : Symbol(exprNumber1, Decl(conditionalOperatorConditionIsObjectType.ts, 5, 3))
 >exprNumber2 : Symbol(exprNumber2, Decl(conditionalOperatorConditionIsObjectType.ts, 11, 3))
 
 ({ a: 1, b: "s" }) ? exprString1 : exprString2;
+>{ a: 1, b: "s" } : Symbol(, Decl(conditionalOperatorConditionIsObjectType.ts, 30, 1))
 >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 30, 2))
 >b : Symbol(b, Decl(conditionalOperatorConditionIsObjectType.ts, 30, 8))
 >exprString1 : Symbol(exprString1, Decl(conditionalOperatorConditionIsObjectType.ts, 6, 3))
 >exprString2 : Symbol(exprString2, Decl(conditionalOperatorConditionIsObjectType.ts, 12, 3))
 
 ({ a: 1, b: "s" }) ? exprIsObject1 : exprIsObject2;
+>{ a: 1, b: "s" } : Symbol(, Decl(conditionalOperatorConditionIsObjectType.ts, 31, 1))
 >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 31, 2))
 >b : Symbol(b, Decl(conditionalOperatorConditionIsObjectType.ts, 31, 8))
 >exprIsObject1 : Symbol(exprIsObject1, Decl(conditionalOperatorConditionIsObjectType.ts, 7, 3))
 >exprIsObject2 : Symbol(exprIsObject2, Decl(conditionalOperatorConditionIsObjectType.ts, 13, 3))
 
 ({ a: 1, b: "s" }) ? exprString1: exprBoolean1; // union
+>{ a: 1, b: "s" } : Symbol(, Decl(conditionalOperatorConditionIsObjectType.ts, 32, 1))
 >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 32, 2))
 >b : Symbol(b, Decl(conditionalOperatorConditionIsObjectType.ts, 32, 8))
 >exprString1 : Symbol(exprString1, Decl(conditionalOperatorConditionIsObjectType.ts, 6, 3))
@@ -187,6 +193,7 @@ var resultIsStringOrBoolean1 = condObject ? exprString1 : exprBoolean1; // union
 
 var resultIsAny2 = ((a: string) => a.length) ? exprAny1 : exprAny2;
 >resultIsAny2 : Symbol(resultIsAny2, Decl(conditionalOperatorConditionIsObjectType.ts, 50, 3))
+>(a: string) => a.length : Symbol((Anonymous function), Decl(conditionalOperatorConditionIsObjectType.ts, 50, 20))
 >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 50, 21))
 >a.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 50, 21))
@@ -196,6 +203,7 @@ var resultIsAny2 = ((a: string) => a.length) ? exprAny1 : exprAny2;
 
 var resultIsBoolean2 = ((a: string) => a.length) ? exprBoolean1 : exprBoolean2;
 >resultIsBoolean2 : Symbol(resultIsBoolean2, Decl(conditionalOperatorConditionIsObjectType.ts, 51, 3))
+>(a: string) => a.length : Symbol((Anonymous function), Decl(conditionalOperatorConditionIsObjectType.ts, 51, 24))
 >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 51, 25))
 >a.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 51, 25))
@@ -205,11 +213,13 @@ var resultIsBoolean2 = ((a: string) => a.length) ? exprBoolean1 : exprBoolean2;
 
 var resultIsNumber2 = ({}) ? exprNumber1 : exprNumber2;
 >resultIsNumber2 : Symbol(resultIsNumber2, Decl(conditionalOperatorConditionIsObjectType.ts, 52, 3))
+>{} : Symbol(, Decl(conditionalOperatorConditionIsObjectType.ts, 52, 23))
 >exprNumber1 : Symbol(exprNumber1, Decl(conditionalOperatorConditionIsObjectType.ts, 5, 3))
 >exprNumber2 : Symbol(exprNumber2, Decl(conditionalOperatorConditionIsObjectType.ts, 11, 3))
 
 var resultIsString2 = ({ a: 1, b: "s" }) ? exprString1 : exprString2;
 >resultIsString2 : Symbol(resultIsString2, Decl(conditionalOperatorConditionIsObjectType.ts, 53, 3))
+>{ a: 1, b: "s" } : Symbol(, Decl(conditionalOperatorConditionIsObjectType.ts, 53, 23))
 >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 53, 24))
 >b : Symbol(b, Decl(conditionalOperatorConditionIsObjectType.ts, 53, 30))
 >exprString1 : Symbol(exprString1, Decl(conditionalOperatorConditionIsObjectType.ts, 6, 3))
@@ -217,6 +227,7 @@ var resultIsString2 = ({ a: 1, b: "s" }) ? exprString1 : exprString2;
 
 var resultIsObject2 = ({ a: 1, b: "s" }) ? exprIsObject1 : exprIsObject2;
 >resultIsObject2 : Symbol(resultIsObject2, Decl(conditionalOperatorConditionIsObjectType.ts, 54, 3))
+>{ a: 1, b: "s" } : Symbol(, Decl(conditionalOperatorConditionIsObjectType.ts, 54, 23))
 >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 54, 24))
 >b : Symbol(b, Decl(conditionalOperatorConditionIsObjectType.ts, 54, 30))
 >exprIsObject1 : Symbol(exprIsObject1, Decl(conditionalOperatorConditionIsObjectType.ts, 7, 3))
@@ -224,6 +235,7 @@ var resultIsObject2 = ({ a: 1, b: "s" }) ? exprIsObject1 : exprIsObject2;
 
 var resultIsStringOrBoolean2 = ({ a: 1, b: "s" }) ? exprString1 : exprBoolean1; // union
 >resultIsStringOrBoolean2 : Symbol(resultIsStringOrBoolean2, Decl(conditionalOperatorConditionIsObjectType.ts, 55, 3))
+>{ a: 1, b: "s" } : Symbol(, Decl(conditionalOperatorConditionIsObjectType.ts, 55, 32))
 >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 55, 33))
 >b : Symbol(b, Decl(conditionalOperatorConditionIsObjectType.ts, 55, 39))
 >exprString1 : Symbol(exprString1, Decl(conditionalOperatorConditionIsObjectType.ts, 6, 3))
diff --git a/tests/baselines/reference/conditionalOperatorWithIdenticalBCT.symbols b/tests/baselines/reference/conditionalOperatorWithIdenticalBCT.symbols
index e4c2e43013dc2..61be0bf40e177 100644
--- a/tests/baselines/reference/conditionalOperatorWithIdenticalBCT.symbols
+++ b/tests/baselines/reference/conditionalOperatorWithIdenticalBCT.symbols
@@ -41,17 +41,24 @@ var result1 = true ? x : a;
 
 //Expr1 and Expr2 are literals
 true ? {} : 1;
+>{} : Symbol(, Decl(conditionalOperatorWithIdenticalBCT.ts, 15, 6))
+
 true ? { a: 1 } : { a: 2, b: 'string' };
+>{ a: 1 } : Symbol(, Decl(conditionalOperatorWithIdenticalBCT.ts, 16, 6))
 >a : Symbol(a, Decl(conditionalOperatorWithIdenticalBCT.ts, 16, 8))
+>{ a: 2, b: 'string' } : Symbol(, Decl(conditionalOperatorWithIdenticalBCT.ts, 16, 17))
 >a : Symbol(a, Decl(conditionalOperatorWithIdenticalBCT.ts, 16, 19))
 >b : Symbol(b, Decl(conditionalOperatorWithIdenticalBCT.ts, 16, 25))
 
 var result2 = true ? {} : 1;
 >result2 : Symbol(result2, Decl(conditionalOperatorWithIdenticalBCT.ts, 17, 3))
+>{} : Symbol(, Decl(conditionalOperatorWithIdenticalBCT.ts, 17, 20))
 
 var result3 = true ? { a: 1 } : { a: 2, b: 'string' };
 >result3 : Symbol(result3, Decl(conditionalOperatorWithIdenticalBCT.ts, 18, 3))
+>{ a: 1 } : Symbol(, Decl(conditionalOperatorWithIdenticalBCT.ts, 18, 20))
 >a : Symbol(a, Decl(conditionalOperatorWithIdenticalBCT.ts, 18, 22))
+>{ a: 2, b: 'string' } : Symbol(, Decl(conditionalOperatorWithIdenticalBCT.ts, 18, 31))
 >a : Symbol(a, Decl(conditionalOperatorWithIdenticalBCT.ts, 18, 33))
 >b : Symbol(b, Decl(conditionalOperatorWithIdenticalBCT.ts, 18, 39))
 
@@ -66,10 +73,12 @@ var result4: (t: A) => any = true ? (m) => m.propertyX : (n) => n.propertyA;
 >result4 : Symbol(result4, Decl(conditionalOperatorWithIdenticalBCT.ts, 22, 3))
 >t : Symbol(t, Decl(conditionalOperatorWithIdenticalBCT.ts, 22, 14))
 >A : Symbol(A, Decl(conditionalOperatorWithIdenticalBCT.ts, 1, 67))
+>(m) => m.propertyX : Symbol((Anonymous function), Decl(conditionalOperatorWithIdenticalBCT.ts, 22, 35))
 >m : Symbol(m, Decl(conditionalOperatorWithIdenticalBCT.ts, 22, 37))
 >m.propertyX : Symbol(X.propertyX, Decl(conditionalOperatorWithIdenticalBCT.ts, 1, 9))
 >m : Symbol(m, Decl(conditionalOperatorWithIdenticalBCT.ts, 22, 37))
 >propertyX : Symbol(X.propertyX, Decl(conditionalOperatorWithIdenticalBCT.ts, 1, 9))
+>(n) => n.propertyA : Symbol((Anonymous function), Decl(conditionalOperatorWithIdenticalBCT.ts, 22, 56))
 >n : Symbol(n, Decl(conditionalOperatorWithIdenticalBCT.ts, 22, 58))
 >n.propertyA : Symbol(A.propertyA, Decl(conditionalOperatorWithIdenticalBCT.ts, 2, 19))
 >n : Symbol(n, Decl(conditionalOperatorWithIdenticalBCT.ts, 22, 58))
@@ -88,18 +97,25 @@ var result5 = true ? a : x;
 
 //Expr1 and Expr2 are literals
 true ? 1 : {};
+>{} : Symbol(, Decl(conditionalOperatorWithIdenticalBCT.ts, 30, 10))
+
 true ? { a: 2, b: 'string' } : { a: 1 };
+>{ a: 2, b: 'string' } : Symbol(, Decl(conditionalOperatorWithIdenticalBCT.ts, 31, 6))
 >a : Symbol(a, Decl(conditionalOperatorWithIdenticalBCT.ts, 31, 8))
 >b : Symbol(b, Decl(conditionalOperatorWithIdenticalBCT.ts, 31, 14))
+>{ a: 1 } : Symbol(, Decl(conditionalOperatorWithIdenticalBCT.ts, 31, 30))
 >a : Symbol(a, Decl(conditionalOperatorWithIdenticalBCT.ts, 31, 32))
 
 var result6 = true ? 1 : {};
 >result6 : Symbol(result6, Decl(conditionalOperatorWithIdenticalBCT.ts, 32, 3))
+>{} : Symbol(, Decl(conditionalOperatorWithIdenticalBCT.ts, 32, 24))
 
 var result7 = true ? { a: 2, b: 'string' } : { a: 1 };
 >result7 : Symbol(result7, Decl(conditionalOperatorWithIdenticalBCT.ts, 33, 3))
+>{ a: 2, b: 'string' } : Symbol(, Decl(conditionalOperatorWithIdenticalBCT.ts, 33, 20))
 >a : Symbol(a, Decl(conditionalOperatorWithIdenticalBCT.ts, 33, 22))
 >b : Symbol(b, Decl(conditionalOperatorWithIdenticalBCT.ts, 33, 28))
+>{ a: 1 } : Symbol(, Decl(conditionalOperatorWithIdenticalBCT.ts, 33, 44))
 >a : Symbol(a, Decl(conditionalOperatorWithIdenticalBCT.ts, 33, 46))
 
 //Contextually typed
@@ -113,10 +129,12 @@ var result8: (t: A) => any = true ? (m) => m.propertyA : (n) => n.propertyX;
 >result8 : Symbol(result8, Decl(conditionalOperatorWithIdenticalBCT.ts, 37, 3))
 >t : Symbol(t, Decl(conditionalOperatorWithIdenticalBCT.ts, 37, 14))
 >A : Symbol(A, Decl(conditionalOperatorWithIdenticalBCT.ts, 1, 67))
+>(m) => m.propertyA : Symbol((Anonymous function), Decl(conditionalOperatorWithIdenticalBCT.ts, 37, 35))
 >m : Symbol(m, Decl(conditionalOperatorWithIdenticalBCT.ts, 37, 37))
 >m.propertyA : Symbol(A.propertyA, Decl(conditionalOperatorWithIdenticalBCT.ts, 2, 19))
 >m : Symbol(m, Decl(conditionalOperatorWithIdenticalBCT.ts, 37, 37))
 >propertyA : Symbol(A.propertyA, Decl(conditionalOperatorWithIdenticalBCT.ts, 2, 19))
+>(n) => n.propertyX : Symbol((Anonymous function), Decl(conditionalOperatorWithIdenticalBCT.ts, 37, 56))
 >n : Symbol(n, Decl(conditionalOperatorWithIdenticalBCT.ts, 37, 58))
 >n.propertyX : Symbol(X.propertyX, Decl(conditionalOperatorWithIdenticalBCT.ts, 1, 9))
 >n : Symbol(n, Decl(conditionalOperatorWithIdenticalBCT.ts, 37, 58))
@@ -134,10 +152,12 @@ var result10: (t: X) => any = true ? (m) => m.propertyX1 : (n) => n.propertyX2;
 >result10 : Symbol(result10, Decl(conditionalOperatorWithIdenticalBCT.ts, 42, 3))
 >t : Symbol(t, Decl(conditionalOperatorWithIdenticalBCT.ts, 42, 15))
 >X : Symbol(X, Decl(conditionalOperatorWithIdenticalBCT.ts, 0, 0))
+>(m) => m.propertyX1 : Symbol((Anonymous function), Decl(conditionalOperatorWithIdenticalBCT.ts, 42, 36))
 >m : Symbol(m, Decl(conditionalOperatorWithIdenticalBCT.ts, 42, 38))
 >m.propertyX1 : Symbol(X.propertyX1, Decl(conditionalOperatorWithIdenticalBCT.ts, 1, 25))
 >m : Symbol(m, Decl(conditionalOperatorWithIdenticalBCT.ts, 42, 38))
 >propertyX1 : Symbol(X.propertyX1, Decl(conditionalOperatorWithIdenticalBCT.ts, 1, 25))
+>(n) => n.propertyX2 : Symbol((Anonymous function), Decl(conditionalOperatorWithIdenticalBCT.ts, 42, 58))
 >n : Symbol(n, Decl(conditionalOperatorWithIdenticalBCT.ts, 42, 60))
 >n.propertyX2 : Symbol(X.propertyX2, Decl(conditionalOperatorWithIdenticalBCT.ts, 1, 45))
 >n : Symbol(n, Decl(conditionalOperatorWithIdenticalBCT.ts, 42, 60))
diff --git a/tests/baselines/reference/conditionallyDuplicateOverloadsCausedByOverloadResolution.symbols b/tests/baselines/reference/conditionallyDuplicateOverloadsCausedByOverloadResolution.symbols
index 85f6c7ee4eb6f..d76ca50cb119d 100644
--- a/tests/baselines/reference/conditionallyDuplicateOverloadsCausedByOverloadResolution.symbols
+++ b/tests/baselines/reference/conditionallyDuplicateOverloadsCausedByOverloadResolution.symbols
@@ -14,6 +14,7 @@ declare function foo(func: (x: string, y: number) => any): string;
 var out = foo((x, y) => {
 >out : Symbol(out, Decl(conditionallyDuplicateOverloadsCausedByOverloadResolution.ts, 3, 3))
 >foo : Symbol(foo, Decl(conditionallyDuplicateOverloadsCausedByOverloadResolution.ts, 0, 0), Decl(conditionallyDuplicateOverloadsCausedByOverloadResolution.ts, 0, 67))
+>(x, y) => {    function bar(a: typeof x): void;    function bar(b: typeof y): void;    function bar() { }    return bar;} : Symbol((Anonymous function), Decl(conditionallyDuplicateOverloadsCausedByOverloadResolution.ts, 3, 14))
 >x : Symbol(x, Decl(conditionallyDuplicateOverloadsCausedByOverloadResolution.ts, 3, 15))
 >y : Symbol(y, Decl(conditionallyDuplicateOverloadsCausedByOverloadResolution.ts, 3, 17))
 
@@ -50,6 +51,7 @@ declare function foo2(func: (x: string, y: number) => any): string;
 var out2 = foo2((x, y) => {
 >out2 : Symbol(out2, Decl(conditionallyDuplicateOverloadsCausedByOverloadResolution.ts, 13, 3))
 >foo2 : Symbol(foo2, Decl(conditionallyDuplicateOverloadsCausedByOverloadResolution.ts, 8, 3), Decl(conditionallyDuplicateOverloadsCausedByOverloadResolution.ts, 10, 68))
+>(x, y) => {    var bar: {        (a: typeof x): void;        (b: typeof y): void;    };    return bar;} : Symbol((Anonymous function), Decl(conditionallyDuplicateOverloadsCausedByOverloadResolution.ts, 13, 16))
 >x : Symbol(x, Decl(conditionallyDuplicateOverloadsCausedByOverloadResolution.ts, 13, 17))
 >y : Symbol(y, Decl(conditionallyDuplicateOverloadsCausedByOverloadResolution.ts, 13, 19))
 
diff --git a/tests/baselines/reference/constEnumPropertyAccess1.symbols b/tests/baselines/reference/constEnumPropertyAccess1.symbols
index e5f2853f15738..065e8e367e638 100644
--- a/tests/baselines/reference/constEnumPropertyAccess1.symbols
+++ b/tests/baselines/reference/constEnumPropertyAccess1.symbols
@@ -30,6 +30,8 @@ var o: {
 >idx : Symbol(idx, Decl(constEnumPropertyAccess1.ts, 13, 5))
 
 } = {
+>{        1: true    } : Symbol(, Decl(constEnumPropertyAccess1.ts, 14, 3))
+
         1: true
     };
 
diff --git a/tests/baselines/reference/constraintSatisfactionWithEmptyObject.symbols b/tests/baselines/reference/constraintSatisfactionWithEmptyObject.symbols
index fd5aae69b86c7..b45119e9cb9b4 100644
--- a/tests/baselines/reference/constraintSatisfactionWithEmptyObject.symbols
+++ b/tests/baselines/reference/constraintSatisfactionWithEmptyObject.symbols
@@ -12,13 +12,16 @@ function foo<T extends Object>(x: T) { }
 var r = foo({});
 >r : Symbol(r, Decl(constraintSatisfactionWithEmptyObject.ts, 4, 3), Decl(constraintSatisfactionWithEmptyObject.ts, 6, 3), Decl(constraintSatisfactionWithEmptyObject.ts, 21, 3), Decl(constraintSatisfactionWithEmptyObject.ts, 23, 3))
 >foo : Symbol(foo, Decl(constraintSatisfactionWithEmptyObject.ts, 0, 0))
+>{} : Symbol(, Decl(constraintSatisfactionWithEmptyObject.ts, 4, 12))
 
 var a = {};
 >a : Symbol(a, Decl(constraintSatisfactionWithEmptyObject.ts, 5, 3), Decl(constraintSatisfactionWithEmptyObject.ts, 22, 3))
+>{} : Symbol(, Decl(constraintSatisfactionWithEmptyObject.ts, 5, 7))
 
 var r = foo({});
 >r : Symbol(r, Decl(constraintSatisfactionWithEmptyObject.ts, 4, 3), Decl(constraintSatisfactionWithEmptyObject.ts, 6, 3), Decl(constraintSatisfactionWithEmptyObject.ts, 21, 3), Decl(constraintSatisfactionWithEmptyObject.ts, 23, 3))
 >foo : Symbol(foo, Decl(constraintSatisfactionWithEmptyObject.ts, 0, 0))
+>{} : Symbol(, Decl(constraintSatisfactionWithEmptyObject.ts, 6, 12))
 
 class C<T extends Object> {
 >C : Symbol(C, Decl(constraintSatisfactionWithEmptyObject.ts, 6, 16))
@@ -33,6 +36,7 @@ class C<T extends Object> {
 var r2 = new C({});
 >r2 : Symbol(r2, Decl(constraintSatisfactionWithEmptyObject.ts, 12, 3), Decl(constraintSatisfactionWithEmptyObject.ts, 29, 3))
 >C : Symbol(C, Decl(constraintSatisfactionWithEmptyObject.ts, 6, 16))
+>{} : Symbol(, Decl(constraintSatisfactionWithEmptyObject.ts, 12, 15))
 
 interface I<T extends Object> {
 >I : Symbol(I, Decl(constraintSatisfactionWithEmptyObject.ts, 12, 19))
@@ -57,13 +61,16 @@ function foo2<T extends {}>(x: T) { }
 var r = foo2({});
 >r : Symbol(r, Decl(constraintSatisfactionWithEmptyObject.ts, 4, 3), Decl(constraintSatisfactionWithEmptyObject.ts, 6, 3), Decl(constraintSatisfactionWithEmptyObject.ts, 21, 3), Decl(constraintSatisfactionWithEmptyObject.ts, 23, 3))
 >foo2 : Symbol(foo2, Decl(constraintSatisfactionWithEmptyObject.ts, 17, 13))
+>{} : Symbol(, Decl(constraintSatisfactionWithEmptyObject.ts, 21, 13))
 
 var a = {};
 >a : Symbol(a, Decl(constraintSatisfactionWithEmptyObject.ts, 5, 3), Decl(constraintSatisfactionWithEmptyObject.ts, 22, 3))
+>{} : Symbol(, Decl(constraintSatisfactionWithEmptyObject.ts, 22, 7))
 
 var r = foo2({});
 >r : Symbol(r, Decl(constraintSatisfactionWithEmptyObject.ts, 4, 3), Decl(constraintSatisfactionWithEmptyObject.ts, 6, 3), Decl(constraintSatisfactionWithEmptyObject.ts, 21, 3), Decl(constraintSatisfactionWithEmptyObject.ts, 23, 3))
 >foo2 : Symbol(foo2, Decl(constraintSatisfactionWithEmptyObject.ts, 17, 13))
+>{} : Symbol(, Decl(constraintSatisfactionWithEmptyObject.ts, 23, 13))
 
 class C2<T extends {}> {
 >C2 : Symbol(C2, Decl(constraintSatisfactionWithEmptyObject.ts, 23, 17))
@@ -77,6 +84,7 @@ class C2<T extends {}> {
 var r2 = new C2({});
 >r2 : Symbol(r2, Decl(constraintSatisfactionWithEmptyObject.ts, 12, 3), Decl(constraintSatisfactionWithEmptyObject.ts, 29, 3))
 >C2 : Symbol(C2, Decl(constraintSatisfactionWithEmptyObject.ts, 23, 17))
+>{} : Symbol(, Decl(constraintSatisfactionWithEmptyObject.ts, 29, 16))
 
 interface I2<T extends {}> {
 >I2 : Symbol(I2, Decl(constraintSatisfactionWithEmptyObject.ts, 29, 20))
diff --git a/tests/baselines/reference/contextualSignatureInstantiation1.symbols b/tests/baselines/reference/contextualSignatureInstantiation1.symbols
index e56e997cffc8b..5cfafca9743fd 100644
--- a/tests/baselines/reference/contextualSignatureInstantiation1.symbols
+++ b/tests/baselines/reference/contextualSignatureInstantiation1.symbols
@@ -13,6 +13,7 @@ declare function map<S, T>(f: (x: S) => T): (a: S[]) => T[];
 
 var e = <K>(x: string, y?: K) => x.length;
 >e : Symbol(e, Decl(contextualSignatureInstantiation1.ts, 1, 3))
+><K>(x: string, y?: K) => x.length : Symbol((Anonymous function), Decl(contextualSignatureInstantiation1.ts, 1, 7))
 >K : Symbol(K, Decl(contextualSignatureInstantiation1.ts, 1, 9))
 >x : Symbol(x, Decl(contextualSignatureInstantiation1.ts, 1, 12))
 >y : Symbol(y, Decl(contextualSignatureInstantiation1.ts, 1, 22))
@@ -41,6 +42,7 @@ declare function map2<S extends { length: number }, T>(f: (x: S) => T): (a: S[])
 
 var e2 = <K>(x: string, y?: K) => x.length;
 >e2 : Symbol(e2, Decl(contextualSignatureInstantiation1.ts, 5, 3))
+><K>(x: string, y?: K) => x.length : Symbol((Anonymous function), Decl(contextualSignatureInstantiation1.ts, 5, 8))
 >K : Symbol(K, Decl(contextualSignatureInstantiation1.ts, 5, 10))
 >x : Symbol(x, Decl(contextualSignatureInstantiation1.ts, 5, 13))
 >y : Symbol(y, Decl(contextualSignatureInstantiation1.ts, 5, 23))
diff --git a/tests/baselines/reference/contextualSignatureInstantiation2.symbols b/tests/baselines/reference/contextualSignatureInstantiation2.symbols
index 62808982eb547..da7b3c616c14b 100644
--- a/tests/baselines/reference/contextualSignatureInstantiation2.symbols
+++ b/tests/baselines/reference/contextualSignatureInstantiation2.symbols
@@ -19,12 +19,14 @@ var dot: <T, S>(f: (_: T) => S) => <U>(g: (_: U) => T) => (_: U) => S;
 
 dot = <T, S>(f: (_: T) => S) => <U>(g: (_: U) => T): (r:U) => S => (x) => f(g(x));
 >dot : Symbol(dot, Decl(contextualSignatureInstantiation2.ts, 1, 3))
+><T, S>(f: (_: T) => S) => <U>(g: (_: U) => T): (r:U) => S => (x) => f(g(x)) : Symbol((Anonymous function), Decl(contextualSignatureInstantiation2.ts, 2, 5))
 >T : Symbol(T, Decl(contextualSignatureInstantiation2.ts, 2, 7))
 >S : Symbol(S, Decl(contextualSignatureInstantiation2.ts, 2, 9))
 >f : Symbol(f, Decl(contextualSignatureInstantiation2.ts, 2, 13))
 >_ : Symbol(_, Decl(contextualSignatureInstantiation2.ts, 2, 17))
 >T : Symbol(T, Decl(contextualSignatureInstantiation2.ts, 2, 7))
 >S : Symbol(S, Decl(contextualSignatureInstantiation2.ts, 2, 9))
+><U>(g: (_: U) => T): (r:U) => S => (x) => f(g(x)) : Symbol((Anonymous function), Decl(contextualSignatureInstantiation2.ts, 2, 31))
 >U : Symbol(U, Decl(contextualSignatureInstantiation2.ts, 2, 33))
 >g : Symbol(g, Decl(contextualSignatureInstantiation2.ts, 2, 36))
 >_ : Symbol(_, Decl(contextualSignatureInstantiation2.ts, 2, 40))
@@ -33,6 +35,7 @@ dot = <T, S>(f: (_: T) => S) => <U>(g: (_: U) => T): (r:U) => S => (x) => f(g(x)
 >r : Symbol(r, Decl(contextualSignatureInstantiation2.ts, 2, 54))
 >U : Symbol(U, Decl(contextualSignatureInstantiation2.ts, 2, 33))
 >S : Symbol(S, Decl(contextualSignatureInstantiation2.ts, 2, 9))
+>(x) => f(g(x)) : Symbol((Anonymous function), Decl(contextualSignatureInstantiation2.ts, 2, 66))
 >x : Symbol(x, Decl(contextualSignatureInstantiation2.ts, 2, 68))
 >f : Symbol(f, Decl(contextualSignatureInstantiation2.ts, 2, 13))
 >g : Symbol(g, Decl(contextualSignatureInstantiation2.ts, 2, 36))
diff --git a/tests/baselines/reference/contextualTypeAny.symbols b/tests/baselines/reference/contextualTypeAny.symbols
index 5132c948a2e27..702fc34152ebb 100644
--- a/tests/baselines/reference/contextualTypeAny.symbols
+++ b/tests/baselines/reference/contextualTypeAny.symbols
@@ -5,6 +5,7 @@ var x: any;
 var obj: { [s: string]: number } = { p: "", q: x };
 >obj : Symbol(obj, Decl(contextualTypeAny.ts, 2, 3))
 >s : Symbol(s, Decl(contextualTypeAny.ts, 2, 12))
+>{ p: "", q: x } : Symbol(, Decl(contextualTypeAny.ts, 2, 34))
 >p : Symbol(p, Decl(contextualTypeAny.ts, 2, 36))
 >q : Symbol(q, Decl(contextualTypeAny.ts, 2, 43))
 >x : Symbol(x, Decl(contextualTypeAny.ts, 0, 3))
diff --git a/tests/baselines/reference/contextualTypeAppliedToVarArgs.symbols b/tests/baselines/reference/contextualTypeAppliedToVarArgs.symbols
index bf8774cc7f08f..5b253fcf79796 100644
--- a/tests/baselines/reference/contextualTypeAppliedToVarArgs.symbols
+++ b/tests/baselines/reference/contextualTypeAppliedToVarArgs.symbols
@@ -8,6 +8,7 @@ function delegate(instance: any, method: (...args: any[]) => any, data?: any): (
 >args : Symbol(args, Decl(contextualTypeAppliedToVarArgs.ts, 0, 80))
 
     return function () { };
+>function () { } : Symbol((Anonymous function), Decl(contextualTypeAppliedToVarArgs.ts, 1, 10))
 }
 
 class Foo{
@@ -20,6 +21,7 @@ class Foo{
         delegate(this, function (source, args2)
 >delegate : Symbol(delegate, Decl(contextualTypeAppliedToVarArgs.ts, 0, 0))
 >this : Symbol(Foo, Decl(contextualTypeAppliedToVarArgs.ts, 2, 1))
+>function (source, args2)        {            var a = source.node;            var b = args2.node;        } : Symbol((Anonymous function), Decl(contextualTypeAppliedToVarArgs.ts, 8, 22))
 >source : Symbol(source, Decl(contextualTypeAppliedToVarArgs.ts, 8, 33))
 >args2 : Symbol(args2, Decl(contextualTypeAppliedToVarArgs.ts, 8, 40))
         {
diff --git a/tests/baselines/reference/contextualTypeArrayReturnType.symbols b/tests/baselines/reference/contextualTypeArrayReturnType.symbols
index ed0e22d698ca6..d7b445a4f9c6a 100644
--- a/tests/baselines/reference/contextualTypeArrayReturnType.symbols
+++ b/tests/baselines/reference/contextualTypeArrayReturnType.symbols
@@ -26,13 +26,17 @@ interface Transform3D {
 var style: IBookStyle = {
 >style : Symbol(style, Decl(contextualTypeArrayReturnType.ts, 12, 3))
 >IBookStyle : Symbol(IBookStyle, Decl(contextualTypeArrayReturnType.ts, 0, 0))
+>{    initialLeftPageTransforms: (width: number) => {        return [            {'ry': null }        ];    }} : Symbol(, Decl(contextualTypeArrayReturnType.ts, 12, 23))
 
     initialLeftPageTransforms: (width: number) => {
 >initialLeftPageTransforms : Symbol(initialLeftPageTransforms, Decl(contextualTypeArrayReturnType.ts, 12, 25))
+>(width: number) => {        return [            {'ry': null }        ];    } : Symbol((Anonymous function), Decl(contextualTypeArrayReturnType.ts, 13, 30))
 >width : Symbol(width, Decl(contextualTypeArrayReturnType.ts, 13, 32))
 
         return [
             {'ry': null }
+>{'ry': null } : Symbol(, Decl(contextualTypeArrayReturnType.ts, 14, 16))
+
         ];
     }
 }
diff --git a/tests/baselines/reference/contextualTypeWithUnionTypeCallSignatures.symbols b/tests/baselines/reference/contextualTypeWithUnionTypeCallSignatures.symbols
index 3e23a7812f5b3..1fdba4e71a604 100644
--- a/tests/baselines/reference/contextualTypeWithUnionTypeCallSignatures.symbols
+++ b/tests/baselines/reference/contextualTypeWithUnionTypeCallSignatures.symbols
@@ -46,6 +46,7 @@ var x: IWithNoCallSignatures | IWithCallSignatures = a => a.toString();
 >x : Symbol(x, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 25, 3))
 >IWithNoCallSignatures : Symbol(IWithNoCallSignatures, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 0, 0))
 >IWithCallSignatures : Symbol(IWithCallSignatures, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 9, 1))
+>a => a.toString() : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeCallSignatures.ts, 25, 52))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 25, 52))
 >a.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 25, 52))
@@ -56,6 +57,7 @@ var x2: IWithCallSignatures | IWithCallSignatures2 = a => a.toString(); // Like
 >x2 : Symbol(x2, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 28, 3), Decl(contextualTypeWithUnionTypeCallSignatures.ts, 29, 3))
 >IWithCallSignatures : Symbol(IWithCallSignatures, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 9, 1))
 >IWithCallSignatures2 : Symbol(IWithCallSignatures2, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 12, 1))
+>a => a.toString() : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeCallSignatures.ts, 28, 52))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 28, 52))
 >a.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 28, 52))
@@ -65,6 +67,7 @@ var x2: IWithCallSignatures | IWithCallSignatures2 = a => a; // Like iWithCallSi
 >x2 : Symbol(x2, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 28, 3), Decl(contextualTypeWithUnionTypeCallSignatures.ts, 29, 3))
 >IWithCallSignatures : Symbol(IWithCallSignatures, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 9, 1))
 >IWithCallSignatures2 : Symbol(IWithCallSignatures2, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 12, 1))
+>a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeCallSignatures.ts, 29, 52))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 29, 52))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 29, 52))
 
@@ -73,6 +76,7 @@ var x3: IWithCallSignatures | IWithCallSignatures3 = a => /*here a should be any
 >x3 : Symbol(x3, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 32, 3))
 >IWithCallSignatures : Symbol(IWithCallSignatures, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 9, 1))
 >IWithCallSignatures3 : Symbol(IWithCallSignatures3, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 15, 1))
+>a => /*here a should be any*/ a.toString() : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeCallSignatures.ts, 32, 52))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 32, 52))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 32, 52))
 
@@ -81,6 +85,7 @@ var x4: IWithCallSignatures | IWithCallSignatures4 = a => /*here a should be any
 >x4 : Symbol(x4, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 35, 3))
 >IWithCallSignatures : Symbol(IWithCallSignatures, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 9, 1))
 >IWithCallSignatures4 : Symbol(IWithCallSignatures4, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 18, 1))
+>a => /*here a should be any*/ a.toString() : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeCallSignatures.ts, 35, 52))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 35, 52))
 >a.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 35, 52))
diff --git a/tests/baselines/reference/contextualTypeWithUnionTypeIndexSignatures.symbols b/tests/baselines/reference/contextualTypeWithUnionTypeIndexSignatures.symbols
index c381377e523f3..7e7ce834a13b8 100644
--- a/tests/baselines/reference/contextualTypeWithUnionTypeIndexSignatures.symbols
+++ b/tests/baselines/reference/contextualTypeWithUnionTypeIndexSignatures.symbols
@@ -69,7 +69,9 @@ var x: IWithNoStringIndexSignature | IWithStringIndexSignature1 = { z: a => a };
 >x : Symbol(x, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 39, 3), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 40, 3), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 41, 3))
 >IWithNoStringIndexSignature : Symbol(IWithNoStringIndexSignature, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 7, 1))
 >IWithStringIndexSignature1 : Symbol(IWithStringIndexSignature1, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 14, 1))
+>{ z: a => a } : Symbol(, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 39, 65))
 >z : Symbol(z, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 39, 67))
+>a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 39, 70))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 39, 70))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 39, 70))
 
@@ -77,7 +79,9 @@ var x: IWithNoStringIndexSignature | IWithStringIndexSignature1 = { foo: a => a
 >x : Symbol(x, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 39, 3), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 40, 3), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 41, 3))
 >IWithNoStringIndexSignature : Symbol(IWithNoStringIndexSignature, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 7, 1))
 >IWithStringIndexSignature1 : Symbol(IWithStringIndexSignature1, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 14, 1))
+>{ foo: a => a } : Symbol(, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 40, 65))
 >foo : Symbol(foo, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 40, 67))
+>a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 40, 72))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 40, 72))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 40, 72))
 
@@ -85,13 +89,16 @@ var x: IWithNoStringIndexSignature | IWithStringIndexSignature1 = { foo: "hello"
 >x : Symbol(x, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 39, 3), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 40, 3), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 41, 3))
 >IWithNoStringIndexSignature : Symbol(IWithNoStringIndexSignature, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 7, 1))
 >IWithStringIndexSignature1 : Symbol(IWithStringIndexSignature1, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 14, 1))
+>{ foo: "hello" } : Symbol(, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 41, 65))
 >foo : Symbol(foo, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 41, 67))
 
 var x2: IWithStringIndexSignature1 | IWithStringIndexSignature2 = { z: a => a.toString() }; // a should be number
 >x2 : Symbol(x2, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 42, 3), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 43, 3))
 >IWithStringIndexSignature1 : Symbol(IWithStringIndexSignature1, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 14, 1))
 >IWithStringIndexSignature2 : Symbol(IWithStringIndexSignature2, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 17, 1))
+>{ z: a => a.toString() } : Symbol(, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 42, 65))
 >z : Symbol(z, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 42, 67))
+>a => a.toString() : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 42, 70))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 42, 70))
 >a.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 42, 70))
@@ -101,7 +108,9 @@ var x2: IWithStringIndexSignature1 | IWithStringIndexSignature2 = { z: a => a };
 >x2 : Symbol(x2, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 42, 3), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 43, 3))
 >IWithStringIndexSignature1 : Symbol(IWithStringIndexSignature1, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 14, 1))
 >IWithStringIndexSignature2 : Symbol(IWithStringIndexSignature2, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 17, 1))
+>{ z: a => a } : Symbol(, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 43, 65))
 >z : Symbol(z, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 43, 67))
+>a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 43, 70))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 43, 70))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 43, 70))
 
@@ -113,6 +122,8 @@ var x3: IWithNoNumberIndexSignature | IWithNumberIndexSignature1 = { 1: a => a }
 >x3 : Symbol(x3, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 49, 3), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 50, 3), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 51, 3))
 >IWithNoNumberIndexSignature : Symbol(IWithNoNumberIndexSignature, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 11, 1))
 >IWithNumberIndexSignature1 : Symbol(IWithNumberIndexSignature1, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 20, 1))
+>{ 1: a => a } : Symbol(, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 49, 66))
+>a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 49, 71))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 49, 71))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 49, 71))
 
@@ -120,6 +131,8 @@ var x3: IWithNoNumberIndexSignature | IWithNumberIndexSignature1 = { 0: a => a }
 >x3 : Symbol(x3, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 49, 3), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 50, 3), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 51, 3))
 >IWithNoNumberIndexSignature : Symbol(IWithNoNumberIndexSignature, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 11, 1))
 >IWithNumberIndexSignature1 : Symbol(IWithNumberIndexSignature1, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 20, 1))
+>{ 0: a => a } : Symbol(, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 50, 66))
+>a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 50, 71))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 50, 71))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 50, 71))
 
@@ -127,11 +140,14 @@ var x3: IWithNoNumberIndexSignature | IWithNumberIndexSignature1 = { 0: "hello"
 >x3 : Symbol(x3, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 49, 3), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 50, 3), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 51, 3))
 >IWithNoNumberIndexSignature : Symbol(IWithNoNumberIndexSignature, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 11, 1))
 >IWithNumberIndexSignature1 : Symbol(IWithNumberIndexSignature1, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 20, 1))
+>{ 0: "hello" } : Symbol(, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 51, 66))
 
 var x4: IWithNumberIndexSignature1 | IWithNumberIndexSignature2 = { 1: a => a.toString() }; // a should be number
 >x4 : Symbol(x4, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 52, 3), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 53, 3))
 >IWithNumberIndexSignature1 : Symbol(IWithNumberIndexSignature1, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 20, 1))
 >IWithNumberIndexSignature2 : Symbol(IWithNumberIndexSignature2, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 23, 1))
+>{ 1: a => a.toString() } : Symbol(, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 52, 65))
+>a => a.toString() : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 52, 70))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 52, 70))
 >a.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 52, 70))
@@ -141,6 +157,8 @@ var x4: IWithNumberIndexSignature1 | IWithNumberIndexSignature2 = { 1: a => a };
 >x4 : Symbol(x4, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 52, 3), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 53, 3))
 >IWithNumberIndexSignature1 : Symbol(IWithNumberIndexSignature1, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 20, 1))
 >IWithNumberIndexSignature2 : Symbol(IWithNumberIndexSignature2, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 23, 1))
+>{ 1: a => a } : Symbol(, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 53, 65))
+>a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 53, 70))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 53, 70))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 53, 70))
 
diff --git a/tests/baselines/reference/contextualTypeWithUnionTypeMembers.symbols b/tests/baselines/reference/contextualTypeWithUnionTypeMembers.symbols
index 3d7b8bf5a189d..3abdda6c5468a 100644
--- a/tests/baselines/reference/contextualTypeWithUnionTypeMembers.symbols
+++ b/tests/baselines/reference/contextualTypeWithUnionTypeMembers.symbols
@@ -76,22 +76,26 @@ var i1Ori2: I1<number> | I2<number> = { // Like i1
 >i1Ori2 : Symbol(i1Ori2, Decl(contextualTypeWithUnionTypeMembers.ts, 23, 3), Decl(contextualTypeWithUnionTypeMembers.ts, 24, 3), Decl(contextualTypeWithUnionTypeMembers.ts, 25, 3), Decl(contextualTypeWithUnionTypeMembers.ts, 33, 3), Decl(contextualTypeWithUnionTypeMembers.ts, 41, 3))
 >I1 : Symbol(I1, Decl(contextualTypeWithUnionTypeMembers.ts, 0, 0))
 >I2 : Symbol(I2, Decl(contextualTypeWithUnionTypeMembers.ts, 9, 1))
+>{ // Like i1    commonPropertyType: "hello",    commonMethodType: a=> a,    commonMethodWithTypeParameter: a => a,    methodOnlyInI1: a => a,    propertyOnlyInI1: "Hello",} : Symbol(, Decl(contextualTypeWithUnionTypeMembers.ts, 25, 37))
 
     commonPropertyType: "hello",
 >commonPropertyType : Symbol(commonPropertyType, Decl(contextualTypeWithUnionTypeMembers.ts, 25, 39))
 
     commonMethodType: a=> a,
 >commonMethodType : Symbol(commonMethodType, Decl(contextualTypeWithUnionTypeMembers.ts, 26, 32))
+>a=> a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 27, 21))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 27, 21))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 27, 21))
 
     commonMethodWithTypeParameter: a => a,
 >commonMethodWithTypeParameter : Symbol(commonMethodWithTypeParameter, Decl(contextualTypeWithUnionTypeMembers.ts, 27, 28))
+>a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 28, 34))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 28, 34))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 28, 34))
 
     methodOnlyInI1: a => a,
 >methodOnlyInI1 : Symbol(methodOnlyInI1, Decl(contextualTypeWithUnionTypeMembers.ts, 28, 42))
+>a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 30, 19))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 30, 19))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 30, 19))
 
@@ -103,22 +107,26 @@ var i1Ori2: I1<number> | I2<number> = { // Like i2
 >i1Ori2 : Symbol(i1Ori2, Decl(contextualTypeWithUnionTypeMembers.ts, 23, 3), Decl(contextualTypeWithUnionTypeMembers.ts, 24, 3), Decl(contextualTypeWithUnionTypeMembers.ts, 25, 3), Decl(contextualTypeWithUnionTypeMembers.ts, 33, 3), Decl(contextualTypeWithUnionTypeMembers.ts, 41, 3))
 >I1 : Symbol(I1, Decl(contextualTypeWithUnionTypeMembers.ts, 0, 0))
 >I2 : Symbol(I2, Decl(contextualTypeWithUnionTypeMembers.ts, 9, 1))
+>{ // Like i2    commonPropertyType: "hello",    commonMethodType: a=> a,    commonMethodWithTypeParameter: a => a,    methodOnlyInI2: a => a,    propertyOnlyInI2: "Hello",} : Symbol(, Decl(contextualTypeWithUnionTypeMembers.ts, 33, 37))
 
     commonPropertyType: "hello",
 >commonPropertyType : Symbol(commonPropertyType, Decl(contextualTypeWithUnionTypeMembers.ts, 33, 39))
 
     commonMethodType: a=> a,
 >commonMethodType : Symbol(commonMethodType, Decl(contextualTypeWithUnionTypeMembers.ts, 34, 32))
+>a=> a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 35, 21))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 35, 21))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 35, 21))
 
     commonMethodWithTypeParameter: a => a,
 >commonMethodWithTypeParameter : Symbol(commonMethodWithTypeParameter, Decl(contextualTypeWithUnionTypeMembers.ts, 35, 28))
+>a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 36, 34))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 36, 34))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 36, 34))
 
     methodOnlyInI2: a => a,
 >methodOnlyInI2 : Symbol(methodOnlyInI2, Decl(contextualTypeWithUnionTypeMembers.ts, 36, 42))
+>a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 38, 19))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 38, 19))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 38, 19))
 
@@ -130,22 +138,26 @@ var i1Ori2: I1<number> | I2<number> = { // Like i1 and i2 both
 >i1Ori2 : Symbol(i1Ori2, Decl(contextualTypeWithUnionTypeMembers.ts, 23, 3), Decl(contextualTypeWithUnionTypeMembers.ts, 24, 3), Decl(contextualTypeWithUnionTypeMembers.ts, 25, 3), Decl(contextualTypeWithUnionTypeMembers.ts, 33, 3), Decl(contextualTypeWithUnionTypeMembers.ts, 41, 3))
 >I1 : Symbol(I1, Decl(contextualTypeWithUnionTypeMembers.ts, 0, 0))
 >I2 : Symbol(I2, Decl(contextualTypeWithUnionTypeMembers.ts, 9, 1))
+>{ // Like i1 and i2 both    commonPropertyType: "hello",    commonMethodType: a=> a,    commonMethodWithTypeParameter: a => a,    methodOnlyInI1: a => a,    propertyOnlyInI1: "Hello",    methodOnlyInI2: a => a,    propertyOnlyInI2: "Hello",} : Symbol(, Decl(contextualTypeWithUnionTypeMembers.ts, 41, 37))
 
     commonPropertyType: "hello",
 >commonPropertyType : Symbol(commonPropertyType, Decl(contextualTypeWithUnionTypeMembers.ts, 41, 39))
 
     commonMethodType: a=> a,
 >commonMethodType : Symbol(commonMethodType, Decl(contextualTypeWithUnionTypeMembers.ts, 42, 32))
+>a=> a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 43, 21))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 43, 21))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 43, 21))
 
     commonMethodWithTypeParameter: a => a,
 >commonMethodWithTypeParameter : Symbol(commonMethodWithTypeParameter, Decl(contextualTypeWithUnionTypeMembers.ts, 43, 28))
+>a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 44, 34))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 44, 34))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 44, 34))
 
     methodOnlyInI1: a => a,
 >methodOnlyInI1 : Symbol(methodOnlyInI1, Decl(contextualTypeWithUnionTypeMembers.ts, 44, 42))
+>a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 45, 19))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 45, 19))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 45, 19))
 
@@ -154,6 +166,7 @@ var i1Ori2: I1<number> | I2<number> = { // Like i1 and i2 both
 
     methodOnlyInI2: a => a,
 >methodOnlyInI2 : Symbol(methodOnlyInI2, Decl(contextualTypeWithUnionTypeMembers.ts, 46, 30))
+>a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 47, 19))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 47, 19))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 47, 19))
 
@@ -169,22 +182,26 @@ var arrayI1OrI2: Array<I1<number> | I2<number>> = [i1, i2, { // Like i1
 >I2 : Symbol(I2, Decl(contextualTypeWithUnionTypeMembers.ts, 9, 1))
 >i1 : Symbol(i1, Decl(contextualTypeWithUnionTypeMembers.ts, 21, 3))
 >i2 : Symbol(i2, Decl(contextualTypeWithUnionTypeMembers.ts, 22, 3))
+>{ // Like i1        commonPropertyType: "hello",        commonMethodType: a=> a,        commonMethodWithTypeParameter: a => a,        methodOnlyInI1: a => a,        propertyOnlyInI1: "Hello",    } : Symbol(, Decl(contextualTypeWithUnionTypeMembers.ts, 51, 58))
 
         commonPropertyType: "hello",
 >commonPropertyType : Symbol(commonPropertyType, Decl(contextualTypeWithUnionTypeMembers.ts, 51, 60))
 
         commonMethodType: a=> a,
 >commonMethodType : Symbol(commonMethodType, Decl(contextualTypeWithUnionTypeMembers.ts, 52, 36))
+>a=> a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 53, 25))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 53, 25))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 53, 25))
 
         commonMethodWithTypeParameter: a => a,
 >commonMethodWithTypeParameter : Symbol(commonMethodWithTypeParameter, Decl(contextualTypeWithUnionTypeMembers.ts, 53, 32))
+>a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 54, 38))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 54, 38))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 54, 38))
 
         methodOnlyInI1: a => a,
 >methodOnlyInI1 : Symbol(methodOnlyInI1, Decl(contextualTypeWithUnionTypeMembers.ts, 54, 46))
+>a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 56, 23))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 56, 23))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 56, 23))
 
@@ -193,21 +210,26 @@ var arrayI1OrI2: Array<I1<number> | I2<number>> = [i1, i2, { // Like i1
 
     },
     { // Like i2
+>{ // Like i2        commonPropertyType: "hello",        commonMethodType: a=> a,        commonMethodWithTypeParameter: a => a,        methodOnlyInI2: a => a,        propertyOnlyInI2: "Hello",    } : Symbol(, Decl(contextualTypeWithUnionTypeMembers.ts, 58, 6))
+
         commonPropertyType: "hello",
 >commonPropertyType : Symbol(commonPropertyType, Decl(contextualTypeWithUnionTypeMembers.ts, 59, 5))
 
         commonMethodType: a=> a,
 >commonMethodType : Symbol(commonMethodType, Decl(contextualTypeWithUnionTypeMembers.ts, 60, 36))
+>a=> a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 61, 25))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 61, 25))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 61, 25))
 
         commonMethodWithTypeParameter: a => a,
 >commonMethodWithTypeParameter : Symbol(commonMethodWithTypeParameter, Decl(contextualTypeWithUnionTypeMembers.ts, 61, 32))
+>a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 62, 38))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 62, 38))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 62, 38))
 
         methodOnlyInI2: a => a,
 >methodOnlyInI2 : Symbol(methodOnlyInI2, Decl(contextualTypeWithUnionTypeMembers.ts, 62, 46))
+>a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 64, 23))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 64, 23))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 64, 23))
 
@@ -215,21 +237,26 @@ var arrayI1OrI2: Array<I1<number> | I2<number>> = [i1, i2, { // Like i1
 >propertyOnlyInI2 : Symbol(propertyOnlyInI2, Decl(contextualTypeWithUnionTypeMembers.ts, 64, 31))
 
     }, { // Like i1 and i2 both
+>{ // Like i1 and i2 both        commonPropertyType: "hello",        commonMethodType: a=> a,        commonMethodWithTypeParameter: a => a,        methodOnlyInI1: a => a,        propertyOnlyInI1: "Hello",        methodOnlyInI2: a => a,        propertyOnlyInI2: "Hello",    } : Symbol(, Decl(contextualTypeWithUnionTypeMembers.ts, 66, 6))
+
         commonPropertyType: "hello",
 >commonPropertyType : Symbol(commonPropertyType, Decl(contextualTypeWithUnionTypeMembers.ts, 66, 8))
 
         commonMethodType: a=> a,
 >commonMethodType : Symbol(commonMethodType, Decl(contextualTypeWithUnionTypeMembers.ts, 67, 36))
+>a=> a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 68, 25))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 68, 25))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 68, 25))
 
         commonMethodWithTypeParameter: a => a,
 >commonMethodWithTypeParameter : Symbol(commonMethodWithTypeParameter, Decl(contextualTypeWithUnionTypeMembers.ts, 68, 32))
+>a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 69, 38))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 69, 38))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 69, 38))
 
         methodOnlyInI1: a => a,
 >methodOnlyInI1 : Symbol(methodOnlyInI1, Decl(contextualTypeWithUnionTypeMembers.ts, 69, 46))
+>a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 70, 23))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 70, 23))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 70, 23))
 
@@ -238,6 +265,7 @@ var arrayI1OrI2: Array<I1<number> | I2<number>> = [i1, i2, { // Like i1
 
         methodOnlyInI2: a => a,
 >methodOnlyInI2 : Symbol(methodOnlyInI2, Decl(contextualTypeWithUnionTypeMembers.ts, 71, 34))
+>a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 72, 23))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 72, 23))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 72, 23))
 
@@ -292,10 +320,12 @@ var i11Ori21: I11 | I21 = {
 >i11Ori21 : Symbol(i11Ori21, Decl(contextualTypeWithUnionTypeMembers.ts, 86, 3), Decl(contextualTypeWithUnionTypeMembers.ts, 87, 3), Decl(contextualTypeWithUnionTypeMembers.ts, 88, 3), Decl(contextualTypeWithUnionTypeMembers.ts, 96, 3))
 >I11 : Symbol(I11, Decl(contextualTypeWithUnionTypeMembers.ts, 74, 7))
 >I21 : Symbol(I21, Decl(contextualTypeWithUnionTypeMembers.ts, 79, 1))
+>{     // Like i1    commonMethodDifferentReturnType: (a, b) => {        var z = a.charAt(b);        return z;      },    commonPropertyDifferentType: "hello",  } : Symbol(, Decl(contextualTypeWithUnionTypeMembers.ts, 88, 25))
 
     // Like i1
     commonMethodDifferentReturnType: (a, b) => {
 >commonMethodDifferentReturnType : Symbol(commonMethodDifferentReturnType, Decl(contextualTypeWithUnionTypeMembers.ts, 88, 27))
+>(a, b) => {        var z = a.charAt(b);        return z;      } : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 90, 36))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 90, 38))
 >b : Symbol(b, Decl(contextualTypeWithUnionTypeMembers.ts, 90, 40))
 
@@ -318,10 +348,12 @@ var i11Ori21: I11 | I21 = {
 >i11Ori21 : Symbol(i11Ori21, Decl(contextualTypeWithUnionTypeMembers.ts, 86, 3), Decl(contextualTypeWithUnionTypeMembers.ts, 87, 3), Decl(contextualTypeWithUnionTypeMembers.ts, 88, 3), Decl(contextualTypeWithUnionTypeMembers.ts, 96, 3))
 >I11 : Symbol(I11, Decl(contextualTypeWithUnionTypeMembers.ts, 74, 7))
 >I21 : Symbol(I21, Decl(contextualTypeWithUnionTypeMembers.ts, 79, 1))
+>{     // Like i2    commonMethodDifferentReturnType: (a, b) => {        var z = a.charCodeAt(b);        return z;    },    commonPropertyDifferentType: 10,} : Symbol(, Decl(contextualTypeWithUnionTypeMembers.ts, 96, 25))
 
     // Like i2
     commonMethodDifferentReturnType: (a, b) => {
 >commonMethodDifferentReturnType : Symbol(commonMethodDifferentReturnType, Decl(contextualTypeWithUnionTypeMembers.ts, 96, 27))
+>(a, b) => {        var z = a.charCodeAt(b);        return z;    } : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 98, 36))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 98, 38))
 >b : Symbol(b, Decl(contextualTypeWithUnionTypeMembers.ts, 98, 40))
 
@@ -349,10 +381,12 @@ var arrayOrI11OrI21: Array<I11 | I21> = [i11, i21, i11 || i21, {
 >i21 : Symbol(i21, Decl(contextualTypeWithUnionTypeMembers.ts, 85, 3))
 >i11 : Symbol(i11, Decl(contextualTypeWithUnionTypeMembers.ts, 84, 3))
 >i21 : Symbol(i21, Decl(contextualTypeWithUnionTypeMembers.ts, 85, 3))
+>{         // Like i1        commonMethodDifferentReturnType: (a, b) => {            var z = a.charAt(b);            return z;        },        commonPropertyDifferentType: "hello",    } : Symbol(, Decl(contextualTypeWithUnionTypeMembers.ts, 104, 62))
 
         // Like i1
         commonMethodDifferentReturnType: (a, b) => {
 >commonMethodDifferentReturnType : Symbol(commonMethodDifferentReturnType, Decl(contextualTypeWithUnionTypeMembers.ts, 104, 64))
+>(a, b) => {            var z = a.charAt(b);            return z;        } : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 106, 40))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 106, 42))
 >b : Symbol(b, Decl(contextualTypeWithUnionTypeMembers.ts, 106, 44))
 
@@ -371,9 +405,12 @@ var arrayOrI11OrI21: Array<I11 | I21> = [i11, i21, i11 || i21, {
 >commonPropertyDifferentType : Symbol(commonPropertyDifferentType, Decl(contextualTypeWithUnionTypeMembers.ts, 109, 10))
 
     }, { 
+>{         // Like i2        commonMethodDifferentReturnType: (a, b) => {            var z = a.charCodeAt(b);            return z;        },        commonPropertyDifferentType: 10,    } : Symbol(, Decl(contextualTypeWithUnionTypeMembers.ts, 111, 6))
+
         // Like i2
         commonMethodDifferentReturnType: (a, b) => {
 >commonMethodDifferentReturnType : Symbol(commonMethodDifferentReturnType, Decl(contextualTypeWithUnionTypeMembers.ts, 111, 8))
+>(a, b) => {            var z = a.charCodeAt(b);            return z;        } : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 113, 40))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 113, 42))
 >b : Symbol(b, Decl(contextualTypeWithUnionTypeMembers.ts, 113, 44))
 
diff --git a/tests/baselines/reference/contextualTyping1.symbols b/tests/baselines/reference/contextualTyping1.symbols
index 00c6fd57f2a1d..446b428a431d7 100644
--- a/tests/baselines/reference/contextualTyping1.symbols
+++ b/tests/baselines/reference/contextualTyping1.symbols
@@ -2,5 +2,6 @@
 var foo: {id:number;} = {id:4};
 >foo : Symbol(foo, Decl(contextualTyping1.ts, 0, 3))
 >id : Symbol(id, Decl(contextualTyping1.ts, 0, 10))
+>{id:4} : Symbol(, Decl(contextualTyping1.ts, 0, 23))
 >id : Symbol(id, Decl(contextualTyping1.ts, 0, 25))
 
diff --git a/tests/baselines/reference/contextualTyping10.symbols b/tests/baselines/reference/contextualTyping10.symbols
index 130116264e0aa..909ea5f534805 100644
--- a/tests/baselines/reference/contextualTyping10.symbols
+++ b/tests/baselines/reference/contextualTyping10.symbols
@@ -3,6 +3,8 @@ class foo { public bar:{id:number;}[] = [{id:1}, {id:2}]; }
 >foo : Symbol(foo, Decl(contextualTyping10.ts, 0, 0))
 >bar : Symbol(bar, Decl(contextualTyping10.ts, 0, 11))
 >id : Symbol(id, Decl(contextualTyping10.ts, 0, 24))
+>{id:1} : Symbol(, Decl(contextualTyping10.ts, 0, 41))
 >id : Symbol(id, Decl(contextualTyping10.ts, 0, 42))
+>{id:2} : Symbol(, Decl(contextualTyping10.ts, 0, 48))
 >id : Symbol(id, Decl(contextualTyping10.ts, 0, 50))
 
diff --git a/tests/baselines/reference/contextualTyping12.symbols b/tests/baselines/reference/contextualTyping12.symbols
index bafef4c8e0a00..0e1d377a325c6 100644
--- a/tests/baselines/reference/contextualTyping12.symbols
+++ b/tests/baselines/reference/contextualTyping12.symbols
@@ -3,7 +3,9 @@ class foo { public bar:{id:number;}[] = [{id:1}, {id:2, name:"foo"}]; }
 >foo : Symbol(foo, Decl(contextualTyping12.ts, 0, 0))
 >bar : Symbol(bar, Decl(contextualTyping12.ts, 0, 11))
 >id : Symbol(id, Decl(contextualTyping12.ts, 0, 24))
+>{id:1} : Symbol(, Decl(contextualTyping12.ts, 0, 41))
 >id : Symbol(id, Decl(contextualTyping12.ts, 0, 42))
+>{id:2, name:"foo"} : Symbol(, Decl(contextualTyping12.ts, 0, 48))
 >id : Symbol(id, Decl(contextualTyping12.ts, 0, 50))
 >name : Symbol(name, Decl(contextualTyping12.ts, 0, 55))
 
diff --git a/tests/baselines/reference/contextualTyping13.symbols b/tests/baselines/reference/contextualTyping13.symbols
index e60131e8433fc..767db204d8b18 100644
--- a/tests/baselines/reference/contextualTyping13.symbols
+++ b/tests/baselines/reference/contextualTyping13.symbols
@@ -2,6 +2,7 @@
 var foo:(a:number)=>number = function(a){return a};
 >foo : Symbol(foo, Decl(contextualTyping13.ts, 0, 3))
 >a : Symbol(a, Decl(contextualTyping13.ts, 0, 9))
+>function(a){return a} : Symbol((Anonymous function), Decl(contextualTyping13.ts, 0, 28))
 >a : Symbol(a, Decl(contextualTyping13.ts, 0, 38))
 >a : Symbol(a, Decl(contextualTyping13.ts, 0, 38))
 
diff --git a/tests/baselines/reference/contextualTyping14.symbols b/tests/baselines/reference/contextualTyping14.symbols
index 7de67445ca8c7..5f226815f2e74 100644
--- a/tests/baselines/reference/contextualTyping14.symbols
+++ b/tests/baselines/reference/contextualTyping14.symbols
@@ -3,6 +3,7 @@ class foo { public bar:(a:number)=>number = function(a){return a}; }
 >foo : Symbol(foo, Decl(contextualTyping14.ts, 0, 0))
 >bar : Symbol(bar, Decl(contextualTyping14.ts, 0, 11))
 >a : Symbol(a, Decl(contextualTyping14.ts, 0, 24))
+>function(a){return a} : Symbol((Anonymous function), Decl(contextualTyping14.ts, 0, 43))
 >a : Symbol(a, Decl(contextualTyping14.ts, 0, 53))
 >a : Symbol(a, Decl(contextualTyping14.ts, 0, 53))
 
diff --git a/tests/baselines/reference/contextualTyping15.symbols b/tests/baselines/reference/contextualTyping15.symbols
index 902fb03dc70d0..746b8c74c210d 100644
--- a/tests/baselines/reference/contextualTyping15.symbols
+++ b/tests/baselines/reference/contextualTyping15.symbols
@@ -3,4 +3,5 @@ class foo { public bar: { (): number; (i: number): number; } = function() { retu
 >foo : Symbol(foo, Decl(contextualTyping15.ts, 0, 0))
 >bar : Symbol(bar, Decl(contextualTyping15.ts, 0, 11))
 >i : Symbol(i, Decl(contextualTyping15.ts, 0, 39))
+>function() { return 1 } : Symbol((Anonymous function), Decl(contextualTyping15.ts, 0, 62))
 
diff --git a/tests/baselines/reference/contextualTyping16.symbols b/tests/baselines/reference/contextualTyping16.symbols
index 9f88ce4c151e2..90fc6ae552c8a 100644
--- a/tests/baselines/reference/contextualTyping16.symbols
+++ b/tests/baselines/reference/contextualTyping16.symbols
@@ -2,7 +2,9 @@
 var foo: {id:number;} = {id:4}; foo = {id:5};
 >foo : Symbol(foo, Decl(contextualTyping16.ts, 0, 3))
 >id : Symbol(id, Decl(contextualTyping16.ts, 0, 10))
+>{id:4} : Symbol(, Decl(contextualTyping16.ts, 0, 23))
 >id : Symbol(id, Decl(contextualTyping16.ts, 0, 25))
 >foo : Symbol(foo, Decl(contextualTyping16.ts, 0, 3))
+>{id:5} : Symbol(, Decl(contextualTyping16.ts, 0, 37))
 >id : Symbol(id, Decl(contextualTyping16.ts, 0, 39))
 
diff --git a/tests/baselines/reference/contextualTyping17.symbols b/tests/baselines/reference/contextualTyping17.symbols
index 55631494105ad..9b530bc9cd09a 100644
--- a/tests/baselines/reference/contextualTyping17.symbols
+++ b/tests/baselines/reference/contextualTyping17.symbols
@@ -2,8 +2,10 @@
 var foo: {id:number;} = {id:4}; foo = {id: 5, name:"foo"};
 >foo : Symbol(foo, Decl(contextualTyping17.ts, 0, 3))
 >id : Symbol(id, Decl(contextualTyping17.ts, 0, 10))
+>{id:4} : Symbol(, Decl(contextualTyping17.ts, 0, 23))
 >id : Symbol(id, Decl(contextualTyping17.ts, 0, 25))
 >foo : Symbol(foo, Decl(contextualTyping17.ts, 0, 3))
+>{id: 5, name:"foo"} : Symbol(, Decl(contextualTyping17.ts, 0, 37))
 >id : Symbol(id, Decl(contextualTyping17.ts, 0, 39))
 >name : Symbol(name, Decl(contextualTyping17.ts, 0, 45))
 
diff --git a/tests/baselines/reference/contextualTyping18.symbols b/tests/baselines/reference/contextualTyping18.symbols
index a5506cfe9009d..3ba6839c9745d 100644
--- a/tests/baselines/reference/contextualTyping18.symbols
+++ b/tests/baselines/reference/contextualTyping18.symbols
@@ -3,6 +3,8 @@ var foo: {id:number;} = <{id:number;}>({ }); foo = {id: 5};
 >foo : Symbol(foo, Decl(contextualTyping18.ts, 0, 3))
 >id : Symbol(id, Decl(contextualTyping18.ts, 0, 10))
 >id : Symbol(id, Decl(contextualTyping18.ts, 0, 26))
+>{ } : Symbol(, Decl(contextualTyping18.ts, 0, 39))
 >foo : Symbol(foo, Decl(contextualTyping18.ts, 0, 3))
+>{id: 5} : Symbol(, Decl(contextualTyping18.ts, 0, 50))
 >id : Symbol(id, Decl(contextualTyping18.ts, 0, 52))
 
diff --git a/tests/baselines/reference/contextualTyping19.symbols b/tests/baselines/reference/contextualTyping19.symbols
index cee3a6e7d24e9..2450b141444e8 100644
--- a/tests/baselines/reference/contextualTyping19.symbols
+++ b/tests/baselines/reference/contextualTyping19.symbols
@@ -2,8 +2,11 @@
 var foo:{id:number;}[] = [{id:1}]; foo = [{id:1}, {id:2}];
 >foo : Symbol(foo, Decl(contextualTyping19.ts, 0, 3))
 >id : Symbol(id, Decl(contextualTyping19.ts, 0, 9))
+>{id:1} : Symbol(, Decl(contextualTyping19.ts, 0, 26))
 >id : Symbol(id, Decl(contextualTyping19.ts, 0, 27))
 >foo : Symbol(foo, Decl(contextualTyping19.ts, 0, 3))
+>{id:1} : Symbol(, Decl(contextualTyping19.ts, 0, 42))
 >id : Symbol(id, Decl(contextualTyping19.ts, 0, 43))
+>{id:2} : Symbol(, Decl(contextualTyping19.ts, 0, 49))
 >id : Symbol(id, Decl(contextualTyping19.ts, 0, 51))
 
diff --git a/tests/baselines/reference/contextualTyping2.symbols b/tests/baselines/reference/contextualTyping2.symbols
index 9c1020929794b..ecaa40d969bfb 100644
--- a/tests/baselines/reference/contextualTyping2.symbols
+++ b/tests/baselines/reference/contextualTyping2.symbols
@@ -2,6 +2,7 @@
 var foo: {id:number;} = {id:4, name:"foo"};
 >foo : Symbol(foo, Decl(contextualTyping2.ts, 0, 3))
 >id : Symbol(id, Decl(contextualTyping2.ts, 0, 10))
+>{id:4, name:"foo"} : Symbol(, Decl(contextualTyping2.ts, 0, 23))
 >id : Symbol(id, Decl(contextualTyping2.ts, 0, 25))
 >name : Symbol(name, Decl(contextualTyping2.ts, 0, 30))
 
diff --git a/tests/baselines/reference/contextualTyping20.symbols b/tests/baselines/reference/contextualTyping20.symbols
index 505c6a04a59f2..bfe591d12cb55 100644
--- a/tests/baselines/reference/contextualTyping20.symbols
+++ b/tests/baselines/reference/contextualTyping20.symbols
@@ -2,9 +2,12 @@
 var foo:{id:number;}[] = [{id:1}]; foo = [{id:1}, {id:2, name:"foo"}];
 >foo : Symbol(foo, Decl(contextualTyping20.ts, 0, 3))
 >id : Symbol(id, Decl(contextualTyping20.ts, 0, 9))
+>{id:1} : Symbol(, Decl(contextualTyping20.ts, 0, 26))
 >id : Symbol(id, Decl(contextualTyping20.ts, 0, 27))
 >foo : Symbol(foo, Decl(contextualTyping20.ts, 0, 3))
+>{id:1} : Symbol(, Decl(contextualTyping20.ts, 0, 42))
 >id : Symbol(id, Decl(contextualTyping20.ts, 0, 43))
+>{id:2, name:"foo"} : Symbol(, Decl(contextualTyping20.ts, 0, 49))
 >id : Symbol(id, Decl(contextualTyping20.ts, 0, 51))
 >name : Symbol(name, Decl(contextualTyping20.ts, 0, 56))
 
diff --git a/tests/baselines/reference/contextualTyping22.symbols b/tests/baselines/reference/contextualTyping22.symbols
index 9a7817a826063..ec54714f07a93 100644
--- a/tests/baselines/reference/contextualTyping22.symbols
+++ b/tests/baselines/reference/contextualTyping22.symbols
@@ -2,9 +2,11 @@
 var foo:(a:number)=>number = function(a){return a}; foo = function(b){return b};
 >foo : Symbol(foo, Decl(contextualTyping22.ts, 0, 3))
 >a : Symbol(a, Decl(contextualTyping22.ts, 0, 9))
+>function(a){return a} : Symbol((Anonymous function), Decl(contextualTyping22.ts, 0, 28))
 >a : Symbol(a, Decl(contextualTyping22.ts, 0, 38))
 >a : Symbol(a, Decl(contextualTyping22.ts, 0, 38))
 >foo : Symbol(foo, Decl(contextualTyping22.ts, 0, 3))
+>function(b){return b} : Symbol((Anonymous function), Decl(contextualTyping22.ts, 0, 57))
 >b : Symbol(b, Decl(contextualTyping22.ts, 0, 67))
 >b : Symbol(b, Decl(contextualTyping22.ts, 0, 67))
 
diff --git a/tests/baselines/reference/contextualTyping23.symbols b/tests/baselines/reference/contextualTyping23.symbols
index bb0daeeee18ae..c8dd900740437 100644
--- a/tests/baselines/reference/contextualTyping23.symbols
+++ b/tests/baselines/reference/contextualTyping23.symbols
@@ -4,5 +4,6 @@ var foo:(a:{():number; (i:number):number; })=>number; foo = function(a){return 5
 >a : Symbol(a, Decl(contextualTyping23.ts, 0, 9))
 >i : Symbol(i, Decl(contextualTyping23.ts, 0, 24))
 >foo : Symbol(foo, Decl(contextualTyping23.ts, 0, 3))
+>function(a){return 5} : Symbol((Anonymous function), Decl(contextualTyping23.ts, 0, 59))
 >a : Symbol(a, Decl(contextualTyping23.ts, 0, 69))
 
diff --git a/tests/baselines/reference/contextualTyping25.symbols b/tests/baselines/reference/contextualTyping25.symbols
index 5446a3c7515d5..2aea0f403f240 100644
--- a/tests/baselines/reference/contextualTyping25.symbols
+++ b/tests/baselines/reference/contextualTyping25.symbols
@@ -5,4 +5,5 @@ function foo(param:{id:number;}){}; foo(<{id:number;}>({}));
 >id : Symbol(id, Decl(contextualTyping25.ts, 0, 20))
 >foo : Symbol(foo, Decl(contextualTyping25.ts, 0, 0))
 >id : Symbol(id, Decl(contextualTyping25.ts, 0, 42))
+>{} : Symbol(, Decl(contextualTyping25.ts, 0, 55))
 
diff --git a/tests/baselines/reference/contextualTyping26.symbols b/tests/baselines/reference/contextualTyping26.symbols
index ccecd501837ba..5bfd286b016fe 100644
--- a/tests/baselines/reference/contextualTyping26.symbols
+++ b/tests/baselines/reference/contextualTyping26.symbols
@@ -5,4 +5,5 @@ function foo(param:{id:number;}){}; foo(<{id:number;}>({}));
 >id : Symbol(id, Decl(contextualTyping26.ts, 0, 20))
 >foo : Symbol(foo, Decl(contextualTyping26.ts, 0, 0))
 >id : Symbol(id, Decl(contextualTyping26.ts, 0, 42))
+>{} : Symbol(, Decl(contextualTyping26.ts, 0, 55))
 
diff --git a/tests/baselines/reference/contextualTyping27.symbols b/tests/baselines/reference/contextualTyping27.symbols
index 0ff8486c1d99d..bceaeeca6386d 100644
--- a/tests/baselines/reference/contextualTyping27.symbols
+++ b/tests/baselines/reference/contextualTyping27.symbols
@@ -5,4 +5,5 @@ function foo(param:{id:number;}){}; foo(<{id:number;}>({}));
 >id : Symbol(id, Decl(contextualTyping27.ts, 0, 20))
 >foo : Symbol(foo, Decl(contextualTyping27.ts, 0, 0))
 >id : Symbol(id, Decl(contextualTyping27.ts, 0, 42))
+>{} : Symbol(, Decl(contextualTyping27.ts, 0, 55))
 
diff --git a/tests/baselines/reference/contextualTyping3.symbols b/tests/baselines/reference/contextualTyping3.symbols
index 584c399e4da6a..491e6ff0f90ed 100644
--- a/tests/baselines/reference/contextualTyping3.symbols
+++ b/tests/baselines/reference/contextualTyping3.symbols
@@ -3,5 +3,6 @@ class foo { public bar:{id:number;} = {id:5}; }
 >foo : Symbol(foo, Decl(contextualTyping3.ts, 0, 0))
 >bar : Symbol(bar, Decl(contextualTyping3.ts, 0, 11))
 >id : Symbol(id, Decl(contextualTyping3.ts, 0, 24))
+>{id:5} : Symbol(, Decl(contextualTyping3.ts, 0, 37))
 >id : Symbol(id, Decl(contextualTyping3.ts, 0, 39))
 
diff --git a/tests/baselines/reference/contextualTyping32.symbols b/tests/baselines/reference/contextualTyping32.symbols
index f4ceeb9349151..b8df48e33f6b7 100644
--- a/tests/baselines/reference/contextualTyping32.symbols
+++ b/tests/baselines/reference/contextualTyping32.symbols
@@ -4,4 +4,6 @@ function foo(param: {():number; (i:number):number; }[]) { }; foo([function(){ret
 >param : Symbol(param, Decl(contextualTyping32.ts, 0, 13))
 >i : Symbol(i, Decl(contextualTyping32.ts, 0, 33))
 >foo : Symbol(foo, Decl(contextualTyping32.ts, 0, 0))
+>function(){return 1;} : Symbol((Anonymous function), Decl(contextualTyping32.ts, 0, 66))
+>function(){return 4} : Symbol((Anonymous function), Decl(contextualTyping32.ts, 0, 88))
 
diff --git a/tests/baselines/reference/contextualTyping34.symbols b/tests/baselines/reference/contextualTyping34.symbols
index 6ea9f09f94b64..cdc88159f0083 100644
--- a/tests/baselines/reference/contextualTyping34.symbols
+++ b/tests/baselines/reference/contextualTyping34.symbols
@@ -2,5 +2,6 @@
 var foo = <{ id: number;}> ({id:4});
 >foo : Symbol(foo, Decl(contextualTyping34.ts, 0, 3))
 >id : Symbol(id, Decl(contextualTyping34.ts, 0, 12))
+>{id:4} : Symbol(, Decl(contextualTyping34.ts, 0, 28))
 >id : Symbol(id, Decl(contextualTyping34.ts, 0, 29))
 
diff --git a/tests/baselines/reference/contextualTyping35.symbols b/tests/baselines/reference/contextualTyping35.symbols
index cb98510089176..aacf78834ebff 100644
--- a/tests/baselines/reference/contextualTyping35.symbols
+++ b/tests/baselines/reference/contextualTyping35.symbols
@@ -2,6 +2,7 @@
 var foo = <{ id: number;}> {id:4, name: "as"};
 >foo : Symbol(foo, Decl(contextualTyping35.ts, 0, 3))
 >id : Symbol(id, Decl(contextualTyping35.ts, 0, 12))
+>{id:4, name: "as"} : Symbol(, Decl(contextualTyping35.ts, 0, 26))
 >id : Symbol(id, Decl(contextualTyping35.ts, 0, 28))
 >name : Symbol(name, Decl(contextualTyping35.ts, 0, 33))
 
diff --git a/tests/baselines/reference/contextualTyping36.symbols b/tests/baselines/reference/contextualTyping36.symbols
index 28ceac9738cc3..acaacd2b77c4d 100644
--- a/tests/baselines/reference/contextualTyping36.symbols
+++ b/tests/baselines/reference/contextualTyping36.symbols
@@ -2,6 +2,8 @@
 var foo = <{ id: number; }[]>[{ id: 4 }, <{ id: number; }>({  })];
 >foo : Symbol(foo, Decl(contextualTyping36.ts, 0, 3))
 >id : Symbol(id, Decl(contextualTyping36.ts, 0, 12))
+>{ id: 4 } : Symbol(, Decl(contextualTyping36.ts, 0, 30))
 >id : Symbol(id, Decl(contextualTyping36.ts, 0, 31))
 >id : Symbol(id, Decl(contextualTyping36.ts, 0, 43))
+>{  } : Symbol(, Decl(contextualTyping36.ts, 0, 59))
 
diff --git a/tests/baselines/reference/contextualTyping37.symbols b/tests/baselines/reference/contextualTyping37.symbols
index 083704750cb35..34cef3cdefe89 100644
--- a/tests/baselines/reference/contextualTyping37.symbols
+++ b/tests/baselines/reference/contextualTyping37.symbols
@@ -2,5 +2,7 @@
 var foo = <{ id: number; }[]>[{ foo: "s" }, {  }];
 >foo : Symbol(foo, Decl(contextualTyping37.ts, 0, 3))
 >id : Symbol(id, Decl(contextualTyping37.ts, 0, 12))
+>{ foo: "s" } : Symbol(, Decl(contextualTyping37.ts, 0, 30))
 >foo : Symbol(foo, Decl(contextualTyping37.ts, 0, 31))
+>{  } : Symbol(, Decl(contextualTyping37.ts, 0, 43))
 
diff --git a/tests/baselines/reference/contextualTyping38.symbols b/tests/baselines/reference/contextualTyping38.symbols
index f208cad698a7f..35bf1def858bd 100644
--- a/tests/baselines/reference/contextualTyping38.symbols
+++ b/tests/baselines/reference/contextualTyping38.symbols
@@ -1,6 +1,7 @@
 === tests/cases/compiler/contextualTyping38.ts ===
 var foo = <{ (): number; }> function(a) { return a };
 >foo : Symbol(foo, Decl(contextualTyping38.ts, 0, 3))
+>function(a) { return a } : Symbol((Anonymous function), Decl(contextualTyping38.ts, 0, 27))
 >a : Symbol(a, Decl(contextualTyping38.ts, 0, 37))
 >a : Symbol(a, Decl(contextualTyping38.ts, 0, 37))
 
diff --git a/tests/baselines/reference/contextualTyping4.symbols b/tests/baselines/reference/contextualTyping4.symbols
index c5dcd4f1577bc..a640a8c0701c2 100644
--- a/tests/baselines/reference/contextualTyping4.symbols
+++ b/tests/baselines/reference/contextualTyping4.symbols
@@ -3,6 +3,7 @@ class foo { public bar:{id:number;} = {id:5, name:"foo"}; }
 >foo : Symbol(foo, Decl(contextualTyping4.ts, 0, 0))
 >bar : Symbol(bar, Decl(contextualTyping4.ts, 0, 11))
 >id : Symbol(id, Decl(contextualTyping4.ts, 0, 24))
+>{id:5, name:"foo"} : Symbol(, Decl(contextualTyping4.ts, 0, 37))
 >id : Symbol(id, Decl(contextualTyping4.ts, 0, 39))
 >name : Symbol(name, Decl(contextualTyping4.ts, 0, 44))
 
diff --git a/tests/baselines/reference/contextualTyping40.symbols b/tests/baselines/reference/contextualTyping40.symbols
index 8606cdd4c41b4..10148051f4218 100644
--- a/tests/baselines/reference/contextualTyping40.symbols
+++ b/tests/baselines/reference/contextualTyping40.symbols
@@ -2,4 +2,5 @@
 var foo = <{():number; (i:number):number; }> function(){return 1;};
 >foo : Symbol(foo, Decl(contextualTyping40.ts, 0, 3))
 >i : Symbol(i, Decl(contextualTyping40.ts, 0, 24))
+>function(){return 1;} : Symbol((Anonymous function), Decl(contextualTyping40.ts, 0, 44))
 
diff --git a/tests/baselines/reference/contextualTyping6.symbols b/tests/baselines/reference/contextualTyping6.symbols
index 23af71d7dba79..b8a2e229f8728 100644
--- a/tests/baselines/reference/contextualTyping6.symbols
+++ b/tests/baselines/reference/contextualTyping6.symbols
@@ -2,6 +2,8 @@
 var foo:{id:number;}[] = [{id:1}, {id:2}];
 >foo : Symbol(foo, Decl(contextualTyping6.ts, 0, 3))
 >id : Symbol(id, Decl(contextualTyping6.ts, 0, 9))
+>{id:1} : Symbol(, Decl(contextualTyping6.ts, 0, 26))
 >id : Symbol(id, Decl(contextualTyping6.ts, 0, 27))
+>{id:2} : Symbol(, Decl(contextualTyping6.ts, 0, 33))
 >id : Symbol(id, Decl(contextualTyping6.ts, 0, 35))
 
diff --git a/tests/baselines/reference/contextualTyping7.symbols b/tests/baselines/reference/contextualTyping7.symbols
index 679c1945f338a..e54d5e60f2591 100644
--- a/tests/baselines/reference/contextualTyping7.symbols
+++ b/tests/baselines/reference/contextualTyping7.symbols
@@ -3,4 +3,5 @@ var foo:{id:number;}[] = [<{id:number;}>({})];
 >foo : Symbol(foo, Decl(contextualTyping7.ts, 0, 3))
 >id : Symbol(id, Decl(contextualTyping7.ts, 0, 9))
 >id : Symbol(id, Decl(contextualTyping7.ts, 0, 28))
+>{} : Symbol(, Decl(contextualTyping7.ts, 0, 41))
 
diff --git a/tests/baselines/reference/contextualTyping8.symbols b/tests/baselines/reference/contextualTyping8.symbols
index 7dadb937ea1e2..23505250cc2eb 100644
--- a/tests/baselines/reference/contextualTyping8.symbols
+++ b/tests/baselines/reference/contextualTyping8.symbols
@@ -3,4 +3,5 @@ var foo:{id:number;}[] = [<{id:number;}>({})];
 >foo : Symbol(foo, Decl(contextualTyping8.ts, 0, 3))
 >id : Symbol(id, Decl(contextualTyping8.ts, 0, 9))
 >id : Symbol(id, Decl(contextualTyping8.ts, 0, 28))
+>{} : Symbol(, Decl(contextualTyping8.ts, 0, 41))
 
diff --git a/tests/baselines/reference/contextualTyping9.symbols b/tests/baselines/reference/contextualTyping9.symbols
index f9ef2220c2013..0984f3cdef620 100644
--- a/tests/baselines/reference/contextualTyping9.symbols
+++ b/tests/baselines/reference/contextualTyping9.symbols
@@ -2,7 +2,9 @@
 var foo:{id:number;}[] = [{id:1}, {id:2, name:"foo"}];
 >foo : Symbol(foo, Decl(contextualTyping9.ts, 0, 3))
 >id : Symbol(id, Decl(contextualTyping9.ts, 0, 9))
+>{id:1} : Symbol(, Decl(contextualTyping9.ts, 0, 26))
 >id : Symbol(id, Decl(contextualTyping9.ts, 0, 27))
+>{id:2, name:"foo"} : Symbol(, Decl(contextualTyping9.ts, 0, 33))
 >id : Symbol(id, Decl(contextualTyping9.ts, 0, 35))
 >name : Symbol(name, Decl(contextualTyping9.ts, 0, 40))
 
diff --git a/tests/baselines/reference/contextualTypingArrayOfLambdas.symbols b/tests/baselines/reference/contextualTypingArrayOfLambdas.symbols
index 79355e0a7c633..1cbf653d1d16d 100644
--- a/tests/baselines/reference/contextualTypingArrayOfLambdas.symbols
+++ b/tests/baselines/reference/contextualTypingArrayOfLambdas.symbols
@@ -24,10 +24,13 @@ class C extends A {
 
 var xs = [(x: A) => { }, (x: B) => { }, (x: C) => { }];
 >xs : Symbol(xs, Decl(contextualTypingArrayOfLambdas.ts, 12, 3))
+>(x: A) => { } : Symbol((Anonymous function), Decl(contextualTypingArrayOfLambdas.ts, 12, 10))
 >x : Symbol(x, Decl(contextualTypingArrayOfLambdas.ts, 12, 11))
 >A : Symbol(A, Decl(contextualTypingArrayOfLambdas.ts, 0, 0))
+>(x: B) => { } : Symbol((Anonymous function), Decl(contextualTypingArrayOfLambdas.ts, 12, 24))
 >x : Symbol(x, Decl(contextualTypingArrayOfLambdas.ts, 12, 26))
 >B : Symbol(B, Decl(contextualTypingArrayOfLambdas.ts, 2, 1))
+>(x: C) => { } : Symbol((Anonymous function), Decl(contextualTypingArrayOfLambdas.ts, 12, 39))
 >x : Symbol(x, Decl(contextualTypingArrayOfLambdas.ts, 12, 41))
 >C : Symbol(C, Decl(contextualTypingArrayOfLambdas.ts, 6, 1))
 
diff --git a/tests/baselines/reference/contextualTypingOfConditionalExpression.symbols b/tests/baselines/reference/contextualTypingOfConditionalExpression.symbols
index 56c3abe0627d9..eb689aeab180c 100644
--- a/tests/baselines/reference/contextualTypingOfConditionalExpression.symbols
+++ b/tests/baselines/reference/contextualTypingOfConditionalExpression.symbols
@@ -2,10 +2,12 @@
 var x: (a: number) => void = true ? (a) => a.toExponential() : (b) => b.toFixed();
 >x : Symbol(x, Decl(contextualTypingOfConditionalExpression.ts, 0, 3))
 >a : Symbol(a, Decl(contextualTypingOfConditionalExpression.ts, 0, 8))
+>(a) => a.toExponential() : Symbol((Anonymous function), Decl(contextualTypingOfConditionalExpression.ts, 0, 35))
 >a : Symbol(a, Decl(contextualTypingOfConditionalExpression.ts, 0, 37))
 >a.toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45))
 >a : Symbol(a, Decl(contextualTypingOfConditionalExpression.ts, 0, 37))
 >toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45))
+>(b) => b.toFixed() : Symbol((Anonymous function), Decl(contextualTypingOfConditionalExpression.ts, 0, 62))
 >b : Symbol(b, Decl(contextualTypingOfConditionalExpression.ts, 0, 64))
 >b.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
 >b : Symbol(b, Decl(contextualTypingOfConditionalExpression.ts, 0, 64))
@@ -36,10 +38,12 @@ var x2: (a: A) => void = true ? (a) => a.foo : (b) => b.foo;
 >x2 : Symbol(x2, Decl(contextualTypingOfConditionalExpression.ts, 12, 3))
 >a : Symbol(a, Decl(contextualTypingOfConditionalExpression.ts, 12, 9))
 >A : Symbol(A, Decl(contextualTypingOfConditionalExpression.ts, 0, 82))
+>(a) => a.foo : Symbol((Anonymous function), Decl(contextualTypingOfConditionalExpression.ts, 12, 31))
 >a : Symbol(a, Decl(contextualTypingOfConditionalExpression.ts, 12, 33))
 >a.foo : Symbol(A.foo, Decl(contextualTypingOfConditionalExpression.ts, 2, 9))
 >a : Symbol(a, Decl(contextualTypingOfConditionalExpression.ts, 12, 33))
 >foo : Symbol(A.foo, Decl(contextualTypingOfConditionalExpression.ts, 2, 9))
+>(b) => b.foo : Symbol((Anonymous function), Decl(contextualTypingOfConditionalExpression.ts, 12, 46))
 >b : Symbol(b, Decl(contextualTypingOfConditionalExpression.ts, 12, 48))
 >b.foo : Symbol(A.foo, Decl(contextualTypingOfConditionalExpression.ts, 2, 9))
 >b : Symbol(b, Decl(contextualTypingOfConditionalExpression.ts, 12, 48))
diff --git a/tests/baselines/reference/contextualTypingOfLambdaWithMultipleSignatures.symbols b/tests/baselines/reference/contextualTypingOfLambdaWithMultipleSignatures.symbols
index 3a0c8e5db97a4..5ec69fd43aa06 100644
--- a/tests/baselines/reference/contextualTypingOfLambdaWithMultipleSignatures.symbols
+++ b/tests/baselines/reference/contextualTypingOfLambdaWithMultipleSignatures.symbols
@@ -19,5 +19,6 @@ foo.getFoo = bar => { };
 >foo.getFoo : Symbol(Foo.getFoo, Decl(contextualTypingOfLambdaWithMultipleSignatures.ts, 0, 15), Decl(contextualTypingOfLambdaWithMultipleSignatures.ts, 1, 28))
 >foo : Symbol(foo, Decl(contextualTypingOfLambdaWithMultipleSignatures.ts, 5, 3))
 >getFoo : Symbol(Foo.getFoo, Decl(contextualTypingOfLambdaWithMultipleSignatures.ts, 0, 15), Decl(contextualTypingOfLambdaWithMultipleSignatures.ts, 1, 28))
+>bar => { } : Symbol((Anonymous function), Decl(contextualTypingOfLambdaWithMultipleSignatures.ts, 6, 12))
 >bar : Symbol(bar, Decl(contextualTypingOfLambdaWithMultipleSignatures.ts, 6, 12))
 
diff --git a/tests/baselines/reference/contextualTypingOfLambdaWithMultipleSignatures2.symbols b/tests/baselines/reference/contextualTypingOfLambdaWithMultipleSignatures2.symbols
index f44d33e1ba8ea..edac6b9b1a875 100644
--- a/tests/baselines/reference/contextualTypingOfLambdaWithMultipleSignatures2.symbols
+++ b/tests/baselines/reference/contextualTypingOfLambdaWithMultipleSignatures2.symbols
@@ -12,6 +12,7 @@ var f: {
 
 f = (a) => { return a.asdf }
 >f : Symbol(f, Decl(contextualTypingOfLambdaWithMultipleSignatures2.ts, 0, 3))
+>(a) => { return a.asdf } : Symbol((Anonymous function), Decl(contextualTypingOfLambdaWithMultipleSignatures2.ts, 5, 3))
 >a : Symbol(a, Decl(contextualTypingOfLambdaWithMultipleSignatures2.ts, 5, 5))
 >a : Symbol(a, Decl(contextualTypingOfLambdaWithMultipleSignatures2.ts, 5, 5))
 
diff --git a/tests/baselines/reference/contextualTypingTwoInstancesOfSameTypeParameter.symbols b/tests/baselines/reference/contextualTypingTwoInstancesOfSameTypeParameter.symbols
index 62870f575c7b0..f2c4121a139be 100644
--- a/tests/baselines/reference/contextualTypingTwoInstancesOfSameTypeParameter.symbols
+++ b/tests/baselines/reference/contextualTypingTwoInstancesOfSameTypeParameter.symbols
@@ -11,8 +11,10 @@ function f6<T>(x: (a: T) => T) {
 } 
 f6(x => f6(y => x = y));
 >f6 : Symbol(f6, Decl(contextualTypingTwoInstancesOfSameTypeParameter.ts, 0, 0))
+>x => f6(y => x = y) : Symbol((Anonymous function), Decl(contextualTypingTwoInstancesOfSameTypeParameter.ts, 3, 3))
 >x : Symbol(x, Decl(contextualTypingTwoInstancesOfSameTypeParameter.ts, 3, 3))
 >f6 : Symbol(f6, Decl(contextualTypingTwoInstancesOfSameTypeParameter.ts, 0, 0))
+>y => x = y : Symbol((Anonymous function), Decl(contextualTypingTwoInstancesOfSameTypeParameter.ts, 3, 11))
 >y : Symbol(y, Decl(contextualTypingTwoInstancesOfSameTypeParameter.ts, 3, 11))
 >x : Symbol(x, Decl(contextualTypingTwoInstancesOfSameTypeParameter.ts, 3, 3))
 >y : Symbol(y, Decl(contextualTypingTwoInstancesOfSameTypeParameter.ts, 3, 11))
diff --git a/tests/baselines/reference/contextualTypingWithGenericAndNonGenericSignature.symbols b/tests/baselines/reference/contextualTypingWithGenericAndNonGenericSignature.symbols
index d7ba6f0ddc376..d764033e4dae2 100644
--- a/tests/baselines/reference/contextualTypingWithGenericAndNonGenericSignature.symbols
+++ b/tests/baselines/reference/contextualTypingWithGenericAndNonGenericSignature.symbols
@@ -21,6 +21,7 @@ var f2: {
 
 f2 = (x, y) => { return x }
 >f2 : Symbol(f2, Decl(contextualTypingWithGenericAndNonGenericSignature.ts, 2, 3))
+>(x, y) => { return x } : Symbol((Anonymous function), Decl(contextualTypingWithGenericAndNonGenericSignature.ts, 7, 4))
 >x : Symbol(x, Decl(contextualTypingWithGenericAndNonGenericSignature.ts, 7, 6))
 >y : Symbol(y, Decl(contextualTypingWithGenericAndNonGenericSignature.ts, 7, 8))
 >x : Symbol(x, Decl(contextualTypingWithGenericAndNonGenericSignature.ts, 7, 6))
@@ -45,6 +46,7 @@ var f3: {
 
 f3 = (x, y) => { return x }
 >f3 : Symbol(f3, Decl(contextualTypingWithGenericAndNonGenericSignature.ts, 9, 3))
+>(x, y) => { return x } : Symbol((Anonymous function), Decl(contextualTypingWithGenericAndNonGenericSignature.ts, 14, 4))
 >x : Symbol(x, Decl(contextualTypingWithGenericAndNonGenericSignature.ts, 14, 6))
 >y : Symbol(y, Decl(contextualTypingWithGenericAndNonGenericSignature.ts, 14, 8))
 >x : Symbol(x, Decl(contextualTypingWithGenericAndNonGenericSignature.ts, 14, 6))
diff --git a/tests/baselines/reference/contextualTypingWithGenericSignature.symbols b/tests/baselines/reference/contextualTypingWithGenericSignature.symbols
index c416a5ca19fda..c564a3b264c91 100644
--- a/tests/baselines/reference/contextualTypingWithGenericSignature.symbols
+++ b/tests/baselines/reference/contextualTypingWithGenericSignature.symbols
@@ -17,6 +17,7 @@ var f2: {
 
 f2 = (x, y) => { return x }
 >f2 : Symbol(f2, Decl(contextualTypingWithGenericSignature.ts, 2, 3))
+>(x, y) => { return x } : Symbol((Anonymous function), Decl(contextualTypingWithGenericSignature.ts, 6, 4))
 >x : Symbol(x, Decl(contextualTypingWithGenericSignature.ts, 6, 6))
 >y : Symbol(y, Decl(contextualTypingWithGenericSignature.ts, 6, 8))
 >x : Symbol(x, Decl(contextualTypingWithGenericSignature.ts, 6, 6))
diff --git a/tests/baselines/reference/contextuallyTypedFunctionExpressionsAndReturnAnnotations.symbols b/tests/baselines/reference/contextuallyTypedFunctionExpressionsAndReturnAnnotations.symbols
index 810f407e1b22f..1a01e2db77ce3 100644
--- a/tests/baselines/reference/contextuallyTypedFunctionExpressionsAndReturnAnnotations.symbols
+++ b/tests/baselines/reference/contextuallyTypedFunctionExpressionsAndReturnAnnotations.symbols
@@ -8,6 +8,7 @@ declare function foo(x: (y: string) => (y2: number) => void);
 // Contextually type the parameter even if there is a return annotation
 foo((y): (y2: number) => void => {
 >foo : Symbol(foo, Decl(contextuallyTypedFunctionExpressionsAndReturnAnnotations.ts, 0, 0))
+>(y): (y2: number) => void => {    var z = y.charAt(0); // Should be string    return null;} : Symbol((Anonymous function), Decl(contextuallyTypedFunctionExpressionsAndReturnAnnotations.ts, 3, 4))
 >y : Symbol(y, Decl(contextuallyTypedFunctionExpressionsAndReturnAnnotations.ts, 3, 5))
 >y2 : Symbol(y2, Decl(contextuallyTypedFunctionExpressionsAndReturnAnnotations.ts, 3, 10))
 
@@ -22,9 +23,11 @@ foo((y): (y2: number) => void => {
 
 foo((y: string) => {
 >foo : Symbol(foo, Decl(contextuallyTypedFunctionExpressionsAndReturnAnnotations.ts, 0, 0))
+>(y: string) => {    return y2 => {        var z = y2.toFixed(); // Should be string        return 0;    };} : Symbol((Anonymous function), Decl(contextuallyTypedFunctionExpressionsAndReturnAnnotations.ts, 8, 4))
 >y : Symbol(y, Decl(contextuallyTypedFunctionExpressionsAndReturnAnnotations.ts, 8, 5))
 
     return y2 => {
+>y2 => {        var z = y2.toFixed(); // Should be string        return 0;    } : Symbol((Anonymous function), Decl(contextuallyTypedFunctionExpressionsAndReturnAnnotations.ts, 9, 10))
 >y2 : Symbol(y2, Decl(contextuallyTypedFunctionExpressionsAndReturnAnnotations.ts, 9, 10))
 
         var z = y2.toFixed(); // Should be string
diff --git a/tests/baselines/reference/contextuallyTypingOrOperator.symbols b/tests/baselines/reference/contextuallyTypingOrOperator.symbols
index 18019aea7cb3e..d53a476e049d7 100644
--- a/tests/baselines/reference/contextuallyTypingOrOperator.symbols
+++ b/tests/baselines/reference/contextuallyTypingOrOperator.symbols
@@ -3,34 +3,44 @@ var v: { a: (_: string) => number } = { a: s => s.length } || { a: s => 1 };
 >v : Symbol(v, Decl(contextuallyTypingOrOperator.ts, 0, 3))
 >a : Symbol(a, Decl(contextuallyTypingOrOperator.ts, 0, 8))
 >_ : Symbol(_, Decl(contextuallyTypingOrOperator.ts, 0, 13))
+>{ a: s => s.length } : Symbol(, Decl(contextuallyTypingOrOperator.ts, 0, 37))
 >a : Symbol(a, Decl(contextuallyTypingOrOperator.ts, 0, 39))
+>s => s.length : Symbol((Anonymous function), Decl(contextuallyTypingOrOperator.ts, 0, 42))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 0, 42))
 >s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 0, 42))
 >length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>{ a: s => 1 } : Symbol(, Decl(contextuallyTypingOrOperator.ts, 0, 61))
 >a : Symbol(a, Decl(contextuallyTypingOrOperator.ts, 0, 63))
+>s => 1 : Symbol((Anonymous function), Decl(contextuallyTypingOrOperator.ts, 0, 66))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 0, 66))
 
 var v2 = (s: string) => s.length || function (s) { s.length };
 >v2 : Symbol(v2, Decl(contextuallyTypingOrOperator.ts, 2, 3))
+>(s: string) => s.length || function (s) { s.length } : Symbol((Anonymous function), Decl(contextuallyTypingOrOperator.ts, 2, 8))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 2, 10))
 >s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 2, 10))
 >length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>function (s) { s.length } : Symbol((Anonymous function), Decl(contextuallyTypingOrOperator.ts, 2, 35))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 2, 46))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 2, 46))
 
 var v3 = (s: string) => s.length || function (s: number) { return 1 };
 >v3 : Symbol(v3, Decl(contextuallyTypingOrOperator.ts, 4, 3))
+>(s: string) => s.length || function (s: number) { return 1 } : Symbol((Anonymous function), Decl(contextuallyTypingOrOperator.ts, 4, 8))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 4, 10))
 >s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 4, 10))
 >length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>function (s: number) { return 1 } : Symbol((Anonymous function), Decl(contextuallyTypingOrOperator.ts, 4, 35))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 4, 46))
 
 var v4 = (s: number) => 1 || function (s: string) { return s.length };
 >v4 : Symbol(v4, Decl(contextuallyTypingOrOperator.ts, 5, 3))
+>(s: number) => 1 || function (s: string) { return s.length } : Symbol((Anonymous function), Decl(contextuallyTypingOrOperator.ts, 5, 8))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 5, 10))
+>function (s: string) { return s.length } : Symbol((Anonymous function), Decl(contextuallyTypingOrOperator.ts, 5, 28))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 5, 39))
 >s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 5, 39))
diff --git a/tests/baselines/reference/contextuallyTypingOrOperator2.symbols b/tests/baselines/reference/contextuallyTypingOrOperator2.symbols
index 99e328fd64a44..70e12183c7445 100644
--- a/tests/baselines/reference/contextuallyTypingOrOperator2.symbols
+++ b/tests/baselines/reference/contextuallyTypingOrOperator2.symbols
@@ -3,20 +3,26 @@ var v: { a: (_: string) => number } = { a: s => s.length } || { a: s => 1 };
 >v : Symbol(v, Decl(contextuallyTypingOrOperator2.ts, 0, 3))
 >a : Symbol(a, Decl(contextuallyTypingOrOperator2.ts, 0, 8))
 >_ : Symbol(_, Decl(contextuallyTypingOrOperator2.ts, 0, 13))
+>{ a: s => s.length } : Symbol(, Decl(contextuallyTypingOrOperator2.ts, 0, 37))
 >a : Symbol(a, Decl(contextuallyTypingOrOperator2.ts, 0, 39))
+>s => s.length : Symbol((Anonymous function), Decl(contextuallyTypingOrOperator2.ts, 0, 42))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator2.ts, 0, 42))
 >s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator2.ts, 0, 42))
 >length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>{ a: s => 1 } : Symbol(, Decl(contextuallyTypingOrOperator2.ts, 0, 61))
 >a : Symbol(a, Decl(contextuallyTypingOrOperator2.ts, 0, 63))
+>s => 1 : Symbol((Anonymous function), Decl(contextuallyTypingOrOperator2.ts, 0, 66))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator2.ts, 0, 66))
 
 var v2 = (s: string) => s.length || function (s) { s.aaa };
 >v2 : Symbol(v2, Decl(contextuallyTypingOrOperator2.ts, 2, 3))
+>(s: string) => s.length || function (s) { s.aaa } : Symbol((Anonymous function), Decl(contextuallyTypingOrOperator2.ts, 2, 8))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator2.ts, 2, 10))
 >s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator2.ts, 2, 10))
 >length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>function (s) { s.aaa } : Symbol((Anonymous function), Decl(contextuallyTypingOrOperator2.ts, 2, 35))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator2.ts, 2, 46))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator2.ts, 2, 46))
 
diff --git a/tests/baselines/reference/covariance1.symbols b/tests/baselines/reference/covariance1.symbols
index db055e20bc6e3..2a7342cd15346 100644
--- a/tests/baselines/reference/covariance1.symbols
+++ b/tests/baselines/reference/covariance1.symbols
@@ -27,6 +27,7 @@ module M {
 
     f({x:a}); // ok
 >f : Symbol(f, Decl(covariance1.ts, 5, 24))
+>{x:a} : Symbol(, Decl(covariance1.ts, 10, 6))
 >x : Symbol(x, Decl(covariance1.ts, 10, 7))
 >a : Symbol(a, Decl(covariance1.ts, 9, 7))
 
@@ -36,6 +37,7 @@ module M {
 
     f({x:b}); // ok covariant subtype
 >f : Symbol(f, Decl(covariance1.ts, 5, 24))
+>{x:b} : Symbol(, Decl(covariance1.ts, 13, 6))
 >x : Symbol(x, Decl(covariance1.ts, 13, 7))
 >b : Symbol(b, Decl(covariance1.ts, 12, 7))
 }
diff --git a/tests/baselines/reference/crashInResolveInterface.symbols b/tests/baselines/reference/crashInResolveInterface.symbols
index c10bf0b26a89a..0b25f96354d72 100644
--- a/tests/baselines/reference/crashInResolveInterface.symbols
+++ b/tests/baselines/reference/crashInResolveInterface.symbols
@@ -42,6 +42,7 @@ var x = q1.each(x => c.log(x));
 >q1.each : Symbol(Q.each, Decl(file1.ts, 0, 16))
 >q1 : Symbol(q1, Decl(file1.ts, 3, 3))
 >each : Symbol(Q.each, Decl(file1.ts, 0, 16))
+>x => c.log(x) : Symbol((Anonymous function), Decl(file1.ts, 4, 16))
 >x : Symbol(x, Decl(file1.ts, 4, 16))
 >c.log : Symbol(C.log, Decl(file2.ts, 5, 13))
 >c : Symbol(c, Decl(file2.ts, 1, 11))
diff --git a/tests/baselines/reference/debuggerEmit.symbols b/tests/baselines/reference/debuggerEmit.symbols
index b8f6228a99dcd..d4688006839e6 100644
--- a/tests/baselines/reference/debuggerEmit.symbols
+++ b/tests/baselines/reference/debuggerEmit.symbols
@@ -1,6 +1,7 @@
 === tests/cases/compiler/debuggerEmit.ts ===
 var x = function () { debugger; }
 >x : Symbol(x, Decl(debuggerEmit.ts, 0, 3))
+>function () { debugger; } : Symbol((Anonymous function), Decl(debuggerEmit.ts, 0, 7))
 
 x();
 >x : Symbol(x, Decl(debuggerEmit.ts, 0, 3))
diff --git a/tests/baselines/reference/declFileModuleAssignmentInObjectLiteralProperty.symbols b/tests/baselines/reference/declFileModuleAssignmentInObjectLiteralProperty.symbols
index b47f6faeb5072..d9ff8d742f75f 100644
--- a/tests/baselines/reference/declFileModuleAssignmentInObjectLiteralProperty.symbols
+++ b/tests/baselines/reference/declFileModuleAssignmentInObjectLiteralProperty.symbols
@@ -9,14 +9,17 @@ module m1 {
 }
 var d = {
 >d : Symbol(d, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 5, 3))
+>{    m1: { m: m1 },    m2: { c: m1.c },} : Symbol(, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 5, 7))
 
     m1: { m: m1 },
 >m1 : Symbol(m1, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 5, 9))
+>{ m: m1 } : Symbol(, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 6, 7))
 >m : Symbol(m, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 6, 9))
 >m1 : Symbol(m1, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 0, 0))
 
     m2: { c: m1.c },
 >m2 : Symbol(m2, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 6, 18))
+>{ c: m1.c } : Symbol(, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 7, 7))
 >c : Symbol(c, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 7, 9))
 >m1.c : Symbol(m1.c, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 1, 11))
 >m1 : Symbol(m1, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 0, 0))
diff --git a/tests/baselines/reference/declFileRegressionTests.symbols b/tests/baselines/reference/declFileRegressionTests.symbols
index ea8f9e2fe2a01..796760cc272f6 100644
--- a/tests/baselines/reference/declFileRegressionTests.symbols
+++ b/tests/baselines/reference/declFileRegressionTests.symbols
@@ -3,9 +3,11 @@
 // function types not piped through correctly
 var n = { w: null, x: '', y: () => { }, z: 32 };
 >n : Symbol(n, Decl(declFileRegressionTests.ts, 2, 3))
+>{ w: null, x: '', y: () => { }, z: 32 } : Symbol(, Decl(declFileRegressionTests.ts, 2, 7))
 >w : Symbol(w, Decl(declFileRegressionTests.ts, 2, 9))
 >x : Symbol(x, Decl(declFileRegressionTests.ts, 2, 18))
 >y : Symbol(y, Decl(declFileRegressionTests.ts, 2, 25))
+>() => { } : Symbol((Anonymous function), Decl(declFileRegressionTests.ts, 2, 28))
 >z : Symbol(z, Decl(declFileRegressionTests.ts, 2, 39))
 
 
diff --git a/tests/baselines/reference/declFileRestParametersOfFunctionAndFunctionType.symbols b/tests/baselines/reference/declFileRestParametersOfFunctionAndFunctionType.symbols
index 49758e4ceb1e4..1c224ef7da278 100644
--- a/tests/baselines/reference/declFileRestParametersOfFunctionAndFunctionType.symbols
+++ b/tests/baselines/reference/declFileRestParametersOfFunctionAndFunctionType.symbols
@@ -26,6 +26,7 @@ function f5<T extends { (...args): void }>() { }
 
 var f6 = () => { return [<any>10]; }
 >f6 : Symbol(f6, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 6, 3))
+>() => { return [<any>10]; } : Symbol((Anonymous function), Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 6, 8))
 
 
 
diff --git a/tests/baselines/reference/declFileTypeAnnotationArrayType.symbols b/tests/baselines/reference/declFileTypeAnnotationArrayType.symbols
index 9092189c3c734..f43c1523add64 100644
--- a/tests/baselines/reference/declFileTypeAnnotationArrayType.symbols
+++ b/tests/baselines/reference/declFileTypeAnnotationArrayType.symbols
@@ -95,11 +95,13 @@ function foo9(): (()=>c)[] {
 >c : Symbol(c, Decl(declFileTypeAnnotationArrayType.ts, 0, 0))
 
     return [() => new c()];
+>() => new c() : Symbol((Anonymous function), Decl(declFileTypeAnnotationArrayType.ts, 46, 12))
 >c : Symbol(c, Decl(declFileTypeAnnotationArrayType.ts, 0, 0))
 }
 function foo10() {
 >foo10 : Symbol(foo10, Decl(declFileTypeAnnotationArrayType.ts, 47, 1))
 
     return [() => new c()];
+>() => new c() : Symbol((Anonymous function), Decl(declFileTypeAnnotationArrayType.ts, 49, 12))
 >c : Symbol(c, Decl(declFileTypeAnnotationArrayType.ts, 0, 0))
 }
diff --git a/tests/baselines/reference/declFileTypeAnnotationParenType.symbols b/tests/baselines/reference/declFileTypeAnnotationParenType.symbols
index bc5668b70bd7e..c7eaf967babbc 100644
--- a/tests/baselines/reference/declFileTypeAnnotationParenType.symbols
+++ b/tests/baselines/reference/declFileTypeAnnotationParenType.symbols
@@ -10,18 +10,22 @@ class c {
 var x: (() => c)[] = [() => new c()];
 >x : Symbol(x, Decl(declFileTypeAnnotationParenType.ts, 5, 3))
 >c : Symbol(c, Decl(declFileTypeAnnotationParenType.ts, 0, 0))
+>() => new c() : Symbol((Anonymous function), Decl(declFileTypeAnnotationParenType.ts, 5, 22))
 >c : Symbol(c, Decl(declFileTypeAnnotationParenType.ts, 0, 0))
 
 var y = [() => new c()];
 >y : Symbol(y, Decl(declFileTypeAnnotationParenType.ts, 6, 3))
+>() => new c() : Symbol((Anonymous function), Decl(declFileTypeAnnotationParenType.ts, 6, 9))
 >c : Symbol(c, Decl(declFileTypeAnnotationParenType.ts, 0, 0))
 
 var k: (() => c) | string = (() => new c()) || "";
 >k : Symbol(k, Decl(declFileTypeAnnotationParenType.ts, 8, 3))
 >c : Symbol(c, Decl(declFileTypeAnnotationParenType.ts, 0, 0))
+>() => new c() : Symbol((Anonymous function), Decl(declFileTypeAnnotationParenType.ts, 8, 29))
 >c : Symbol(c, Decl(declFileTypeAnnotationParenType.ts, 0, 0))
 
 var l = (() => new c()) || "";
 >l : Symbol(l, Decl(declFileTypeAnnotationParenType.ts, 9, 3))
+>() => new c() : Symbol((Anonymous function), Decl(declFileTypeAnnotationParenType.ts, 9, 9))
 >c : Symbol(c, Decl(declFileTypeAnnotationParenType.ts, 0, 0))
 
diff --git a/tests/baselines/reference/declFileTypeAnnotationTupleType.symbols b/tests/baselines/reference/declFileTypeAnnotationTupleType.symbols
index 9eea6dfd9f953..3445b419a110a 100644
--- a/tests/baselines/reference/declFileTypeAnnotationTupleType.symbols
+++ b/tests/baselines/reference/declFileTypeAnnotationTupleType.symbols
@@ -44,6 +44,7 @@ var x: [g<string>, m.g<number>, () => c] = [new g<string>(), new m.g<number>(),
 >m.g : Symbol(m.g, Decl(declFileTypeAnnotationTupleType.ts, 5, 5))
 >m : Symbol(m, Decl(declFileTypeAnnotationTupleType.ts, 2, 1))
 >g : Symbol(m.g, Decl(declFileTypeAnnotationTupleType.ts, 5, 5))
+>() => new c() : Symbol((Anonymous function), Decl(declFileTypeAnnotationTupleType.ts, 16, 79))
 >c : Symbol(c, Decl(declFileTypeAnnotationTupleType.ts, 0, 0))
 
 var y = x;
diff --git a/tests/baselines/reference/declFileTypeAnnotationUnionType.symbols b/tests/baselines/reference/declFileTypeAnnotationUnionType.symbols
index f57df197579b6..1ed4129b583e5 100644
--- a/tests/baselines/reference/declFileTypeAnnotationUnionType.symbols
+++ b/tests/baselines/reference/declFileTypeAnnotationUnionType.symbols
@@ -59,6 +59,7 @@ var x: g<string> | m.g<number> |  (() => c) = new g<string>() ||  new m.g<number
 >m.g : Symbol(m.g, Decl(declFileTypeAnnotationUnionType.ts, 7, 5))
 >m : Symbol(m, Decl(declFileTypeAnnotationUnionType.ts, 3, 1))
 >g : Symbol(m.g, Decl(declFileTypeAnnotationUnionType.ts, 7, 5))
+>() => new c() : Symbol((Anonymous function), Decl(declFileTypeAnnotationUnionType.ts, 20, 88))
 >c : Symbol(c, Decl(declFileTypeAnnotationUnionType.ts, 0, 0))
 
 var y = new g<string>() || new m.g<number>() || (() => new c());
@@ -67,5 +68,6 @@ var y = new g<string>() || new m.g<number>() || (() => new c());
 >m.g : Symbol(m.g, Decl(declFileTypeAnnotationUnionType.ts, 7, 5))
 >m : Symbol(m, Decl(declFileTypeAnnotationUnionType.ts, 3, 1))
 >g : Symbol(m.g, Decl(declFileTypeAnnotationUnionType.ts, 7, 5))
+>() => new c() : Symbol((Anonymous function), Decl(declFileTypeAnnotationUnionType.ts, 21, 49))
 >c : Symbol(c, Decl(declFileTypeAnnotationUnionType.ts, 0, 0))
 
diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.symbols b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.symbols
new file mode 100644
index 0000000000000..da8017f570aa6
--- /dev/null
+++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.symbols
@@ -0,0 +1,182 @@
+=== tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts ===
+
+module m {
+>m : Symbol(m, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 0, 0))
+
+    class private1 {
+>private1 : Symbol(private1, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 1, 10))
+    }
+
+    export class public1 {
+>public1 : Symbol(public1, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 3, 5))
+    }
+
+    module m2 {
+>m2 : Symbol(m2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 6, 5))
+
+        export class public2 {
+>public2 : Symbol(public2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 8, 15))
+        }
+    }
+    
+    export class c {
+>c : Symbol(c, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 11, 5))
+
+        // getter with annotation
+        get foo1(): private1 {
+>foo1 : Symbol(foo1, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 13, 20))
+>private1 : Symbol(private1, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 1, 10))
+
+            return;
+        }
+
+        // getter without annotation
+        get foo2() {
+>foo2 : Symbol(foo2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 17, 9))
+
+            return new private1();
+>private1 : Symbol(private1, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 1, 10))
+        }
+
+        // setter with annotation
+        set foo3(param: private1) {
+>foo3 : Symbol(foo3, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 22, 9))
+>param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 25, 17))
+>private1 : Symbol(private1, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 1, 10))
+        }
+
+        // Both - getter without annotation, setter with annotation
+        get foo4() {
+>foo4 : Symbol(foo4, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 26, 9), Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 31, 9))
+
+            return new private1();
+>private1 : Symbol(private1, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 1, 10))
+        }
+        set foo4(param: private1) {
+>foo4 : Symbol(foo4, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 26, 9), Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 31, 9))
+>param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 32, 17))
+>private1 : Symbol(private1, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 1, 10))
+        }
+
+        // Both - with annotation
+        get foo5(): private1 {
+>foo5 : Symbol(foo5, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 33, 9), Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 38, 9))
+>private1 : Symbol(private1, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 1, 10))
+
+            return;
+        }
+        set foo5(param: private1) {
+>foo5 : Symbol(foo5, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 33, 9), Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 38, 9))
+>param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 39, 17))
+>private1 : Symbol(private1, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 1, 10))
+        }
+    
+        // getter with annotation
+        get foo11(): public1 {
+>foo11 : Symbol(foo11, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 40, 9))
+>public1 : Symbol(public1, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 3, 5))
+
+            return;
+        }
+
+        // getter without annotation
+        get foo12() {
+>foo12 : Symbol(foo12, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 45, 9))
+
+            return new public1();
+>public1 : Symbol(public1, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 3, 5))
+        }
+
+        // setter with annotation
+        set foo13(param: public1) {
+>foo13 : Symbol(foo13, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 50, 9))
+>param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 53, 18))
+>public1 : Symbol(public1, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 3, 5))
+        }
+
+        // Both - getter without annotation, setter with annotation
+        get foo14() {
+>foo14 : Symbol(foo14, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 54, 9), Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 59, 9))
+
+            return new public1();
+>public1 : Symbol(public1, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 3, 5))
+        }
+        set foo14(param: public1) {
+>foo14 : Symbol(foo14, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 54, 9), Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 59, 9))
+>param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 60, 18))
+>public1 : Symbol(public1, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 3, 5))
+        }
+
+        // Both - with annotation
+        get foo15(): public1 {
+>foo15 : Symbol(foo15, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 61, 9), Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 66, 9))
+>public1 : Symbol(public1, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 3, 5))
+
+            return;
+        }
+        set foo15(param: public1) {
+>foo15 : Symbol(foo15, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 61, 9), Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 66, 9))
+>param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 67, 18))
+>public1 : Symbol(public1, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 3, 5))
+        }
+
+        // getter with annotation
+        get foo111(): m2.public2 {
+>foo111 : Symbol(foo111, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 68, 9))
+>m2 : Symbol(m2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 6, 5))
+>public2 : Symbol(m2.public2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 8, 15))
+
+            return;
+        }
+
+        // getter without annotation
+        get foo112() {
+>foo112 : Symbol(foo112, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 73, 9))
+
+            return new m2.public2();
+>m2.public2 : Symbol(m2.public2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 8, 15))
+>m2 : Symbol(m2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 6, 5))
+>public2 : Symbol(m2.public2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 8, 15))
+        }
+
+        // setter with annotation
+        set foo113(param: m2.public2) {
+>foo113 : Symbol(foo113, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 78, 9))
+>param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 81, 19))
+>m2 : Symbol(m2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 6, 5))
+>public2 : Symbol(m2.public2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 8, 15))
+        }
+
+        // Both - getter without annotation, setter with annotation
+        get foo114() {
+>foo114 : Symbol(foo114, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 82, 9), Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 87, 9))
+
+            return new m2.public2();
+>m2.public2 : Symbol(m2.public2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 8, 15))
+>m2 : Symbol(m2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 6, 5))
+>public2 : Symbol(m2.public2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 8, 15))
+        }
+        set foo114(param: m2.public2) {
+>foo114 : Symbol(foo114, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 82, 9), Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 87, 9))
+>param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 88, 19))
+>m2 : Symbol(m2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 6, 5))
+>public2 : Symbol(m2.public2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 8, 15))
+        }
+
+        // Both - with annotation
+        get foo115(): m2.public2 {
+>foo115 : Symbol(foo115, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 89, 9), Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 94, 9))
+>m2 : Symbol(m2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 6, 5))
+>public2 : Symbol(m2.public2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 8, 15))
+
+            return;
+        }
+        set foo115(param: m2.public2) {
+>foo115 : Symbol(foo115, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 89, 9), Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 94, 9))
+>param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 95, 19))
+>m2 : Symbol(m2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 6, 5))
+>public2 : Symbol(m2.public2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 8, 15))
+        }
+    }
+}
+
diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorParameterOfFunction.symbols b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorParameterOfFunction.symbols
new file mode 100644
index 0000000000000..9bdfecf1f51ca
--- /dev/null
+++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorParameterOfFunction.symbols
@@ -0,0 +1,95 @@
+=== tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts ===
+
+module m {
+>m : Symbol(m, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 0, 0))
+
+    class private1 {
+>private1 : Symbol(private1, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 1, 10))
+    }
+
+    export class public1 {
+>public1 : Symbol(public1, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 3, 5))
+    }
+
+    // Directly using names from this module
+    function foo1(param: private1) {
+>foo1 : Symbol(foo1, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 6, 5))
+>param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 9, 18))
+>private1 : Symbol(private1, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 1, 10))
+    }
+    function foo2(param = new private1()) {
+>foo2 : Symbol(foo2, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 10, 5))
+>param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 11, 18))
+>private1 : Symbol(private1, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 1, 10))
+    }
+
+    export function foo3(param : private1) {
+>foo3 : Symbol(foo3, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 12, 5))
+>param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 14, 25))
+>private1 : Symbol(private1, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 1, 10))
+    }
+    export function foo4(param = new private1()) {
+>foo4 : Symbol(foo4, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 15, 5))
+>param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 16, 25))
+>private1 : Symbol(private1, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 1, 10))
+    }
+
+    function foo11(param: public1) {
+>foo11 : Symbol(foo11, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 17, 5))
+>param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 19, 19))
+>public1 : Symbol(public1, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 3, 5))
+    }
+    function foo12(param = new public1()) {
+>foo12 : Symbol(foo12, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 20, 5))
+>param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 21, 19))
+>public1 : Symbol(public1, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 3, 5))
+    }
+
+    export function foo13(param: public1) {
+>foo13 : Symbol(foo13, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 22, 5))
+>param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 24, 26))
+>public1 : Symbol(public1, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 3, 5))
+    }
+    export function foo14(param = new public1()) {
+>foo14 : Symbol(foo14, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 25, 5))
+>param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 26, 26))
+>public1 : Symbol(public1, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 3, 5))
+    }
+
+    module m2 {
+>m2 : Symbol(m2, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 27, 5))
+
+        export class public2 {
+>public2 : Symbol(public2, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 29, 15))
+        }
+    }
+
+    function foo111(param: m2.public2) {
+>foo111 : Symbol(foo111, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 32, 5))
+>param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 34, 20))
+>m2 : Symbol(m2, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 27, 5))
+>public2 : Symbol(m2.public2, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 29, 15))
+    }
+    function foo112(param = new m2.public2()) {
+>foo112 : Symbol(foo112, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 35, 5))
+>param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 36, 20))
+>m2.public2 : Symbol(m2.public2, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 29, 15))
+>m2 : Symbol(m2, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 27, 5))
+>public2 : Symbol(m2.public2, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 29, 15))
+    }
+
+    export function foo113(param: m2.public2) {
+>foo113 : Symbol(foo113, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 37, 5))
+>param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 39, 27))
+>m2 : Symbol(m2, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 27, 5))
+>public2 : Symbol(m2.public2, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 29, 15))
+    }
+    export function foo114(param = new m2.public2()) {
+>foo114 : Symbol(foo114, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 40, 5))
+>param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 41, 27))
+>m2.public2 : Symbol(m2.public2, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 29, 15))
+>m2 : Symbol(m2, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 27, 5))
+>public2 : Symbol(m2.public2, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 29, 15))
+    }
+}
+
diff --git a/tests/baselines/reference/declFileTypeofFunction.symbols b/tests/baselines/reference/declFileTypeofFunction.symbols
index 649c09cba0662..62a10457029ca 100644
--- a/tests/baselines/reference/declFileTypeofFunction.symbols
+++ b/tests/baselines/reference/declFileTypeofFunction.symbols
@@ -55,12 +55,14 @@ var foo2 = foo;
 
 var foo3 = function () {
 >foo3 : Symbol(foo3, Decl(declFileTypeofFunction.ts, 20, 3))
+>function () {    return foo3;} : Symbol((Anonymous function), Decl(declFileTypeofFunction.ts, 20, 10))
 
     return foo3;
 >foo3 : Symbol(foo3, Decl(declFileTypeofFunction.ts, 20, 3))
 }
 var x = () => {
 >x : Symbol(x, Decl(declFileTypeofFunction.ts, 23, 3))
+>() => {    return x;} : Symbol((Anonymous function), Decl(declFileTypeofFunction.ts, 23, 7))
 
     return x;
 >x : Symbol(x, Decl(declFileTypeofFunction.ts, 23, 3))
diff --git a/tests/baselines/reference/declFileTypeofInAnonymousType.symbols b/tests/baselines/reference/declFileTypeofInAnonymousType.symbols
index 426f953d6f214..7065168d7259e 100644
--- a/tests/baselines/reference/declFileTypeofInAnonymousType.symbols
+++ b/tests/baselines/reference/declFileTypeofInAnonymousType.symbols
@@ -27,6 +27,7 @@ var a: { c: m1.c; };
 
 var b = {
 >b : Symbol(b, Decl(declFileTypeofInAnonymousType.ts, 11, 3))
+>{    c: m1.c,    m1: m1} : Symbol(, Decl(declFileTypeofInAnonymousType.ts, 11, 7))
 
     c: m1.c,
 >c : Symbol(c, Decl(declFileTypeofInAnonymousType.ts, 11, 9))
@@ -41,19 +42,23 @@ var b = {
 };
 var c = { m1: m1 };
 >c : Symbol(c, Decl(declFileTypeofInAnonymousType.ts, 15, 3))
+>{ m1: m1 } : Symbol(, Decl(declFileTypeofInAnonymousType.ts, 15, 7))
 >m1 : Symbol(m1, Decl(declFileTypeofInAnonymousType.ts, 15, 9))
 >m1 : Symbol(m1, Decl(declFileTypeofInAnonymousType.ts, 0, 0))
 
 var d = {
 >d : Symbol(d, Decl(declFileTypeofInAnonymousType.ts, 16, 3))
+>{    m: { mod: m1 },    mc: { cl: m1.c },    me: { en: m1.e },    mh: m1.e.holiday} : Symbol(, Decl(declFileTypeofInAnonymousType.ts, 16, 7))
 
     m: { mod: m1 },
 >m : Symbol(m, Decl(declFileTypeofInAnonymousType.ts, 16, 9))
+>{ mod: m1 } : Symbol(, Decl(declFileTypeofInAnonymousType.ts, 17, 6))
 >mod : Symbol(mod, Decl(declFileTypeofInAnonymousType.ts, 17, 8))
 >m1 : Symbol(m1, Decl(declFileTypeofInAnonymousType.ts, 0, 0))
 
     mc: { cl: m1.c },
 >mc : Symbol(mc, Decl(declFileTypeofInAnonymousType.ts, 17, 19))
+>{ cl: m1.c } : Symbol(, Decl(declFileTypeofInAnonymousType.ts, 18, 7))
 >cl : Symbol(cl, Decl(declFileTypeofInAnonymousType.ts, 18, 9))
 >m1.c : Symbol(m1.c, Decl(declFileTypeofInAnonymousType.ts, 1, 11))
 >m1 : Symbol(m1, Decl(declFileTypeofInAnonymousType.ts, 0, 0))
@@ -61,6 +66,7 @@ var d = {
 
     me: { en: m1.e },
 >me : Symbol(me, Decl(declFileTypeofInAnonymousType.ts, 18, 21))
+>{ en: m1.e } : Symbol(, Decl(declFileTypeofInAnonymousType.ts, 19, 7))
 >en : Symbol(en, Decl(declFileTypeofInAnonymousType.ts, 19, 9))
 >m1.e : Symbol(m1.e, Decl(declFileTypeofInAnonymousType.ts, 3, 5))
 >m1 : Symbol(m1, Decl(declFileTypeofInAnonymousType.ts, 0, 0))
diff --git a/tests/baselines/reference/declInput3.symbols b/tests/baselines/reference/declInput3.symbols
index 06f35db0164e3..40e169510b988 100644
--- a/tests/baselines/reference/declInput3.symbols
+++ b/tests/baselines/reference/declInput3.symbols
@@ -12,6 +12,7 @@ class bar {
 
   public g() { return {a: <bar>null, b: undefined, c: void 4 }; }
 >g : Symbol(g, Decl(declInput3.ts, 5, 27))
+>{a: <bar>null, b: undefined, c: void 4 } : Symbol(, Decl(declInput3.ts, 6, 21))
 >a : Symbol(a, Decl(declInput3.ts, 6, 23))
 >bar : Symbol(bar, Decl(declInput3.ts, 2, 1))
 >b : Symbol(b, Decl(declInput3.ts, 6, 36))
diff --git a/tests/baselines/reference/declarationEmitDefaultExport7.symbols b/tests/baselines/reference/declarationEmitDefaultExport7.symbols
new file mode 100644
index 0000000000000..20ac298eb03d0
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitDefaultExport7.symbols
@@ -0,0 +1,7 @@
+=== tests/cases/compiler/declarationEmitDefaultExport7.ts ===
+class A {}
+>A : Symbol(A, Decl(declarationEmitDefaultExport7.ts, 0, 0))
+
+export default new A();
+>A : Symbol(A, Decl(declarationEmitDefaultExport7.ts, 0, 0))
+
diff --git a/tests/baselines/reference/declarationEmitDestructuring4.symbols b/tests/baselines/reference/declarationEmitDestructuring4.symbols
index 9f2eb162b6fe2..29270ecd92f0b 100644
--- a/tests/baselines/reference/declarationEmitDestructuring4.symbols
+++ b/tests/baselines/reference/declarationEmitDestructuring4.symbols
@@ -16,6 +16,7 @@ function baz3({}) { }
 
 function baz4({} = { x: 10 }) { }
 >baz4 : Symbol(baz4, Decl(declarationEmitDestructuring4.ts, 7, 21))
+>{ x: 10 } : Symbol(, Decl(declarationEmitDestructuring4.ts, 8, 18))
 >x : Symbol(x, Decl(declarationEmitDestructuring4.ts, 8, 20))
 
 
diff --git a/tests/baselines/reference/declarationEmitDestructuringArrayPattern2.symbols b/tests/baselines/reference/declarationEmitDestructuringArrayPattern2.symbols
index 9e0e48f89e8a3..031e660053ebb 100644
--- a/tests/baselines/reference/declarationEmitDestructuringArrayPattern2.symbols
+++ b/tests/baselines/reference/declarationEmitDestructuringArrayPattern2.symbols
@@ -18,8 +18,10 @@ var [a2, [b2, { x12, y12: c2 }]=["abc", { x12: 10, y12: false }]] = [1, ["hello"
 >b2 : Symbol(b2, Decl(declarationEmitDestructuringArrayPattern2.ts, 5, 10))
 >x12 : Symbol(x12, Decl(declarationEmitDestructuringArrayPattern2.ts, 5, 15))
 >c2 : Symbol(c2, Decl(declarationEmitDestructuringArrayPattern2.ts, 5, 20))
+>{ x12: 10, y12: false } : Symbol(, Decl(declarationEmitDestructuringArrayPattern2.ts, 5, 39))
 >x12 : Symbol(x12, Decl(declarationEmitDestructuringArrayPattern2.ts, 5, 41))
 >y12 : Symbol(y12, Decl(declarationEmitDestructuringArrayPattern2.ts, 5, 50))
+>{ x12: 5, y12: true } : Symbol(, Decl(declarationEmitDestructuringArrayPattern2.ts, 5, 81))
 >x12 : Symbol(x12, Decl(declarationEmitDestructuringArrayPattern2.ts, 5, 83))
 >y12 : Symbol(y12, Decl(declarationEmitDestructuringArrayPattern2.ts, 5, 91))
 
@@ -32,6 +34,7 @@ var [a3, b3] = [[x13, y13], { x: x13, y: y13 }];
 >b3 : Symbol(b3, Decl(declarationEmitDestructuringArrayPattern2.ts, 8, 8))
 >x13 : Symbol(x13, Decl(declarationEmitDestructuringArrayPattern2.ts, 7, 5))
 >y13 : Symbol(y13, Decl(declarationEmitDestructuringArrayPattern2.ts, 7, 9))
+>{ x: x13, y: y13 } : Symbol(, Decl(declarationEmitDestructuringArrayPattern2.ts, 8, 27))
 >x : Symbol(x, Decl(declarationEmitDestructuringArrayPattern2.ts, 8, 29))
 >x13 : Symbol(x13, Decl(declarationEmitDestructuringArrayPattern2.ts, 7, 5))
 >y : Symbol(y, Decl(declarationEmitDestructuringArrayPattern2.ts, 8, 37))
diff --git a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern.symbols b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern.symbols
index 3cb4ef28c2bbd..bf9a1f31f0581 100644
--- a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern.symbols
+++ b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern.symbols
@@ -1,38 +1,45 @@
 === tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern.ts ===
 
 var { } = { x: 5, y: "hello" };
+>{ x: 5, y: "hello" } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 1, 9))
 >x : Symbol(x, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 1, 11))
 >y : Symbol(y, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 1, 17))
 
 var { x4 } = { x4: 5, y4: "hello" };
 >x4 : Symbol(x4, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 2, 5))
+>{ x4: 5, y4: "hello" } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 2, 12))
 >x4 : Symbol(x4, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 2, 14))
 >y4 : Symbol(y4, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 2, 21))
 
 var { y5 } = { x5: 5, y5: "hello" };
 >y5 : Symbol(y5, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 3, 5))
+>{ x5: 5, y5: "hello" } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 3, 12))
 >x5 : Symbol(x5, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 3, 14))
 >y5 : Symbol(y5, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 3, 21))
 
 var { x6, y6 } = { x6: 5, y6: "hello" };
 >x6 : Symbol(x6, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 4, 5))
 >y6 : Symbol(y6, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 4, 9))
+>{ x6: 5, y6: "hello" } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 4, 16))
 >x6 : Symbol(x6, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 4, 18))
 >y6 : Symbol(y6, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 4, 25))
 
 var { x7: a1 } = { x7: 5, y7: "hello" };
 >a1 : Symbol(a1, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 5, 5))
+>{ x7: 5, y7: "hello" } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 5, 16))
 >x7 : Symbol(x7, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 5, 18))
 >y7 : Symbol(y7, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 5, 25))
 
 var { y8: b1 } = { x8: 5, y8: "hello" };
 >b1 : Symbol(b1, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 6, 5))
+>{ x8: 5, y8: "hello" } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 6, 16))
 >x8 : Symbol(x8, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 6, 18))
 >y8 : Symbol(y8, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 6, 25))
 
 var { x9: a2, y9: b2 } = { x9: 5, y9: "hello" };
 >a2 : Symbol(a2, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 7, 5))
 >b2 : Symbol(b2, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 7, 13))
+>{ x9: 5, y9: "hello" } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 7, 24))
 >x9 : Symbol(x9, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 7, 26))
 >y9 : Symbol(y9, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 7, 33))
 
@@ -40,10 +47,13 @@ var { a: x11, b: { a: y11, b: { a: z11 }}} = { a: 1, b: { a: "hello", b: { a: tr
 >x11 : Symbol(x11, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 9, 5))
 >y11 : Symbol(y11, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 9, 18))
 >z11 : Symbol(z11, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 9, 31))
+>{ a: 1, b: { a: "hello", b: { a: true } } } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 9, 44))
 >a : Symbol(a, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 9, 46))
 >b : Symbol(b, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 9, 52))
+>{ a: "hello", b: { a: true } } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 9, 55))
 >a : Symbol(a, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 9, 57))
 >b : Symbol(b, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 9, 69))
+>{ a: true } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 9, 72))
 >a : Symbol(a, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 9, 74))
 
 function f15() {
@@ -59,6 +69,7 @@ function f15() {
 >c4 : Symbol(c4, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 14, 7))
 
     return { a4, b4, c4 };
+>{ a4, b4, c4 } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 15, 10))
 >a4 : Symbol(a4, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 15, 12))
 >b4 : Symbol(b4, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 15, 16))
 >c4 : Symbol(c4, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 15, 20))
diff --git a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern1.symbols b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern1.symbols
index a4c43a07bc85e..51e85849739ad 100644
--- a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern1.symbols
+++ b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern1.symbols
@@ -1,38 +1,45 @@
 === tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern1.ts ===
 
 var { } = { x: 5, y: "hello" };
+>{ x: 5, y: "hello" } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 1, 9))
 >x : Symbol(x, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 1, 11))
 >y : Symbol(y, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 1, 17))
 
 var { x4 } = { x4: 5, y4: "hello" };
 >x4 : Symbol(x4, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 2, 5))
+>{ x4: 5, y4: "hello" } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 2, 12))
 >x4 : Symbol(x4, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 2, 14))
 >y4 : Symbol(y4, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 2, 21))
 
 var { y5 } = { x5: 5, y5: "hello" };
 >y5 : Symbol(y5, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 3, 5))
+>{ x5: 5, y5: "hello" } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 3, 12))
 >x5 : Symbol(x5, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 3, 14))
 >y5 : Symbol(y5, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 3, 21))
 
 var { x6, y6 } = { x6: 5, y6: "hello" };
 >x6 : Symbol(x6, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 4, 5))
 >y6 : Symbol(y6, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 4, 9))
+>{ x6: 5, y6: "hello" } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 4, 16))
 >x6 : Symbol(x6, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 4, 18))
 >y6 : Symbol(y6, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 4, 25))
 
 var { x7: a1 } = { x7: 5, y7: "hello" };
 >a1 : Symbol(a1, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 5, 5))
+>{ x7: 5, y7: "hello" } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 5, 16))
 >x7 : Symbol(x7, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 5, 18))
 >y7 : Symbol(y7, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 5, 25))
 
 var { y8: b1 } = { x8: 5, y8: "hello" };
 >b1 : Symbol(b1, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 6, 5))
+>{ x8: 5, y8: "hello" } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 6, 16))
 >x8 : Symbol(x8, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 6, 18))
 >y8 : Symbol(y8, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 6, 25))
 
 var { x9: a2, y9: b2 } = { x9: 5, y9: "hello" };
 >a2 : Symbol(a2, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 7, 5))
 >b2 : Symbol(b2, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 7, 13))
+>{ x9: 5, y9: "hello" } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 7, 24))
 >x9 : Symbol(x9, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 7, 26))
 >y9 : Symbol(y9, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 7, 33))
 
diff --git a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern2.symbols b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern2.symbols
index 76440b600382d..c4af268af2322 100644
--- a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern2.symbols
+++ b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern2.symbols
@@ -4,10 +4,13 @@ var { a: x11, b: { a: y11, b: { a: z11 }}} = { a: 1, b: { a: "hello", b: { a: tr
 >x11 : Symbol(x11, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 5))
 >y11 : Symbol(y11, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 18))
 >z11 : Symbol(z11, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 31))
+>{ a: 1, b: { a: "hello", b: { a: true } } } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 44))
 >a : Symbol(a, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 46))
 >b : Symbol(b, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 52))
+>{ a: "hello", b: { a: true } } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 55))
 >a : Symbol(a, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 57))
 >b : Symbol(b, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 69))
+>{ a: true } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 72))
 >a : Symbol(a, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 74))
 
 function f15() {
@@ -23,6 +26,7 @@ function f15() {
 >c4 : Symbol(c4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 6, 7))
 
     return { a4, b4, c4 };
+>{ a4, b4, c4 } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 7, 10))
 >a4 : Symbol(a4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 7, 12))
 >b4 : Symbol(b4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 7, 16))
 >c4 : Symbol(c4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 7, 20))
diff --git a/tests/baselines/reference/declarationEmitDestructuringPrivacyError.symbols b/tests/baselines/reference/declarationEmitDestructuringPrivacyError.symbols
new file mode 100644
index 0000000000000..caca0d45b7b33
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitDestructuringPrivacyError.symbols
@@ -0,0 +1,13 @@
+=== tests/cases/compiler/declarationEmitDestructuringPrivacyError.ts ===
+module m {
+>m : Symbol(m, Decl(declarationEmitDestructuringPrivacyError.ts, 0, 0))
+
+    class c {
+>c : Symbol(c, Decl(declarationEmitDestructuringPrivacyError.ts, 0, 10))
+    }
+    export var [x, y, z] = [10, new c(), 30];
+>x : Symbol(x, Decl(declarationEmitDestructuringPrivacyError.ts, 3, 16))
+>y : Symbol(y, Decl(declarationEmitDestructuringPrivacyError.ts, 3, 18))
+>z : Symbol(z, Decl(declarationEmitDestructuringPrivacyError.ts, 3, 21))
+>c : Symbol(c, Decl(declarationEmitDestructuringPrivacyError.ts, 0, 10))
+}
diff --git a/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.symbols b/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.symbols
index f7c96097cafda..0702e77f72f0f 100644
--- a/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.symbols
+++ b/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.symbols
@@ -13,6 +13,7 @@ function filter(handler: any) {
 >handler : Symbol(handler, Decl(b.ts, 2, 16))
 
     return function (target: any, propertyKey: string) {
+>function (target: any, propertyKey: string) {        // ...    } : Symbol((Anonymous function), Decl(b.ts, 3, 10))
 >target : Symbol(target, Decl(b.ts, 3, 21))
 >propertyKey : Symbol(propertyKey, Decl(b.ts, 3, 33))
 
@@ -25,6 +26,7 @@ class Wat {
 
     @filter(() => test == 'abc')
 >filter : Symbol(filter, Decl(b.ts, 0, 27))
+>() => test == 'abc' : Symbol((Anonymous function), Decl(b.ts, 9, 12))
 >test : Symbol(test, Decl(b.ts, 0, 8))
 
     static whatever() {
diff --git a/tests/baselines/reference/decrementOperatorWithAnyOtherType.symbols b/tests/baselines/reference/decrementOperatorWithAnyOtherType.symbols
index 594e6d50ac475..fddefe467b072 100644
--- a/tests/baselines/reference/decrementOperatorWithAnyOtherType.symbols
+++ b/tests/baselines/reference/decrementOperatorWithAnyOtherType.symbols
@@ -12,6 +12,7 @@ var ANY2: any[] = ["", ""];
 
 var obj = {x:1,y:null};
 >obj : Symbol(obj, Decl(decrementOperatorWithAnyOtherType.ts, 5, 3))
+>{x:1,y:null} : Symbol(, Decl(decrementOperatorWithAnyOtherType.ts, 5, 9))
 >x : Symbol(x, Decl(decrementOperatorWithAnyOtherType.ts, 5, 11))
 >y : Symbol(y, Decl(decrementOperatorWithAnyOtherType.ts, 5, 15))
 
diff --git a/tests/baselines/reference/defaultIndexProps1.symbols b/tests/baselines/reference/defaultIndexProps1.symbols
index e294b9e7dba37..48a3c48c89acd 100644
--- a/tests/baselines/reference/defaultIndexProps1.symbols
+++ b/tests/baselines/reference/defaultIndexProps1.symbols
@@ -17,6 +17,7 @@ var q = f["v"];
 
 var o = {v:"Yo2"};
 >o : Symbol(o, Decl(defaultIndexProps1.ts, 8, 3))
+>{v:"Yo2"} : Symbol(, Decl(defaultIndexProps1.ts, 8, 7))
 >v : Symbol(v, Decl(defaultIndexProps1.ts, 8, 9))
 
 var q2 = o["v"];
diff --git a/tests/baselines/reference/defaultIndexProps2.symbols b/tests/baselines/reference/defaultIndexProps2.symbols
index 53d433351c331..0049f3a57907f 100644
--- a/tests/baselines/reference/defaultIndexProps2.symbols
+++ b/tests/baselines/reference/defaultIndexProps2.symbols
@@ -14,6 +14,7 @@ var f = new Foo();
 
 var o = {v:"Yo2"};
 >o : Symbol(o, Decl(defaultIndexProps2.ts, 8, 3))
+>{v:"Yo2"} : Symbol(, Decl(defaultIndexProps2.ts, 8, 7))
 >v : Symbol(v, Decl(defaultIndexProps2.ts, 8, 9))
 
 // WScript.Echo(o[0]);
diff --git a/tests/baselines/reference/deleteOperatorWithBooleanType.symbols b/tests/baselines/reference/deleteOperatorWithBooleanType.symbols
index 71cb78760f6d2..a02e9e50a06e0 100644
--- a/tests/baselines/reference/deleteOperatorWithBooleanType.symbols
+++ b/tests/baselines/reference/deleteOperatorWithBooleanType.symbols
@@ -37,6 +37,7 @@ var ResultIsBoolean2 = delete true;
 
 var ResultIsBoolean3 = delete { x: true, y: false };
 >ResultIsBoolean3 : Symbol(ResultIsBoolean3, Decl(deleteOperatorWithBooleanType.ts, 20, 3))
+>{ x: true, y: false } : Symbol(, Decl(deleteOperatorWithBooleanType.ts, 20, 29))
 >x : Symbol(x, Decl(deleteOperatorWithBooleanType.ts, 20, 31))
 >y : Symbol(y, Decl(deleteOperatorWithBooleanType.ts, 20, 40))
 
diff --git a/tests/baselines/reference/deleteOperatorWithNumberType.symbols b/tests/baselines/reference/deleteOperatorWithNumberType.symbols
index 589b1f91db274..42a0709d442be 100644
--- a/tests/baselines/reference/deleteOperatorWithNumberType.symbols
+++ b/tests/baselines/reference/deleteOperatorWithNumberType.symbols
@@ -44,13 +44,16 @@ var ResultIsBoolean3 = delete 1;
 
 var ResultIsBoolean4 = delete { x: 1, y: 2};
 >ResultIsBoolean4 : Symbol(ResultIsBoolean4, Decl(deleteOperatorWithNumberType.ts, 22, 3))
+>{ x: 1, y: 2} : Symbol(, Decl(deleteOperatorWithNumberType.ts, 22, 29))
 >x : Symbol(x, Decl(deleteOperatorWithNumberType.ts, 22, 31))
 >y : Symbol(y, Decl(deleteOperatorWithNumberType.ts, 22, 37))
 
 var ResultIsBoolean5 = delete { x: 1, y: (n: number) => { return n; } };
 >ResultIsBoolean5 : Symbol(ResultIsBoolean5, Decl(deleteOperatorWithNumberType.ts, 23, 3))
+>{ x: 1, y: (n: number) => { return n; } } : Symbol(, Decl(deleteOperatorWithNumberType.ts, 23, 29))
 >x : Symbol(x, Decl(deleteOperatorWithNumberType.ts, 23, 31))
 >y : Symbol(y, Decl(deleteOperatorWithNumberType.ts, 23, 37))
+>(n: number) => { return n; } : Symbol((Anonymous function), Decl(deleteOperatorWithNumberType.ts, 23, 40))
 >n : Symbol(n, Decl(deleteOperatorWithNumberType.ts, 23, 42))
 >n : Symbol(n, Decl(deleteOperatorWithNumberType.ts, 23, 42))
 
diff --git a/tests/baselines/reference/deleteOperatorWithStringType.symbols b/tests/baselines/reference/deleteOperatorWithStringType.symbols
index a13ddd5fa3982..38a6b057316d6 100644
--- a/tests/baselines/reference/deleteOperatorWithStringType.symbols
+++ b/tests/baselines/reference/deleteOperatorWithStringType.symbols
@@ -44,13 +44,16 @@ var ResultIsBoolean3 = delete "";
 
 var ResultIsBoolean4 = delete { x: "", y: "" };
 >ResultIsBoolean4 : Symbol(ResultIsBoolean4, Decl(deleteOperatorWithStringType.ts, 22, 3))
+>{ x: "", y: "" } : Symbol(, Decl(deleteOperatorWithStringType.ts, 22, 29))
 >x : Symbol(x, Decl(deleteOperatorWithStringType.ts, 22, 31))
 >y : Symbol(y, Decl(deleteOperatorWithStringType.ts, 22, 38))
 
 var ResultIsBoolean5 = delete { x: "", y: (s: string) => { return s; } };
 >ResultIsBoolean5 : Symbol(ResultIsBoolean5, Decl(deleteOperatorWithStringType.ts, 23, 3))
+>{ x: "", y: (s: string) => { return s; } } : Symbol(, Decl(deleteOperatorWithStringType.ts, 23, 29))
 >x : Symbol(x, Decl(deleteOperatorWithStringType.ts, 23, 31))
 >y : Symbol(y, Decl(deleteOperatorWithStringType.ts, 23, 38))
+>(s: string) => { return s; } : Symbol((Anonymous function), Decl(deleteOperatorWithStringType.ts, 23, 41))
 >s : Symbol(s, Decl(deleteOperatorWithStringType.ts, 23, 43))
 >s : Symbol(s, Decl(deleteOperatorWithStringType.ts, 23, 43))
 
diff --git a/tests/baselines/reference/derivedClasses.symbols b/tests/baselines/reference/derivedClasses.symbols
index f265c2dce538f..160738bb02b71 100644
--- a/tests/baselines/reference/derivedClasses.symbols
+++ b/tests/baselines/reference/derivedClasses.symbols
@@ -8,6 +8,7 @@ class Red extends Color {
 
     	var getHue = () => { return this.hue(); };
 >getHue : Symbol(getHue, Decl(derivedClasses.ts, 2, 8))
+>() => { return this.hue(); } : Symbol((Anonymous function), Decl(derivedClasses.ts, 2, 17))
 >this.hue : Symbol(Color.hue, Decl(derivedClasses.ts, 8, 43))
 >this : Symbol(Red, Decl(derivedClasses.ts, 0, 0))
 >hue : Symbol(Color.hue, Decl(derivedClasses.ts, 8, 43))
@@ -36,6 +37,7 @@ class Blue extends Color {
 
     	var getHue = () => { return this.hue(); };
 >getHue : Symbol(getHue, Decl(derivedClasses.ts, 15, 8))
+>() => { return this.hue(); } : Symbol((Anonymous function), Decl(derivedClasses.ts, 15, 17))
 >this.hue : Symbol(Color.hue, Decl(derivedClasses.ts, 8, 43))
 >this : Symbol(Blue, Decl(derivedClasses.ts, 10, 1))
 >hue : Symbol(Color.hue, Decl(derivedClasses.ts, 8, 43))
diff --git a/tests/baselines/reference/derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.symbols b/tests/baselines/reference/derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.symbols
index e935d7bf66aa2..f2c8c911109e5 100644
--- a/tests/baselines/reference/derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.symbols
+++ b/tests/baselines/reference/derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.symbols
@@ -35,6 +35,7 @@ class Derived extends Base {
 >super.foo : Symbol(Base.foo, Decl(derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.ts, 0, 12))
 >super : Symbol(Base, Decl(derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.ts, 0, 0))
 >foo : Symbol(Base.foo, Decl(derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.ts, 0, 12))
+>{ a: 1 } : Symbol(, Decl(derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.ts, 12, 26))
 >a : Symbol(a, Decl(derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.ts, 12, 27))
 
         var r2 = super.foo({ a: 1, b: 2 }); // { a: number }
@@ -42,6 +43,7 @@ class Derived extends Base {
 >super.foo : Symbol(Base.foo, Decl(derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.ts, 0, 12))
 >super : Symbol(Base, Decl(derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.ts, 0, 0))
 >foo : Symbol(Base.foo, Decl(derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.ts, 0, 12))
+>{ a: 1, b: 2 } : Symbol(, Decl(derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.ts, 13, 27))
 >a : Symbol(a, Decl(derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.ts, 13, 28))
 >b : Symbol(b, Decl(derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.ts, 13, 34))
 
@@ -50,6 +52,7 @@ class Derived extends Base {
 >this.foo : Symbol(foo, Decl(derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.ts, 6, 28))
 >this : Symbol(Derived, Decl(derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.ts, 4, 1))
 >foo : Symbol(foo, Decl(derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.ts, 6, 28))
+>{ a: 1, b: 2 } : Symbol(, Decl(derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.ts, 14, 26))
 >a : Symbol(a, Decl(derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.ts, 14, 27))
 >b : Symbol(b, Decl(derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.ts, 14, 33))
     }
diff --git a/tests/baselines/reference/destructuringObjectBindingPatternAndAssignment1ES5.symbols b/tests/baselines/reference/destructuringObjectBindingPatternAndAssignment1ES5.symbols
index 017a7f71e612e..9f0c56317ecc9 100644
--- a/tests/baselines/reference/destructuringObjectBindingPatternAndAssignment1ES5.symbols
+++ b/tests/baselines/reference/destructuringObjectBindingPatternAndAssignment1ES5.symbols
@@ -10,30 +10,39 @@ var { a1 }: any = undefined;
 
 var { a2 }: any = {};
 >a2 : Symbol(a2, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 6, 5))
+>{} : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 6, 17))
 
 // V is an object assignment pattern and, for each assignment property P in V,
 //      S has an apparent property with the property name specified in
 //          P of a type that is assignable to the target given in P, or
 var { b1, } = { b1:1, };
 >b1 : Symbol(b1, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 11, 5))
+>{ b1:1, } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 11, 13))
 >b1 : Symbol(b1, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 11, 15))
 
 var { b2: { b21 } = { b21: "string" }  } = { b2: { b21: "world" } };
 >b21 : Symbol(b21, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 12, 11))
+>{ b21: "string" } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 12, 19))
 >b21 : Symbol(b21, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 12, 21))
+>{ b2: { b21: "world" } } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 12, 42))
 >b2 : Symbol(b2, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 12, 44))
+>{ b21: "world" } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 12, 48))
 >b21 : Symbol(b21, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 12, 50))
 
 var {1: b3} = { 1: "string" };
 >b3 : Symbol(b3, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 13, 5))
+>{ 1: "string" } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 13, 13))
 
 var {b4 = 1}: any = { b4: 100000 };
 >b4 : Symbol(b4, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 14, 5))
+>{ b4: 100000 } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 14, 19))
 >b4 : Symbol(b4, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 14, 21))
 
 var {b5: { b52 }  } = { b5: { b52 } };
 >b52 : Symbol(b52, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 15, 10))
+>{ b5: { b52 } } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 15, 21))
 >b5 : Symbol(b5, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 15, 23))
+>{ b52 } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 15, 27))
 >b52 : Symbol(b52, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 15, 29))
 
 // V is an object assignment pattern and, for each assignment property P in V,
@@ -52,6 +61,8 @@ function foo(): F {
 >F : Symbol(F, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 15, 38))
 
     return {
+>{        1: true    } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 26, 10))
+
         1: true
     };
 }
@@ -61,6 +72,8 @@ function bar(): F {
 >F : Symbol(F, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 15, 38))
 
     return {
+>{        2: true    } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 32, 10))
+
         2: true
     };
 }
@@ -87,6 +100,8 @@ function foo1(): F1 {
 >F1 : Symbol(F1, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 37, 20))
 
     return {
+>{        "prop1": 2    } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 47, 10))
+
         "prop1": 2
     }
 }
diff --git a/tests/baselines/reference/destructuringObjectBindingPatternAndAssignment1ES6.symbols b/tests/baselines/reference/destructuringObjectBindingPatternAndAssignment1ES6.symbols
index 11289210ee4d4..ca8c301f0386b 100644
--- a/tests/baselines/reference/destructuringObjectBindingPatternAndAssignment1ES6.symbols
+++ b/tests/baselines/reference/destructuringObjectBindingPatternAndAssignment1ES6.symbols
@@ -10,30 +10,39 @@ var { a1 }: any = undefined;
 
 var { a2 }: any = {};
 >a2 : Symbol(a2, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 6, 5))
+>{} : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 6, 17))
 
 // V is an object assignment pattern and, for each assignment property P in V,
 //      S has an apparent property with the property name specified in
 //          P of a type that is assignable to the target given in P, or
 var { b1, } = { b1:1, };
 >b1 : Symbol(b1, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 11, 5))
+>{ b1:1, } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 11, 13))
 >b1 : Symbol(b1, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 11, 15))
 
 var { b2: { b21 } = { b21: "string" }  } = { b2: { b21: "world" } };
 >b21 : Symbol(b21, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 12, 11))
+>{ b21: "string" } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 12, 19))
 >b21 : Symbol(b21, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 12, 21))
+>{ b2: { b21: "world" } } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 12, 42))
 >b2 : Symbol(b2, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 12, 44))
+>{ b21: "world" } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 12, 48))
 >b21 : Symbol(b21, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 12, 50))
 
 var {1: b3} = { 1: "string" };
 >b3 : Symbol(b3, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 13, 5))
+>{ 1: "string" } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 13, 13))
 
 var {b4 = 1}: any = { b4: 100000 };
 >b4 : Symbol(b4, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 14, 5))
+>{ b4: 100000 } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 14, 19))
 >b4 : Symbol(b4, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 14, 21))
 
 var {b5: { b52 }  } = { b5: { b52 } };
 >b52 : Symbol(b52, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 15, 10))
+>{ b5: { b52 } } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 15, 21))
 >b5 : Symbol(b5, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 15, 23))
+>{ b52 } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 15, 27))
 >b52 : Symbol(b52, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 15, 29))
 
 // V is an object assignment pattern and, for each assignment property P in V,
@@ -52,6 +61,8 @@ function foo(): F {
 >F : Symbol(F, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 15, 38))
 
     return {
+>{        1: true    } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 26, 10))
+
         1: true
     };
 }
@@ -61,6 +72,8 @@ function bar(): F {
 >F : Symbol(F, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 15, 38))
 
     return {
+>{        2: true    } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 32, 10))
+
         2: true
     };
 }
@@ -87,6 +100,8 @@ function foo1(): F1 {
 >F1 : Symbol(F1, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 37, 20))
 
     return {
+>{        "prop1": 2    } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 47, 10))
+
         "prop1": 2
     }
 }
diff --git a/tests/baselines/reference/destructuringVariableDeclaration1ES5.symbols b/tests/baselines/reference/destructuringVariableDeclaration1ES5.symbols
index 2a2f2a358ca5b..754235d4e6cca 100644
--- a/tests/baselines/reference/destructuringVariableDeclaration1ES5.symbols
+++ b/tests/baselines/reference/destructuringVariableDeclaration1ES5.symbols
@@ -6,6 +6,7 @@ var {a1, a2}: { a1: number, a2: string } = { a1: 10, a2: "world" }
 >a2 : Symbol(a2, Decl(destructuringVariableDeclaration1ES5.ts, 2, 8))
 >a1 : Symbol(a1, Decl(destructuringVariableDeclaration1ES5.ts, 2, 15))
 >a2 : Symbol(a2, Decl(destructuringVariableDeclaration1ES5.ts, 2, 27))
+>{ a1: 10, a2: "world" } : Symbol(, Decl(destructuringVariableDeclaration1ES5.ts, 2, 42))
 >a1 : Symbol(a1, Decl(destructuringVariableDeclaration1ES5.ts, 2, 44))
 >a2 : Symbol(a2, Decl(destructuringVariableDeclaration1ES5.ts, 2, 52))
 
@@ -18,12 +19,16 @@ var [a3, [[a4]], a5]: [number, [[string]], boolean] = [1, [["hello"]], true];
 //      Otherwise, if the declaration includes an initializer expression, T is the type of that initializer expression.
 var { b1: { b11 } = { b11: "string" }  } = { b1: { b11: "world" } };
 >b11 : Symbol(b11, Decl(destructuringVariableDeclaration1ES5.ts, 7, 11))
+>{ b11: "string" } : Symbol(, Decl(destructuringVariableDeclaration1ES5.ts, 7, 19))
 >b11 : Symbol(b11, Decl(destructuringVariableDeclaration1ES5.ts, 7, 21))
+>{ b1: { b11: "world" } } : Symbol(, Decl(destructuringVariableDeclaration1ES5.ts, 7, 42))
 >b1 : Symbol(b1, Decl(destructuringVariableDeclaration1ES5.ts, 7, 44))
+>{ b11: "world" } : Symbol(, Decl(destructuringVariableDeclaration1ES5.ts, 7, 48))
 >b11 : Symbol(b11, Decl(destructuringVariableDeclaration1ES5.ts, 7, 50))
 
 var temp = { t1: true, t2: "false" };
 >temp : Symbol(temp, Decl(destructuringVariableDeclaration1ES5.ts, 8, 3))
+>{ t1: true, t2: "false" } : Symbol(, Decl(destructuringVariableDeclaration1ES5.ts, 8, 10))
 >t1 : Symbol(t1, Decl(destructuringVariableDeclaration1ES5.ts, 8, 12))
 >t2 : Symbol(t2, Decl(destructuringVariableDeclaration1ES5.ts, 8, 22))
 
@@ -32,6 +37,7 @@ var [b2 = 3, b3 = true, b4 = temp] = [3, false, { t1: false, t2: "hello" }];
 >b3 : Symbol(b3, Decl(destructuringVariableDeclaration1ES5.ts, 9, 12))
 >b4 : Symbol(b4, Decl(destructuringVariableDeclaration1ES5.ts, 9, 23))
 >temp : Symbol(temp, Decl(destructuringVariableDeclaration1ES5.ts, 8, 3))
+>{ t1: false, t2: "hello" } : Symbol(, Decl(destructuringVariableDeclaration1ES5.ts, 9, 47))
 >t1 : Symbol(t1, Decl(destructuringVariableDeclaration1ES5.ts, 9, 49))
 >t2 : Symbol(t2, Decl(destructuringVariableDeclaration1ES5.ts, 9, 60))
 
@@ -77,9 +83,12 @@ var {e: [e1, e2, e3 = { b1: 1000, b4: 200 }]} = { e: [1, 2, { b1: 4, b4: 0 }] };
 >e1 : Symbol(e1, Decl(destructuringVariableDeclaration1ES5.ts, 31, 9))
 >e2 : Symbol(e2, Decl(destructuringVariableDeclaration1ES5.ts, 31, 12))
 >e3 : Symbol(e3, Decl(destructuringVariableDeclaration1ES5.ts, 31, 16))
+>{ b1: 1000, b4: 200 } : Symbol(, Decl(destructuringVariableDeclaration1ES5.ts, 31, 21))
 >b1 : Symbol(b1, Decl(destructuringVariableDeclaration1ES5.ts, 31, 23))
 >b4 : Symbol(b4, Decl(destructuringVariableDeclaration1ES5.ts, 31, 33))
+>{ e: [1, 2, { b1: 4, b4: 0 }] } : Symbol(, Decl(destructuringVariableDeclaration1ES5.ts, 31, 47))
 >e : Symbol(e, Decl(destructuringVariableDeclaration1ES5.ts, 31, 49))
+>{ b1: 4, b4: 0 } : Symbol(, Decl(destructuringVariableDeclaration1ES5.ts, 31, 59))
 >b1 : Symbol(b1, Decl(destructuringVariableDeclaration1ES5.ts, 31, 61))
 >b4 : Symbol(b4, Decl(destructuringVariableDeclaration1ES5.ts, 31, 68))
 
@@ -88,7 +97,9 @@ var {f: [f1, f2, { f3: f4, f5 }, , ]} = { f: [1, 2, { f3: 4, f5: 0 }] };
 >f2 : Symbol(f2, Decl(destructuringVariableDeclaration1ES5.ts, 32, 12))
 >f4 : Symbol(f4, Decl(destructuringVariableDeclaration1ES5.ts, 32, 18))
 >f5 : Symbol(f5, Decl(destructuringVariableDeclaration1ES5.ts, 32, 26))
+>{ f: [1, 2, { f3: 4, f5: 0 }] } : Symbol(, Decl(destructuringVariableDeclaration1ES5.ts, 32, 39))
 >f : Symbol(f, Decl(destructuringVariableDeclaration1ES5.ts, 32, 41))
+>{ f3: 4, f5: 0 } : Symbol(, Decl(destructuringVariableDeclaration1ES5.ts, 32, 51))
 >f3 : Symbol(f3, Decl(destructuringVariableDeclaration1ES5.ts, 32, 53))
 >f5 : Symbol(f5, Decl(destructuringVariableDeclaration1ES5.ts, 32, 60))
 
@@ -100,7 +111,9 @@ var {g: {g1 = [undefined, null]}}: { g: { g1: any[] } } = { g: { g1: [1, 2] } };
 >undefined : Symbol(undefined)
 >g : Symbol(g, Decl(destructuringVariableDeclaration1ES5.ts, 37, 36))
 >g1 : Symbol(g1, Decl(destructuringVariableDeclaration1ES5.ts, 37, 41))
+>{ g: { g1: [1, 2] } } : Symbol(, Decl(destructuringVariableDeclaration1ES5.ts, 37, 57))
 >g : Symbol(g, Decl(destructuringVariableDeclaration1ES5.ts, 37, 59))
+>{ g1: [1, 2] } : Symbol(, Decl(destructuringVariableDeclaration1ES5.ts, 37, 62))
 >g1 : Symbol(g1, Decl(destructuringVariableDeclaration1ES5.ts, 37, 64))
 
 var {h: {h1 = [undefined, null]}}: { h: { h1: number[] } } = { h: { h1: [1, 2] } };
@@ -108,7 +121,9 @@ var {h: {h1 = [undefined, null]}}: { h: { h1: number[] } } = { h: { h1: [1, 2] }
 >undefined : Symbol(undefined)
 >h : Symbol(h, Decl(destructuringVariableDeclaration1ES5.ts, 38, 36))
 >h1 : Symbol(h1, Decl(destructuringVariableDeclaration1ES5.ts, 38, 41))
+>{ h: { h1: [1, 2] } } : Symbol(, Decl(destructuringVariableDeclaration1ES5.ts, 38, 60))
 >h : Symbol(h, Decl(destructuringVariableDeclaration1ES5.ts, 38, 62))
+>{ h1: [1, 2] } : Symbol(, Decl(destructuringVariableDeclaration1ES5.ts, 38, 65))
 >h1 : Symbol(h1, Decl(destructuringVariableDeclaration1ES5.ts, 38, 67))
 
 
diff --git a/tests/baselines/reference/destructuringVariableDeclaration1ES6.symbols b/tests/baselines/reference/destructuringVariableDeclaration1ES6.symbols
index 0350ff3525144..929cd6222abb9 100644
--- a/tests/baselines/reference/destructuringVariableDeclaration1ES6.symbols
+++ b/tests/baselines/reference/destructuringVariableDeclaration1ES6.symbols
@@ -6,6 +6,7 @@ var {a1, a2}: { a1: number, a2: string } = { a1: 10, a2: "world" }
 >a2 : Symbol(a2, Decl(destructuringVariableDeclaration1ES6.ts, 2, 8))
 >a1 : Symbol(a1, Decl(destructuringVariableDeclaration1ES6.ts, 2, 15))
 >a2 : Symbol(a2, Decl(destructuringVariableDeclaration1ES6.ts, 2, 27))
+>{ a1: 10, a2: "world" } : Symbol(, Decl(destructuringVariableDeclaration1ES6.ts, 2, 42))
 >a1 : Symbol(a1, Decl(destructuringVariableDeclaration1ES6.ts, 2, 44))
 >a2 : Symbol(a2, Decl(destructuringVariableDeclaration1ES6.ts, 2, 52))
 
@@ -18,12 +19,16 @@ var [a3, [[a4]], a5]: [number, [[string]], boolean] = [1, [["hello"]], true];
 //      Otherwise, if the declaration includes an initializer expression, T is the type of that initializer expression.
 var { b1: { b11 } = { b11: "string" }  } = { b1: { b11: "world" } };
 >b11 : Symbol(b11, Decl(destructuringVariableDeclaration1ES6.ts, 7, 11))
+>{ b11: "string" } : Symbol(, Decl(destructuringVariableDeclaration1ES6.ts, 7, 19))
 >b11 : Symbol(b11, Decl(destructuringVariableDeclaration1ES6.ts, 7, 21))
+>{ b1: { b11: "world" } } : Symbol(, Decl(destructuringVariableDeclaration1ES6.ts, 7, 42))
 >b1 : Symbol(b1, Decl(destructuringVariableDeclaration1ES6.ts, 7, 44))
+>{ b11: "world" } : Symbol(, Decl(destructuringVariableDeclaration1ES6.ts, 7, 48))
 >b11 : Symbol(b11, Decl(destructuringVariableDeclaration1ES6.ts, 7, 50))
 
 var temp = { t1: true, t2: "false" };
 >temp : Symbol(temp, Decl(destructuringVariableDeclaration1ES6.ts, 8, 3))
+>{ t1: true, t2: "false" } : Symbol(, Decl(destructuringVariableDeclaration1ES6.ts, 8, 10))
 >t1 : Symbol(t1, Decl(destructuringVariableDeclaration1ES6.ts, 8, 12))
 >t2 : Symbol(t2, Decl(destructuringVariableDeclaration1ES6.ts, 8, 22))
 
@@ -32,6 +37,7 @@ var [b2 = 3, b3 = true, b4 = temp] = [3, false, { t1: false, t2: "hello" }];
 >b3 : Symbol(b3, Decl(destructuringVariableDeclaration1ES6.ts, 9, 12))
 >b4 : Symbol(b4, Decl(destructuringVariableDeclaration1ES6.ts, 9, 23))
 >temp : Symbol(temp, Decl(destructuringVariableDeclaration1ES6.ts, 8, 3))
+>{ t1: false, t2: "hello" } : Symbol(, Decl(destructuringVariableDeclaration1ES6.ts, 9, 47))
 >t1 : Symbol(t1, Decl(destructuringVariableDeclaration1ES6.ts, 9, 49))
 >t2 : Symbol(t2, Decl(destructuringVariableDeclaration1ES6.ts, 9, 60))
 
@@ -77,9 +83,12 @@ var {e: [e1, e2, e3 = { b1: 1000, b4: 200 }]} = { e: [1, 2, { b1: 4, b4: 0 }] };
 >e1 : Symbol(e1, Decl(destructuringVariableDeclaration1ES6.ts, 31, 9))
 >e2 : Symbol(e2, Decl(destructuringVariableDeclaration1ES6.ts, 31, 12))
 >e3 : Symbol(e3, Decl(destructuringVariableDeclaration1ES6.ts, 31, 16))
+>{ b1: 1000, b4: 200 } : Symbol(, Decl(destructuringVariableDeclaration1ES6.ts, 31, 21))
 >b1 : Symbol(b1, Decl(destructuringVariableDeclaration1ES6.ts, 31, 23))
 >b4 : Symbol(b4, Decl(destructuringVariableDeclaration1ES6.ts, 31, 33))
+>{ e: [1, 2, { b1: 4, b4: 0 }] } : Symbol(, Decl(destructuringVariableDeclaration1ES6.ts, 31, 47))
 >e : Symbol(e, Decl(destructuringVariableDeclaration1ES6.ts, 31, 49))
+>{ b1: 4, b4: 0 } : Symbol(, Decl(destructuringVariableDeclaration1ES6.ts, 31, 59))
 >b1 : Symbol(b1, Decl(destructuringVariableDeclaration1ES6.ts, 31, 61))
 >b4 : Symbol(b4, Decl(destructuringVariableDeclaration1ES6.ts, 31, 68))
 
@@ -88,7 +97,9 @@ var {f: [f1, f2, { f3: f4, f5 }, , ]} = { f: [1, 2, { f3: 4, f5: 0 }] };
 >f2 : Symbol(f2, Decl(destructuringVariableDeclaration1ES6.ts, 32, 12))
 >f4 : Symbol(f4, Decl(destructuringVariableDeclaration1ES6.ts, 32, 18))
 >f5 : Symbol(f5, Decl(destructuringVariableDeclaration1ES6.ts, 32, 26))
+>{ f: [1, 2, { f3: 4, f5: 0 }] } : Symbol(, Decl(destructuringVariableDeclaration1ES6.ts, 32, 39))
 >f : Symbol(f, Decl(destructuringVariableDeclaration1ES6.ts, 32, 41))
+>{ f3: 4, f5: 0 } : Symbol(, Decl(destructuringVariableDeclaration1ES6.ts, 32, 51))
 >f3 : Symbol(f3, Decl(destructuringVariableDeclaration1ES6.ts, 32, 53))
 >f5 : Symbol(f5, Decl(destructuringVariableDeclaration1ES6.ts, 32, 60))
 
@@ -100,7 +111,9 @@ var {g: {g1 = [undefined, null]}}: { g: { g1: any[] } } = { g: { g1: [1, 2] } };
 >undefined : Symbol(undefined)
 >g : Symbol(g, Decl(destructuringVariableDeclaration1ES6.ts, 37, 36))
 >g1 : Symbol(g1, Decl(destructuringVariableDeclaration1ES6.ts, 37, 41))
+>{ g: { g1: [1, 2] } } : Symbol(, Decl(destructuringVariableDeclaration1ES6.ts, 37, 57))
 >g : Symbol(g, Decl(destructuringVariableDeclaration1ES6.ts, 37, 59))
+>{ g1: [1, 2] } : Symbol(, Decl(destructuringVariableDeclaration1ES6.ts, 37, 62))
 >g1 : Symbol(g1, Decl(destructuringVariableDeclaration1ES6.ts, 37, 64))
 
 var {h: {h1 = [undefined, null]}}: { h: { h1: number[] } } = { h: { h1: [1, 2] } };
@@ -108,7 +121,9 @@ var {h: {h1 = [undefined, null]}}: { h: { h1: number[] } } = { h: { h1: [1, 2] }
 >undefined : Symbol(undefined)
 >h : Symbol(h, Decl(destructuringVariableDeclaration1ES6.ts, 38, 36))
 >h1 : Symbol(h1, Decl(destructuringVariableDeclaration1ES6.ts, 38, 41))
+>{ h: { h1: [1, 2] } } : Symbol(, Decl(destructuringVariableDeclaration1ES6.ts, 38, 60))
 >h : Symbol(h, Decl(destructuringVariableDeclaration1ES6.ts, 38, 62))
+>{ h1: [1, 2] } : Symbol(, Decl(destructuringVariableDeclaration1ES6.ts, 38, 65))
 >h1 : Symbol(h1, Decl(destructuringVariableDeclaration1ES6.ts, 38, 67))
 
 
diff --git a/tests/baselines/reference/detachedCommentAtStartOfConstructor1.symbols b/tests/baselines/reference/detachedCommentAtStartOfConstructor1.symbols
index 9590abaa4608c..3e123c4e08975 100644
--- a/tests/baselines/reference/detachedCommentAtStartOfConstructor1.symbols
+++ b/tests/baselines/reference/detachedCommentAtStartOfConstructor1.symbols
@@ -15,6 +15,7 @@ class TestFile {
         /// <param name="message" type="String" />
         var getMessage = () => message + this.name;
 >getMessage : Symbol(getMessage, Decl(detachedCommentAtStartOfConstructor1.ts, 6, 11))
+>() => message + this.name : Symbol((Anonymous function), Decl(detachedCommentAtStartOfConstructor1.ts, 6, 24))
 >message : Symbol(message, Decl(detachedCommentAtStartOfConstructor1.ts, 3, 16))
 >this.name : Symbol(name, Decl(detachedCommentAtStartOfConstructor1.ts, 1, 27))
 >this : Symbol(TestFile, Decl(detachedCommentAtStartOfConstructor1.ts, 0, 0))
diff --git a/tests/baselines/reference/detachedCommentAtStartOfConstructor2.symbols b/tests/baselines/reference/detachedCommentAtStartOfConstructor2.symbols
index 78af94300342f..af061db4903d9 100644
--- a/tests/baselines/reference/detachedCommentAtStartOfConstructor2.symbols
+++ b/tests/baselines/reference/detachedCommentAtStartOfConstructor2.symbols
@@ -16,6 +16,7 @@ class TestFile {
 
         var getMessage = () => message + this.name;
 >getMessage : Symbol(getMessage, Decl(detachedCommentAtStartOfConstructor2.ts, 7, 11))
+>() => message + this.name : Symbol((Anonymous function), Decl(detachedCommentAtStartOfConstructor2.ts, 7, 24))
 >message : Symbol(message, Decl(detachedCommentAtStartOfConstructor2.ts, 3, 16))
 >this.name : Symbol(name, Decl(detachedCommentAtStartOfConstructor2.ts, 1, 27))
 >this : Symbol(TestFile, Decl(detachedCommentAtStartOfConstructor2.ts, 0, 0))
diff --git a/tests/baselines/reference/detachedCommentAtStartOfLambdaFunction1.symbols b/tests/baselines/reference/detachedCommentAtStartOfLambdaFunction1.symbols
index aa34885d79b80..eb29cbf932fbb 100644
--- a/tests/baselines/reference/detachedCommentAtStartOfLambdaFunction1.symbols
+++ b/tests/baselines/reference/detachedCommentAtStartOfLambdaFunction1.symbols
@@ -10,6 +10,7 @@ class TestFile {
 >message : Symbol(message, Decl(detachedCommentAtStartOfLambdaFunction1.ts, 2, 8))
 
         return (...x: string[]) =>
+>(...x: string[]) =>            /// <summary>Test summary</summary>            /// <param name="message" type="String" />            /// <returns type="Function" />            message + this.name : Symbol((Anonymous function), Decl(detachedCommentAtStartOfLambdaFunction1.ts, 3, 14))
 >x : Symbol(x, Decl(detachedCommentAtStartOfLambdaFunction1.ts, 3, 16))
 
             /// <summary>Test summary</summary>
diff --git a/tests/baselines/reference/detachedCommentAtStartOfLambdaFunction2.symbols b/tests/baselines/reference/detachedCommentAtStartOfLambdaFunction2.symbols
index 29cef430c3a72..3cca6c28e5802 100644
--- a/tests/baselines/reference/detachedCommentAtStartOfLambdaFunction2.symbols
+++ b/tests/baselines/reference/detachedCommentAtStartOfLambdaFunction2.symbols
@@ -10,6 +10,7 @@ class TestFile {
 >message : Symbol(message, Decl(detachedCommentAtStartOfLambdaFunction2.ts, 2, 8))
 
         return (...x: string[]) =>
+>(...x: string[]) =>            /// <summary>Test summary</summary>            /// <param name="message" type="String" />            /// <returns type="Function" />            message + this.name : Symbol((Anonymous function), Decl(detachedCommentAtStartOfLambdaFunction2.ts, 3, 14))
 >x : Symbol(x, Decl(detachedCommentAtStartOfLambdaFunction2.ts, 3, 16))
 
             /// <summary>Test summary</summary>
diff --git a/tests/baselines/reference/doNotWidenAtObjectLiteralPropertyAssignment.symbols b/tests/baselines/reference/doNotWidenAtObjectLiteralPropertyAssignment.symbols
index 7aaf3b98f4ae2..597e269801c72 100644
--- a/tests/baselines/reference/doNotWidenAtObjectLiteralPropertyAssignment.symbols
+++ b/tests/baselines/reference/doNotWidenAtObjectLiteralPropertyAssignment.symbols
@@ -21,7 +21,9 @@ interface IIntervalTreeNode {
 var test: IIntervalTreeNode[] = [{ interval: { begin: 0 }, children: null }]; // was error here because best common type is {}
 >test : Symbol(test, Decl(doNotWidenAtObjectLiteralPropertyAssignment.ts, 9, 3))
 >IIntervalTreeNode : Symbol(IIntervalTreeNode, Decl(doNotWidenAtObjectLiteralPropertyAssignment.ts, 2, 1))
+>{ interval: { begin: 0 }, children: null } : Symbol(, Decl(doNotWidenAtObjectLiteralPropertyAssignment.ts, 9, 33))
 >interval : Symbol(interval, Decl(doNotWidenAtObjectLiteralPropertyAssignment.ts, 9, 34))
+>{ begin: 0 } : Symbol(, Decl(doNotWidenAtObjectLiteralPropertyAssignment.ts, 9, 44))
 >begin : Symbol(begin, Decl(doNotWidenAtObjectLiteralPropertyAssignment.ts, 9, 46))
 >children : Symbol(children, Decl(doNotWidenAtObjectLiteralPropertyAssignment.ts, 9, 58))
 
diff --git a/tests/baselines/reference/doWhileBreakStatements.symbols b/tests/baselines/reference/doWhileBreakStatements.symbols
index 7d9db9a5ebb51..5551957f64ff9 100644
--- a/tests/baselines/reference/doWhileBreakStatements.symbols
+++ b/tests/baselines/reference/doWhileBreakStatements.symbols
@@ -35,6 +35,7 @@ EIGHT:
 do{
     var fn = function () { }
 >fn : Symbol(fn, Decl(doWhileBreakStatements.ts, 34, 7))
+>function () { } : Symbol((Anonymous function), Decl(doWhileBreakStatements.ts, 34, 12))
 
     break EIGHT;
 }while(true)
diff --git a/tests/baselines/reference/doWhileContinueStatements.symbols b/tests/baselines/reference/doWhileContinueStatements.symbols
index e4c6d577d5aa4..4236b40de70f8 100644
--- a/tests/baselines/reference/doWhileContinueStatements.symbols
+++ b/tests/baselines/reference/doWhileContinueStatements.symbols
@@ -35,6 +35,7 @@ EIGHT:
 do{
     var fn = function () { }
 >fn : Symbol(fn, Decl(doWhileContinueStatements.ts, 34, 7))
+>function () { } : Symbol((Anonymous function), Decl(doWhileContinueStatements.ts, 34, 12))
 
     continue EIGHT;
 }while(true)
diff --git a/tests/baselines/reference/dottedSymbolResolution1.symbols b/tests/baselines/reference/dottedSymbolResolution1.symbols
index 25ff8a6fe9200..b0d8987ff3ef4 100644
--- a/tests/baselines/reference/dottedSymbolResolution1.symbols
+++ b/tests/baselines/reference/dottedSymbolResolution1.symbols
@@ -65,6 +65,7 @@ function _setBarAndText(): void {
 >x.find : Symbol(JQuery.find, Decl(dottedSymbolResolution1.ts, 0, 18))
 >x : Symbol(x, Decl(dottedSymbolResolution1.ts, 19, 7))
 >find : Symbol(JQuery.find, Decl(dottedSymbolResolution1.ts, 0, 18))
+>function () {        var $this: JQuery = $(''),            thisBar = $this.find(".fx-usagebars-calloutbar-this"); // bug lead to 'could not find dotted symbol' here    } : Symbol((Anonymous function), Decl(dottedSymbolResolution1.ts, 20, 21))
 
         var $this: JQuery = $(''),
 >$this : Symbol($this, Decl(dottedSymbolResolution1.ts, 21, 11))
diff --git a/tests/baselines/reference/downlevelLetConst12.symbols b/tests/baselines/reference/downlevelLetConst12.symbols
index d1c7fe3ea5b9e..69b25bb02c969 100644
--- a/tests/baselines/reference/downlevelLetConst12.symbols
+++ b/tests/baselines/reference/downlevelLetConst12.symbols
@@ -13,6 +13,7 @@ let [baz] = [];
 
 let {a: baz2} = { a: 1 };
 >baz2 : Symbol(baz2, Decl(downlevelLetConst12.ts, 7, 5))
+>{ a: 1 } : Symbol(, Decl(downlevelLetConst12.ts, 7, 15))
 >a : Symbol(a, Decl(downlevelLetConst12.ts, 7, 17))
 
 const [baz3] = []
@@ -20,5 +21,6 @@ const [baz3] = []
 
 const {a: baz4} = { a: 1 };
 >baz4 : Symbol(baz4, Decl(downlevelLetConst12.ts, 10, 7))
+>{ a: 1 } : Symbol(, Decl(downlevelLetConst12.ts, 10, 17))
 >a : Symbol(a, Decl(downlevelLetConst12.ts, 10, 19))
 
diff --git a/tests/baselines/reference/downlevelLetConst13.symbols b/tests/baselines/reference/downlevelLetConst13.symbols
index 1b06184f2b3d4..5408e6bfe96c1 100644
--- a/tests/baselines/reference/downlevelLetConst13.symbols
+++ b/tests/baselines/reference/downlevelLetConst13.symbols
@@ -17,10 +17,12 @@ export const [bar2] = [2];
 
 export let {a: bar3} = { a: 1 };
 >bar3 : Symbol(bar3, Decl(downlevelLetConst13.ts, 8, 12))
+>{ a: 1 } : Symbol(, Decl(downlevelLetConst13.ts, 8, 22))
 >a : Symbol(a, Decl(downlevelLetConst13.ts, 8, 24))
 
 export const {a: bar4} = { a: 1 };
 >bar4 : Symbol(bar4, Decl(downlevelLetConst13.ts, 9, 14))
+>{ a: 1 } : Symbol(, Decl(downlevelLetConst13.ts, 9, 24))
 >a : Symbol(a, Decl(downlevelLetConst13.ts, 9, 26))
 
 export module M {
@@ -40,9 +42,11 @@ export module M {
 
     export let {a: bar7} = { a: 1 };
 >bar7 : Symbol(bar7, Decl(downlevelLetConst13.ts, 16, 16))
+>{ a: 1 } : Symbol(, Decl(downlevelLetConst13.ts, 16, 26))
 >a : Symbol(a, Decl(downlevelLetConst13.ts, 16, 28))
 
     export const {a: bar8} = { a: 1 };
 >bar8 : Symbol(bar8, Decl(downlevelLetConst13.ts, 17, 18))
+>{ a: 1 } : Symbol(, Decl(downlevelLetConst13.ts, 17, 28))
 >a : Symbol(a, Decl(downlevelLetConst13.ts, 17, 30))
 }
diff --git a/tests/baselines/reference/downlevelLetConst14.symbols b/tests/baselines/reference/downlevelLetConst14.symbols
index bf3450af71cda..ee3d2d6da07c1 100644
--- a/tests/baselines/reference/downlevelLetConst14.symbols
+++ b/tests/baselines/reference/downlevelLetConst14.symbols
@@ -36,6 +36,7 @@ var z0, z1, z2, z3;
 
     let {a: z2} = { a: 1 };
 >z2 : Symbol(z2, Decl(downlevelLetConst14.ts, 13, 9))
+>{ a: 1 } : Symbol(, Decl(downlevelLetConst14.ts, 13, 17))
 >a : Symbol(a, Decl(downlevelLetConst14.ts, 13, 19))
 
     use(z2);
@@ -44,6 +45,7 @@ var z0, z1, z2, z3;
 
     let {a: z3} = { a: 1 };
 >z3 : Symbol(z3, Decl(downlevelLetConst14.ts, 15, 9))
+>{ a: 1 } : Symbol(, Decl(downlevelLetConst14.ts, 15, 17))
 >a : Symbol(a, Decl(downlevelLetConst14.ts, 15, 19))
 
     use(z3);
@@ -87,6 +89,7 @@ var y = true;
 
         let {a: z6} = {a: 1}
 >z6 : Symbol(z6, Decl(downlevelLetConst14.ts, 30, 13))
+>{a: 1} : Symbol(, Decl(downlevelLetConst14.ts, 30, 21))
 >a : Symbol(a, Decl(downlevelLetConst14.ts, 30, 23))
 
         use(y);
@@ -130,6 +133,7 @@ var z5 = 1;
 
         let {a: _z5} = { a: 1 };
 >_z5 : Symbol(_z5, Decl(downlevelLetConst14.ts, 47, 13))
+>{ a: 1 } : Symbol(, Decl(downlevelLetConst14.ts, 47, 22))
 >a : Symbol(a, Decl(downlevelLetConst14.ts, 47, 24))
 
         // try to step on generated name
diff --git a/tests/baselines/reference/downlevelLetConst15.symbols b/tests/baselines/reference/downlevelLetConst15.symbols
index 159e5a6d67665..b19bb43f36308 100644
--- a/tests/baselines/reference/downlevelLetConst15.symbols
+++ b/tests/baselines/reference/downlevelLetConst15.symbols
@@ -29,6 +29,7 @@ var z0, z1, z2, z3;
 
     const [{a: z1}] = [{a: 1}]
 >z1 : Symbol(z1, Decl(downlevelLetConst15.ts, 11, 12))
+>{a: 1} : Symbol(, Decl(downlevelLetConst15.ts, 11, 23))
 >a : Symbol(a, Decl(downlevelLetConst15.ts, 11, 24))
 
     use(z1);
@@ -37,6 +38,7 @@ var z0, z1, z2, z3;
 
     const {a: z2} = { a: 1 };
 >z2 : Symbol(z2, Decl(downlevelLetConst15.ts, 13, 11))
+>{ a: 1 } : Symbol(, Decl(downlevelLetConst15.ts, 13, 19))
 >a : Symbol(a, Decl(downlevelLetConst15.ts, 13, 21))
 
     use(z2);
@@ -45,7 +47,9 @@ var z0, z1, z2, z3;
 
     const {a: {b: z3}} = { a: {b: 1} };
 >z3 : Symbol(z3, Decl(downlevelLetConst15.ts, 15, 15))
+>{ a: {b: 1} } : Symbol(, Decl(downlevelLetConst15.ts, 15, 24))
 >a : Symbol(a, Decl(downlevelLetConst15.ts, 15, 26))
+>{b: 1} : Symbol(, Decl(downlevelLetConst15.ts, 15, 29))
 >b : Symbol(b, Decl(downlevelLetConst15.ts, 15, 31))
 
     use(z3);
@@ -89,6 +93,7 @@ var y = true;
 
         const {a: z6} = { a: 1 }
 >z6 : Symbol(z6, Decl(downlevelLetConst15.ts, 30, 15))
+>{ a: 1 } : Symbol(, Decl(downlevelLetConst15.ts, 30, 23))
 >a : Symbol(a, Decl(downlevelLetConst15.ts, 30, 25))
 
         use(y);
@@ -132,6 +137,7 @@ var z5 = 1;
 
         const {a: _z5} = { a: 1 };
 >_z5 : Symbol(_z5, Decl(downlevelLetConst15.ts, 47, 15))
+>{ a: 1 } : Symbol(, Decl(downlevelLetConst15.ts, 47, 24))
 >a : Symbol(a, Decl(downlevelLetConst15.ts, 47, 26))
 
         // try to step on generated name
diff --git a/tests/baselines/reference/duplicateOverloadInTypeAugmentation1.symbols b/tests/baselines/reference/duplicateOverloadInTypeAugmentation1.symbols
index 4191616255387..a075f319a0632 100644
--- a/tests/baselines/reference/duplicateOverloadInTypeAugmentation1.symbols
+++ b/tests/baselines/reference/duplicateOverloadInTypeAugmentation1.symbols
@@ -47,6 +47,7 @@ var r5 = a.reduce((x, y) => x + y);
 >a.reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 20), Decl(duplicateOverloadInTypeAugmentation1.ts, 2, 29))
 >a : Symbol(a, Decl(duplicateOverloadInTypeAugmentation1.ts, 6, 3))
 >reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 20), Decl(duplicateOverloadInTypeAugmentation1.ts, 2, 29))
+>(x, y) => x + y : Symbol((Anonymous function), Decl(duplicateOverloadInTypeAugmentation1.ts, 7, 18))
 >x : Symbol(x, Decl(duplicateOverloadInTypeAugmentation1.ts, 7, 19))
 >y : Symbol(y, Decl(duplicateOverloadInTypeAugmentation1.ts, 7, 21))
 >x : Symbol(x, Decl(duplicateOverloadInTypeAugmentation1.ts, 7, 19))
diff --git a/tests/baselines/reference/emitArrowFunction.symbols b/tests/baselines/reference/emitArrowFunction.symbols
index 33de13d877c68..6e7993150b596 100644
--- a/tests/baselines/reference/emitArrowFunction.symbols
+++ b/tests/baselines/reference/emitArrowFunction.symbols
@@ -1,20 +1,24 @@
 === tests/cases/conformance/es6/arrowFunction/emitArrowFunction.ts ===
 var f1 = () => { }
 >f1 : Symbol(f1, Decl(emitArrowFunction.ts, 0, 3))
+>() => { } : Symbol((Anonymous function), Decl(emitArrowFunction.ts, 0, 8))
 
 var f2 = (x: string, y: string) => { }
 >f2 : Symbol(f2, Decl(emitArrowFunction.ts, 1, 3))
+>(x: string, y: string) => { } : Symbol((Anonymous function), Decl(emitArrowFunction.ts, 1, 8))
 >x : Symbol(x, Decl(emitArrowFunction.ts, 1, 10))
 >y : Symbol(y, Decl(emitArrowFunction.ts, 1, 20))
 
 var f3 = (x: string, y: number, ...rest) => { }
 >f3 : Symbol(f3, Decl(emitArrowFunction.ts, 2, 3))
+>(x: string, y: number, ...rest) => { } : Symbol((Anonymous function), Decl(emitArrowFunction.ts, 2, 8))
 >x : Symbol(x, Decl(emitArrowFunction.ts, 2, 10))
 >y : Symbol(y, Decl(emitArrowFunction.ts, 2, 20))
 >rest : Symbol(rest, Decl(emitArrowFunction.ts, 2, 31))
 
 var f4 = (x: string, y: number, z = 10) => { }
 >f4 : Symbol(f4, Decl(emitArrowFunction.ts, 3, 3))
+>(x: string, y: number, z = 10) => { } : Symbol((Anonymous function), Decl(emitArrowFunction.ts, 3, 8))
 >x : Symbol(x, Decl(emitArrowFunction.ts, 3, 10))
 >y : Symbol(y, Decl(emitArrowFunction.ts, 3, 20))
 >z : Symbol(z, Decl(emitArrowFunction.ts, 3, 31))
@@ -25,7 +29,9 @@ function foo(func: () => boolean) { }
 
 foo(() => true);
 >foo : Symbol(foo, Decl(emitArrowFunction.ts, 3, 46))
+>() => true : Symbol((Anonymous function), Decl(emitArrowFunction.ts, 5, 4))
 
 foo(() => { return false; });
 >foo : Symbol(foo, Decl(emitArrowFunction.ts, 3, 46))
+>() => { return false; } : Symbol((Anonymous function), Decl(emitArrowFunction.ts, 6, 4))
 
diff --git a/tests/baselines/reference/emitArrowFunctionAsIs.symbols b/tests/baselines/reference/emitArrowFunctionAsIs.symbols
index d853996ccd9b9..360cfb19f1036 100644
--- a/tests/baselines/reference/emitArrowFunctionAsIs.symbols
+++ b/tests/baselines/reference/emitArrowFunctionAsIs.symbols
@@ -1,14 +1,17 @@
 === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionAsIs.ts ===
 var arrow1 = a => { };
 >arrow1 : Symbol(arrow1, Decl(emitArrowFunctionAsIs.ts, 0, 3))
+>a => { } : Symbol((Anonymous function), Decl(emitArrowFunctionAsIs.ts, 0, 12))
 >a : Symbol(a, Decl(emitArrowFunctionAsIs.ts, 0, 12))
 
 var arrow2 = (a) => { };
 >arrow2 : Symbol(arrow2, Decl(emitArrowFunctionAsIs.ts, 1, 3))
+>(a) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionAsIs.ts, 1, 12))
 >a : Symbol(a, Decl(emitArrowFunctionAsIs.ts, 1, 14))
 
 var arrow3 = (a, b) => { };
 >arrow3 : Symbol(arrow3, Decl(emitArrowFunctionAsIs.ts, 3, 3))
+>(a, b) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionAsIs.ts, 3, 12))
 >a : Symbol(a, Decl(emitArrowFunctionAsIs.ts, 3, 14))
 >b : Symbol(b, Decl(emitArrowFunctionAsIs.ts, 3, 16))
 
diff --git a/tests/baselines/reference/emitArrowFunctionAsIsES6.symbols b/tests/baselines/reference/emitArrowFunctionAsIsES6.symbols
index c435db556484a..331ce889a6523 100644
--- a/tests/baselines/reference/emitArrowFunctionAsIsES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionAsIsES6.symbols
@@ -1,14 +1,17 @@
 === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionAsIsES6.ts ===
 var arrow1 =  a => { };
 >arrow1 : Symbol(arrow1, Decl(emitArrowFunctionAsIsES6.ts, 0, 3))
+>a => { } : Symbol((Anonymous function), Decl(emitArrowFunctionAsIsES6.ts, 0, 12))
 >a : Symbol(a, Decl(emitArrowFunctionAsIsES6.ts, 0, 12))
 
 var arrow2 = (a) => { };
 >arrow2 : Symbol(arrow2, Decl(emitArrowFunctionAsIsES6.ts, 1, 3))
+>(a) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionAsIsES6.ts, 1, 12))
 >a : Symbol(a, Decl(emitArrowFunctionAsIsES6.ts, 1, 14))
 
 var arrow3 = (a, b) => { };
 >arrow3 : Symbol(arrow3, Decl(emitArrowFunctionAsIsES6.ts, 3, 3))
+>(a, b) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionAsIsES6.ts, 3, 12))
 >a : Symbol(a, Decl(emitArrowFunctionAsIsES6.ts, 3, 14))
 >b : Symbol(b, Decl(emitArrowFunctionAsIsES6.ts, 3, 16))
 
diff --git a/tests/baselines/reference/emitArrowFunctionES6.symbols b/tests/baselines/reference/emitArrowFunctionES6.symbols
index 06f83f7f6f0b3..1b5a018dbc42d 100644
--- a/tests/baselines/reference/emitArrowFunctionES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionES6.symbols
@@ -1,20 +1,24 @@
 === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionES6.ts ===
 var f1 = () => { }
 >f1 : Symbol(f1, Decl(emitArrowFunctionES6.ts, 0, 3))
+>() => { } : Symbol((Anonymous function), Decl(emitArrowFunctionES6.ts, 0, 8))
 
 var f2 = (x: string, y: string) => { }
 >f2 : Symbol(f2, Decl(emitArrowFunctionES6.ts, 1, 3))
+>(x: string, y: string) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionES6.ts, 1, 8))
 >x : Symbol(x, Decl(emitArrowFunctionES6.ts, 1, 10))
 >y : Symbol(y, Decl(emitArrowFunctionES6.ts, 1, 20))
 
 var f3 = (x: string, y: number, ...rest) => { }
 >f3 : Symbol(f3, Decl(emitArrowFunctionES6.ts, 2, 3))
+>(x: string, y: number, ...rest) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionES6.ts, 2, 8))
 >x : Symbol(x, Decl(emitArrowFunctionES6.ts, 2, 10))
 >y : Symbol(y, Decl(emitArrowFunctionES6.ts, 2, 20))
 >rest : Symbol(rest, Decl(emitArrowFunctionES6.ts, 2, 31))
 
 var f4 = (x: string, y: number, z=10) => { }
 >f4 : Symbol(f4, Decl(emitArrowFunctionES6.ts, 3, 3))
+>(x: string, y: number, z=10) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionES6.ts, 3, 8))
 >x : Symbol(x, Decl(emitArrowFunctionES6.ts, 3, 10))
 >y : Symbol(y, Decl(emitArrowFunctionES6.ts, 3, 20))
 >z : Symbol(z, Decl(emitArrowFunctionES6.ts, 3, 31))
@@ -25,50 +29,63 @@ function foo(func: () => boolean) { }
 
 foo(() => true);
 >foo : Symbol(foo, Decl(emitArrowFunctionES6.ts, 3, 44))
+>() => true : Symbol((Anonymous function), Decl(emitArrowFunctionES6.ts, 5, 4))
 
 foo(() => { return false; });
 >foo : Symbol(foo, Decl(emitArrowFunctionES6.ts, 3, 44))
+>() => { return false; } : Symbol((Anonymous function), Decl(emitArrowFunctionES6.ts, 6, 4))
 
 // Binding patterns in arrow functions
 var p1 = ([a]) => { };
 >p1 : Symbol(p1, Decl(emitArrowFunctionES6.ts, 9, 3))
+>([a]) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionES6.ts, 9, 8))
 >a : Symbol(a, Decl(emitArrowFunctionES6.ts, 9, 11))
 
 var p2 = ([...a]) => { };
 >p2 : Symbol(p2, Decl(emitArrowFunctionES6.ts, 10, 3))
+>([...a]) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionES6.ts, 10, 8))
 >a : Symbol(a, Decl(emitArrowFunctionES6.ts, 10, 11))
 
 var p3 = ([, a]) => { };
 >p3 : Symbol(p3, Decl(emitArrowFunctionES6.ts, 11, 3))
+>([, a]) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionES6.ts, 11, 8))
 >a : Symbol(a, Decl(emitArrowFunctionES6.ts, 11, 12))
 
 var p4 = ([, ...a]) => { };
 >p4 : Symbol(p4, Decl(emitArrowFunctionES6.ts, 12, 3))
+>([, ...a]) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionES6.ts, 12, 8))
 >a : Symbol(a, Decl(emitArrowFunctionES6.ts, 12, 12))
 
 var p5 = ([a = 1]) => { };
 >p5 : Symbol(p5, Decl(emitArrowFunctionES6.ts, 13, 3))
+>([a = 1]) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionES6.ts, 13, 8))
 >a : Symbol(a, Decl(emitArrowFunctionES6.ts, 13, 11))
 
 var p6 = ({ a }) => { };
 >p6 : Symbol(p6, Decl(emitArrowFunctionES6.ts, 14, 3))
+>({ a }) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionES6.ts, 14, 8))
 >a : Symbol(a, Decl(emitArrowFunctionES6.ts, 14, 11))
 
 var p7 = ({ a: { b } }) => { };
 >p7 : Symbol(p7, Decl(emitArrowFunctionES6.ts, 15, 3))
+>({ a: { b } }) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionES6.ts, 15, 8))
 >b : Symbol(b, Decl(emitArrowFunctionES6.ts, 15, 16))
 
 var p8 = ({ a = 1 }) => { };
 >p8 : Symbol(p8, Decl(emitArrowFunctionES6.ts, 16, 3))
+>({ a = 1 }) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionES6.ts, 16, 8))
 >a : Symbol(a, Decl(emitArrowFunctionES6.ts, 16, 11))
 
 var p9 = ({ a: { b = 1 } = { b: 1 } }) => { };
 >p9 : Symbol(p9, Decl(emitArrowFunctionES6.ts, 17, 3))
+>({ a: { b = 1 } = { b: 1 } }) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionES6.ts, 17, 8))
 >b : Symbol(b, Decl(emitArrowFunctionES6.ts, 17, 16))
+>{ b: 1 } : Symbol(, Decl(emitArrowFunctionES6.ts, 17, 26))
 >b : Symbol(b, Decl(emitArrowFunctionES6.ts, 17, 28))
 
 var p10 = ([{ value, done }]) => { };
 >p10 : Symbol(p10, Decl(emitArrowFunctionES6.ts, 18, 3))
+>([{ value, done }]) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionES6.ts, 18, 9))
 >value : Symbol(value, Decl(emitArrowFunctionES6.ts, 18, 13))
 >done : Symbol(done, Decl(emitArrowFunctionES6.ts, 18, 20))
 
diff --git a/tests/baselines/reference/emitArrowFunctionThisCapturing.symbols b/tests/baselines/reference/emitArrowFunctionThisCapturing.symbols
index ad62a0df5be92..4e2b2a74b9640 100644
--- a/tests/baselines/reference/emitArrowFunctionThisCapturing.symbols
+++ b/tests/baselines/reference/emitArrowFunctionThisCapturing.symbols
@@ -1,12 +1,14 @@
 === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionThisCapturing.ts ===
 var f1 = () => {
 >f1 : Symbol(f1, Decl(emitArrowFunctionThisCapturing.ts, 0, 3))
+>() => {    this.age = 10} : Symbol((Anonymous function), Decl(emitArrowFunctionThisCapturing.ts, 0, 8))
 
     this.age = 10
 };
 
 var f2 = (x: string) => {
 >f2 : Symbol(f2, Decl(emitArrowFunctionThisCapturing.ts, 4, 3))
+>(x: string) => {    this.name = x} : Symbol((Anonymous function), Decl(emitArrowFunctionThisCapturing.ts, 4, 8))
 >x : Symbol(x, Decl(emitArrowFunctionThisCapturing.ts, 4, 10))
 
     this.name = x
@@ -19,6 +21,7 @@ function foo(func: () => boolean) { }
 
 foo(() => {
 >foo : Symbol(foo, Decl(emitArrowFunctionThisCapturing.ts, 6, 1))
+>() => {    this.age = 100;    return true;} : Symbol((Anonymous function), Decl(emitArrowFunctionThisCapturing.ts, 9, 4))
 
     this.age = 100;
     return true;
diff --git a/tests/baselines/reference/emitArrowFunctionThisCapturingES6.symbols b/tests/baselines/reference/emitArrowFunctionThisCapturingES6.symbols
index 0e8855dd680c5..62bb2428731f6 100644
--- a/tests/baselines/reference/emitArrowFunctionThisCapturingES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionThisCapturingES6.symbols
@@ -1,12 +1,14 @@
 === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionThisCapturingES6.ts ===
 var f1 = () => {
 >f1 : Symbol(f1, Decl(emitArrowFunctionThisCapturingES6.ts, 0, 3))
+>() => {    this.age = 10} : Symbol((Anonymous function), Decl(emitArrowFunctionThisCapturingES6.ts, 0, 8))
 
     this.age = 10
 };
 
 var f2 = (x: string) => {
 >f2 : Symbol(f2, Decl(emitArrowFunctionThisCapturingES6.ts, 4, 3))
+>(x: string) => {    this.name = x} : Symbol((Anonymous function), Decl(emitArrowFunctionThisCapturingES6.ts, 4, 8))
 >x : Symbol(x, Decl(emitArrowFunctionThisCapturingES6.ts, 4, 10))
 
     this.name = x
@@ -19,6 +21,7 @@ function foo(func: () => boolean){ }
 
 foo(() => {
 >foo : Symbol(foo, Decl(emitArrowFunctionThisCapturingES6.ts, 6, 1))
+>() => {    this.age = 100;    return true;} : Symbol((Anonymous function), Decl(emitArrowFunctionThisCapturingES6.ts, 9, 4))
 
     this.age = 100;
     return true;
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments01_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments01_ES6.symbols
index 698b32da7ad98..ef80a7dc44240 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments01_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments01_ES6.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments01_ES6.ts ===
 var a = () => {
 >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 0, 3))
+>() => {    var arg = arguments[0];  // error} : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 0, 7))
 
     var arg = arguments[0];  // error
 >arg : Symbol(arg, Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 1, 7))
@@ -9,9 +10,11 @@ var a = () => {
 
 var b = function () {
 >b : Symbol(b, Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 4, 3))
+>function () {    var a = () => {        var arg = arguments[0];  // error    }} : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 4, 7))
 
     var a = () => {
 >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 5, 7))
+>() => {        var arg = arguments[0];  // error    } : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 5, 11))
 
         var arg = arguments[0];  // error
 >arg : Symbol(arg, Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 6, 11))
@@ -23,6 +26,8 @@ function baz() {
 >baz : Symbol(baz, Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 8, 1))
 
 	() => {
+>() => {		var arg = arguments[0];	} : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 10, 16))
+
 		var arg = arguments[0];
 >arg : Symbol(arg, Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 12, 5))
 >arguments : Symbol(arguments)
@@ -35,6 +40,7 @@ function foo(inputFunc: () => void) { }
 
 foo(() => {
 >foo : Symbol(foo, Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 14, 1))
+>() => {    var arg = arguments[0];  // error} : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 17, 4))
 
     var arg = arguments[0];  // error
 >arg : Symbol(arg, Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 18, 7))
@@ -52,6 +58,8 @@ function bar() {
 
 
 () => {
+>() => {	function foo() {		var arg = arguments[0];  // no error	}} : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 23, 1))
+
 	function foo() {
 >foo : Symbol(foo, Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 26, 7))
 
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.symbols
index e403a2c3da1a9..d10756fa50a00 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.symbols
@@ -2,5 +2,6 @@
 
 var a = () => arguments;
 >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments02_ES6.ts, 1, 3))
+>() => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments02_ES6.ts, 1, 7))
 >arguments : Symbol(arguments)
 
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.symbols
index 08bae3827942b..23c5592b8471b 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.symbols
@@ -5,5 +5,6 @@ var arguments;
 
 var a = () => arguments;
 >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments03_ES6.ts, 2, 3))
+>() => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments03_ES6.ts, 2, 7))
 >arguments : Symbol(arguments)
 
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.symbols
index 708615a95c606..37b20c805c1af 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.symbols
@@ -8,5 +8,6 @@ function f() {
 
     var a = () => arguments;
 >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments04_ES6.ts, 3, 7))
+>() => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments04_ES6.ts, 3, 11))
 >arguments : Symbol(arguments)
 }
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.symbols
index 379a5cf92f128..a3b38fdf93620 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.symbols
@@ -6,5 +6,6 @@ function f(arguments) {
 
     var a = () => arguments;
 >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments05_ES6.ts, 2, 7))
+>() => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments05_ES6.ts, 2, 11))
 >arguments : Symbol(arguments)
 }
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.symbols
index e59f487f86405..6dd11e6c544b2 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.symbols
@@ -6,5 +6,7 @@ function f(arguments) {
 
     var a = () => () => arguments;
 >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments06_ES6.ts, 2, 7))
+>() => () => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments06_ES6.ts, 2, 11))
+>() => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments06_ES6.ts, 2, 17))
 >arguments : Symbol(arguments)
 }
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.symbols
index 5de21ffbebd53..d157f1fa08dd9 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.symbols
@@ -6,6 +6,8 @@ function f(arguments) {
 
     var a = (arguments) => () => arguments;
 >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments07_ES6.ts, 2, 7))
+>(arguments) => () => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments07_ES6.ts, 2, 11))
 >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments07_ES6.ts, 2, 13))
+>() => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments07_ES6.ts, 2, 26))
 >arguments : Symbol(arguments)
 }
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.symbols
index 80f7f5079788d..65df0ec716fd6 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.symbols
@@ -6,6 +6,8 @@ function f(arguments) {
 
     var a = () => (arguments) => arguments;
 >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments08.ts, 2, 7))
+>() => (arguments) => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments08.ts, 2, 11))
+>(arguments) => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments08.ts, 2, 17))
 >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments08.ts, 2, 19))
 >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments08.ts, 2, 19))
 }
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.symbols
index bfbb055cc3249..4ac4d6633bb43 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.symbols
@@ -6,6 +6,8 @@ function f(arguments) {
 
     var a = () => (arguments) => arguments;
 >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments08_ES6.ts, 2, 7))
+>() => (arguments) => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments08_ES6.ts, 2, 11))
+>(arguments) => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments08_ES6.ts, 2, 17))
 >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments08_ES6.ts, 2, 19))
 >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments08_ES6.ts, 2, 19))
 }
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.symbols
index ff8f114c052e8..dae7fe8e40b9f 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.symbols
@@ -6,5 +6,7 @@ function f(_arguments) {
 
     var a = () => () => arguments;
 >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments09_ES6.ts, 2, 7))
+>() => () => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments09_ES6.ts, 2, 11))
+>() => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments09_ES6.ts, 2, 17))
 >arguments : Symbol(arguments)
 }
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.symbols
index 1d9965fa6adc0..8bb64294ea621 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.symbols
@@ -8,5 +8,7 @@ function f() {
 
     var a = () => () => arguments;
 >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments10_ES6.ts, 3, 7))
+>() => () => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments10_ES6.ts, 3, 11))
+>() => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments10_ES6.ts, 3, 17))
 >arguments : Symbol(arguments)
 }
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.symbols
index a8f9c86c1b212..291b3a84d16cf 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.symbols
@@ -9,5 +9,7 @@ function f(arguments) {
 
     var a = () => () => arguments;
 >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments11_ES6.ts, 3, 7))
+>() => () => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments11_ES6.ts, 3, 11))
+>() => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments11_ES6.ts, 3, 17))
 >arguments : Symbol(arguments)
 }
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.symbols
index b46d8ab1a63e9..c78ff46979b6a 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.symbols
@@ -8,6 +8,8 @@ function f() {
 
     var a = (arguments) => () => _arguments;
 >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments13.ts, 3, 7))
+>(arguments) => () => _arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments13.ts, 3, 11))
 >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments13.ts, 3, 13))
+>() => _arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments13.ts, 3, 26))
 >_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments13.ts, 2, 7))
 }
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.symbols
index 5c4ec4cb687f8..0b2e7f14c18ca 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.symbols
@@ -8,6 +8,8 @@ function f() {
 
     var a = (arguments) => () => _arguments;
 >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments13_ES6.ts, 3, 7))
+>(arguments) => () => _arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments13_ES6.ts, 3, 11))
 >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments13_ES6.ts, 3, 13))
+>() => _arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments13_ES6.ts, 3, 26))
 >_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments13_ES6.ts, 2, 7))
 }
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols
index ad1482e7f1afd..b18d2bc2c7fa8 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols
@@ -12,6 +12,7 @@ function f() {
 >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments14_ES6.ts, 3, 11))
 
         return () => arguments;
+>() => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments14_ES6.ts, 4, 14))
 >arguments : Symbol(arguments)
     }
 }
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols
index 42db5aeaa859f..9f6c1f9aa3585 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols
@@ -15,6 +15,7 @@ function f() {
 >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments15_ES6.ts, 4, 13))
 
         return () => arguments;
+>() => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments15_ES6.ts, 5, 14))
 >arguments : Symbol(arguments)
     }
 }
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols
index 453e04d752136..41780bc189a90 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols
@@ -12,6 +12,7 @@ function f() {
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 
         return () => arguments[0];
+>() => arguments[0] : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments16_ES6.ts, 4, 14))
 >arguments : Symbol(arguments)
     }
     var arguments = "world";
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols
index b686dd1959243..59a681219826b 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols
@@ -5,6 +5,7 @@ function f() {
 
     var { arguments } = { arguments: "hello" };
 >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 2, 9), Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 6, 7))
+>{ arguments: "hello" } : Symbol(, Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 2, 23))
 >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 2, 25))
 
     if (Math.random()) {
@@ -13,6 +14,7 @@ function f() {
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 
         return () => arguments[0];
+>() => arguments[0] : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 4, 14))
 >arguments : Symbol(arguments)
     }
     var arguments = "world";
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols
index 4ac60f9b429d5..26262cc6bed9d 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols
@@ -5,6 +5,7 @@ function f() {
 
     var { arguments: args } = { arguments };
 >args : Symbol(args, Decl(emitArrowFunctionWhenUsingArguments18_ES6.ts, 2, 9))
+>{ arguments } : Symbol(, Decl(emitArrowFunctionWhenUsingArguments18_ES6.ts, 2, 29))
 >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments18_ES6.ts, 2, 31))
 
     if (Math.random()) {
@@ -13,6 +14,7 @@ function f() {
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 
         return () => arguments;
+>() => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments18_ES6.ts, 4, 14))
 >arguments : Symbol(arguments)
     }
 }
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.symbols
index 9e6392daaf18e..82c1392249840 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.symbols
@@ -14,6 +14,7 @@ function f() {
 
             var capture = () => arguments;  // Should trigger an '_arguments' capture into function 'h'
 >capture : Symbol(capture, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 5, 15))
+>() => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 5, 25))
 >arguments : Symbol(arguments)
 
             foo(_arguments);                // Error as this does not resolve to the user defined '_arguments'
diff --git a/tests/baselines/reference/emitArrowFunctionsAsIs.symbols b/tests/baselines/reference/emitArrowFunctionsAsIs.symbols
index 73c68bd194d6f..ec1fa132a5cb7 100644
--- a/tests/baselines/reference/emitArrowFunctionsAsIs.symbols
+++ b/tests/baselines/reference/emitArrowFunctionsAsIs.symbols
@@ -1,14 +1,17 @@
 === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionsAsIs.ts ===
 var arrow1 = a => { };
 >arrow1 : Symbol(arrow1, Decl(emitArrowFunctionsAsIs.ts, 0, 3))
+>a => { } : Symbol((Anonymous function), Decl(emitArrowFunctionsAsIs.ts, 0, 12))
 >a : Symbol(a, Decl(emitArrowFunctionsAsIs.ts, 0, 12))
 
 var arrow2 = (a) => { };
 >arrow2 : Symbol(arrow2, Decl(emitArrowFunctionsAsIs.ts, 1, 3))
+>(a) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionsAsIs.ts, 1, 12))
 >a : Symbol(a, Decl(emitArrowFunctionsAsIs.ts, 1, 14))
 
 var arrow3 = (a, b) => { };
 >arrow3 : Symbol(arrow3, Decl(emitArrowFunctionsAsIs.ts, 3, 3))
+>(a, b) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionsAsIs.ts, 3, 12))
 >a : Symbol(a, Decl(emitArrowFunctionsAsIs.ts, 3, 14))
 >b : Symbol(b, Decl(emitArrowFunctionsAsIs.ts, 3, 16))
 
diff --git a/tests/baselines/reference/emitArrowFunctionsAsIsES6.symbols b/tests/baselines/reference/emitArrowFunctionsAsIsES6.symbols
index 73f4df744e86b..86e3e3a96d4ec 100644
--- a/tests/baselines/reference/emitArrowFunctionsAsIsES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionsAsIsES6.symbols
@@ -1,14 +1,17 @@
 === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionsAsIsES6.ts ===
 var arrow1 =  a => { };
 >arrow1 : Symbol(arrow1, Decl(emitArrowFunctionsAsIsES6.ts, 0, 3))
+>a => { } : Symbol((Anonymous function), Decl(emitArrowFunctionsAsIsES6.ts, 0, 12))
 >a : Symbol(a, Decl(emitArrowFunctionsAsIsES6.ts, 0, 12))
 
 var arrow2 = (a) => { };
 >arrow2 : Symbol(arrow2, Decl(emitArrowFunctionsAsIsES6.ts, 1, 3))
+>(a) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionsAsIsES6.ts, 1, 12))
 >a : Symbol(a, Decl(emitArrowFunctionsAsIsES6.ts, 1, 14))
 
 var arrow3 = (a, b) => { };
 >arrow3 : Symbol(arrow3, Decl(emitArrowFunctionsAsIsES6.ts, 3, 3))
+>(a, b) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionsAsIsES6.ts, 3, 12))
 >a : Symbol(a, Decl(emitArrowFunctionsAsIsES6.ts, 3, 14))
 >b : Symbol(b, Decl(emitArrowFunctionsAsIsES6.ts, 3, 16))
 
diff --git a/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.symbols b/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.symbols
index 13ce54e0641be..fa83f38432339 100644
--- a/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.symbols
+++ b/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.symbols
@@ -17,6 +17,7 @@ class Foo extends Parent {
 
         var x = () => super.foo();
 >x : Symbol(x, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 8, 11))
+>() => super.foo() : Symbol((Anonymous function), Decl(emitClassDeclarationWithSuperMethodCall01.ts, 8, 15))
 >super.foo : Symbol(Parent.foo, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 1, 14))
 >super : Symbol(Parent, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 0, 0))
 >foo : Symbol(Parent.foo, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 1, 14))
diff --git a/tests/baselines/reference/emitDefaultParametersFunctionExpression.symbols b/tests/baselines/reference/emitDefaultParametersFunctionExpression.symbols
index 59c9c2207878e..d040321f7f3a8 100644
--- a/tests/baselines/reference/emitDefaultParametersFunctionExpression.symbols
+++ b/tests/baselines/reference/emitDefaultParametersFunctionExpression.symbols
@@ -1,37 +1,44 @@
 === tests/cases/conformance/es6/defaultParameters/emitDefaultParametersFunctionExpression.ts ===
 var lambda1 = (y = "hello") => { }
 >lambda1 : Symbol(lambda1, Decl(emitDefaultParametersFunctionExpression.ts, 0, 3))
+>(y = "hello") => { } : Symbol((Anonymous function), Decl(emitDefaultParametersFunctionExpression.ts, 0, 13))
 >y : Symbol(y, Decl(emitDefaultParametersFunctionExpression.ts, 0, 15))
 
 var lambda2 = (x: number, y = "hello") => { }
 >lambda2 : Symbol(lambda2, Decl(emitDefaultParametersFunctionExpression.ts, 1, 3))
+>(x: number, y = "hello") => { } : Symbol((Anonymous function), Decl(emitDefaultParametersFunctionExpression.ts, 1, 13))
 >x : Symbol(x, Decl(emitDefaultParametersFunctionExpression.ts, 1, 15))
 >y : Symbol(y, Decl(emitDefaultParametersFunctionExpression.ts, 1, 25))
 
 var lambda3 = (x: number, y = "hello", ...rest) => { }
 >lambda3 : Symbol(lambda3, Decl(emitDefaultParametersFunctionExpression.ts, 2, 3))
+>(x: number, y = "hello", ...rest) => { } : Symbol((Anonymous function), Decl(emitDefaultParametersFunctionExpression.ts, 2, 13))
 >x : Symbol(x, Decl(emitDefaultParametersFunctionExpression.ts, 2, 15))
 >y : Symbol(y, Decl(emitDefaultParametersFunctionExpression.ts, 2, 25))
 >rest : Symbol(rest, Decl(emitDefaultParametersFunctionExpression.ts, 2, 38))
 
 var lambda4 = (y = "hello", ...rest) => { }
 >lambda4 : Symbol(lambda4, Decl(emitDefaultParametersFunctionExpression.ts, 3, 3))
+>(y = "hello", ...rest) => { } : Symbol((Anonymous function), Decl(emitDefaultParametersFunctionExpression.ts, 3, 13))
 >y : Symbol(y, Decl(emitDefaultParametersFunctionExpression.ts, 3, 15))
 >rest : Symbol(rest, Decl(emitDefaultParametersFunctionExpression.ts, 3, 27))
 
 var x = function (str = "hello", ...rest) { }
 >x : Symbol(x, Decl(emitDefaultParametersFunctionExpression.ts, 5, 3))
+>function (str = "hello", ...rest) { } : Symbol((Anonymous function), Decl(emitDefaultParametersFunctionExpression.ts, 5, 7))
 >str : Symbol(str, Decl(emitDefaultParametersFunctionExpression.ts, 5, 18))
 >rest : Symbol(rest, Decl(emitDefaultParametersFunctionExpression.ts, 5, 32))
 
 var y = (function (num = 10, boo = false, ...rest) { })()
 >y : Symbol(y, Decl(emitDefaultParametersFunctionExpression.ts, 6, 3))
+>function (num = 10, boo = false, ...rest) { } : Symbol((Anonymous function), Decl(emitDefaultParametersFunctionExpression.ts, 6, 9))
 >num : Symbol(num, Decl(emitDefaultParametersFunctionExpression.ts, 6, 19))
 >boo : Symbol(boo, Decl(emitDefaultParametersFunctionExpression.ts, 6, 28))
 >rest : Symbol(rest, Decl(emitDefaultParametersFunctionExpression.ts, 6, 41))
 
 var z = (function (num: number, boo = false, ...rest) { })(10)
 >z : Symbol(z, Decl(emitDefaultParametersFunctionExpression.ts, 7, 3))
+>function (num: number, boo = false, ...rest) { } : Symbol((Anonymous function), Decl(emitDefaultParametersFunctionExpression.ts, 7, 9))
 >num : Symbol(num, Decl(emitDefaultParametersFunctionExpression.ts, 7, 19))
 >boo : Symbol(boo, Decl(emitDefaultParametersFunctionExpression.ts, 7, 31))
 >rest : Symbol(rest, Decl(emitDefaultParametersFunctionExpression.ts, 7, 44))
diff --git a/tests/baselines/reference/emitDefaultParametersFunctionExpressionES6.symbols b/tests/baselines/reference/emitDefaultParametersFunctionExpressionES6.symbols
index 36eef9b9a1d06..6e1bc97f420d3 100644
--- a/tests/baselines/reference/emitDefaultParametersFunctionExpressionES6.symbols
+++ b/tests/baselines/reference/emitDefaultParametersFunctionExpressionES6.symbols
@@ -1,37 +1,44 @@
 === tests/cases/conformance/es6/defaultParameters/emitDefaultParametersFunctionExpressionES6.ts ===
 var lambda1 = (y = "hello") => { }
 >lambda1 : Symbol(lambda1, Decl(emitDefaultParametersFunctionExpressionES6.ts, 0, 3))
+>(y = "hello") => { } : Symbol((Anonymous function), Decl(emitDefaultParametersFunctionExpressionES6.ts, 0, 13))
 >y : Symbol(y, Decl(emitDefaultParametersFunctionExpressionES6.ts, 0, 15))
 
 var lambda2 = (x: number, y = "hello") => { }
 >lambda2 : Symbol(lambda2, Decl(emitDefaultParametersFunctionExpressionES6.ts, 1, 3))
+>(x: number, y = "hello") => { } : Symbol((Anonymous function), Decl(emitDefaultParametersFunctionExpressionES6.ts, 1, 13))
 >x : Symbol(x, Decl(emitDefaultParametersFunctionExpressionES6.ts, 1, 15))
 >y : Symbol(y, Decl(emitDefaultParametersFunctionExpressionES6.ts, 1, 25))
 
 var lambda3 = (x: number, y = "hello", ...rest) => { }
 >lambda3 : Symbol(lambda3, Decl(emitDefaultParametersFunctionExpressionES6.ts, 2, 3))
+>(x: number, y = "hello", ...rest) => { } : Symbol((Anonymous function), Decl(emitDefaultParametersFunctionExpressionES6.ts, 2, 13))
 >x : Symbol(x, Decl(emitDefaultParametersFunctionExpressionES6.ts, 2, 15))
 >y : Symbol(y, Decl(emitDefaultParametersFunctionExpressionES6.ts, 2, 25))
 >rest : Symbol(rest, Decl(emitDefaultParametersFunctionExpressionES6.ts, 2, 38))
 
 var lambda4 = (y = "hello", ...rest) => { }
 >lambda4 : Symbol(lambda4, Decl(emitDefaultParametersFunctionExpressionES6.ts, 3, 3))
+>(y = "hello", ...rest) => { } : Symbol((Anonymous function), Decl(emitDefaultParametersFunctionExpressionES6.ts, 3, 13))
 >y : Symbol(y, Decl(emitDefaultParametersFunctionExpressionES6.ts, 3, 15))
 >rest : Symbol(rest, Decl(emitDefaultParametersFunctionExpressionES6.ts, 3, 27))
 
 var x = function (str = "hello", ...rest) { }
 >x : Symbol(x, Decl(emitDefaultParametersFunctionExpressionES6.ts, 5, 3))
+>function (str = "hello", ...rest) { } : Symbol((Anonymous function), Decl(emitDefaultParametersFunctionExpressionES6.ts, 5, 7))
 >str : Symbol(str, Decl(emitDefaultParametersFunctionExpressionES6.ts, 5, 18))
 >rest : Symbol(rest, Decl(emitDefaultParametersFunctionExpressionES6.ts, 5, 32))
 
 var y = (function (num = 10, boo = false, ...rest) { })()
 >y : Symbol(y, Decl(emitDefaultParametersFunctionExpressionES6.ts, 6, 3))
+>function (num = 10, boo = false, ...rest) { } : Symbol((Anonymous function), Decl(emitDefaultParametersFunctionExpressionES6.ts, 6, 9))
 >num : Symbol(num, Decl(emitDefaultParametersFunctionExpressionES6.ts, 6, 19))
 >boo : Symbol(boo, Decl(emitDefaultParametersFunctionExpressionES6.ts, 6, 28))
 >rest : Symbol(rest, Decl(emitDefaultParametersFunctionExpressionES6.ts, 6, 41))
 
 var z = (function (num: number, boo = false, ...rest) { })(10)
 >z : Symbol(z, Decl(emitDefaultParametersFunctionExpressionES6.ts, 7, 3))
+>function (num: number, boo = false, ...rest) { } : Symbol((Anonymous function), Decl(emitDefaultParametersFunctionExpressionES6.ts, 7, 9))
 >num : Symbol(num, Decl(emitDefaultParametersFunctionExpressionES6.ts, 7, 19))
 >boo : Symbol(boo, Decl(emitDefaultParametersFunctionExpressionES6.ts, 7, 31))
 >rest : Symbol(rest, Decl(emitDefaultParametersFunctionExpressionES6.ts, 7, 44))
diff --git a/tests/baselines/reference/emitDefaultParametersFunctionProperty.symbols b/tests/baselines/reference/emitDefaultParametersFunctionProperty.symbols
index f377e8bd69631..7423c3f4d50d4 100644
--- a/tests/baselines/reference/emitDefaultParametersFunctionProperty.symbols
+++ b/tests/baselines/reference/emitDefaultParametersFunctionProperty.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/defaultParameters/emitDefaultParametersFunctionProperty.ts ===
 var obj2 = {
 >obj2 : Symbol(obj2, Decl(emitDefaultParametersFunctionProperty.ts, 0, 3))
+>{    func1(y = 10, ...rest) { },    func2(x = "hello") { },    func3(x: string, z: number, y = "hello") { },    func4(x: string, z: number, y = "hello", ...rest) { },} : Symbol(, Decl(emitDefaultParametersFunctionProperty.ts, 0, 10))
 
     func1(y = 10, ...rest) { },
 >func1 : Symbol(func1, Decl(emitDefaultParametersFunctionProperty.ts, 0, 12))
diff --git a/tests/baselines/reference/emitDefaultParametersFunctionPropertyES6.symbols b/tests/baselines/reference/emitDefaultParametersFunctionPropertyES6.symbols
index 88bad28bbf89a..621cb0b702bbf 100644
--- a/tests/baselines/reference/emitDefaultParametersFunctionPropertyES6.symbols
+++ b/tests/baselines/reference/emitDefaultParametersFunctionPropertyES6.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/defaultParameters/emitDefaultParametersFunctionPropertyES6.ts ===
 var obj2 = {
 >obj2 : Symbol(obj2, Decl(emitDefaultParametersFunctionPropertyES6.ts, 0, 3))
+>{    func1(y = 10, ...rest) { },    func2(x = "hello") { },    func3(x: string, z: number, y = "hello") { },    func4(x: string, z: number, y = "hello", ...rest) { },} : Symbol(, Decl(emitDefaultParametersFunctionPropertyES6.ts, 0, 10))
 
     func1(y = 10, ...rest) { },
 >func1 : Symbol(func1, Decl(emitDefaultParametersFunctionPropertyES6.ts, 0, 12))
diff --git a/tests/baselines/reference/emitRestParametersFunctionExpression.symbols b/tests/baselines/reference/emitRestParametersFunctionExpression.symbols
index 8a42e7b5296e0..1b5a34d7b9d7d 100644
--- a/tests/baselines/reference/emitRestParametersFunctionExpression.symbols
+++ b/tests/baselines/reference/emitRestParametersFunctionExpression.symbols
@@ -1,18 +1,22 @@
 === tests/cases/conformance/es6/restParameters/emitRestParametersFunctionExpression.ts ===
 var funcExp = (...rest) => { }
 >funcExp : Symbol(funcExp, Decl(emitRestParametersFunctionExpression.ts, 0, 3))
+>(...rest) => { } : Symbol((Anonymous function), Decl(emitRestParametersFunctionExpression.ts, 0, 13))
 >rest : Symbol(rest, Decl(emitRestParametersFunctionExpression.ts, 0, 15))
 
 var funcExp1 = (X: number, ...rest) => { }
 >funcExp1 : Symbol(funcExp1, Decl(emitRestParametersFunctionExpression.ts, 1, 3))
+>(X: number, ...rest) => { } : Symbol((Anonymous function), Decl(emitRestParametersFunctionExpression.ts, 1, 14))
 >X : Symbol(X, Decl(emitRestParametersFunctionExpression.ts, 1, 16))
 >rest : Symbol(rest, Decl(emitRestParametersFunctionExpression.ts, 1, 26))
 
 var funcExp2 = function (...rest) { }
 >funcExp2 : Symbol(funcExp2, Decl(emitRestParametersFunctionExpression.ts, 2, 3))
+>function (...rest) { } : Symbol((Anonymous function), Decl(emitRestParametersFunctionExpression.ts, 2, 14))
 >rest : Symbol(rest, Decl(emitRestParametersFunctionExpression.ts, 2, 25))
 
 var funcExp3 = (function (...rest) { })()
 >funcExp3 : Symbol(funcExp3, Decl(emitRestParametersFunctionExpression.ts, 3, 3))
+>function (...rest) { } : Symbol((Anonymous function), Decl(emitRestParametersFunctionExpression.ts, 3, 16))
 >rest : Symbol(rest, Decl(emitRestParametersFunctionExpression.ts, 3, 26))
 
diff --git a/tests/baselines/reference/emitRestParametersFunctionExpressionES6.symbols b/tests/baselines/reference/emitRestParametersFunctionExpressionES6.symbols
index cf39ed21a8820..e9dbcd0f2d35b 100644
--- a/tests/baselines/reference/emitRestParametersFunctionExpressionES6.symbols
+++ b/tests/baselines/reference/emitRestParametersFunctionExpressionES6.symbols
@@ -1,18 +1,22 @@
 === tests/cases/conformance/es6/restParameters/emitRestParametersFunctionExpressionES6.ts ===
 var funcExp = (...rest) => { }
 >funcExp : Symbol(funcExp, Decl(emitRestParametersFunctionExpressionES6.ts, 0, 3))
+>(...rest) => { } : Symbol((Anonymous function), Decl(emitRestParametersFunctionExpressionES6.ts, 0, 13))
 >rest : Symbol(rest, Decl(emitRestParametersFunctionExpressionES6.ts, 0, 15))
 
 var funcExp1 = (X: number, ...rest) => { }
 >funcExp1 : Symbol(funcExp1, Decl(emitRestParametersFunctionExpressionES6.ts, 1, 3))
+>(X: number, ...rest) => { } : Symbol((Anonymous function), Decl(emitRestParametersFunctionExpressionES6.ts, 1, 14))
 >X : Symbol(X, Decl(emitRestParametersFunctionExpressionES6.ts, 1, 16))
 >rest : Symbol(rest, Decl(emitRestParametersFunctionExpressionES6.ts, 1, 26))
 
 var funcExp2 = function (...rest) { }
 >funcExp2 : Symbol(funcExp2, Decl(emitRestParametersFunctionExpressionES6.ts, 2, 3))
+>function (...rest) { } : Symbol((Anonymous function), Decl(emitRestParametersFunctionExpressionES6.ts, 2, 14))
 >rest : Symbol(rest, Decl(emitRestParametersFunctionExpressionES6.ts, 2, 25))
 
 var funcExp3 = (function (...rest) { })()
 >funcExp3 : Symbol(funcExp3, Decl(emitRestParametersFunctionExpressionES6.ts, 3, 3))
+>function (...rest) { } : Symbol((Anonymous function), Decl(emitRestParametersFunctionExpressionES6.ts, 3, 16))
 >rest : Symbol(rest, Decl(emitRestParametersFunctionExpressionES6.ts, 3, 26))
 
diff --git a/tests/baselines/reference/emitRestParametersFunctionProperty.symbols b/tests/baselines/reference/emitRestParametersFunctionProperty.symbols
index 2a0505831b9f3..5fbaf746c809f 100644
--- a/tests/baselines/reference/emitRestParametersFunctionProperty.symbols
+++ b/tests/baselines/reference/emitRestParametersFunctionProperty.symbols
@@ -9,6 +9,7 @@ var obj: {
 
 var obj2 = {
 >obj2 : Symbol(obj2, Decl(emitRestParametersFunctionProperty.ts, 4, 3))
+>{    func(...rest) { }} : Symbol(, Decl(emitRestParametersFunctionProperty.ts, 4, 10))
 
     func(...rest) { }
 >func : Symbol(func, Decl(emitRestParametersFunctionProperty.ts, 4, 12))
diff --git a/tests/baselines/reference/emitRestParametersFunctionPropertyES6.symbols b/tests/baselines/reference/emitRestParametersFunctionPropertyES6.symbols
index a6b00757eec93..a24165f70bc42 100644
--- a/tests/baselines/reference/emitRestParametersFunctionPropertyES6.symbols
+++ b/tests/baselines/reference/emitRestParametersFunctionPropertyES6.symbols
@@ -9,6 +9,7 @@ var obj: {
 
 var obj2 = {
 >obj2 : Symbol(obj2, Decl(emitRestParametersFunctionPropertyES6.ts, 4, 3))
+>{    func(...rest) { }} : Symbol(, Decl(emitRestParametersFunctionPropertyES6.ts, 4, 10))
 
     func(...rest) { }
 >func : Symbol(func, Decl(emitRestParametersFunctionPropertyES6.ts, 4, 12))
diff --git a/tests/baselines/reference/emptyExpr.symbols b/tests/baselines/reference/emptyExpr.symbols
index e699404332f09..7f48b4c1eeb0d 100644
--- a/tests/baselines/reference/emptyExpr.symbols
+++ b/tests/baselines/reference/emptyExpr.symbols
@@ -1,3 +1,4 @@
 === tests/cases/compiler/emptyExpr.ts ===
 [{},]
-No type information for this code.
\ No newline at end of file
+>{} : Symbol(, Decl(emptyExpr.ts, 0, 1))
+
diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter04.symbols b/tests/baselines/reference/emptyObjectBindingPatternParameter04.symbols
index 9922d4cd074d8..641d6338c5138 100644
--- a/tests/baselines/reference/emptyObjectBindingPatternParameter04.symbols
+++ b/tests/baselines/reference/emptyObjectBindingPatternParameter04.symbols
@@ -3,6 +3,7 @@
 
 function f({} = {a: 1, b: "2", c: true}) {
 >f : Symbol(f, Decl(emptyObjectBindingPatternParameter04.ts, 0, 0))
+>{a: 1, b: "2", c: true} : Symbol(, Decl(emptyObjectBindingPatternParameter04.ts, 2, 15))
 >a : Symbol(a, Decl(emptyObjectBindingPatternParameter04.ts, 2, 17))
 >b : Symbol(b, Decl(emptyObjectBindingPatternParameter04.ts, 2, 22))
 >c : Symbol(c, Decl(emptyObjectBindingPatternParameter04.ts, 2, 30))
diff --git a/tests/baselines/reference/enumIndexer.symbols b/tests/baselines/reference/enumIndexer.symbols
index 3f65044c2ec55..6a595a4133f37 100644
--- a/tests/baselines/reference/enumIndexer.symbols
+++ b/tests/baselines/reference/enumIndexer.symbols
@@ -8,7 +8,9 @@ enum MyEnumType {
 }
 var _arr = [{ key: 'foo' }, { key: 'bar' }]
 >_arr : Symbol(_arr, Decl(enumIndexer.ts, 3, 3))
+>{ key: 'foo' } : Symbol(, Decl(enumIndexer.ts, 3, 12))
 >key : Symbol(key, Decl(enumIndexer.ts, 3, 13))
+>{ key: 'bar' } : Symbol(, Decl(enumIndexer.ts, 3, 27))
 >key : Symbol(key, Decl(enumIndexer.ts, 3, 29))
 
 var enumValue = MyEnumType.foo;
@@ -22,6 +24,7 @@ var x = _arr.map(o => MyEnumType[o.key] === enumValue); // these are not same ty
 >_arr.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
 >_arr : Symbol(_arr, Decl(enumIndexer.ts, 3, 3))
 >map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>o => MyEnumType[o.key] === enumValue : Symbol((Anonymous function), Decl(enumIndexer.ts, 5, 17))
 >o : Symbol(o, Decl(enumIndexer.ts, 5, 17))
 >MyEnumType : Symbol(MyEnumType, Decl(enumIndexer.ts, 0, 0))
 >o.key : Symbol(key, Decl(enumIndexer.ts, 3, 13))
diff --git a/tests/baselines/reference/es6ClassTest5.symbols b/tests/baselines/reference/es6ClassTest5.symbols
index 89c6921e1635d..1a0b30521fe43 100644
--- a/tests/baselines/reference/es6ClassTest5.symbols
+++ b/tests/baselines/reference/es6ClassTest5.symbols
@@ -8,6 +8,7 @@ class C1T5 {
 >s : Symbol(s, Decl(es6ClassTest5.ts, 1, 20))
 
 	   	(i) => {
+>(i) => {	        return i;	    } : Symbol((Anonymous function), Decl(es6ClassTest5.ts, 1, 43))
 >i : Symbol(i, Decl(es6ClassTest5.ts, 2, 6))
 
 	        return i;
diff --git a/tests/baselines/reference/es6ClassTest8.symbols b/tests/baselines/reference/es6ClassTest8.symbols
index b02b80e7017ec..e6735a03d8528 100644
--- a/tests/baselines/reference/es6ClassTest8.symbols
+++ b/tests/baselines/reference/es6ClassTest8.symbols
@@ -10,6 +10,7 @@ class C {
     constructor() {
         var bar:any = (function() {
 >bar : Symbol(bar, Decl(es6ClassTest8.ts, 4, 11))
+>function() {            return bar; // 'bar' should be resolvable        } : Symbol((Anonymous function), Decl(es6ClassTest8.ts, 4, 23))
 
             return bar; // 'bar' should be resolvable
 >bar : Symbol(bar, Decl(es6ClassTest8.ts, 4, 11))
diff --git a/tests/baselines/reference/escapedIdentifiers.symbols b/tests/baselines/reference/escapedIdentifiers.symbols
index 6c84b25647f6a..01207a584a7d0 100644
--- a/tests/baselines/reference/escapedIdentifiers.symbols
+++ b/tests/baselines/reference/escapedIdentifiers.symbols
@@ -131,6 +131,7 @@ interface interfaceType\u0032 {
 var interfaceType1Object1 = <interfaceType1>{ bar1: 0 };
 >interfaceType1Object1 : Symbol(interfaceType1Object1, Decl(escapedIdentifiers.ts, 59, 3))
 >interfaceType1 : Symbol(interfaceType1, Decl(escapedIdentifiers.ts, 49, 27))
+>{ bar1: 0 } : Symbol(, Decl(escapedIdentifiers.ts, 59, 44))
 >bar1 : Symbol(bar1, Decl(escapedIdentifiers.ts, 59, 45))
 
 interfaceType1Object1.bar1 = 2;
@@ -141,6 +142,7 @@ interfaceType1Object1.bar1 = 2;
 var interfaceType1Object2 = <interfaceType\u0031>{ bar1: 0 };
 >interfaceType1Object2 : Symbol(interfaceType1Object2, Decl(escapedIdentifiers.ts, 61, 3))
 >interfaceType\u0031 : Symbol(interfaceType1, Decl(escapedIdentifiers.ts, 49, 27))
+>{ bar1: 0 } : Symbol(, Decl(escapedIdentifiers.ts, 61, 49))
 >bar1 : Symbol(bar1, Decl(escapedIdentifiers.ts, 61, 50))
 
 interfaceType1Object2.bar1 = 2;
@@ -151,6 +153,7 @@ interfaceType1Object2.bar1 = 2;
 var interfaceType2Object1 = <interfaceType2>{ bar2: 0 };
 >interfaceType2Object1 : Symbol(interfaceType2Object1, Decl(escapedIdentifiers.ts, 63, 3))
 >interfaceType2 : Symbol(interfaceType\u0032, Decl(escapedIdentifiers.ts, 54, 1))
+>{ bar2: 0 } : Symbol(, Decl(escapedIdentifiers.ts, 63, 44))
 >bar2 : Symbol(bar2, Decl(escapedIdentifiers.ts, 63, 45))
 
 interfaceType2Object1.bar2 = 2;
@@ -161,6 +164,7 @@ interfaceType2Object1.bar2 = 2;
 var interfaceType2Object2 = <interfaceType\u0032>{ bar2: 0 };
 >interfaceType2Object2 : Symbol(interfaceType2Object2, Decl(escapedIdentifiers.ts, 65, 3))
 >interfaceType\u0032 : Symbol(interfaceType\u0032, Decl(escapedIdentifiers.ts, 54, 1))
+>{ bar2: 0 } : Symbol(, Decl(escapedIdentifiers.ts, 65, 49))
 >bar2 : Symbol(bar2, Decl(escapedIdentifiers.ts, 65, 50))
 
 interfaceType2Object2.bar2 = 2;
diff --git a/tests/baselines/reference/escapedReservedCompilerNamedIdentifier.symbols b/tests/baselines/reference/escapedReservedCompilerNamedIdentifier.symbols
index b629c5bd8750c..6b4816d2e1adc 100644
--- a/tests/baselines/reference/escapedReservedCompilerNamedIdentifier.symbols
+++ b/tests/baselines/reference/escapedReservedCompilerNamedIdentifier.symbols
@@ -5,6 +5,7 @@ var __proto__ = 10;
 
 var o = {
 >o : Symbol(o, Decl(escapedReservedCompilerNamedIdentifier.ts, 2, 3))
+>{    "__proto__": 0} : Symbol(, Decl(escapedReservedCompilerNamedIdentifier.ts, 2, 7))
 
     "__proto__": 0
 };
@@ -15,6 +16,7 @@ var b = o["__proto__"];
 
 var o1 = {
 >o1 : Symbol(o1, Decl(escapedReservedCompilerNamedIdentifier.ts, 6, 3))
+>{    __proto__: 0} : Symbol(, Decl(escapedReservedCompilerNamedIdentifier.ts, 6, 8))
 
     __proto__: 0
 >__proto__ : Symbol(__proto__, Decl(escapedReservedCompilerNamedIdentifier.ts, 6, 10))
@@ -31,6 +33,7 @@ var ___proto__ = 10;
 
 var o2 = {
 >o2 : Symbol(o2, Decl(escapedReservedCompilerNamedIdentifier.ts, 12, 3))
+>{    "___proto__": 0} : Symbol(, Decl(escapedReservedCompilerNamedIdentifier.ts, 12, 8))
 
     "___proto__": 0
 };
@@ -41,6 +44,7 @@ var b2 = o2["___proto__"];
 
 var o3 = {
 >o3 : Symbol(o3, Decl(escapedReservedCompilerNamedIdentifier.ts, 16, 3))
+>{    ___proto__: 0} : Symbol(, Decl(escapedReservedCompilerNamedIdentifier.ts, 16, 8))
 
     ___proto__: 0
 >___proto__ : Symbol(___proto__, Decl(escapedReservedCompilerNamedIdentifier.ts, 16, 10))
@@ -57,6 +61,7 @@ var _proto__ = 10;
 
 var o4 = {
 >o4 : Symbol(o4, Decl(escapedReservedCompilerNamedIdentifier.ts, 22, 3))
+>{    "_proto__": 0} : Symbol(, Decl(escapedReservedCompilerNamedIdentifier.ts, 22, 8))
 
     "_proto__": 0
 };
@@ -67,6 +72,7 @@ var b4 = o4["_proto__"];
 
 var o5 = {
 >o5 : Symbol(o5, Decl(escapedReservedCompilerNamedIdentifier.ts, 26, 3))
+>{    _proto__: 0} : Symbol(, Decl(escapedReservedCompilerNamedIdentifier.ts, 26, 8))
 
     _proto__: 0
 >_proto__ : Symbol(_proto__, Decl(escapedReservedCompilerNamedIdentifier.ts, 26, 10))
diff --git a/tests/baselines/reference/everyTypeWithAnnotationAndInitializer.symbols b/tests/baselines/reference/everyTypeWithAnnotationAndInitializer.symbols
index 489903750f5b3..1d795b1c12da3 100644
--- a/tests/baselines/reference/everyTypeWithAnnotationAndInitializer.symbols
+++ b/tests/baselines/reference/everyTypeWithAnnotationAndInitializer.symbols
@@ -101,6 +101,7 @@ var aGenericClass: D<string> = new D<string>();
 var anObjectLiteral: I = { id: 12 };
 >anObjectLiteral : Symbol(anObjectLiteral, Decl(everyTypeWithAnnotationAndInitializer.ts, 36, 3))
 >I : Symbol(I, Decl(everyTypeWithAnnotationAndInitializer.ts, 0, 0))
+>{ id: 12 } : Symbol(, Decl(everyTypeWithAnnotationAndInitializer.ts, 36, 24))
 >id : Symbol(id, Decl(everyTypeWithAnnotationAndInitializer.ts, 36, 26))
 
 var anOtherObjectLiteral: { id: number } = new C();
@@ -121,6 +122,7 @@ var anOtherFunction: (x: string) => number = F;
 var aLambda: typeof F = (x) => 2;
 >aLambda : Symbol(aLambda, Decl(everyTypeWithAnnotationAndInitializer.ts, 41, 3))
 >F : Symbol(F, Decl(everyTypeWithAnnotationAndInitializer.ts, 12, 1))
+>(x) => 2 : Symbol((Anonymous function), Decl(everyTypeWithAnnotationAndInitializer.ts, 41, 23))
 >x : Symbol(x, Decl(everyTypeWithAnnotationAndInitializer.ts, 41, 25))
 
 var aModule: typeof M = M;
@@ -141,6 +143,7 @@ var aFunctionInModule: typeof M.F2 = (x) => 'this is a string';
 >M.F2 : Symbol(M.F2, Decl(everyTypeWithAnnotationAndInitializer.ts, 19, 5))
 >M : Symbol(M, Decl(everyTypeWithAnnotationAndInitializer.ts, 14, 44))
 >F2 : Symbol(M.F2, Decl(everyTypeWithAnnotationAndInitializer.ts, 19, 5))
+>(x) => 'this is a string' : Symbol((Anonymous function), Decl(everyTypeWithAnnotationAndInitializer.ts, 45, 36))
 >x : Symbol(x, Decl(everyTypeWithAnnotationAndInitializer.ts, 45, 38))
 
 
diff --git a/tests/baselines/reference/everyTypeWithInitializer.symbols b/tests/baselines/reference/everyTypeWithInitializer.symbols
index 0a22252164ba5..d92e7ef6bc34f 100644
--- a/tests/baselines/reference/everyTypeWithInitializer.symbols
+++ b/tests/baselines/reference/everyTypeWithInitializer.symbols
@@ -92,6 +92,7 @@ var aGenericClass = new D<string>();
 
 var anObjectLiteral = { id: 12 };
 >anObjectLiteral : Symbol(anObjectLiteral, Decl(everyTypeWithInitializer.ts, 36, 3))
+>{ id: 12 } : Symbol(, Decl(everyTypeWithInitializer.ts, 36, 21))
 >id : Symbol(id, Decl(everyTypeWithInitializer.ts, 36, 23))
 
 var aFunction = F;
@@ -100,6 +101,7 @@ var aFunction = F;
 
 var aLambda = (x) => 2;
 >aLambda : Symbol(aLambda, Decl(everyTypeWithInitializer.ts, 39, 3))
+>(x) => 2 : Symbol((Anonymous function), Decl(everyTypeWithInitializer.ts, 39, 13))
 >x : Symbol(x, Decl(everyTypeWithInitializer.ts, 39, 15))
 
 var aModule = M;
diff --git a/tests/baselines/reference/exportAssignmentMergedInterface.symbols b/tests/baselines/reference/exportAssignmentMergedInterface.symbols
index a199ed4e6c510..e25a52c7b8df9 100644
--- a/tests/baselines/reference/exportAssignmentMergedInterface.symbols
+++ b/tests/baselines/reference/exportAssignmentMergedInterface.symbols
@@ -25,6 +25,7 @@ if(!!x.c){ }
 
 var z = {x: 1, y: 2};
 >z : Symbol(z, Decl(foo_1.ts, 6, 3))
+>{x: 1, y: 2} : Symbol(, Decl(foo_1.ts, 6, 7))
 >x : Symbol(x, Decl(foo_1.ts, 6, 9))
 >y : Symbol(y, Decl(foo_1.ts, 6, 14))
 
diff --git a/tests/baselines/reference/exportAssignmentWithoutIdentifier1.symbols b/tests/baselines/reference/exportAssignmentWithoutIdentifier1.symbols
index bcbf5eb1f60af..033df591411e0 100644
--- a/tests/baselines/reference/exportAssignmentWithoutIdentifier1.symbols
+++ b/tests/baselines/reference/exportAssignmentWithoutIdentifier1.symbols
@@ -8,6 +8,7 @@ Greeter.prototype.greet = function () {
 >Greeter.prototype : Symbol(Function.prototype, Decl(lib.d.ts, 249, 48))
 >Greeter : Symbol(Greeter, Decl(exportAssignmentWithoutIdentifier1.ts, 0, 0))
 >prototype : Symbol(Function.prototype, Decl(lib.d.ts, 249, 48))
+>function () {    //...} : Symbol((Anonymous function), Decl(exportAssignmentWithoutIdentifier1.ts, 3, 25))
 
     //...
 }
diff --git a/tests/baselines/reference/exportImportNonInstantiatedModule.symbols b/tests/baselines/reference/exportImportNonInstantiatedModule.symbols
index 6e044368bfb40..6122853da9dbe 100644
--- a/tests/baselines/reference/exportImportNonInstantiatedModule.symbols
+++ b/tests/baselines/reference/exportImportNonInstantiatedModule.symbols
@@ -21,5 +21,6 @@ var x: B.A1.I = { x: 1 };
 >B : Symbol(B, Decl(exportImportNonInstantiatedModule.ts, 2, 1))
 >A1 : Symbol(B.A1, Decl(exportImportNonInstantiatedModule.ts, 4, 10))
 >I : Symbol(A.I, Decl(exportImportNonInstantiatedModule.ts, 0, 10))
+>{ x: 1 } : Symbol(, Decl(exportImportNonInstantiatedModule.ts, 9, 15))
 >x : Symbol(x, Decl(exportImportNonInstantiatedModule.ts, 9, 17))
 
diff --git a/tests/baselines/reference/exportedVariable1.symbols b/tests/baselines/reference/exportedVariable1.symbols
index 96c4b0210ba12..d785419c068a1 100644
--- a/tests/baselines/reference/exportedVariable1.symbols
+++ b/tests/baselines/reference/exportedVariable1.symbols
@@ -1,6 +1,7 @@
 === tests/cases/compiler/exportedVariable1.ts ===
 export var foo = {name: "Bill"};
 >foo : Symbol(foo, Decl(exportedVariable1.ts, 0, 10))
+>{name: "Bill"} : Symbol(, Decl(exportedVariable1.ts, 0, 16))
 >name : Symbol(name, Decl(exportedVariable1.ts, 0, 18))
 
 var upper = foo.name.toUpperCase();
diff --git a/tests/baselines/reference/extendingClassFromAliasAndUsageInIndexer.symbols b/tests/baselines/reference/extendingClassFromAliasAndUsageInIndexer.symbols
index 02d57509a5507..7caacb23e1382 100644
--- a/tests/baselines/reference/extendingClassFromAliasAndUsageInIndexer.symbols
+++ b/tests/baselines/reference/extendingClassFromAliasAndUsageInIndexer.symbols
@@ -26,6 +26,7 @@ var moduleMap: { [key: string]: IHasVisualizationModel } = {
 >moduleMap : Symbol(moduleMap, Decl(extendingClassFromAliasAndUsageInIndexer_main.ts, 7, 3))
 >key : Symbol(key, Decl(extendingClassFromAliasAndUsageInIndexer_main.ts, 7, 18))
 >IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(extendingClassFromAliasAndUsageInIndexer_main.ts, 2, 77))
+>{    "moduleA": moduleA,    "moduleB": moduleB} : Symbol(, Decl(extendingClassFromAliasAndUsageInIndexer_main.ts, 7, 58))
 
     "moduleA": moduleA,
 >moduleA : Symbol(moduleA, Decl(extendingClassFromAliasAndUsageInIndexer_main.ts, 0, 79))
diff --git a/tests/baselines/reference/fatArrowSelf.symbols b/tests/baselines/reference/fatArrowSelf.symbols
index 4008b648ae6e5..1af3f8728ab2b 100644
--- a/tests/baselines/reference/fatArrowSelf.symbols
+++ b/tests/baselines/reference/fatArrowSelf.symbols
@@ -40,6 +40,7 @@ module Consumer {
 >this : Symbol(EventEmitterConsummer, Decl(fatArrowSelf.ts, 10, 17))
 >emitter : Symbol(emitter, Decl(fatArrowSelf.ts, 12, 21))
 >addListener : Symbol(Events.EventEmitter.addListener, Decl(fatArrowSelf.ts, 4, 31))
+>(e) => {                this.changed();            } : Symbol((Anonymous function), Decl(fatArrowSelf.ts, 15, 46))
 >e : Symbol(e, Decl(fatArrowSelf.ts, 15, 48))
 
                 this.changed();
diff --git a/tests/baselines/reference/fatArrowfunctionAsType.symbols b/tests/baselines/reference/fatArrowfunctionAsType.symbols
index 9764149bade7e..a105da83c791f 100644
--- a/tests/baselines/reference/fatArrowfunctionAsType.symbols
+++ b/tests/baselines/reference/fatArrowfunctionAsType.symbols
@@ -10,6 +10,7 @@ var c: <T>(x: T) => void = function <T>(x: T) { return 42; }
 >T : Symbol(T, Decl(fatArrowfunctionAsType.ts, 2, 8))
 >x : Symbol(x, Decl(fatArrowfunctionAsType.ts, 2, 11))
 >T : Symbol(T, Decl(fatArrowfunctionAsType.ts, 2, 8))
+>function <T>(x: T) { return 42; } : Symbol((Anonymous function), Decl(fatArrowfunctionAsType.ts, 2, 26))
 >T : Symbol(T, Decl(fatArrowfunctionAsType.ts, 2, 37))
 >x : Symbol(x, Decl(fatArrowfunctionAsType.ts, 2, 40))
 >T : Symbol(T, Decl(fatArrowfunctionAsType.ts, 2, 37))
diff --git a/tests/baselines/reference/fatarrowfunctions.symbols b/tests/baselines/reference/fatarrowfunctions.symbols
index 6ed865b091459..96cbe1ee28114 100644
--- a/tests/baselines/reference/fatarrowfunctions.symbols
+++ b/tests/baselines/reference/fatarrowfunctions.symbols
@@ -11,6 +11,7 @@ function foo(x:any) {
 
 foo((x:number,y,z)=>{return x+y+z;});
 >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0))
+>(x:number,y,z)=>{return x+y+z;} : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 6, 4))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 6, 5))
 >y : Symbol(y, Decl(fatarrowfunctions.ts, 6, 14))
 >z : Symbol(z, Decl(fatarrowfunctions.ts, 6, 16))
@@ -20,6 +21,7 @@ foo((x:number,y,z)=>{return x+y+z;});
 
 foo((x,y,z)=>{return x+y+z;});
 >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0))
+>(x,y,z)=>{return x+y+z;} : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 7, 4))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 7, 5))
 >y : Symbol(y, Decl(fatarrowfunctions.ts, 7, 7))
 >z : Symbol(z, Decl(fatarrowfunctions.ts, 7, 9))
@@ -29,6 +31,7 @@ foo((x,y,z)=>{return x+y+z;});
 
 foo((x,y:number,z)=>{return x+y+z;});
 >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0))
+>(x,y:number,z)=>{return x+y+z;} : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 8, 4))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 8, 5))
 >y : Symbol(y, Decl(fatarrowfunctions.ts, 8, 7))
 >z : Symbol(z, Decl(fatarrowfunctions.ts, 8, 16))
@@ -38,6 +41,7 @@ foo((x,y:number,z)=>{return x+y+z;});
 
 foo((x,y:number,z:number)=>{return x+y+z;});
 >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0))
+>(x,y:number,z:number)=>{return x+y+z;} : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 9, 4))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 9, 5))
 >y : Symbol(y, Decl(fatarrowfunctions.ts, 9, 7))
 >z : Symbol(z, Decl(fatarrowfunctions.ts, 9, 16))
@@ -47,6 +51,7 @@ foo((x,y:number,z:number)=>{return x+y+z;});
 
 foo((x,y,z:number)=>{return x+y+z;});
 >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0))
+>(x,y,z:number)=>{return x+y+z;} : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 10, 4))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 10, 5))
 >y : Symbol(y, Decl(fatarrowfunctions.ts, 10, 7))
 >z : Symbol(z, Decl(fatarrowfunctions.ts, 10, 9))
@@ -56,9 +61,11 @@ foo((x,y,z:number)=>{return x+y+z;});
 
 foo(()=>{return 0;});
 >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0))
+>()=>{return 0;} : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 11, 4))
 
 foo((x:number,y,z)=>x+y+z);
 >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0))
+>(x:number,y,z)=>x+y+z : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 13, 4))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 13, 5))
 >y : Symbol(y, Decl(fatarrowfunctions.ts, 13, 14))
 >z : Symbol(z, Decl(fatarrowfunctions.ts, 13, 16))
@@ -68,6 +75,7 @@ foo((x:number,y,z)=>x+y+z);
 
 foo((x,y,z)=>x+y+z);
 >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0))
+>(x,y,z)=>x+y+z : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 14, 4))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 14, 5))
 >y : Symbol(y, Decl(fatarrowfunctions.ts, 14, 7))
 >z : Symbol(z, Decl(fatarrowfunctions.ts, 14, 9))
@@ -77,6 +85,7 @@ foo((x,y,z)=>x+y+z);
 
 foo((x,y:number,z)=>{return x+y+z;});
 >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0))
+>(x,y:number,z)=>{return x+y+z;} : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 15, 4))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 15, 5))
 >y : Symbol(y, Decl(fatarrowfunctions.ts, 15, 7))
 >z : Symbol(z, Decl(fatarrowfunctions.ts, 15, 16))
@@ -86,6 +95,7 @@ foo((x,y:number,z)=>{return x+y+z;});
 
 foo((x,y:number,z:number)=>{return x+y+z;});
 >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0))
+>(x,y:number,z:number)=>{return x+y+z;} : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 16, 4))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 16, 5))
 >y : Symbol(y, Decl(fatarrowfunctions.ts, 16, 7))
 >z : Symbol(z, Decl(fatarrowfunctions.ts, 16, 16))
@@ -95,6 +105,7 @@ foo((x,y:number,z:number)=>{return x+y+z;});
 
 foo((x,y,z:number)=>{return x+y+z;});
 >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0))
+>(x,y,z:number)=>{return x+y+z;} : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 17, 4))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 17, 5))
 >y : Symbol(y, Decl(fatarrowfunctions.ts, 17, 7))
 >z : Symbol(z, Decl(fatarrowfunctions.ts, 17, 9))
@@ -104,33 +115,39 @@ foo((x,y,z:number)=>{return x+y+z;});
 
 foo(()=>{return 0;});
 >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0))
+>()=>{return 0;} : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 18, 4))
 
 
 foo(((x) => x));
 >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0))
+>(x) => x : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 21, 5))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 21, 6))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 21, 6))
 
 foo(x => x*x);
 >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0))
+>x => x*x : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 23, 4))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 23, 4))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 23, 4))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 23, 4))
 
 var y = x => x*x;
 >y : Symbol(y, Decl(fatarrowfunctions.ts, 25, 3))
+>x => x*x : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 25, 7))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 25, 7))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 25, 7))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 25, 7))
 
 var z = (x:number) => x*x;
 >z : Symbol(z, Decl(fatarrowfunctions.ts, 26, 3))
+>(x:number) => x*x : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 26, 7))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 26, 9))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 26, 9))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 26, 9))
 
 var w = () => 3;
 >w : Symbol(w, Decl(fatarrowfunctions.ts, 28, 3))
+>() => 3 : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 28, 7))
 
 function ternaryTest(isWhile:boolean) {
 >ternaryTest : Symbol(ternaryTest, Decl(fatarrowfunctions.ts, 28, 16))
@@ -139,8 +156,10 @@ function ternaryTest(isWhile:boolean) {
                 var f = isWhile ? function (n) { return n > 0; } : function (n) { return n === 0; };
 >f : Symbol(f, Decl(fatarrowfunctions.ts, 32, 19))
 >isWhile : Symbol(isWhile, Decl(fatarrowfunctions.ts, 30, 21))
+>function (n) { return n > 0; } : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 32, 33))
 >n : Symbol(n, Decl(fatarrowfunctions.ts, 32, 44))
 >n : Symbol(n, Decl(fatarrowfunctions.ts, 32, 44))
+>function (n) { return n === 0; } : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 32, 66))
 >n : Symbol(n, Decl(fatarrowfunctions.ts, 32, 77))
 >n : Symbol(n, Decl(fatarrowfunctions.ts, 32, 77))
 
@@ -154,15 +173,18 @@ declare function setTimeout(expression: any, msec?: number, language?: any): num
 
 var messenger = {
 >messenger : Symbol(messenger, Decl(fatarrowfunctions.ts, 38, 3))
+>{    message: "Hello World",    start: function() {        setTimeout(() => { this.message.toString(); }, 3000);    }} : Symbol(, Decl(fatarrowfunctions.ts, 38, 15))
 
     message: "Hello World",
 >message : Symbol(message, Decl(fatarrowfunctions.ts, 38, 17))
 
     start: function() {
 >start : Symbol(start, Decl(fatarrowfunctions.ts, 39, 27))
+>function() {        setTimeout(() => { this.message.toString(); }, 3000);    } : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 40, 10))
 
         setTimeout(() => { this.message.toString(); }, 3000);
 >setTimeout : Symbol(setTimeout, Decl(fatarrowfunctions.ts, 34, 1))
+>() => { this.message.toString(); } : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 41, 19))
     }
 };
 
diff --git a/tests/baselines/reference/fatarrowfunctionsInFunctionParameterDefaults.symbols b/tests/baselines/reference/fatarrowfunctionsInFunctionParameterDefaults.symbols
index 731e8558bab1b..c7256f8c38ba6 100644
--- a/tests/baselines/reference/fatarrowfunctionsInFunctionParameterDefaults.symbols
+++ b/tests/baselines/reference/fatarrowfunctionsInFunctionParameterDefaults.symbols
@@ -2,6 +2,7 @@
 function fn(x = () => this, y = x()) {
 >fn : Symbol(fn, Decl(fatarrowfunctionsInFunctionParameterDefaults.ts, 0, 0))
 >x : Symbol(x, Decl(fatarrowfunctionsInFunctionParameterDefaults.ts, 0, 12))
+>() => this : Symbol((Anonymous function), Decl(fatarrowfunctionsInFunctionParameterDefaults.ts, 0, 15))
 >y : Symbol(y, Decl(fatarrowfunctionsInFunctionParameterDefaults.ts, 0, 27))
 >x : Symbol(x, Decl(fatarrowfunctionsInFunctionParameterDefaults.ts, 0, 12))
 
diff --git a/tests/baselines/reference/fatarrowfunctionsInFunctions.symbols b/tests/baselines/reference/fatarrowfunctionsInFunctions.symbols
index 0a86affc21589..98d0c1f6d5871 100644
--- a/tests/baselines/reference/fatarrowfunctionsInFunctions.symbols
+++ b/tests/baselines/reference/fatarrowfunctionsInFunctions.symbols
@@ -7,18 +7,21 @@ declare function setTimeout(expression: any, msec?: number, language?: any): num
 
 var messenger = {
 >messenger : Symbol(messenger, Decl(fatarrowfunctionsInFunctions.ts, 2, 3))
+>{    message: "Hello World",    start: function() {        var _self = this;        setTimeout(function() {            _self.message.toString();         }, 3000);     }} : Symbol(, Decl(fatarrowfunctionsInFunctions.ts, 2, 15))
 
     message: "Hello World",
 >message : Symbol(message, Decl(fatarrowfunctionsInFunctions.ts, 2, 17))
 
     start: function() {
 >start : Symbol(start, Decl(fatarrowfunctionsInFunctions.ts, 3, 27))
+>function() {        var _self = this;        setTimeout(function() {            _self.message.toString();         }, 3000);     } : Symbol((Anonymous function), Decl(fatarrowfunctionsInFunctions.ts, 4, 10))
 
         var _self = this;
 >_self : Symbol(_self, Decl(fatarrowfunctionsInFunctions.ts, 5, 11))
 
         setTimeout(function() {
 >setTimeout : Symbol(setTimeout, Decl(fatarrowfunctionsInFunctions.ts, 0, 0))
+>function() {            _self.message.toString();         } : Symbol((Anonymous function), Decl(fatarrowfunctionsInFunctions.ts, 6, 19))
 
             _self.message.toString(); 
 >_self : Symbol(_self, Decl(fatarrowfunctionsInFunctions.ts, 5, 11))
diff --git a/tests/baselines/reference/for-of18.symbols b/tests/baselines/reference/for-of18.symbols
index 066d9534051ef..d09e5810d1dfa 100644
--- a/tests/baselines/reference/for-of18.symbols
+++ b/tests/baselines/reference/for-of18.symbols
@@ -13,6 +13,8 @@ class StringIterator {
 >next : Symbol(next, Decl(for-of18.ts, 3, 22))
 
         return {
+>{            value: "",            done: false        } : Symbol(, Decl(for-of18.ts, 5, 14))
+
             value: "",
 >value : Symbol(value, Decl(for-of18.ts, 5, 16))
 
diff --git a/tests/baselines/reference/for-of19.symbols b/tests/baselines/reference/for-of19.symbols
index 8c34f6f0d7a4e..b65b147b30452 100644
--- a/tests/baselines/reference/for-of19.symbols
+++ b/tests/baselines/reference/for-of19.symbols
@@ -17,6 +17,8 @@ class FooIterator {
 >next : Symbol(next, Decl(for-of19.ts, 5, 19))
 
         return {
+>{            value: new Foo,            done: false        } : Symbol(, Decl(for-of19.ts, 7, 14))
+
             value: new Foo,
 >value : Symbol(value, Decl(for-of19.ts, 7, 16))
 >Foo : Symbol(Foo, Decl(for-of19.ts, 2, 1))
diff --git a/tests/baselines/reference/for-of20.symbols b/tests/baselines/reference/for-of20.symbols
index 4e7aaf7e362bf..68d6871a4ced0 100644
--- a/tests/baselines/reference/for-of20.symbols
+++ b/tests/baselines/reference/for-of20.symbols
@@ -17,6 +17,8 @@ class FooIterator {
 >next : Symbol(next, Decl(for-of20.ts, 5, 19))
 
         return {
+>{            value: new Foo,            done: false        } : Symbol(, Decl(for-of20.ts, 7, 14))
+
             value: new Foo,
 >value : Symbol(value, Decl(for-of20.ts, 7, 16))
 >Foo : Symbol(Foo, Decl(for-of20.ts, 2, 1))
diff --git a/tests/baselines/reference/for-of21.symbols b/tests/baselines/reference/for-of21.symbols
index 70c1132afbd6d..ee8b99a09b466 100644
--- a/tests/baselines/reference/for-of21.symbols
+++ b/tests/baselines/reference/for-of21.symbols
@@ -17,6 +17,8 @@ class FooIterator {
 >next : Symbol(next, Decl(for-of21.ts, 5, 19))
 
         return {
+>{            value: new Foo,            done: false        } : Symbol(, Decl(for-of21.ts, 7, 14))
+
             value: new Foo,
 >value : Symbol(value, Decl(for-of21.ts, 7, 16))
 >Foo : Symbol(Foo, Decl(for-of21.ts, 2, 1))
diff --git a/tests/baselines/reference/for-of22.symbols b/tests/baselines/reference/for-of22.symbols
index 4650725593796..7fa0fd6da4a55 100644
--- a/tests/baselines/reference/for-of22.symbols
+++ b/tests/baselines/reference/for-of22.symbols
@@ -18,6 +18,8 @@ class FooIterator {
 >next : Symbol(next, Decl(for-of22.ts, 6, 19))
 
         return {
+>{            value: new Foo,            done: false        } : Symbol(, Decl(for-of22.ts, 8, 14))
+
             value: new Foo,
 >value : Symbol(value, Decl(for-of22.ts, 8, 16))
 >Foo : Symbol(Foo, Decl(for-of22.ts, 3, 1))
diff --git a/tests/baselines/reference/for-of23.symbols b/tests/baselines/reference/for-of23.symbols
index 8401de024d976..2dd7bc1f48626 100644
--- a/tests/baselines/reference/for-of23.symbols
+++ b/tests/baselines/reference/for-of23.symbols
@@ -17,6 +17,8 @@ class FooIterator {
 >next : Symbol(next, Decl(for-of23.ts, 5, 19))
 
         return {
+>{            value: new Foo,            done: false        } : Symbol(, Decl(for-of23.ts, 7, 14))
+
             value: new Foo,
 >value : Symbol(value, Decl(for-of23.ts, 7, 16))
 >Foo : Symbol(Foo, Decl(for-of23.ts, 2, 1))
diff --git a/tests/baselines/reference/for-of41.symbols b/tests/baselines/reference/for-of41.symbols
index cf8db913919a2..d8d2c4df0ae4f 100644
--- a/tests/baselines/reference/for-of41.symbols
+++ b/tests/baselines/reference/for-of41.symbols
@@ -1,8 +1,10 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of41.ts ===
 var array = [{x: [0], y: {p: ""}}]
 >array : Symbol(array, Decl(for-of41.ts, 0, 3))
+>{x: [0], y: {p: ""}} : Symbol(, Decl(for-of41.ts, 0, 13))
 >x : Symbol(x, Decl(for-of41.ts, 0, 14))
 >y : Symbol(y, Decl(for-of41.ts, 0, 21))
+>{p: ""} : Symbol(, Decl(for-of41.ts, 0, 24))
 >p : Symbol(p, Decl(for-of41.ts, 0, 26))
 
 for (var {x: [a], y: {p}} of array) {
diff --git a/tests/baselines/reference/for-of42.symbols b/tests/baselines/reference/for-of42.symbols
index b310fb1044f99..04bf7c478a5f4 100644
--- a/tests/baselines/reference/for-of42.symbols
+++ b/tests/baselines/reference/for-of42.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of42.ts ===
 var array = [{ x: "", y: 0 }]
 >array : Symbol(array, Decl(for-of42.ts, 0, 3))
+>{ x: "", y: 0 } : Symbol(, Decl(for-of42.ts, 0, 13))
 >x : Symbol(x, Decl(for-of42.ts, 0, 14))
 >y : Symbol(y, Decl(for-of42.ts, 0, 21))
 
diff --git a/tests/baselines/reference/forBreakStatements.symbols b/tests/baselines/reference/forBreakStatements.symbols
index 76db9309a3969..92514b9c588ac 100644
--- a/tests/baselines/reference/forBreakStatements.symbols
+++ b/tests/baselines/reference/forBreakStatements.symbols
@@ -34,6 +34,7 @@ EIGHT:
 for (; ;) {
     var fn = function () { }
 >fn : Symbol(fn, Decl(forBreakStatements.ts, 33, 7))
+>function () { } : Symbol((Anonymous function), Decl(forBreakStatements.ts, 33, 12))
 
     break EIGHT;
 }
diff --git a/tests/baselines/reference/forContinueStatements.symbols b/tests/baselines/reference/forContinueStatements.symbols
index e24eb2aaa9252..491c9f15ddde2 100644
--- a/tests/baselines/reference/forContinueStatements.symbols
+++ b/tests/baselines/reference/forContinueStatements.symbols
@@ -34,6 +34,7 @@ EIGHT:
 for (; ;) {
     var fn = function () { }
 >fn : Symbol(fn, Decl(forContinueStatements.ts, 33, 7))
+>function () { } : Symbol((Anonymous function), Decl(forContinueStatements.ts, 33, 12))
 
     continue EIGHT;
 }
diff --git a/tests/baselines/reference/forInBreakStatements.symbols b/tests/baselines/reference/forInBreakStatements.symbols
index 7984edc3fd699..2303631289982 100644
--- a/tests/baselines/reference/forInBreakStatements.symbols
+++ b/tests/baselines/reference/forInBreakStatements.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/statements/breakStatements/forInBreakStatements.ts ===
 for(var x in {}) {
 >x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8))
+>{} : Symbol(, Decl(forInBreakStatements.ts, 0, 12))
 
     break;
 }
@@ -8,6 +9,7 @@ for(var x in {}) {
 ONE:
 for(var x in {}) {
 >x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8))
+>{} : Symbol(, Decl(forInBreakStatements.ts, 5, 12))
 
     break ONE;
 }
@@ -16,6 +18,7 @@ TWO:
 THREE:
 for(var x in {}) {
 >x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8))
+>{} : Symbol(, Decl(forInBreakStatements.ts, 11, 12))
 
     break THREE;
 }
@@ -23,10 +26,12 @@ for(var x in {}) {
 FOUR:
 for(var x in {}) {
 >x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8))
+>{} : Symbol(, Decl(forInBreakStatements.ts, 16, 12))
 
     FIVE:
     for(var x in {}) {
 >x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8))
+>{} : Symbol(, Decl(forInBreakStatements.ts, 18, 16))
 
         break FOUR;
     }
@@ -34,24 +39,31 @@ for(var x in {}) {
 
 for(var x in {}) {
 >x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8))
+>{} : Symbol(, Decl(forInBreakStatements.ts, 23, 12))
 
     SIX:
     for(var x in {}) break SIX;
 >x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8))
+>{} : Symbol(, Decl(forInBreakStatements.ts, 25, 16))
 }
 
 SEVEN:
 for (var x in {}) for (var x in {}) for (var x in {}) break SEVEN;
 >x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8))
+>{} : Symbol(, Decl(forInBreakStatements.ts, 29, 13))
 >x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8))
+>{} : Symbol(, Decl(forInBreakStatements.ts, 29, 31))
 >x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8))
+>{} : Symbol(, Decl(forInBreakStatements.ts, 29, 49))
 
 EIGHT:
 for (var x in {}){
 >x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8))
+>{} : Symbol(, Decl(forInBreakStatements.ts, 32, 13))
 
     var fn = function () { }
 >fn : Symbol(fn, Decl(forInBreakStatements.ts, 33, 7))
+>function () { } : Symbol((Anonymous function), Decl(forInBreakStatements.ts, 33, 12))
 
     break EIGHT;
 }
diff --git a/tests/baselines/reference/forInContinueStatements.symbols b/tests/baselines/reference/forInContinueStatements.symbols
index 88129a50d21ce..8bd70b8dd3afe 100644
--- a/tests/baselines/reference/forInContinueStatements.symbols
+++ b/tests/baselines/reference/forInContinueStatements.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/statements/continueStatements/forInContinueStatements.ts ===
 for(var x in {}) {
 >x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8))
+>{} : Symbol(, Decl(forInContinueStatements.ts, 0, 12))
 
     continue;
 }
@@ -8,6 +9,7 @@ for(var x in {}) {
 ONE:
 for(var x in {}) {
 >x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8))
+>{} : Symbol(, Decl(forInContinueStatements.ts, 5, 12))
 
     continue ONE;
 }
@@ -16,6 +18,7 @@ TWO:
 THREE:
 for(var x in {}) {
 >x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8))
+>{} : Symbol(, Decl(forInContinueStatements.ts, 11, 12))
 
     continue THREE;
 }
@@ -23,10 +26,12 @@ for(var x in {}) {
 FOUR:
 for(var x in {}) {
 >x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8))
+>{} : Symbol(, Decl(forInContinueStatements.ts, 16, 12))
 
     FIVE:
     for(var x in {}) {
 >x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8))
+>{} : Symbol(, Decl(forInContinueStatements.ts, 18, 16))
 
         continue FOUR;
     }
@@ -34,24 +39,31 @@ for(var x in {}) {
 
 for(var x in {}) {
 >x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8))
+>{} : Symbol(, Decl(forInContinueStatements.ts, 23, 12))
 
     SIX:
     for(var x in {}) continue SIX;
 >x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8))
+>{} : Symbol(, Decl(forInContinueStatements.ts, 25, 16))
 }
 
 SEVEN:
 for (var x in {}) for (var x in {}) for (var x in {}) continue SEVEN;
 >x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8))
+>{} : Symbol(, Decl(forInContinueStatements.ts, 29, 13))
 >x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8))
+>{} : Symbol(, Decl(forInContinueStatements.ts, 29, 31))
 >x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8))
+>{} : Symbol(, Decl(forInContinueStatements.ts, 29, 49))
 
 EIGHT:
 for (var x in {}){
 >x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8))
+>{} : Symbol(, Decl(forInContinueStatements.ts, 32, 13))
 
     var fn = function () { }
 >fn : Symbol(fn, Decl(forInContinueStatements.ts, 33, 7))
+>function () { } : Symbol((Anonymous function), Decl(forInContinueStatements.ts, 33, 12))
 
     continue EIGHT;
 }
diff --git a/tests/baselines/reference/forStatements.symbols b/tests/baselines/reference/forStatements.symbols
index 6f7c6d6cdbe3a..6d12aab096a12 100644
--- a/tests/baselines/reference/forStatements.symbols
+++ b/tests/baselines/reference/forStatements.symbols
@@ -101,6 +101,7 @@ for(var aGenericClass: D<string> = new D<string>();;){}
 for(var anObjectLiteral: I = { id: 12 };;){}
 >anObjectLiteral : Symbol(anObjectLiteral, Decl(forStatements.ts, 36, 7))
 >I : Symbol(I, Decl(forStatements.ts, 0, 0))
+>{ id: 12 } : Symbol(, Decl(forStatements.ts, 36, 28))
 >id : Symbol(id, Decl(forStatements.ts, 36, 30))
 
 for(var anOtherObjectLiteral: { id: number } = new C();;){}
@@ -121,6 +122,7 @@ for(var anOtherFunction: (x: string) => number = F;;){}
 for(var aLambda: typeof F = (x) => 2;;){}
 >aLambda : Symbol(aLambda, Decl(forStatements.ts, 41, 7))
 >F : Symbol(F, Decl(forStatements.ts, 12, 1))
+>(x) => 2 : Symbol((Anonymous function), Decl(forStatements.ts, 41, 27))
 >x : Symbol(x, Decl(forStatements.ts, 41, 29))
 
 for(var aModule: typeof M = M;;){}
@@ -141,5 +143,6 @@ for(var aFunctionInModule: typeof M.F2 = (x) => 'this is a string';;){}
 >M.F2 : Symbol(M.F2, Decl(forStatements.ts, 19, 5))
 >M : Symbol(M, Decl(forStatements.ts, 14, 44))
 >F2 : Symbol(M.F2, Decl(forStatements.ts, 19, 5))
+>(x) => 'this is a string' : Symbol((Anonymous function), Decl(forStatements.ts, 45, 40))
 >x : Symbol(x, Decl(forStatements.ts, 45, 42))
 
diff --git a/tests/baselines/reference/forStatementsMultipleValidDecl.symbols b/tests/baselines/reference/forStatementsMultipleValidDecl.symbols
index 6a98fbf133ea1..f8fa1ca146934 100644
--- a/tests/baselines/reference/forStatementsMultipleValidDecl.symbols
+++ b/tests/baselines/reference/forStatementsMultipleValidDecl.symbols
@@ -29,18 +29,21 @@ for (var p: Point; ;) { }
 
 for (var p = { x: 1, y: 2 }; ;) { }
 >p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8))
+>{ x: 1, y: 2 } : Symbol(, Decl(forStatementsMultipleValidDecl.ts, 13, 12))
 >x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 13, 14))
 >y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 13, 20))
 
 for (var p: Point = { x: 0, y: undefined }; ;) { }
 >p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8))
 >Point : Symbol(Point, Decl(forStatementsMultipleValidDecl.ts, 9, 1))
+>{ x: 0, y: undefined } : Symbol(, Decl(forStatementsMultipleValidDecl.ts, 14, 19))
 >x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 14, 21))
 >y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 14, 27))
 >undefined : Symbol(undefined)
 
 for (var p = { x: 1, y: <number>undefined }; ;) { }
 >p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8))
+>{ x: 1, y: <number>undefined } : Symbol(, Decl(forStatementsMultipleValidDecl.ts, 15, 12))
 >x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 15, 14))
 >y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 15, 20))
 >undefined : Symbol(undefined)
@@ -49,6 +52,7 @@ for (var p: { x: number; y: number; } = { x: 1, y: 2 }; ;) { }
 >p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8))
 >x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 16, 13))
 >y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 16, 24))
+>{ x: 1, y: 2 } : Symbol(, Decl(forStatementsMultipleValidDecl.ts, 16, 39))
 >x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 16, 41))
 >y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 16, 47))
 
@@ -56,6 +60,7 @@ for (var p = <{ x: number; y: number; }>{ x: 0, y: undefined }; ;) { }
 >p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8))
 >x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 17, 15))
 >y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 17, 26))
+>{ x: 0, y: undefined } : Symbol(, Decl(forStatementsMultipleValidDecl.ts, 17, 40))
 >x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 17, 41))
 >y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 17, 47))
 >undefined : Symbol(undefined)
@@ -66,10 +71,12 @@ for (var p: typeof p; ;) { }
 
 for (var fn = function (s: string) { return 42; }; ;) { }
 >fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 20, 8), Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8))
+>function (s: string) { return 42; } : Symbol((Anonymous function), Decl(forStatementsMultipleValidDecl.ts, 20, 13))
 >s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 20, 24))
 
 for (var fn = (s: string) => 3; ;) { }
 >fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 20, 8), Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8))
+>(s: string) => 3 : Symbol((Anonymous function), Decl(forStatementsMultipleValidDecl.ts, 21, 13))
 >s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 21, 15))
 
 for (var fn: (s: string) => number; ;) { }
diff --git a/tests/baselines/reference/funcdecl.symbols b/tests/baselines/reference/funcdecl.symbols
index 2538e3a9a0402..e9d5c24603269 100644
--- a/tests/baselines/reference/funcdecl.symbols
+++ b/tests/baselines/reference/funcdecl.symbols
@@ -126,6 +126,7 @@ m2.foo(() =>  {
 >m2.foo : Symbol(m2.foo, Decl(funcdecl.ts, 50, 11))
 >m2 : Symbol(m2, Decl(funcdecl.ts, 48, 29))
 >foo : Symbol(m2.foo, Decl(funcdecl.ts, 50, 11))
+>() =>  {    var b = 30;    return b;} : Symbol((Anonymous function), Decl(funcdecl.ts, 56, 7))
 
     var b = 30;
 >b : Symbol(b, Decl(funcdecl.ts, 58, 7))
@@ -150,6 +151,7 @@ declare function overloadAmbient(s: string): string;
 
 var f2 = () => {
 >f2 : Symbol(f2, Decl(funcdecl.ts, 68, 3))
+>() => {    return "string";} : Symbol((Anonymous function), Decl(funcdecl.ts, 68, 8))
 
     return "string";
 }
diff --git a/tests/baselines/reference/functionAssignmentError.symbols b/tests/baselines/reference/functionAssignmentError.symbols
index b0d57ac410233..dc1edaab9119b 100644
--- a/tests/baselines/reference/functionAssignmentError.symbols
+++ b/tests/baselines/reference/functionAssignmentError.symbols
@@ -1,7 +1,9 @@
 === tests/cases/compiler/functionAssignmentError.ts ===
 var func = function (){return "ONE";};
 >func : Symbol(func, Decl(functionAssignmentError.ts, 0, 3))
+>function (){return "ONE";} : Symbol((Anonymous function), Decl(functionAssignmentError.ts, 0, 10))
 
 func = function (){return "ONE";};
 >func : Symbol(func, Decl(functionAssignmentError.ts, 0, 3))
+>function (){return "ONE";} : Symbol((Anonymous function), Decl(functionAssignmentError.ts, 1, 6))
 
diff --git a/tests/baselines/reference/functionConstraintSatisfaction.symbols b/tests/baselines/reference/functionConstraintSatisfaction.symbols
index eb71bb78e25f2..8b9695f7f4d9d 100644
--- a/tests/baselines/reference/functionConstraintSatisfaction.symbols
+++ b/tests/baselines/reference/functionConstraintSatisfaction.symbols
@@ -44,24 +44,28 @@ var r = foo(new Function());
 var r1 = foo((x) => x);
 >r1 : Symbol(r1, Decl(functionConstraintSatisfaction.ts, 18, 3))
 >foo : Symbol(foo, Decl(functionConstraintSatisfaction.ts, 0, 0))
+>(x) => x : Symbol((Anonymous function), Decl(functionConstraintSatisfaction.ts, 18, 13))
 >x : Symbol(x, Decl(functionConstraintSatisfaction.ts, 18, 14))
 >x : Symbol(x, Decl(functionConstraintSatisfaction.ts, 18, 14))
 
 var r2 = foo((x: string[]) => x);
 >r2 : Symbol(r2, Decl(functionConstraintSatisfaction.ts, 19, 3))
 >foo : Symbol(foo, Decl(functionConstraintSatisfaction.ts, 0, 0))
+>(x: string[]) => x : Symbol((Anonymous function), Decl(functionConstraintSatisfaction.ts, 19, 13))
 >x : Symbol(x, Decl(functionConstraintSatisfaction.ts, 19, 14))
 >x : Symbol(x, Decl(functionConstraintSatisfaction.ts, 19, 14))
 
 var r3 = foo(function (x) { return x });
 >r3 : Symbol(r3, Decl(functionConstraintSatisfaction.ts, 20, 3))
 >foo : Symbol(foo, Decl(functionConstraintSatisfaction.ts, 0, 0))
+>function (x) { return x } : Symbol((Anonymous function), Decl(functionConstraintSatisfaction.ts, 20, 13))
 >x : Symbol(x, Decl(functionConstraintSatisfaction.ts, 20, 23))
 >x : Symbol(x, Decl(functionConstraintSatisfaction.ts, 20, 23))
 
 var r4 = foo(function (x: string[]) { return x });
 >r4 : Symbol(r4, Decl(functionConstraintSatisfaction.ts, 21, 3))
 >foo : Symbol(foo, Decl(functionConstraintSatisfaction.ts, 0, 0))
+>function (x: string[]) { return x } : Symbol((Anonymous function), Decl(functionConstraintSatisfaction.ts, 21, 13))
 >x : Symbol(x, Decl(functionConstraintSatisfaction.ts, 21, 23))
 >x : Symbol(x, Decl(functionConstraintSatisfaction.ts, 21, 23))
 
@@ -137,6 +141,7 @@ var c2: { <T>(x: T): T; <T>(x: T, y: T): T };
 var r9 = foo(<U>(x: U) => x);
 >r9 : Symbol(r9, Decl(functionConstraintSatisfaction.ts, 40, 3))
 >foo : Symbol(foo, Decl(functionConstraintSatisfaction.ts, 0, 0))
+><U>(x: U) => x : Symbol((Anonymous function), Decl(functionConstraintSatisfaction.ts, 40, 13))
 >U : Symbol(U, Decl(functionConstraintSatisfaction.ts, 40, 14))
 >x : Symbol(x, Decl(functionConstraintSatisfaction.ts, 40, 17))
 >U : Symbol(U, Decl(functionConstraintSatisfaction.ts, 40, 14))
@@ -145,6 +150,7 @@ var r9 = foo(<U>(x: U) => x);
 var r10 = foo(function <U>(x: U) { return x; });
 >r10 : Symbol(r10, Decl(functionConstraintSatisfaction.ts, 41, 3))
 >foo : Symbol(foo, Decl(functionConstraintSatisfaction.ts, 0, 0))
+>function <U>(x: U) { return x; } : Symbol((Anonymous function), Decl(functionConstraintSatisfaction.ts, 41, 14))
 >U : Symbol(U, Decl(functionConstraintSatisfaction.ts, 41, 24))
 >x : Symbol(x, Decl(functionConstraintSatisfaction.ts, 41, 27))
 >U : Symbol(U, Decl(functionConstraintSatisfaction.ts, 41, 24))
@@ -153,6 +159,7 @@ var r10 = foo(function <U>(x: U) { return x; });
 var r11 = foo(<U extends Date>(x: U) => x);
 >r11 : Symbol(r11, Decl(functionConstraintSatisfaction.ts, 42, 3))
 >foo : Symbol(foo, Decl(functionConstraintSatisfaction.ts, 0, 0))
+><U extends Date>(x: U) => x : Symbol((Anonymous function), Decl(functionConstraintSatisfaction.ts, 42, 14))
 >U : Symbol(U, Decl(functionConstraintSatisfaction.ts, 42, 15))
 >Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
 >x : Symbol(x, Decl(functionConstraintSatisfaction.ts, 42, 31))
@@ -162,6 +169,7 @@ var r11 = foo(<U extends Date>(x: U) => x);
 var r12 = foo(<U, V>(x: U, y: V) => x);
 >r12 : Symbol(r12, Decl(functionConstraintSatisfaction.ts, 43, 3))
 >foo : Symbol(foo, Decl(functionConstraintSatisfaction.ts, 0, 0))
+><U, V>(x: U, y: V) => x : Symbol((Anonymous function), Decl(functionConstraintSatisfaction.ts, 43, 14))
 >U : Symbol(U, Decl(functionConstraintSatisfaction.ts, 43, 15))
 >V : Symbol(V, Decl(functionConstraintSatisfaction.ts, 43, 17))
 >x : Symbol(x, Decl(functionConstraintSatisfaction.ts, 43, 21))
diff --git a/tests/baselines/reference/functionConstraintSatisfaction3.symbols b/tests/baselines/reference/functionConstraintSatisfaction3.symbols
index 74f3a65aa8e3f..330d41d611979 100644
--- a/tests/baselines/reference/functionConstraintSatisfaction3.symbols
+++ b/tests/baselines/reference/functionConstraintSatisfaction3.symbols
@@ -39,24 +39,28 @@ var c: { (): string; (x): string };
 var r1 = foo((x) => x);
 >r1 : Symbol(r1, Decl(functionConstraintSatisfaction3.ts, 17, 3))
 >foo : Symbol(foo, Decl(functionConstraintSatisfaction3.ts, 0, 0))
+>(x) => x : Symbol((Anonymous function), Decl(functionConstraintSatisfaction3.ts, 17, 13))
 >x : Symbol(x, Decl(functionConstraintSatisfaction3.ts, 17, 14))
 >x : Symbol(x, Decl(functionConstraintSatisfaction3.ts, 17, 14))
 
 var r2 = foo((x: string) => x);
 >r2 : Symbol(r2, Decl(functionConstraintSatisfaction3.ts, 18, 3))
 >foo : Symbol(foo, Decl(functionConstraintSatisfaction3.ts, 0, 0))
+>(x: string) => x : Symbol((Anonymous function), Decl(functionConstraintSatisfaction3.ts, 18, 13))
 >x : Symbol(x, Decl(functionConstraintSatisfaction3.ts, 18, 14))
 >x : Symbol(x, Decl(functionConstraintSatisfaction3.ts, 18, 14))
 
 var r3 = foo(function (x) { return x });
 >r3 : Symbol(r3, Decl(functionConstraintSatisfaction3.ts, 19, 3))
 >foo : Symbol(foo, Decl(functionConstraintSatisfaction3.ts, 0, 0))
+>function (x) { return x } : Symbol((Anonymous function), Decl(functionConstraintSatisfaction3.ts, 19, 13))
 >x : Symbol(x, Decl(functionConstraintSatisfaction3.ts, 19, 23))
 >x : Symbol(x, Decl(functionConstraintSatisfaction3.ts, 19, 23))
 
 var r4 = foo(function (x: string) { return x });
 >r4 : Symbol(r4, Decl(functionConstraintSatisfaction3.ts, 20, 3))
 >foo : Symbol(foo, Decl(functionConstraintSatisfaction3.ts, 0, 0))
+>function (x: string) { return x } : Symbol((Anonymous function), Decl(functionConstraintSatisfaction3.ts, 20, 13))
 >x : Symbol(x, Decl(functionConstraintSatisfaction3.ts, 20, 23))
 >x : Symbol(x, Decl(functionConstraintSatisfaction3.ts, 20, 23))
 
@@ -122,6 +126,7 @@ var c2: { <T>(x: T): T; <T>(x: T, y: T): T };
 var r9 = foo(function <U>(x: U) { return x; });
 >r9 : Symbol(r9, Decl(functionConstraintSatisfaction3.ts, 37, 3))
 >foo : Symbol(foo, Decl(functionConstraintSatisfaction3.ts, 0, 0))
+>function <U>(x: U) { return x; } : Symbol((Anonymous function), Decl(functionConstraintSatisfaction3.ts, 37, 13))
 >U : Symbol(U, Decl(functionConstraintSatisfaction3.ts, 37, 23))
 >x : Symbol(x, Decl(functionConstraintSatisfaction3.ts, 37, 26))
 >U : Symbol(U, Decl(functionConstraintSatisfaction3.ts, 37, 23))
@@ -130,6 +135,7 @@ var r9 = foo(function <U>(x: U) { return x; });
 var r10 = foo(<U extends string>(x: U) => x);
 >r10 : Symbol(r10, Decl(functionConstraintSatisfaction3.ts, 38, 3))
 >foo : Symbol(foo, Decl(functionConstraintSatisfaction3.ts, 0, 0))
+><U extends string>(x: U) => x : Symbol((Anonymous function), Decl(functionConstraintSatisfaction3.ts, 38, 14))
 >U : Symbol(U, Decl(functionConstraintSatisfaction3.ts, 38, 15))
 >x : Symbol(x, Decl(functionConstraintSatisfaction3.ts, 38, 33))
 >U : Symbol(U, Decl(functionConstraintSatisfaction3.ts, 38, 15))
diff --git a/tests/baselines/reference/functionExpressionAndLambdaMatchesFunction.symbols b/tests/baselines/reference/functionExpressionAndLambdaMatchesFunction.symbols
index db66aa5618b99..b9ea38442b606 100644
--- a/tests/baselines/reference/functionExpressionAndLambdaMatchesFunction.symbols
+++ b/tests/baselines/reference/functionExpressionAndLambdaMatchesFunction.symbols
@@ -10,10 +10,12 @@ class CDoc {
         }
         doSomething(() => undefined);
 >doSomething : Symbol(doSomething, Decl(functionExpressionAndLambdaMatchesFunction.ts, 1, 23))
+>() => undefined : Symbol((Anonymous function), Decl(functionExpressionAndLambdaMatchesFunction.ts, 4, 20))
 >undefined : Symbol(undefined)
 
         doSomething(function () { });
 >doSomething : Symbol(doSomething, Decl(functionExpressionAndLambdaMatchesFunction.ts, 1, 23))
+>function () { } : Symbol((Anonymous function), Decl(functionExpressionAndLambdaMatchesFunction.ts, 5, 20))
     }
 }
 
diff --git a/tests/baselines/reference/functionExpressionContextualTyping1.symbols b/tests/baselines/reference/functionExpressionContextualTyping1.symbols
index 6182e4bb9a8e4..fb3ee291be6d7 100644
--- a/tests/baselines/reference/functionExpressionContextualTyping1.symbols
+++ b/tests/baselines/reference/functionExpressionContextualTyping1.symbols
@@ -14,6 +14,7 @@ var a0: (n: number, s: string) => number = (num, str) => {
 >a0 : Symbol(a0, Decl(functionExpressionContextualTyping1.ts, 8, 3))
 >n : Symbol(n, Decl(functionExpressionContextualTyping1.ts, 8, 9))
 >s : Symbol(s, Decl(functionExpressionContextualTyping1.ts, 8, 19))
+>(num, str) => {    num.toExponential();    return 0;} : Symbol((Anonymous function), Decl(functionExpressionContextualTyping1.ts, 8, 42))
 >num : Symbol(num, Decl(functionExpressionContextualTyping1.ts, 8, 44))
 >str : Symbol(str, Decl(functionExpressionContextualTyping1.ts, 8, 48))
 
@@ -38,6 +39,7 @@ var a1: (c: Class<Number>) => number = (a1) => {
 >c : Symbol(c, Decl(functionExpressionContextualTyping1.ts, 17, 9))
 >Class : Symbol(Class, Decl(functionExpressionContextualTyping1.ts, 11, 1))
 >Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+>(a1) => {    a1.foo();    return 1;} : Symbol((Anonymous function), Decl(functionExpressionContextualTyping1.ts, 17, 38))
 >a1 : Symbol(a1, Decl(functionExpressionContextualTyping1.ts, 17, 40))
 
     a1.foo();
@@ -62,6 +64,7 @@ var b1: ((s: string, w: boolean) => void) | ((s: string, w: boolean) => string);
 
 b1 = (k, h) => { };
 >b1 : Symbol(b1, Decl(functionExpressionContextualTyping1.ts, 27, 3))
+>(k, h) => { } : Symbol((Anonymous function), Decl(functionExpressionContextualTyping1.ts, 28, 4))
 >k : Symbol(k, Decl(functionExpressionContextualTyping1.ts, 28, 6))
 >h : Symbol(h, Decl(functionExpressionContextualTyping1.ts, 28, 8))
 
@@ -73,12 +76,14 @@ var b2: typeof a0 | ((n: number, s: string) => string);
 
 b2 = (foo, bar) => { return foo + 1; }
 >b2 : Symbol(b2, Decl(functionExpressionContextualTyping1.ts, 29, 3))
+>(foo, bar) => { return foo + 1; } : Symbol((Anonymous function), Decl(functionExpressionContextualTyping1.ts, 30, 4))
 >foo : Symbol(foo, Decl(functionExpressionContextualTyping1.ts, 30, 6))
 >bar : Symbol(bar, Decl(functionExpressionContextualTyping1.ts, 30, 10))
 >foo : Symbol(foo, Decl(functionExpressionContextualTyping1.ts, 30, 6))
 
 b2 = (foo, bar) => { return "hello"; }
 >b2 : Symbol(b2, Decl(functionExpressionContextualTyping1.ts, 29, 3))
+>(foo, bar) => { return "hello"; } : Symbol((Anonymous function), Decl(functionExpressionContextualTyping1.ts, 31, 4))
 >foo : Symbol(foo, Decl(functionExpressionContextualTyping1.ts, 31, 6))
 >bar : Symbol(bar, Decl(functionExpressionContextualTyping1.ts, 31, 10))
 
@@ -90,6 +95,7 @@ var b3: (name: string, num: number, boo: boolean) => void;
 
 b3 = (name, number) => { };
 >b3 : Symbol(b3, Decl(functionExpressionContextualTyping1.ts, 32, 3))
+>(name, number) => { } : Symbol((Anonymous function), Decl(functionExpressionContextualTyping1.ts, 33, 4))
 >name : Symbol(name, Decl(functionExpressionContextualTyping1.ts, 33, 6))
 >number : Symbol(number, Decl(functionExpressionContextualTyping1.ts, 33, 11))
 
@@ -97,11 +103,13 @@ var b4: (n: E) => string = (number = 1) => { return "hello"; };
 >b4 : Symbol(b4, Decl(functionExpressionContextualTyping1.ts, 35, 3))
 >n : Symbol(n, Decl(functionExpressionContextualTyping1.ts, 35, 9))
 >E : Symbol(E, Decl(functionExpressionContextualTyping1.ts, 0, 0))
+>(number = 1) => { return "hello"; } : Symbol((Anonymous function), Decl(functionExpressionContextualTyping1.ts, 35, 26))
 >number : Symbol(number, Decl(functionExpressionContextualTyping1.ts, 35, 28))
 
 var b5: (n: {}) => string = (number = "string") => { return "hello"; };
 >b5 : Symbol(b5, Decl(functionExpressionContextualTyping1.ts, 36, 3))
 >n : Symbol(n, Decl(functionExpressionContextualTyping1.ts, 36, 9))
+>(number = "string") => { return "hello"; } : Symbol((Anonymous function), Decl(functionExpressionContextualTyping1.ts, 36, 27))
 >number : Symbol(number, Decl(functionExpressionContextualTyping1.ts, 36, 29))
 
 // A contextual signature S is extracted from a function type T as follows:
@@ -121,11 +129,13 @@ var b7: ((s: string, w: boolean) => void) | ((s: string, w: number) => string);
 
 b6 = (k) => { k.toLowerCase() };
 >b6 : Symbol(b6, Decl(functionExpressionContextualTyping1.ts, 40, 3))
+>(k) => { k.toLowerCase() } : Symbol((Anonymous function), Decl(functionExpressionContextualTyping1.ts, 42, 4))
 >k : Symbol(k, Decl(functionExpressionContextualTyping1.ts, 42, 6))
 >k : Symbol(k, Decl(functionExpressionContextualTyping1.ts, 42, 6))
 
 b6 = (i) => {
 >b6 : Symbol(b6, Decl(functionExpressionContextualTyping1.ts, 40, 3))
+>(i) => {    i.toExponential();    return i;} : Symbol((Anonymous function), Decl(functionExpressionContextualTyping1.ts, 43, 4))
 >i : Symbol(i, Decl(functionExpressionContextualTyping1.ts, 43, 6))
 
     i.toExponential();
@@ -137,6 +147,7 @@ b6 = (i) => {
 };                   // Per spec, no contextual signature can be extracted in this case. (Otherwise clause)
 b7 = (j, m) => { };  // Per spec, no contextual signature can be extracted in this case. (Otherwise clause)
 >b7 : Symbol(b7, Decl(functionExpressionContextualTyping1.ts, 41, 3))
+>(j, m) => { } : Symbol((Anonymous function), Decl(functionExpressionContextualTyping1.ts, 47, 4))
 >j : Symbol(j, Decl(functionExpressionContextualTyping1.ts, 47, 6))
 >m : Symbol(m, Decl(functionExpressionContextualTyping1.ts, 47, 8))
 
@@ -157,6 +168,7 @@ class C<T, U> {
 >j : Symbol(j, Decl(functionExpressionContextualTyping1.ts, 51, 45))
 >k : Symbol(k, Decl(functionExpressionContextualTyping1.ts, 51, 55))
 >U : Symbol(U, Decl(functionExpressionContextualTyping1.ts, 49, 10))
+>(j, k) => {            return [j, k];        } : Symbol((Anonymous function), Decl(functionExpressionContextualTyping1.ts, 51, 75))
 >j : Symbol(j, Decl(functionExpressionContextualTyping1.ts, 51, 77))
 >k : Symbol(k, Decl(functionExpressionContextualTyping1.ts, 51, 79))
 
diff --git a/tests/baselines/reference/functionExpressionReturningItself.symbols b/tests/baselines/reference/functionExpressionReturningItself.symbols
index ba4d29f275aff..93005a27e8c5f 100644
--- a/tests/baselines/reference/functionExpressionReturningItself.symbols
+++ b/tests/baselines/reference/functionExpressionReturningItself.symbols
@@ -1,6 +1,7 @@
 === tests/cases/compiler/functionExpressionReturningItself.ts ===
 var x = function somefn() { return somefn; };
 >x : Symbol(x, Decl(functionExpressionReturningItself.ts, 0, 3))
+>function somefn() { return somefn; } : Symbol(somefn, Decl(functionExpressionReturningItself.ts, 0, 7))
 >somefn : Symbol(somefn, Decl(functionExpressionReturningItself.ts, 0, 7))
 >somefn : Symbol(somefn, Decl(functionExpressionReturningItself.ts, 0, 7))
 
diff --git a/tests/baselines/reference/functionExpressionWithResolutionOfTypeNamedArguments01.symbols b/tests/baselines/reference/functionExpressionWithResolutionOfTypeNamedArguments01.symbols
index d2455fd0106cf..cd658db87d5bb 100644
--- a/tests/baselines/reference/functionExpressionWithResolutionOfTypeNamedArguments01.symbols
+++ b/tests/baselines/reference/functionExpressionWithResolutionOfTypeNamedArguments01.symbols
@@ -5,6 +5,7 @@ interface arguments {
 
 var x = function f() {
 >x : Symbol(x, Decl(functionExpressionWithResolutionOfTypeNamedArguments01.ts, 3, 3))
+>function f() {    <arguments>arguments;} : Symbol(f, Decl(functionExpressionWithResolutionOfTypeNamedArguments01.ts, 3, 7))
 >f : Symbol(f, Decl(functionExpressionWithResolutionOfTypeNamedArguments01.ts, 3, 7))
 
     <arguments>arguments;
diff --git a/tests/baselines/reference/functionExpressionWithResolutionOfTypeOfSameName01.symbols b/tests/baselines/reference/functionExpressionWithResolutionOfTypeOfSameName01.symbols
index cd2248c601884..c1f074d5c1c3f 100644
--- a/tests/baselines/reference/functionExpressionWithResolutionOfTypeOfSameName01.symbols
+++ b/tests/baselines/reference/functionExpressionWithResolutionOfTypeOfSameName01.symbols
@@ -5,6 +5,7 @@ interface f {
 
 var x = function f() {
 >x : Symbol(x, Decl(functionExpressionWithResolutionOfTypeOfSameName01.ts, 3, 3))
+>function f() {    <f>f;} : Symbol(f, Decl(functionExpressionWithResolutionOfTypeOfSameName01.ts, 3, 7))
 >f : Symbol(f, Decl(functionExpressionWithResolutionOfTypeOfSameName01.ts, 3, 7))
 
     <f>f;
diff --git a/tests/baselines/reference/functionExpressionWithResolutionOfTypeOfSameName02.symbols b/tests/baselines/reference/functionExpressionWithResolutionOfTypeOfSameName02.symbols
index 89b46c99b4ea6..6632b54ee520a 100644
--- a/tests/baselines/reference/functionExpressionWithResolutionOfTypeOfSameName02.symbols
+++ b/tests/baselines/reference/functionExpressionWithResolutionOfTypeOfSameName02.symbols
@@ -5,6 +5,7 @@ interface Foo {
 
 var x = function Foo() {
 >x : Symbol(x, Decl(functionExpressionWithResolutionOfTypeOfSameName02.ts, 3, 3))
+>function Foo() {    var x: Foo;} : Symbol(Foo, Decl(functionExpressionWithResolutionOfTypeOfSameName02.ts, 3, 7))
 >Foo : Symbol(Foo, Decl(functionExpressionWithResolutionOfTypeOfSameName02.ts, 3, 7))
 
     var x: Foo;
diff --git a/tests/baselines/reference/functionImplementations.symbols b/tests/baselines/reference/functionImplementations.symbols
index f9205f3765077..0fab22deaebac 100644
--- a/tests/baselines/reference/functionImplementations.symbols
+++ b/tests/baselines/reference/functionImplementations.symbols
@@ -2,10 +2,12 @@
 // FunctionExpression with no return type annotation and no return statement returns void
 var v: void = function () { } ();
 >v : Symbol(v, Decl(functionImplementations.ts, 1, 3))
+>function () { } : Symbol((Anonymous function), Decl(functionImplementations.ts, 1, 13))
 
 // FunctionExpression f with no return type annotation and directly references f in its body returns any
 var a: any = function f() {
 >a : Symbol(a, Decl(functionImplementations.ts, 4, 3), Decl(functionImplementations.ts, 7, 3), Decl(functionImplementations.ts, 12, 3), Decl(functionImplementations.ts, 24, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 84, 3))
+>function f() {    return f;} : Symbol(f, Decl(functionImplementations.ts, 4, 12))
 >f : Symbol(f, Decl(functionImplementations.ts, 4, 12))
 
     return f;
@@ -14,6 +16,7 @@ var a: any = function f() {
 };
 var a: any = function f() {
 >a : Symbol(a, Decl(functionImplementations.ts, 4, 3), Decl(functionImplementations.ts, 7, 3), Decl(functionImplementations.ts, 12, 3), Decl(functionImplementations.ts, 24, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 84, 3))
+>function f() {    return f();} : Symbol(f, Decl(functionImplementations.ts, 7, 12))
 >f : Symbol(f, Decl(functionImplementations.ts, 7, 12))
 
     return f();
@@ -24,6 +27,7 @@ var a: any = function f() {
 // FunctionExpression f with no return type annotation and indirectly references f in its body returns any
 var a: any = function f() {
 >a : Symbol(a, Decl(functionImplementations.ts, 4, 3), Decl(functionImplementations.ts, 7, 3), Decl(functionImplementations.ts, 12, 3), Decl(functionImplementations.ts, 24, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 84, 3))
+>function f() {    var x = f;    return x;} : Symbol(f, Decl(functionImplementations.ts, 12, 12))
 >f : Symbol(f, Decl(functionImplementations.ts, 12, 12))
 
     var x = f;
@@ -83,6 +87,7 @@ var n = rec4();
 // FunctionExpression with no return type annotation and returns a number
 var n = function () {
 >n : Symbol(n, Decl(functionImplementations.ts, 34, 3), Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 39, 3), Decl(functionImplementations.ts, 56, 3), Decl(functionImplementations.ts, 61, 3), Decl(functionImplementations.ts, 66, 3))
+>function () {    return 3;} : Symbol((Anonymous function), Decl(functionImplementations.ts, 39, 7))
 
     return 3;
 } ();
@@ -93,6 +98,7 @@ var nu = null;
 
 var nu = function () {
 >nu : Symbol(nu, Decl(functionImplementations.ts, 44, 3), Decl(functionImplementations.ts, 45, 3))
+>function () {    return null;} : Symbol((Anonymous function), Decl(functionImplementations.ts, 45, 8))
 
     return null;
 } ();
@@ -104,6 +110,7 @@ var un = undefined;
 
 var un = function () {
 >un : Symbol(un, Decl(functionImplementations.ts, 50, 3), Decl(functionImplementations.ts, 51, 3))
+>function () {    return undefined;} : Symbol((Anonymous function), Decl(functionImplementations.ts, 51, 8))
 
     return undefined;
 >undefined : Symbol(undefined)
@@ -113,6 +120,7 @@ var un = function () {
 // FunctionExpression with no return type annotation and returns a type parameter type
 var n = function <T>(x: T) {
 >n : Symbol(n, Decl(functionImplementations.ts, 34, 3), Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 39, 3), Decl(functionImplementations.ts, 56, 3), Decl(functionImplementations.ts, 61, 3), Decl(functionImplementations.ts, 66, 3))
+>function <T>(x: T) {    return x;} : Symbol((Anonymous function), Decl(functionImplementations.ts, 56, 7))
 >T : Symbol(T, Decl(functionImplementations.ts, 56, 18))
 >x : Symbol(x, Decl(functionImplementations.ts, 56, 21))
 >T : Symbol(T, Decl(functionImplementations.ts, 56, 18))
@@ -125,6 +133,7 @@ var n = function <T>(x: T) {
 // FunctionExpression with no return type annotation and returns a constrained type parameter type
 var n = function <T extends {}>(x: T) {
 >n : Symbol(n, Decl(functionImplementations.ts, 34, 3), Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 39, 3), Decl(functionImplementations.ts, 56, 3), Decl(functionImplementations.ts, 61, 3), Decl(functionImplementations.ts, 66, 3))
+>function <T extends {}>(x: T) {    return x;} : Symbol((Anonymous function), Decl(functionImplementations.ts, 61, 7))
 >T : Symbol(T, Decl(functionImplementations.ts, 61, 18))
 >x : Symbol(x, Decl(functionImplementations.ts, 61, 32))
 >T : Symbol(T, Decl(functionImplementations.ts, 61, 18))
@@ -137,6 +146,7 @@ var n = function <T extends {}>(x: T) {
 // FunctionExpression with no return type annotation with multiple return statements with identical types
 var n = function () {
 >n : Symbol(n, Decl(functionImplementations.ts, 34, 3), Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 39, 3), Decl(functionImplementations.ts, 56, 3), Decl(functionImplementations.ts, 61, 3), Decl(functionImplementations.ts, 66, 3))
+>function () {    return 3;    return 5;} : Symbol((Anonymous function), Decl(functionImplementations.ts, 66, 7))
 
     return 3;
     return 5;
@@ -162,6 +172,7 @@ var b: Base;
 
 var b = function () {
 >b : Symbol(b, Decl(functionImplementations.ts, 78, 3), Decl(functionImplementations.ts, 79, 3))
+>function () {    return new Base(); return new Derived();} : Symbol((Anonymous function), Decl(functionImplementations.ts, 79, 7))
 
     return new Base(); return new Derived();
 >Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4))
@@ -172,6 +183,7 @@ var b = function () {
 // FunctionExpression with no return type annotation with multiple return statements with one a recursive call
 var a = function f() {
 >a : Symbol(a, Decl(functionImplementations.ts, 4, 3), Decl(functionImplementations.ts, 7, 3), Decl(functionImplementations.ts, 12, 3), Decl(functionImplementations.ts, 24, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 84, 3))
+>function f() {    return new Base(); return new Derived(); return f(); // ?} : Symbol(f, Decl(functionImplementations.ts, 84, 7))
 >f : Symbol(f, Decl(functionImplementations.ts, 84, 7))
 
     return new Base(); return new Derived(); return f(); // ?
@@ -184,6 +196,7 @@ var a = function f() {
 // FunctionExpression with non -void return type annotation with a single throw statement
 undefined === function (): number {
 >undefined : Symbol(undefined)
+>function (): number {    throw undefined;} : Symbol((Anonymous function), Decl(functionImplementations.ts, 89, 13))
 
     throw undefined;
 >undefined : Symbol(undefined)
@@ -218,6 +231,7 @@ function opt1(n = 4) {
 function opt2(n = { x: null, y: undefined }) {
 >opt2 : Symbol(opt2, Decl(functionImplementations.ts, 103, 1))
 >n : Symbol(n, Decl(functionImplementations.ts, 106, 14))
+>{ x: null, y: undefined } : Symbol(, Decl(functionImplementations.ts, 106, 17))
 >x : Symbol(x, Decl(functionImplementations.ts, 106, 19))
 >y : Symbol(y, Decl(functionImplementations.ts, 106, 28))
 >undefined : Symbol(undefined)
@@ -272,6 +286,7 @@ class AnotherClass { private x }
 var f7: (x: number) => string | number = x => { // should be (x: number) => number | string
 >f7 : Symbol(f7, Decl(functionImplementations.ts, 130, 3))
 >x : Symbol(x, Decl(functionImplementations.ts, 130, 9))
+>x => { // should be (x: number) => number | string    if (x < 0) { return x; }    return x.toString();} : Symbol((Anonymous function), Decl(functionImplementations.ts, 130, 40))
 >x : Symbol(x, Decl(functionImplementations.ts, 130, 40))
 
     if (x < 0) { return x; }
@@ -286,6 +301,7 @@ var f7: (x: number) => string | number = x => { // should be (x: number) => numb
 var f8: (x: number) => any = x => { // should be (x: number) => Base
 >f8 : Symbol(f8, Decl(functionImplementations.ts, 134, 3))
 >x : Symbol(x, Decl(functionImplementations.ts, 134, 9))
+>x => { // should be (x: number) => Base    return new Base();    return new Derived2();} : Symbol((Anonymous function), Decl(functionImplementations.ts, 134, 28))
 >x : Symbol(x, Decl(functionImplementations.ts, 134, 28))
 
     return new Base();
@@ -297,6 +313,7 @@ var f8: (x: number) => any = x => { // should be (x: number) => Base
 var f9: (x: number) => any = x => { // should be (x: number) => Base
 >f9 : Symbol(f9, Decl(functionImplementations.ts, 138, 3))
 >x : Symbol(x, Decl(functionImplementations.ts, 138, 9))
+>x => { // should be (x: number) => Base    return new Base();    return new Derived();    return new Derived2();} : Symbol((Anonymous function), Decl(functionImplementations.ts, 138, 28))
 >x : Symbol(x, Decl(functionImplementations.ts, 138, 28))
 
     return new Base();
@@ -311,6 +328,7 @@ var f9: (x: number) => any = x => { // should be (x: number) => Base
 var f10: (x: number) => any = x => { // should be (x: number) => Derived | Derived1
 >f10 : Symbol(f10, Decl(functionImplementations.ts, 143, 3))
 >x : Symbol(x, Decl(functionImplementations.ts, 143, 10))
+>x => { // should be (x: number) => Derived | Derived1    return new Derived();    return new Derived2();} : Symbol((Anonymous function), Decl(functionImplementations.ts, 143, 29))
 >x : Symbol(x, Decl(functionImplementations.ts, 143, 29))
 
     return new Derived();
@@ -322,6 +340,7 @@ var f10: (x: number) => any = x => { // should be (x: number) => Derived | Deriv
 var f11: (x: number) => any = x => { // should be (x: number) => Base | AnotherClass
 >f11 : Symbol(f11, Decl(functionImplementations.ts, 147, 3))
 >x : Symbol(x, Decl(functionImplementations.ts, 147, 10))
+>x => { // should be (x: number) => Base | AnotherClass    return new Base();    return new AnotherClass();} : Symbol((Anonymous function), Decl(functionImplementations.ts, 147, 29))
 >x : Symbol(x, Decl(functionImplementations.ts, 147, 29))
 
     return new Base();
@@ -333,6 +352,7 @@ var f11: (x: number) => any = x => { // should be (x: number) => Base | AnotherC
 var f12: (x: number) => any = x => { // should be (x: number) => Base | AnotherClass
 >f12 : Symbol(f12, Decl(functionImplementations.ts, 151, 3))
 >x : Symbol(x, Decl(functionImplementations.ts, 151, 10))
+>x => { // should be (x: number) => Base | AnotherClass    return new Base();    return; // should be ignored    return new AnotherClass();} : Symbol((Anonymous function), Decl(functionImplementations.ts, 151, 29))
 >x : Symbol(x, Decl(functionImplementations.ts, 151, 29))
 
     return new Base();
diff --git a/tests/baselines/reference/functionLiteral.symbols b/tests/baselines/reference/functionLiteral.symbols
index 3a8a4cfbad712..514a71bca41db 100644
--- a/tests/baselines/reference/functionLiteral.symbols
+++ b/tests/baselines/reference/functionLiteral.symbols
@@ -3,6 +3,7 @@
 
 var x = () => 1;
 >x : Symbol(x, Decl(functionLiteral.ts, 2, 3), Decl(functionLiteral.ts, 3, 3))
+>() => 1 : Symbol((Anonymous function), Decl(functionLiteral.ts, 2, 7))
 
 var x: {
 >x : Symbol(x, Decl(functionLiteral.ts, 2, 3), Decl(functionLiteral.ts, 3, 3))
@@ -24,6 +25,7 @@ var y2: { <T>(x: T): T; } = <T>(x: T) => x
 >x : Symbol(x, Decl(functionLiteral.ts, 9, 14))
 >T : Symbol(T, Decl(functionLiteral.ts, 9, 11))
 >T : Symbol(T, Decl(functionLiteral.ts, 9, 11))
+><T>(x: T) => x : Symbol((Anonymous function), Decl(functionLiteral.ts, 9, 27))
 >T : Symbol(T, Decl(functionLiteral.ts, 9, 29))
 >x : Symbol(x, Decl(functionLiteral.ts, 9, 32))
 >T : Symbol(T, Decl(functionLiteral.ts, 9, 29))
diff --git a/tests/baselines/reference/functionLiteralForOverloads.symbols b/tests/baselines/reference/functionLiteralForOverloads.symbols
index 205945b73ea10..952b8d81f6bba 100644
--- a/tests/baselines/reference/functionLiteralForOverloads.symbols
+++ b/tests/baselines/reference/functionLiteralForOverloads.symbols
@@ -11,6 +11,7 @@ var f: {
 >x : Symbol(x, Decl(functionLiteralForOverloads.ts, 4, 5))
 
 } = (x) => x;
+>(x) => x : Symbol((Anonymous function), Decl(functionLiteralForOverloads.ts, 5, 3))
 >x : Symbol(x, Decl(functionLiteralForOverloads.ts, 5, 5))
 >x : Symbol(x, Decl(functionLiteralForOverloads.ts, 5, 5))
 
@@ -26,6 +27,7 @@ var f2: {
 >x : Symbol(x, Decl(functionLiteralForOverloads.ts, 9, 8))
 
 } = (x) => x;
+>(x) => x : Symbol((Anonymous function), Decl(functionLiteralForOverloads.ts, 10, 3))
 >x : Symbol(x, Decl(functionLiteralForOverloads.ts, 10, 5))
 >x : Symbol(x, Decl(functionLiteralForOverloads.ts, 10, 5))
 
@@ -43,6 +45,7 @@ var f3: {
 >T : Symbol(T, Decl(functionLiteralForOverloads.ts, 14, 5))
 
 } = (x) => x;
+>(x) => x : Symbol((Anonymous function), Decl(functionLiteralForOverloads.ts, 15, 3))
 >x : Symbol(x, Decl(functionLiteralForOverloads.ts, 15, 5))
 >x : Symbol(x, Decl(functionLiteralForOverloads.ts, 15, 5))
 
@@ -60,6 +63,7 @@ var f4: {
 >T : Symbol(T, Decl(functionLiteralForOverloads.ts, 19, 5))
 
 } = (x) => x;
+>(x) => x : Symbol((Anonymous function), Decl(functionLiteralForOverloads.ts, 20, 3))
 >x : Symbol(x, Decl(functionLiteralForOverloads.ts, 20, 5))
 >x : Symbol(x, Decl(functionLiteralForOverloads.ts, 20, 5))
 
diff --git a/tests/baselines/reference/functionOverloads14.symbols b/tests/baselines/reference/functionOverloads14.symbols
index 4f4c3e4750b3d..33b8bc1d70b04 100644
--- a/tests/baselines/reference/functionOverloads14.symbols
+++ b/tests/baselines/reference/functionOverloads14.symbols
@@ -10,5 +10,6 @@ function foo():{a:string;}
 function foo():{a:any;} { return {a:1} }
 >foo : Symbol(foo, Decl(functionOverloads14.ts, 0, 0), Decl(functionOverloads14.ts, 0, 26), Decl(functionOverloads14.ts, 1, 26))
 >a : Symbol(a, Decl(functionOverloads14.ts, 2, 16))
+>{a:1} : Symbol(, Decl(functionOverloads14.ts, 2, 32))
 >a : Symbol(a, Decl(functionOverloads14.ts, 2, 34))
 
diff --git a/tests/baselines/reference/functionOverloads24.symbols b/tests/baselines/reference/functionOverloads24.symbols
index 0753e1f832b29..bc2f098826ec6 100644
--- a/tests/baselines/reference/functionOverloads24.symbols
+++ b/tests/baselines/reference/functionOverloads24.symbols
@@ -13,4 +13,5 @@ function foo(bar:any):(a)=>void { return function(){} }
 >foo : Symbol(foo, Decl(functionOverloads24.ts, 0, 0), Decl(functionOverloads24.ts, 0, 42), Decl(functionOverloads24.ts, 1, 42))
 >bar : Symbol(bar, Decl(functionOverloads24.ts, 2, 13))
 >a : Symbol(a, Decl(functionOverloads24.ts, 2, 23))
+>function(){} : Symbol((Anonymous function), Decl(functionOverloads24.ts, 2, 40))
 
diff --git a/tests/baselines/reference/functionOverloads35.symbols b/tests/baselines/reference/functionOverloads35.symbols
index 44a65a452f4f7..dfcc9aba0539c 100644
--- a/tests/baselines/reference/functionOverloads35.symbols
+++ b/tests/baselines/reference/functionOverloads35.symbols
@@ -18,5 +18,6 @@ function foo(bar:{a:any;}):any{ return bar }
 var x = foo({a:1});
 >x : Symbol(x, Decl(functionOverloads35.ts, 3, 3))
 >foo : Symbol(foo, Decl(functionOverloads35.ts, 0, 0), Decl(functionOverloads35.ts, 0, 37), Decl(functionOverloads35.ts, 1, 37))
+>{a:1} : Symbol(, Decl(functionOverloads35.ts, 3, 12))
 >a : Symbol(a, Decl(functionOverloads35.ts, 3, 13))
 
diff --git a/tests/baselines/reference/functionOverloads36.symbols b/tests/baselines/reference/functionOverloads36.symbols
index fa6df8fafac05..bc2d1a703d30a 100644
--- a/tests/baselines/reference/functionOverloads36.symbols
+++ b/tests/baselines/reference/functionOverloads36.symbols
@@ -18,5 +18,6 @@ function foo(bar:{a:any;}):any{ return bar }
 var x = foo({a:'foo'});
 >x : Symbol(x, Decl(functionOverloads36.ts, 3, 3))
 >foo : Symbol(foo, Decl(functionOverloads36.ts, 0, 0), Decl(functionOverloads36.ts, 0, 37), Decl(functionOverloads36.ts, 1, 37))
+>{a:'foo'} : Symbol(, Decl(functionOverloads36.ts, 3, 12))
 >a : Symbol(a, Decl(functionOverloads36.ts, 3, 13))
 
diff --git a/tests/baselines/reference/functionOverloads38.symbols b/tests/baselines/reference/functionOverloads38.symbols
index 460ea75377666..3b2fe84cd6713 100644
--- a/tests/baselines/reference/functionOverloads38.symbols
+++ b/tests/baselines/reference/functionOverloads38.symbols
@@ -18,5 +18,6 @@ function foo(bar:{a:any;}[]):any{ return bar }
 var x = foo([{a:1}]);
 >x : Symbol(x, Decl(functionOverloads38.ts, 3, 3))
 >foo : Symbol(foo, Decl(functionOverloads38.ts, 0, 0), Decl(functionOverloads38.ts, 0, 39), Decl(functionOverloads38.ts, 1, 40))
+>{a:1} : Symbol(, Decl(functionOverloads38.ts, 3, 13))
 >a : Symbol(a, Decl(functionOverloads38.ts, 3, 14))
 
diff --git a/tests/baselines/reference/functionOverloads39.symbols b/tests/baselines/reference/functionOverloads39.symbols
index 37bb56117d519..ed724a2e6cc42 100644
--- a/tests/baselines/reference/functionOverloads39.symbols
+++ b/tests/baselines/reference/functionOverloads39.symbols
@@ -18,5 +18,6 @@ function foo(bar:{a:any;}[]):any{ return bar }
 var x = foo([{a:true}]);
 >x : Symbol(x, Decl(functionOverloads39.ts, 3, 3))
 >foo : Symbol(foo, Decl(functionOverloads39.ts, 0, 0), Decl(functionOverloads39.ts, 0, 39), Decl(functionOverloads39.ts, 1, 40))
+>{a:true} : Symbol(, Decl(functionOverloads39.ts, 3, 13))
 >a : Symbol(a, Decl(functionOverloads39.ts, 3, 14))
 
diff --git a/tests/baselines/reference/functionOverloads42.symbols b/tests/baselines/reference/functionOverloads42.symbols
index 6cca9a552f240..5ef2d3f868b3e 100644
--- a/tests/baselines/reference/functionOverloads42.symbols
+++ b/tests/baselines/reference/functionOverloads42.symbols
@@ -18,5 +18,6 @@ function foo(bar:{a:any;}[]):any{ return bar }
 var x = foo([{a:'s'}]);
 >x : Symbol(x, Decl(functionOverloads42.ts, 3, 3))
 >foo : Symbol(foo, Decl(functionOverloads42.ts, 0, 0), Decl(functionOverloads42.ts, 0, 39), Decl(functionOverloads42.ts, 1, 36))
+>{a:'s'} : Symbol(, Decl(functionOverloads42.ts, 3, 13))
 >a : Symbol(a, Decl(functionOverloads42.ts, 3, 14))
 
diff --git a/tests/baselines/reference/functionWithAnyReturnTypeAndNoReturnExpression.symbols b/tests/baselines/reference/functionWithAnyReturnTypeAndNoReturnExpression.symbols
index 71a678b6c9331..71d20a743e96d 100644
--- a/tests/baselines/reference/functionWithAnyReturnTypeAndNoReturnExpression.symbols
+++ b/tests/baselines/reference/functionWithAnyReturnTypeAndNoReturnExpression.symbols
@@ -5,7 +5,9 @@ function f(): any { }
 
 var f2: () => any = () => { };
 >f2 : Symbol(f2, Decl(functionWithAnyReturnTypeAndNoReturnExpression.ts, 2, 3))
+>() => { } : Symbol((Anonymous function), Decl(functionWithAnyReturnTypeAndNoReturnExpression.ts, 2, 19))
 
 var f3 = (): any => { };
 >f3 : Symbol(f3, Decl(functionWithAnyReturnTypeAndNoReturnExpression.ts, 3, 3))
+>(): any => { } : Symbol((Anonymous function), Decl(functionWithAnyReturnTypeAndNoReturnExpression.ts, 3, 8))
 
diff --git a/tests/baselines/reference/generatedContextualTyping.symbols b/tests/baselines/reference/generatedContextualTyping.symbols
index 287b7be66d091..5c3671979d528 100644
--- a/tests/baselines/reference/generatedContextualTyping.symbols
+++ b/tests/baselines/reference/generatedContextualTyping.symbols
@@ -31,18 +31,21 @@ var b = new Base(), d1 = new Derived1(), d2 = new Derived2();
 var x1: () => Base[] = () => [d1, d2];
 >x1 : Symbol(x1, Decl(generatedContextualTyping.ts, 5, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 5, 22))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x2: () => Base[] = function() { return [d1, d2] };
 >x2 : Symbol(x2, Decl(generatedContextualTyping.ts, 6, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 6, 22))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x3: () => Base[] = function named() { return [d1, d2] };
 >x3 : Symbol(x3, Decl(generatedContextualTyping.ts, 7, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 7, 22))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 7, 22))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -50,18 +53,21 @@ var x3: () => Base[] = function named() { return [d1, d2] };
 var x4: { (): Base[]; } = () => [d1, d2];
 >x4 : Symbol(x4, Decl(generatedContextualTyping.ts, 8, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 8, 25))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x5: { (): Base[]; } = function() { return [d1, d2] };
 >x5 : Symbol(x5, Decl(generatedContextualTyping.ts, 9, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 9, 25))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x6: { (): Base[]; } = function named() { return [d1, d2] };
 >x6 : Symbol(x6, Decl(generatedContextualTyping.ts, 10, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 10, 25))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 10, 25))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -90,6 +96,7 @@ var x10: {n: Base[]; }  = { n: [d1, d2] };
 >x10 : Symbol(x10, Decl(generatedContextualTyping.ts, 14, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 14, 10))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 14, 25))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 14, 27))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -98,6 +105,7 @@ var x11: (s: Base[]) => any = n => { var n: Base[]; return null; };
 >x11 : Symbol(x11, Decl(generatedContextualTyping.ts, 15, 3))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 15, 10))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 15, 29))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 15, 29), Decl(generatedContextualTyping.ts, 15, 40))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 15, 29), Decl(generatedContextualTyping.ts, 15, 40))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -106,7 +114,9 @@ var x12: Genric<Base> = { func: n => { return [d1, d2]; } };
 >x12 : Symbol(x12, Decl(generatedContextualTyping.ts, 16, 3))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 16, 23))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 16, 25))
+>n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 16, 31))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 16, 31))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -115,6 +125,7 @@ class x13 { member: () => Base[] = () => [d1, d2] }
 >x13 : Symbol(x13, Decl(generatedContextualTyping.ts, 16, 60))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 17, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 17, 34))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -122,6 +133,7 @@ class x14 { member: () => Base[] = function() { return [d1, d2] } }
 >x14 : Symbol(x14, Decl(generatedContextualTyping.ts, 17, 51))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 18, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 18, 34))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -129,6 +141,7 @@ class x15 { member: () => Base[] = function named() { return [d1, d2] } }
 >x15 : Symbol(x15, Decl(generatedContextualTyping.ts, 18, 67))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 19, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 19, 34))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 19, 34))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -137,6 +150,7 @@ class x16 { member: { (): Base[]; } = () => [d1, d2] }
 >x16 : Symbol(x16, Decl(generatedContextualTyping.ts, 19, 73))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 20, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 20, 37))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -144,6 +158,7 @@ class x17 { member: { (): Base[]; } = function() { return [d1, d2] } }
 >x17 : Symbol(x17, Decl(generatedContextualTyping.ts, 20, 54))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 21, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 21, 37))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -151,6 +166,7 @@ class x18 { member: { (): Base[]; } = function named() { return [d1, d2] } }
 >x18 : Symbol(x18, Decl(generatedContextualTyping.ts, 21, 70))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 22, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 22, 37))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 22, 37))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -183,6 +199,7 @@ class x22 { member: {n: Base[]; }  = { n: [d1, d2] } }
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 26, 11))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 26, 21))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 26, 36))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 26, 38))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -192,6 +209,7 @@ class x23 { member: (s: Base[]) => any = n => { var n: Base[]; return null; } }
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 27, 11))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 27, 21))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 27, 40))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 27, 40), Decl(generatedContextualTyping.ts, 27, 51))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 27, 40), Decl(generatedContextualTyping.ts, 27, 51))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -201,7 +219,9 @@ class x24 { member: Genric<Base> = { func: n => { return [d1, d2]; } } }
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 28, 11))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 28, 34))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 28, 36))
+>n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 28, 42))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 28, 42))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -210,6 +230,7 @@ class x25 { private member: () => Base[] = () => [d1, d2] }
 >x25 : Symbol(x25, Decl(generatedContextualTyping.ts, 28, 72))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 29, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 29, 42))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -217,6 +238,7 @@ class x26 { private member: () => Base[] = function() { return [d1, d2] } }
 >x26 : Symbol(x26, Decl(generatedContextualTyping.ts, 29, 59))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 30, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 30, 42))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -224,6 +246,7 @@ class x27 { private member: () => Base[] = function named() { return [d1, d2] }
 >x27 : Symbol(x27, Decl(generatedContextualTyping.ts, 30, 75))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 31, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 31, 42))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 31, 42))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -232,6 +255,7 @@ class x28 { private member: { (): Base[]; } = () => [d1, d2] }
 >x28 : Symbol(x28, Decl(generatedContextualTyping.ts, 31, 81))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 32, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 32, 45))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -239,6 +263,7 @@ class x29 { private member: { (): Base[]; } = function() { return [d1, d2] } }
 >x29 : Symbol(x29, Decl(generatedContextualTyping.ts, 32, 62))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 33, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 33, 45))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -246,6 +271,7 @@ class x30 { private member: { (): Base[]; } = function named() { return [d1, d2]
 >x30 : Symbol(x30, Decl(generatedContextualTyping.ts, 33, 78))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 34, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 34, 45))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 34, 45))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -278,6 +304,7 @@ class x34 { private member: {n: Base[]; }  = { n: [d1, d2] } }
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 38, 11))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 38, 29))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 38, 44))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 38, 46))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -287,6 +314,7 @@ class x35 { private member: (s: Base[]) => any = n => { var n: Base[]; return nu
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 39, 11))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 39, 29))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 39, 48))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 39, 48), Decl(generatedContextualTyping.ts, 39, 59))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 39, 48), Decl(generatedContextualTyping.ts, 39, 59))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -296,7 +324,9 @@ class x36 { private member: Genric<Base> = { func: n => { return [d1, d2]; } } }
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 40, 11))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 40, 42))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 40, 44))
+>n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 40, 50))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 40, 50))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -305,6 +335,7 @@ class x37 { public member: () => Base[] = () => [d1, d2] }
 >x37 : Symbol(x37, Decl(generatedContextualTyping.ts, 40, 80))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 41, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 41, 41))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -312,6 +343,7 @@ class x38 { public member: () => Base[] = function() { return [d1, d2] } }
 >x38 : Symbol(x38, Decl(generatedContextualTyping.ts, 41, 58))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 42, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 42, 41))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -319,6 +351,7 @@ class x39 { public member: () => Base[] = function named() { return [d1, d2] } }
 >x39 : Symbol(x39, Decl(generatedContextualTyping.ts, 42, 74))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 43, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 43, 41))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 43, 41))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -327,6 +360,7 @@ class x40 { public member: { (): Base[]; } = () => [d1, d2] }
 >x40 : Symbol(x40, Decl(generatedContextualTyping.ts, 43, 80))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 44, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 44, 44))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -334,6 +368,7 @@ class x41 { public member: { (): Base[]; } = function() { return [d1, d2] } }
 >x41 : Symbol(x41, Decl(generatedContextualTyping.ts, 44, 61))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 45, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 45, 44))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -341,6 +376,7 @@ class x42 { public member: { (): Base[]; } = function named() { return [d1, d2]
 >x42 : Symbol(x42, Decl(generatedContextualTyping.ts, 45, 77))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 46, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 46, 44))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 46, 44))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -373,6 +409,7 @@ class x46 { public member: {n: Base[]; }  = { n: [d1, d2] } }
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 50, 11))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 50, 28))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 50, 43))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 50, 45))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -382,6 +419,7 @@ class x47 { public member: (s: Base[]) => any = n => { var n: Base[]; return nul
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 51, 11))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 51, 28))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 51, 47))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 51, 47), Decl(generatedContextualTyping.ts, 51, 58))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 51, 47), Decl(generatedContextualTyping.ts, 51, 58))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -391,7 +429,9 @@ class x48 { public member: Genric<Base> = { func: n => { return [d1, d2]; } } }
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 52, 11))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 52, 41))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 52, 43))
+>n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 52, 49))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 52, 49))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -400,6 +440,7 @@ class x49 { static member: () => Base[] = () => [d1, d2] }
 >x49 : Symbol(x49, Decl(generatedContextualTyping.ts, 52, 79))
 >member : Symbol(x49.member, Decl(generatedContextualTyping.ts, 53, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 53, 41))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -407,6 +448,7 @@ class x50 { static member: () => Base[] = function() { return [d1, d2] } }
 >x50 : Symbol(x50, Decl(generatedContextualTyping.ts, 53, 58))
 >member : Symbol(x50.member, Decl(generatedContextualTyping.ts, 54, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 54, 41))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -414,6 +456,7 @@ class x51 { static member: () => Base[] = function named() { return [d1, d2] } }
 >x51 : Symbol(x51, Decl(generatedContextualTyping.ts, 54, 74))
 >member : Symbol(x51.member, Decl(generatedContextualTyping.ts, 55, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 55, 41))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 55, 41))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -422,6 +465,7 @@ class x52 { static member: { (): Base[]; } = () => [d1, d2] }
 >x52 : Symbol(x52, Decl(generatedContextualTyping.ts, 55, 80))
 >member : Symbol(x52.member, Decl(generatedContextualTyping.ts, 56, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 56, 44))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -429,6 +473,7 @@ class x53 { static member: { (): Base[]; } = function() { return [d1, d2] } }
 >x53 : Symbol(x53, Decl(generatedContextualTyping.ts, 56, 61))
 >member : Symbol(x53.member, Decl(generatedContextualTyping.ts, 57, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 57, 44))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -436,6 +481,7 @@ class x54 { static member: { (): Base[]; } = function named() { return [d1, d2]
 >x54 : Symbol(x54, Decl(generatedContextualTyping.ts, 57, 77))
 >member : Symbol(x54.member, Decl(generatedContextualTyping.ts, 58, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 58, 44))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 58, 44))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -468,6 +514,7 @@ class x58 { static member: {n: Base[]; }  = { n: [d1, d2] } }
 >member : Symbol(x58.member, Decl(generatedContextualTyping.ts, 62, 11))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 62, 28))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 62, 43))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 62, 45))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -477,6 +524,7 @@ class x59 { static member: (s: Base[]) => any = n => { var n: Base[]; return nul
 >member : Symbol(x59.member, Decl(generatedContextualTyping.ts, 63, 11))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 63, 28))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 63, 47))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 63, 47), Decl(generatedContextualTyping.ts, 63, 58))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 63, 47), Decl(generatedContextualTyping.ts, 63, 58))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -486,7 +534,9 @@ class x60 { static member: Genric<Base> = { func: n => { return [d1, d2]; } } }
 >member : Symbol(x60.member, Decl(generatedContextualTyping.ts, 64, 11))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 64, 41))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 64, 43))
+>n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 64, 49))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 64, 49))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -495,6 +545,7 @@ class x61 { private static member: () => Base[] = () => [d1, d2] }
 >x61 : Symbol(x61, Decl(generatedContextualTyping.ts, 64, 79))
 >member : Symbol(x61.member, Decl(generatedContextualTyping.ts, 65, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 65, 49))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -502,6 +553,7 @@ class x62 { private static member: () => Base[] = function() { return [d1, d2] }
 >x62 : Symbol(x62, Decl(generatedContextualTyping.ts, 65, 66))
 >member : Symbol(x62.member, Decl(generatedContextualTyping.ts, 66, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 66, 49))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -509,6 +561,7 @@ class x63 { private static member: () => Base[] = function named() { return [d1,
 >x63 : Symbol(x63, Decl(generatedContextualTyping.ts, 66, 82))
 >member : Symbol(x63.member, Decl(generatedContextualTyping.ts, 67, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 67, 49))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 67, 49))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -517,6 +570,7 @@ class x64 { private static member: { (): Base[]; } = () => [d1, d2] }
 >x64 : Symbol(x64, Decl(generatedContextualTyping.ts, 67, 88))
 >member : Symbol(x64.member, Decl(generatedContextualTyping.ts, 68, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 68, 52))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -524,6 +578,7 @@ class x65 { private static member: { (): Base[]; } = function() { return [d1, d2
 >x65 : Symbol(x65, Decl(generatedContextualTyping.ts, 68, 69))
 >member : Symbol(x65.member, Decl(generatedContextualTyping.ts, 69, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 69, 52))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -531,6 +586,7 @@ class x66 { private static member: { (): Base[]; } = function named() { return [
 >x66 : Symbol(x66, Decl(generatedContextualTyping.ts, 69, 85))
 >member : Symbol(x66.member, Decl(generatedContextualTyping.ts, 70, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 70, 52))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 70, 52))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -563,6 +619,7 @@ class x70 { private static member: {n: Base[]; }  = { n: [d1, d2] } }
 >member : Symbol(x70.member, Decl(generatedContextualTyping.ts, 74, 11))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 74, 36))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 74, 51))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 74, 53))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -572,6 +629,7 @@ class x71 { private static member: (s: Base[]) => any = n => { var n: Base[]; re
 >member : Symbol(x71.member, Decl(generatedContextualTyping.ts, 75, 11))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 75, 36))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 75, 55))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 75, 55), Decl(generatedContextualTyping.ts, 75, 66))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 75, 55), Decl(generatedContextualTyping.ts, 75, 66))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -581,7 +639,9 @@ class x72 { private static member: Genric<Base> = { func: n => { return [d1, d2]
 >member : Symbol(x72.member, Decl(generatedContextualTyping.ts, 76, 11))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 76, 49))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 76, 51))
+>n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 76, 57))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 76, 57))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -590,6 +650,7 @@ class x73 { public static member: () => Base[] = () => [d1, d2] }
 >x73 : Symbol(x73, Decl(generatedContextualTyping.ts, 76, 87))
 >member : Symbol(x73.member, Decl(generatedContextualTyping.ts, 77, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 77, 48))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -597,6 +658,7 @@ class x74 { public static member: () => Base[] = function() { return [d1, d2] }
 >x74 : Symbol(x74, Decl(generatedContextualTyping.ts, 77, 65))
 >member : Symbol(x74.member, Decl(generatedContextualTyping.ts, 78, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 78, 48))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -604,6 +666,7 @@ class x75 { public static member: () => Base[] = function named() { return [d1,
 >x75 : Symbol(x75, Decl(generatedContextualTyping.ts, 78, 81))
 >member : Symbol(x75.member, Decl(generatedContextualTyping.ts, 79, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 79, 48))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 79, 48))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -612,6 +675,7 @@ class x76 { public static member: { (): Base[]; } = () => [d1, d2] }
 >x76 : Symbol(x76, Decl(generatedContextualTyping.ts, 79, 87))
 >member : Symbol(x76.member, Decl(generatedContextualTyping.ts, 80, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 80, 51))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -619,6 +683,7 @@ class x77 { public static member: { (): Base[]; } = function() { return [d1, d2]
 >x77 : Symbol(x77, Decl(generatedContextualTyping.ts, 80, 68))
 >member : Symbol(x77.member, Decl(generatedContextualTyping.ts, 81, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 81, 51))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -626,6 +691,7 @@ class x78 { public static member: { (): Base[]; } = function named() { return [d
 >x78 : Symbol(x78, Decl(generatedContextualTyping.ts, 81, 84))
 >member : Symbol(x78.member, Decl(generatedContextualTyping.ts, 82, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 82, 51))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 82, 51))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -658,6 +724,7 @@ class x82 { public static member: {n: Base[]; }  = { n: [d1, d2] } }
 >member : Symbol(x82.member, Decl(generatedContextualTyping.ts, 86, 11))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 86, 35))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 86, 50))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 86, 52))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -667,6 +734,7 @@ class x83 { public static member: (s: Base[]) => any = n => { var n: Base[]; ret
 >member : Symbol(x83.member, Decl(generatedContextualTyping.ts, 87, 11))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 87, 35))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 87, 54))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 87, 54), Decl(generatedContextualTyping.ts, 87, 65))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 87, 54), Decl(generatedContextualTyping.ts, 87, 65))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -676,7 +744,9 @@ class x84 { public static member: Genric<Base> = { func: n => { return [d1, d2];
 >member : Symbol(x84.member, Decl(generatedContextualTyping.ts, 88, 11))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 88, 48))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 88, 50))
+>n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 88, 56))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 88, 56))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -685,6 +755,7 @@ class x85 { constructor(parm: () => Base[] = () => [d1, d2]) { } }
 >x85 : Symbol(x85, Decl(generatedContextualTyping.ts, 88, 86))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 89, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 89, 44))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -692,6 +763,7 @@ class x86 { constructor(parm: () => Base[] = function() { return [d1, d2] }) { }
 >x86 : Symbol(x86, Decl(generatedContextualTyping.ts, 89, 66))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 90, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 90, 44))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -699,6 +771,7 @@ class x87 { constructor(parm: () => Base[] = function named() { return [d1, d2]
 >x87 : Symbol(x87, Decl(generatedContextualTyping.ts, 90, 82))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 91, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 91, 44))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 91, 44))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -707,6 +780,7 @@ class x88 { constructor(parm: { (): Base[]; } = () => [d1, d2]) { } }
 >x88 : Symbol(x88, Decl(generatedContextualTyping.ts, 91, 88))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 92, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 92, 47))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -714,6 +788,7 @@ class x89 { constructor(parm: { (): Base[]; } = function() { return [d1, d2] })
 >x89 : Symbol(x89, Decl(generatedContextualTyping.ts, 92, 69))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 93, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 93, 47))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -721,6 +796,7 @@ class x90 { constructor(parm: { (): Base[]; } = function named() { return [d1, d
 >x90 : Symbol(x90, Decl(generatedContextualTyping.ts, 93, 85))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 94, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 94, 47))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 94, 47))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -753,6 +829,7 @@ class x94 { constructor(parm: {n: Base[]; }  = { n: [d1, d2] }) { } }
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 98, 24))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 98, 31))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 98, 46))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 98, 48))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -762,6 +839,7 @@ class x95 { constructor(parm: (s: Base[]) => any = n => { var n: Base[]; return
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 99, 24))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 99, 31))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 99, 50))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 99, 50), Decl(generatedContextualTyping.ts, 99, 61))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 99, 50), Decl(generatedContextualTyping.ts, 99, 61))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -771,7 +849,9 @@ class x96 { constructor(parm: Genric<Base> = { func: n => { return [d1, d2]; } }
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 100, 24))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 100, 44))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 100, 46))
+>n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 100, 52))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 100, 52))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -780,6 +860,7 @@ class x97 { constructor(public parm: () => Base[] = () => [d1, d2]) { } }
 >x97 : Symbol(x97, Decl(generatedContextualTyping.ts, 100, 87))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 101, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 101, 51))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -787,6 +868,7 @@ class x98 { constructor(public parm: () => Base[] = function() { return [d1, d2]
 >x98 : Symbol(x98, Decl(generatedContextualTyping.ts, 101, 73))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 102, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 102, 51))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -794,6 +876,7 @@ class x99 { constructor(public parm: () => Base[] = function named() { return [d
 >x99 : Symbol(x99, Decl(generatedContextualTyping.ts, 102, 89))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 103, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 103, 51))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 103, 51))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -802,6 +885,7 @@ class x100 { constructor(public parm: { (): Base[]; } = () => [d1, d2]) { } }
 >x100 : Symbol(x100, Decl(generatedContextualTyping.ts, 103, 95))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 104, 25))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 104, 55))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -809,6 +893,7 @@ class x101 { constructor(public parm: { (): Base[]; } = function() { return [d1,
 >x101 : Symbol(x101, Decl(generatedContextualTyping.ts, 104, 77))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 105, 25))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 105, 55))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -816,6 +901,7 @@ class x102 { constructor(public parm: { (): Base[]; } = function named() { retur
 >x102 : Symbol(x102, Decl(generatedContextualTyping.ts, 105, 93))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 106, 25))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 106, 55))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 106, 55))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -848,6 +934,7 @@ class x106 { constructor(public parm: {n: Base[]; }  = { n: [d1, d2] }) { } }
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 110, 25))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 110, 39))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 110, 54))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 110, 56))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -857,6 +944,7 @@ class x107 { constructor(public parm: (s: Base[]) => any = n => { var n: Base[];
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 111, 25))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 111, 39))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 111, 58))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 111, 58), Decl(generatedContextualTyping.ts, 111, 69))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 111, 58), Decl(generatedContextualTyping.ts, 111, 69))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -866,7 +954,9 @@ class x108 { constructor(public parm: Genric<Base> = { func: n => { return [d1,
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 112, 25))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 112, 52))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 112, 54))
+>n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 112, 60))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 112, 60))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -875,6 +965,7 @@ class x109 { constructor(private parm: () => Base[] = () => [d1, d2]) { } }
 >x109 : Symbol(x109, Decl(generatedContextualTyping.ts, 112, 95))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 113, 25))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 113, 53))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -882,6 +973,7 @@ class x110 { constructor(private parm: () => Base[] = function() { return [d1, d
 >x110 : Symbol(x110, Decl(generatedContextualTyping.ts, 113, 75))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 114, 25))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 114, 53))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -889,6 +981,7 @@ class x111 { constructor(private parm: () => Base[] = function named() { return
 >x111 : Symbol(x111, Decl(generatedContextualTyping.ts, 114, 91))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 115, 25))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 115, 53))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 115, 53))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -897,6 +990,7 @@ class x112 { constructor(private parm: { (): Base[]; } = () => [d1, d2]) { } }
 >x112 : Symbol(x112, Decl(generatedContextualTyping.ts, 115, 97))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 116, 25))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 116, 56))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -904,6 +998,7 @@ class x113 { constructor(private parm: { (): Base[]; } = function() { return [d1
 >x113 : Symbol(x113, Decl(generatedContextualTyping.ts, 116, 78))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 117, 25))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 117, 56))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -911,6 +1006,7 @@ class x114 { constructor(private parm: { (): Base[]; } = function named() { retu
 >x114 : Symbol(x114, Decl(generatedContextualTyping.ts, 117, 94))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 118, 25))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 118, 56))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 118, 56))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -943,6 +1039,7 @@ class x118 { constructor(private parm: {n: Base[]; }  = { n: [d1, d2] }) { } }
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 122, 25))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 122, 40))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 122, 55))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 122, 57))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -952,6 +1049,7 @@ class x119 { constructor(private parm: (s: Base[]) => any = n => { var n: Base[]
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 123, 25))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 123, 40))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 123, 59))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 123, 59), Decl(generatedContextualTyping.ts, 123, 70))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 123, 59), Decl(generatedContextualTyping.ts, 123, 70))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -961,7 +1059,9 @@ class x120 { constructor(private parm: Genric<Base> = { func: n => { return [d1,
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 124, 25))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 124, 53))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 124, 55))
+>n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 124, 61))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 124, 61))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -970,6 +1070,7 @@ function x121(parm: () => Base[] = () => [d1, d2]) { }
 >x121 : Symbol(x121, Decl(generatedContextualTyping.ts, 124, 96))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 125, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 125, 34))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -977,6 +1078,7 @@ function x122(parm: () => Base[] = function() { return [d1, d2] }) { }
 >x122 : Symbol(x122, Decl(generatedContextualTyping.ts, 125, 54))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 126, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 126, 34))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -984,6 +1086,7 @@ function x123(parm: () => Base[] = function named() { return [d1, d2] }) { }
 >x123 : Symbol(x123, Decl(generatedContextualTyping.ts, 126, 70))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 127, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 127, 34))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 127, 34))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -992,6 +1095,7 @@ function x124(parm: { (): Base[]; } = () => [d1, d2]) { }
 >x124 : Symbol(x124, Decl(generatedContextualTyping.ts, 127, 76))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 128, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 128, 37))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -999,6 +1103,7 @@ function x125(parm: { (): Base[]; } = function() { return [d1, d2] }) { }
 >x125 : Symbol(x125, Decl(generatedContextualTyping.ts, 128, 57))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 129, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 129, 37))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1006,6 +1111,7 @@ function x126(parm: { (): Base[]; } = function named() { return [d1, d2] }) { }
 >x126 : Symbol(x126, Decl(generatedContextualTyping.ts, 129, 73))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 130, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 130, 37))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 130, 37))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1038,6 +1144,7 @@ function x130(parm: {n: Base[]; }  = { n: [d1, d2] }) { }
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 134, 14))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 134, 21))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 134, 36))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 134, 38))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1047,6 +1154,7 @@ function x131(parm: (s: Base[]) => any = n => { var n: Base[]; return null; }) {
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 135, 14))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 135, 21))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 135, 40))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 135, 40), Decl(generatedContextualTyping.ts, 135, 51))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 135, 40), Decl(generatedContextualTyping.ts, 135, 51))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -1056,7 +1164,9 @@ function x132(parm: Genric<Base> = { func: n => { return [d1, d2]; } }) { }
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 136, 14))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 136, 34))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 136, 36))
+>n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 136, 42))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 136, 42))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1064,18 +1174,21 @@ function x132(parm: Genric<Base> = { func: n => { return [d1, d2]; } }) { }
 function x133(): () => Base[] { return () => [d1, d2]; }
 >x133 : Symbol(x133, Decl(generatedContextualTyping.ts, 136, 75))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 137, 38))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 function x134(): () => Base[] { return function() { return [d1, d2] }; }
 >x134 : Symbol(x134, Decl(generatedContextualTyping.ts, 137, 56))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 138, 38))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 function x135(): () => Base[] { return function named() { return [d1, d2] }; }
 >x135 : Symbol(x135, Decl(generatedContextualTyping.ts, 138, 72))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 139, 38))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 139, 38))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1083,18 +1196,21 @@ function x135(): () => Base[] { return function named() { return [d1, d2] }; }
 function x136(): { (): Base[]; } { return () => [d1, d2]; }
 >x136 : Symbol(x136, Decl(generatedContextualTyping.ts, 139, 78))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 140, 41))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 function x137(): { (): Base[]; } { return function() { return [d1, d2] }; }
 >x137 : Symbol(x137, Decl(generatedContextualTyping.ts, 140, 59))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 141, 41))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 function x138(): { (): Base[]; } { return function named() { return [d1, d2] }; }
 >x138 : Symbol(x138, Decl(generatedContextualTyping.ts, 141, 75))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 142, 41))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 142, 41))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1123,6 +1239,7 @@ function x142(): {n: Base[]; }  { return { n: [d1, d2] }; }
 >x142 : Symbol(x142, Decl(generatedContextualTyping.ts, 145, 60))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 146, 18))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 146, 40))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 146, 42))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1131,6 +1248,7 @@ function x143(): (s: Base[]) => any { return n => { var n: Base[]; return null;
 >x143 : Symbol(x143, Decl(generatedContextualTyping.ts, 146, 59))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 147, 18))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 147, 44))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 147, 44), Decl(generatedContextualTyping.ts, 147, 55))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 147, 44), Decl(generatedContextualTyping.ts, 147, 55))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -1139,7 +1257,9 @@ function x144(): Genric<Base> { return { func: n => { return [d1, d2]; } }; }
 >x144 : Symbol(x144, Decl(generatedContextualTyping.ts, 147, 84))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 148, 38))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 148, 40))
+>n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 148, 46))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 148, 46))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1147,25 +1267,31 @@ function x144(): Genric<Base> { return { func: n => { return [d1, d2]; } }; }
 function x145(): () => Base[] { return () => [d1, d2]; return () => [d1, d2]; }
 >x145 : Symbol(x145, Decl(generatedContextualTyping.ts, 148, 77))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 149, 38))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 149, 61))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 function x146(): () => Base[] { return function() { return [d1, d2] }; return function() { return [d1, d2] }; }
 >x146 : Symbol(x146, Decl(generatedContextualTyping.ts, 149, 79))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 150, 38))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 150, 77))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 function x147(): () => Base[] { return function named() { return [d1, d2] }; return function named() { return [d1, d2] }; }
 >x147 : Symbol(x147, Decl(generatedContextualTyping.ts, 150, 111))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 151, 38))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 151, 38))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 151, 83))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 151, 83))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1173,25 +1299,31 @@ function x147(): () => Base[] { return function named() { return [d1, d2] }; ret
 function x148(): { (): Base[]; } { return () => [d1, d2]; return () => [d1, d2]; }
 >x148 : Symbol(x148, Decl(generatedContextualTyping.ts, 151, 123))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 152, 41))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 152, 64))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 function x149(): { (): Base[]; } { return function() { return [d1, d2] }; return function() { return [d1, d2] }; }
 >x149 : Symbol(x149, Decl(generatedContextualTyping.ts, 152, 82))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 153, 41))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 153, 80))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 function x150(): { (): Base[]; } { return function named() { return [d1, d2] }; return function named() { return [d1, d2] }; }
 >x150 : Symbol(x150, Decl(generatedContextualTyping.ts, 153, 114))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 154, 41))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 154, 41))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 154, 86))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 154, 86))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1226,9 +1358,11 @@ function x154(): {n: Base[]; }  { return { n: [d1, d2] }; return { n: [d1, d2] }
 >x154 : Symbol(x154, Decl(generatedContextualTyping.ts, 157, 77))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 158, 18))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 158, 40))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 158, 42))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 158, 64))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 158, 66))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1237,9 +1371,11 @@ function x155(): (s: Base[]) => any { return n => { var n: Base[]; return null;
 >x155 : Symbol(x155, Decl(generatedContextualTyping.ts, 158, 83))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 159, 18))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 159, 44))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 44), Decl(generatedContextualTyping.ts, 159, 55))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 44), Decl(generatedContextualTyping.ts, 159, 55))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 159, 89))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 89), Decl(generatedContextualTyping.ts, 159, 100))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 89), Decl(generatedContextualTyping.ts, 159, 100))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -1248,11 +1384,15 @@ function x156(): Genric<Base> { return { func: n => { return [d1, d2]; } }; retu
 >x156 : Symbol(x156, Decl(generatedContextualTyping.ts, 159, 129))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 160, 38))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 160, 40))
+>n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 160, 46))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 160, 46))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 160, 82))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 160, 84))
+>n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 160, 90))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 160, 90))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1260,18 +1400,24 @@ function x156(): Genric<Base> { return { func: n => { return [d1, d2]; } }; retu
 var x157: () => () => Base[] = () => { return () => [d1, d2]; };
 >x157 : Symbol(x157, Decl(generatedContextualTyping.ts, 161, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => { return () => [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 161, 30))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 161, 45))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x158: () => () => Base[] = () => { return function() { return [d1, d2] }; };
 >x158 : Symbol(x158, Decl(generatedContextualTyping.ts, 162, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => { return function() { return [d1, d2] }; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 162, 30))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 162, 45))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x159: () => () => Base[] = () => { return function named() { return [d1, d2] }; };
 >x159 : Symbol(x159, Decl(generatedContextualTyping.ts, 163, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => { return function named() { return [d1, d2] }; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 163, 30))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 163, 45))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 163, 45))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1279,18 +1425,24 @@ var x159: () => () => Base[] = () => { return function named() { return [d1, d2]
 var x160: () => { (): Base[]; } = () => { return () => [d1, d2]; };
 >x160 : Symbol(x160, Decl(generatedContextualTyping.ts, 164, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => { return () => [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 164, 33))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 164, 48))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x161: () => { (): Base[]; } = () => { return function() { return [d1, d2] }; };
 >x161 : Symbol(x161, Decl(generatedContextualTyping.ts, 165, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => { return function() { return [d1, d2] }; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 165, 33))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 165, 48))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x162: () => { (): Base[]; } = () => { return function named() { return [d1, d2] }; };
 >x162 : Symbol(x162, Decl(generatedContextualTyping.ts, 166, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => { return function named() { return [d1, d2] }; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 166, 33))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 166, 48))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 166, 48))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1298,6 +1450,7 @@ var x162: () => { (): Base[]; } = () => { return function named() { return [d1,
 var x163: () => Base[] = () => { return [d1, d2]; };
 >x163 : Symbol(x163, Decl(generatedContextualTyping.ts, 167, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 167, 24))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1305,6 +1458,7 @@ var x164: () => Array<Base> = () => { return [d1, d2]; };
 >x164 : Symbol(x164, Decl(generatedContextualTyping.ts, 168, 3))
 >Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 168, 29))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1312,6 +1466,7 @@ var x165: () => { [n: number]: Base; } = () => { return [d1, d2]; };
 >x165 : Symbol(x165, Decl(generatedContextualTyping.ts, 169, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 169, 19))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 169, 40))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1319,6 +1474,8 @@ var x166: () => {n: Base[]; }  = () => { return { n: [d1, d2] }; };
 >x166 : Symbol(x166, Decl(generatedContextualTyping.ts, 170, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 170, 17))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => { return { n: [d1, d2] }; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 170, 32))
+>{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 170, 47))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 170, 49))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1327,6 +1484,8 @@ var x167: () => (s: Base[]) => any = () => { return n => { var n: Base[]; return
 >x167 : Symbol(x167, Decl(generatedContextualTyping.ts, 171, 3))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 171, 17))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => { return n => { var n: Base[]; return null; }; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 171, 36))
+>n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 171, 51))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 171, 51), Decl(generatedContextualTyping.ts, 171, 62))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 171, 51), Decl(generatedContextualTyping.ts, 171, 62))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -1335,7 +1494,10 @@ var x168: () => Genric<Base> = () => { return { func: n => { return [d1, d2]; }
 >x168 : Symbol(x168, Decl(generatedContextualTyping.ts, 172, 3))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => { return { func: n => { return [d1, d2]; } }; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 172, 30))
+>{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 172, 45))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 172, 47))
+>n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 172, 53))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 172, 53))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1343,18 +1505,24 @@ var x168: () => Genric<Base> = () => { return { func: n => { return [d1, d2]; }
 var x169: () => () => Base[] = function() { return () => [d1, d2]; };
 >x169 : Symbol(x169, Decl(generatedContextualTyping.ts, 173, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return () => [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 173, 30))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 173, 50))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x170: () => () => Base[] = function() { return function() { return [d1, d2] }; };
 >x170 : Symbol(x170, Decl(generatedContextualTyping.ts, 174, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return function() { return [d1, d2] }; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 174, 30))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 174, 50))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x171: () => () => Base[] = function() { return function named() { return [d1, d2] }; };
 >x171 : Symbol(x171, Decl(generatedContextualTyping.ts, 175, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return function named() { return [d1, d2] }; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 175, 30))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 175, 50))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 175, 50))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1362,18 +1530,24 @@ var x171: () => () => Base[] = function() { return function named() { return [d1
 var x172: () => { (): Base[]; } = function() { return () => [d1, d2]; };
 >x172 : Symbol(x172, Decl(generatedContextualTyping.ts, 176, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return () => [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 176, 33))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 176, 53))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x173: () => { (): Base[]; } = function() { return function() { return [d1, d2] }; };
 >x173 : Symbol(x173, Decl(generatedContextualTyping.ts, 177, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return function() { return [d1, d2] }; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 177, 33))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 177, 53))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x174: () => { (): Base[]; } = function() { return function named() { return [d1, d2] }; };
 >x174 : Symbol(x174, Decl(generatedContextualTyping.ts, 178, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return function named() { return [d1, d2] }; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 178, 33))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 178, 53))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 178, 53))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1381,6 +1555,7 @@ var x174: () => { (): Base[]; } = function() { return function named() { return
 var x175: () => Base[] = function() { return [d1, d2]; };
 >x175 : Symbol(x175, Decl(generatedContextualTyping.ts, 179, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 179, 24))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1388,6 +1563,7 @@ var x176: () => Array<Base> = function() { return [d1, d2]; };
 >x176 : Symbol(x176, Decl(generatedContextualTyping.ts, 180, 3))
 >Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 180, 29))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1395,6 +1571,7 @@ var x177: () => { [n: number]: Base; } = function() { return [d1, d2]; };
 >x177 : Symbol(x177, Decl(generatedContextualTyping.ts, 181, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 181, 19))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 181, 40))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1402,6 +1579,8 @@ var x178: () => {n: Base[]; }  = function() { return { n: [d1, d2] }; };
 >x178 : Symbol(x178, Decl(generatedContextualTyping.ts, 182, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 182, 17))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return { n: [d1, d2] }; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 182, 32))
+>{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 182, 52))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 182, 54))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1410,6 +1589,8 @@ var x179: () => (s: Base[]) => any = function() { return n => { var n: Base[]; r
 >x179 : Symbol(x179, Decl(generatedContextualTyping.ts, 183, 3))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 183, 17))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return n => { var n: Base[]; return null; }; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 183, 36))
+>n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 183, 56))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 183, 56), Decl(generatedContextualTyping.ts, 183, 67))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 183, 56), Decl(generatedContextualTyping.ts, 183, 67))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -1418,7 +1599,10 @@ var x180: () => Genric<Base> = function() { return { func: n => { return [d1, d2
 >x180 : Symbol(x180, Decl(generatedContextualTyping.ts, 184, 3))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return { func: n => { return [d1, d2]; } }; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 184, 30))
+>{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 184, 50))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 184, 52))
+>n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 184, 58))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 184, 58))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1427,6 +1611,7 @@ module x181 { var t: () => Base[] = () => [d1, d2]; }
 >x181 : Symbol(x181, Decl(generatedContextualTyping.ts, 184, 90))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 185, 17))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 185, 35))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1434,6 +1619,7 @@ module x182 { var t: () => Base[] = function() { return [d1, d2] }; }
 >x182 : Symbol(x182, Decl(generatedContextualTyping.ts, 185, 53))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 186, 17))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 186, 35))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1441,6 +1627,7 @@ module x183 { var t: () => Base[] = function named() { return [d1, d2] }; }
 >x183 : Symbol(x183, Decl(generatedContextualTyping.ts, 186, 69))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 187, 17))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 187, 35))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 187, 35))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1449,6 +1636,7 @@ module x184 { var t: { (): Base[]; } = () => [d1, d2]; }
 >x184 : Symbol(x184, Decl(generatedContextualTyping.ts, 187, 75))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 188, 17))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 188, 38))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1456,6 +1644,7 @@ module x185 { var t: { (): Base[]; } = function() { return [d1, d2] }; }
 >x185 : Symbol(x185, Decl(generatedContextualTyping.ts, 188, 56))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 189, 17))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 189, 38))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1463,6 +1652,7 @@ module x186 { var t: { (): Base[]; } = function named() { return [d1, d2] }; }
 >x186 : Symbol(x186, Decl(generatedContextualTyping.ts, 189, 72))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 190, 17))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 190, 38))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 190, 38))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1495,6 +1685,7 @@ module x190 { var t: {n: Base[]; }  = { n: [d1, d2] }; }
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 194, 17))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 194, 22))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 194, 37))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 194, 39))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1504,6 +1695,7 @@ module x191 { var t: (s: Base[]) => any = n => { var n: Base[]; return null; };
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 195, 17))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 195, 22))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 195, 41))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 195, 41), Decl(generatedContextualTyping.ts, 195, 52))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 195, 41), Decl(generatedContextualTyping.ts, 195, 52))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -1513,7 +1705,9 @@ module x192 { var t: Genric<Base> = { func: n => { return [d1, d2]; } }; }
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 196, 17))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 196, 35))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 196, 37))
+>n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 196, 43))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 196, 43))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1522,6 +1716,7 @@ module x193 { export var t: () => Base[] = () => [d1, d2]; }
 >x193 : Symbol(x193, Decl(generatedContextualTyping.ts, 196, 74))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 197, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 197, 42))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1529,6 +1724,7 @@ module x194 { export var t: () => Base[] = function() { return [d1, d2] }; }
 >x194 : Symbol(x194, Decl(generatedContextualTyping.ts, 197, 60))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 198, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 198, 42))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1536,6 +1732,7 @@ module x195 { export var t: () => Base[] = function named() { return [d1, d2] };
 >x195 : Symbol(x195, Decl(generatedContextualTyping.ts, 198, 76))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 199, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 199, 42))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 199, 42))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1544,6 +1741,7 @@ module x196 { export var t: { (): Base[]; } = () => [d1, d2]; }
 >x196 : Symbol(x196, Decl(generatedContextualTyping.ts, 199, 82))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 200, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 200, 45))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1551,6 +1749,7 @@ module x197 { export var t: { (): Base[]; } = function() { return [d1, d2] }; }
 >x197 : Symbol(x197, Decl(generatedContextualTyping.ts, 200, 63))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 201, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 201, 45))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1558,6 +1757,7 @@ module x198 { export var t: { (): Base[]; } = function named() { return [d1, d2]
 >x198 : Symbol(x198, Decl(generatedContextualTyping.ts, 201, 79))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 202, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 202, 45))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 202, 45))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1590,6 +1790,7 @@ module x202 { export var t: {n: Base[]; }  = { n: [d1, d2] }; }
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 206, 24))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 206, 29))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 206, 44))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 206, 46))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1599,6 +1800,7 @@ module x203 { export var t: (s: Base[]) => any = n => { var n: Base[]; return nu
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 207, 24))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 207, 29))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 207, 48))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 207, 48), Decl(generatedContextualTyping.ts, 207, 59))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 207, 48), Decl(generatedContextualTyping.ts, 207, 59))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -1608,7 +1810,9 @@ module x204 { export var t: Genric<Base> = { func: n => { return [d1, d2]; } };
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 208, 24))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 208, 42))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 208, 44))
+>n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 208, 50))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 208, 50))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1616,12 +1820,14 @@ module x204 { export var t: Genric<Base> = { func: n => { return [d1, d2]; } };
 var x206 = <() => Base[]>function() { return [d1, d2] };
 >x206 : Symbol(x206, Decl(generatedContextualTyping.ts, 209, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 209, 25))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x207 = <() => Base[]>function named() { return [d1, d2] };
 >x207 : Symbol(x207, Decl(generatedContextualTyping.ts, 210, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 210, 25))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 210, 25))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1629,12 +1835,14 @@ var x207 = <() => Base[]>function named() { return [d1, d2] };
 var x209 = <{ (): Base[]; }>function() { return [d1, d2] };
 >x209 : Symbol(x209, Decl(generatedContextualTyping.ts, 211, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 211, 28))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x210 = <{ (): Base[]; }>function named() { return [d1, d2] };
 >x210 : Symbol(x210, Decl(generatedContextualTyping.ts, 212, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 212, 28))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 212, 28))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1663,6 +1871,7 @@ var x214 = <{n: Base[]; } >{ n: [d1, d2] };
 >x214 : Symbol(x214, Decl(generatedContextualTyping.ts, 216, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 216, 13))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 216, 27))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 216, 28))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1671,7 +1880,9 @@ var x216 = <Genric<Base>>{ func: n => { return [d1, d2]; } };
 >x216 : Symbol(x216, Decl(generatedContextualTyping.ts, 217, 3))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 217, 25))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 217, 26))
+>n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 217, 32))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 217, 32))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1680,6 +1891,7 @@ var x217 = (<() => Base[]>undefined) || function() { return [d1, d2] };
 >x217 : Symbol(x217, Decl(generatedContextualTyping.ts, 218, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 218, 39))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1687,6 +1899,7 @@ var x218 = (<() => Base[]>undefined) || function named() { return [d1, d2] };
 >x218 : Symbol(x218, Decl(generatedContextualTyping.ts, 219, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 219, 39))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 219, 39))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1695,6 +1908,7 @@ var x219 = (<{ (): Base[]; }>undefined) || function() { return [d1, d2] };
 >x219 : Symbol(x219, Decl(generatedContextualTyping.ts, 220, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 220, 42))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1702,6 +1916,7 @@ var x220 = (<{ (): Base[]; }>undefined) || function named() { return [d1, d2] };
 >x220 : Symbol(x220, Decl(generatedContextualTyping.ts, 221, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 221, 42))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 221, 42))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1734,6 +1949,7 @@ var x224 = (<{n: Base[]; } >undefined) || { n: [d1, d2] };
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 225, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
+>{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 225, 41))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 225, 43))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1742,6 +1958,7 @@ var x225: () => Base[]; x225 = () => [d1, d2];
 >x225 : Symbol(x225, Decl(generatedContextualTyping.ts, 226, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x225 : Symbol(x225, Decl(generatedContextualTyping.ts, 226, 3))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 226, 30))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1749,6 +1966,7 @@ var x226: () => Base[]; x226 = function() { return [d1, d2] };
 >x226 : Symbol(x226, Decl(generatedContextualTyping.ts, 227, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x226 : Symbol(x226, Decl(generatedContextualTyping.ts, 227, 3))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 227, 30))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1756,6 +1974,7 @@ var x227: () => Base[]; x227 = function named() { return [d1, d2] };
 >x227 : Symbol(x227, Decl(generatedContextualTyping.ts, 228, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x227 : Symbol(x227, Decl(generatedContextualTyping.ts, 228, 3))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 228, 30))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 228, 30))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1764,6 +1983,7 @@ var x228: { (): Base[]; }; x228 = () => [d1, d2];
 >x228 : Symbol(x228, Decl(generatedContextualTyping.ts, 229, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x228 : Symbol(x228, Decl(generatedContextualTyping.ts, 229, 3))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 229, 33))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1771,6 +1991,7 @@ var x229: { (): Base[]; }; x229 = function() { return [d1, d2] };
 >x229 : Symbol(x229, Decl(generatedContextualTyping.ts, 230, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x229 : Symbol(x229, Decl(generatedContextualTyping.ts, 230, 3))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 230, 33))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1778,6 +1999,7 @@ var x230: { (): Base[]; }; x230 = function named() { return [d1, d2] };
 >x230 : Symbol(x230, Decl(generatedContextualTyping.ts, 231, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x230 : Symbol(x230, Decl(generatedContextualTyping.ts, 231, 3))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 231, 33))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 231, 33))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1810,6 +2032,7 @@ var x234: {n: Base[]; } ; x234 = { n: [d1, d2] };
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 235, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x234 : Symbol(x234, Decl(generatedContextualTyping.ts, 235, 3))
+>{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 235, 32))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 235, 34))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1819,6 +2042,7 @@ var x235: (s: Base[]) => any; x235 = n => { var n: Base[]; return null; };
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 236, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x235 : Symbol(x235, Decl(generatedContextualTyping.ts, 236, 3))
+>n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 236, 36))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 236, 36), Decl(generatedContextualTyping.ts, 236, 47))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 236, 36), Decl(generatedContextualTyping.ts, 236, 47))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -1828,7 +2052,9 @@ var x236: Genric<Base>; x236 = { func: n => { return [d1, d2]; } };
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x236 : Symbol(x236, Decl(generatedContextualTyping.ts, 237, 3))
+>{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 237, 30))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 237, 32))
+>n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 237, 38))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 237, 38))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1837,7 +2063,9 @@ var x237: { n: () => Base[]; } = { n: () => [d1, d2] };
 >x237 : Symbol(x237, Decl(generatedContextualTyping.ts, 238, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 238, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ n: () => [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 238, 32))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 238, 34))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 238, 37))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1845,7 +2073,9 @@ var x238: { n: () => Base[]; } = { n: function() { return [d1, d2] } };
 >x238 : Symbol(x238, Decl(generatedContextualTyping.ts, 239, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 239, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ n: function() { return [d1, d2] } } : Symbol(, Decl(generatedContextualTyping.ts, 239, 32))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 239, 34))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 239, 37))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1853,7 +2083,9 @@ var x239: { n: () => Base[]; } = { n: function named() { return [d1, d2] } };
 >x239 : Symbol(x239, Decl(generatedContextualTyping.ts, 240, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 240, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ n: function named() { return [d1, d2] } } : Symbol(, Decl(generatedContextualTyping.ts, 240, 32))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 240, 34))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 240, 37))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 240, 37))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1862,7 +2094,9 @@ var x240: { n: { (): Base[]; }; } = { n: () => [d1, d2] };
 >x240 : Symbol(x240, Decl(generatedContextualTyping.ts, 241, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 241, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ n: () => [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 241, 35))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 241, 37))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 241, 40))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1870,7 +2104,9 @@ var x241: { n: { (): Base[]; }; } = { n: function() { return [d1, d2] } };
 >x241 : Symbol(x241, Decl(generatedContextualTyping.ts, 242, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 242, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ n: function() { return [d1, d2] } } : Symbol(, Decl(generatedContextualTyping.ts, 242, 35))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 242, 37))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 242, 40))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1878,7 +2114,9 @@ var x242: { n: { (): Base[]; }; } = { n: function named() { return [d1, d2] } };
 >x242 : Symbol(x242, Decl(generatedContextualTyping.ts, 243, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 243, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ n: function named() { return [d1, d2] } } : Symbol(, Decl(generatedContextualTyping.ts, 243, 35))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 243, 37))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 243, 40))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 243, 40))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1887,6 +2125,7 @@ var x243: { n: Base[]; } = { n: [d1, d2] };
 >x243 : Symbol(x243, Decl(generatedContextualTyping.ts, 244, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 244, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 244, 26))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 244, 28))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1896,6 +2135,7 @@ var x244: { n: Array<Base>; } = { n: [d1, d2] };
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 245, 11))
 >Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 245, 31))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 245, 33))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1905,6 +2145,7 @@ var x245: { n: { [n: number]: Base; }; } = { n: [d1, d2] };
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 246, 11))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 246, 18))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 246, 42))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 246, 44))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1914,7 +2155,9 @@ var x246: { n: {n: Base[]; } ; } = { n: { n: [d1, d2] } };
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 11))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 16))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ n: { n: [d1, d2] } } : Symbol(, Decl(generatedContextualTyping.ts, 247, 34))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 36))
+>{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 247, 39))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 41))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1924,7 +2167,9 @@ var x247: { n: (s: Base[]) => any; } = { n: n => { var n: Base[]; return null; }
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 11))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 248, 16))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ n: n => { var n: Base[]; return null; } } : Symbol(, Decl(generatedContextualTyping.ts, 248, 38))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 40))
+>n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 248, 43))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 43), Decl(generatedContextualTyping.ts, 248, 54))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 43), Decl(generatedContextualTyping.ts, 248, 54))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -1934,8 +2179,11 @@ var x248: { n: Genric<Base>; } = { n: { func: n => { return [d1, d2]; } } };
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 11))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ n: { func: n => { return [d1, d2]; } } } : Symbol(, Decl(generatedContextualTyping.ts, 249, 32))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 34))
+>{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 249, 37))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 249, 39))
+>n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 249, 45))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 45))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1943,18 +2191,21 @@ var x248: { n: Genric<Base>; } = { n: { func: n => { return [d1, d2]; } } };
 var x252: { (): Base[]; }[] = [() => [d1, d2]];
 >x252 : Symbol(x252, Decl(generatedContextualTyping.ts, 250, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 250, 31))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x253: { (): Base[]; }[] = [function() { return [d1, d2] }];
 >x253 : Symbol(x253, Decl(generatedContextualTyping.ts, 251, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 251, 31))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x254: { (): Base[]; }[] = [function named() { return [d1, d2] }];
 >x254 : Symbol(x254, Decl(generatedContextualTyping.ts, 252, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 252, 31))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 252, 31))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1983,6 +2234,7 @@ var x258: {n: Base[]; } [] = [{ n: [d1, d2] }];
 >x258 : Symbol(x258, Decl(generatedContextualTyping.ts, 256, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 256, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 256, 30))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 256, 31))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1991,7 +2243,9 @@ var x260: Genric<Base>[] = [{ func: n => { return [d1, d2]; } }];
 >x260 : Symbol(x260, Decl(generatedContextualTyping.ts, 257, 3))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 257, 28))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 257, 29))
+>n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 257, 35))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 257, 35))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1999,6 +2253,7 @@ var x260: Genric<Base>[] = [{ func: n => { return [d1, d2]; } }];
 var x261: () => Base[] = function() { return [d1, d2] } || undefined;
 >x261 : Symbol(x261, Decl(generatedContextualTyping.ts, 258, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 258, 24))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 >undefined : Symbol(undefined)
@@ -2006,6 +2261,7 @@ var x261: () => Base[] = function() { return [d1, d2] } || undefined;
 var x262: () => Base[] = function named() { return [d1, d2] } || undefined;
 >x262 : Symbol(x262, Decl(generatedContextualTyping.ts, 259, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 259, 24))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 259, 24))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2014,6 +2270,7 @@ var x262: () => Base[] = function named() { return [d1, d2] } || undefined;
 var x263: { (): Base[]; } = function() { return [d1, d2] } || undefined;
 >x263 : Symbol(x263, Decl(generatedContextualTyping.ts, 260, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 260, 27))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 >undefined : Symbol(undefined)
@@ -2021,6 +2278,7 @@ var x263: { (): Base[]; } = function() { return [d1, d2] } || undefined;
 var x264: { (): Base[]; } = function named() { return [d1, d2] } || undefined;
 >x264 : Symbol(x264, Decl(generatedContextualTyping.ts, 261, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 261, 27))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 261, 27))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2053,6 +2311,7 @@ var x268: {n: Base[]; }  = { n: [d1, d2] } || undefined;
 >x268 : Symbol(x268, Decl(generatedContextualTyping.ts, 265, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 265, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 265, 26))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 265, 28))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2062,6 +2321,7 @@ var x269: () => Base[] = undefined || function() { return [d1, d2] };
 >x269 : Symbol(x269, Decl(generatedContextualTyping.ts, 266, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 266, 37))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -2069,6 +2329,7 @@ var x270: () => Base[] = undefined || function named() { return [d1, d2] };
 >x270 : Symbol(x270, Decl(generatedContextualTyping.ts, 267, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 267, 37))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 267, 37))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2077,6 +2338,7 @@ var x271: { (): Base[]; } = undefined || function() { return [d1, d2] };
 >x271 : Symbol(x271, Decl(generatedContextualTyping.ts, 268, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 268, 40))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -2084,6 +2346,7 @@ var x272: { (): Base[]; } = undefined || function named() { return [d1, d2] };
 >x272 : Symbol(x272, Decl(generatedContextualTyping.ts, 269, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 269, 40))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 269, 40))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2116,6 +2379,7 @@ var x276: {n: Base[]; }  = undefined || { n: [d1, d2] };
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 273, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
+>{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 273, 39))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 273, 41))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2123,17 +2387,21 @@ var x276: {n: Base[]; }  = undefined || { n: [d1, d2] };
 var x277: () => Base[] = function() { return [d1, d2] } || function() { return [d1, d2] };
 >x277 : Symbol(x277, Decl(generatedContextualTyping.ts, 274, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 274, 24))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 274, 58))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x278: () => Base[] = function named() { return [d1, d2] } || function named() { return [d1, d2] };
 >x278 : Symbol(x278, Decl(generatedContextualTyping.ts, 275, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 275, 24))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 275, 24))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 275, 64))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 275, 64))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2141,17 +2409,21 @@ var x278: () => Base[] = function named() { return [d1, d2] } || function named(
 var x279: { (): Base[]; } = function() { return [d1, d2] } || function() { return [d1, d2] };
 >x279 : Symbol(x279, Decl(generatedContextualTyping.ts, 276, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 276, 27))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 276, 61))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x280: { (): Base[]; } = function named() { return [d1, d2] } || function named() { return [d1, d2] };
 >x280 : Symbol(x280, Decl(generatedContextualTyping.ts, 277, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 277, 27))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 277, 27))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 277, 67))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 277, 67))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2186,9 +2458,11 @@ var x284: {n: Base[]; }  = { n: [d1, d2] } || { n: [d1, d2] };
 >x284 : Symbol(x284, Decl(generatedContextualTyping.ts, 281, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 281, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 281, 26))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 281, 28))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 281, 45))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 281, 47))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2196,25 +2470,31 @@ var x284: {n: Base[]; }  = { n: [d1, d2] } || { n: [d1, d2] };
 var x285: () => Base[] = true ? () => [d1, d2] : () => [d1, d2];
 >x285 : Symbol(x285, Decl(generatedContextualTyping.ts, 282, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 282, 31))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 282, 48))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x286: () => Base[] = true ? function() { return [d1, d2] } : function() { return [d1, d2] };
 >x286 : Symbol(x286, Decl(generatedContextualTyping.ts, 283, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 283, 31))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 283, 64))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x287: () => Base[] = true ? function named() { return [d1, d2] } : function named() { return [d1, d2] };
 >x287 : Symbol(x287, Decl(generatedContextualTyping.ts, 284, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 284, 31))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 284, 31))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 284, 70))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 284, 70))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2222,25 +2502,31 @@ var x287: () => Base[] = true ? function named() { return [d1, d2] } : function
 var x288: { (): Base[]; } = true ? () => [d1, d2] : () => [d1, d2];
 >x288 : Symbol(x288, Decl(generatedContextualTyping.ts, 285, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 285, 34))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 285, 51))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x289: { (): Base[]; } = true ? function() { return [d1, d2] } : function() { return [d1, d2] };
 >x289 : Symbol(x289, Decl(generatedContextualTyping.ts, 286, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 286, 34))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 286, 67))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x290: { (): Base[]; } = true ? function named() { return [d1, d2] } : function named() { return [d1, d2] };
 >x290 : Symbol(x290, Decl(generatedContextualTyping.ts, 287, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 287, 34))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 287, 34))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 287, 73))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 287, 73))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2275,9 +2561,11 @@ var x294: {n: Base[]; }  = true ? { n: [d1, d2] } : { n: [d1, d2] };
 >x294 : Symbol(x294, Decl(generatedContextualTyping.ts, 291, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 291, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 291, 33))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 291, 35))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 291, 51))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 291, 53))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2286,9 +2574,11 @@ var x295: (s: Base[]) => any = true ? n => { var n: Base[]; return null; } : n =
 >x295 : Symbol(x295, Decl(generatedContextualTyping.ts, 292, 3))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 292, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 292, 37))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 37), Decl(generatedContextualTyping.ts, 292, 48))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 37), Decl(generatedContextualTyping.ts, 292, 48))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 292, 76))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 76), Decl(generatedContextualTyping.ts, 292, 87))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 76), Decl(generatedContextualTyping.ts, 292, 87))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -2297,11 +2587,15 @@ var x296: Genric<Base> = true ? { func: n => { return [d1, d2]; } } : { func: n
 >x296 : Symbol(x296, Decl(generatedContextualTyping.ts, 293, 3))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 293, 31))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 293, 33))
+>n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 293, 39))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 293, 39))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 293, 69))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 293, 71))
+>n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 293, 77))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 293, 77))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2310,6 +2604,7 @@ var x297: () => Base[] = true ? undefined : () => [d1, d2];
 >x297 : Symbol(x297, Decl(generatedContextualTyping.ts, 294, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 294, 43))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -2317,6 +2612,7 @@ var x298: () => Base[] = true ? undefined : function() { return [d1, d2] };
 >x298 : Symbol(x298, Decl(generatedContextualTyping.ts, 295, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 295, 43))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -2324,6 +2620,7 @@ var x299: () => Base[] = true ? undefined : function named() { return [d1, d2] }
 >x299 : Symbol(x299, Decl(generatedContextualTyping.ts, 296, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 296, 43))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 296, 43))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2332,6 +2629,7 @@ var x300: { (): Base[]; } = true ? undefined : () => [d1, d2];
 >x300 : Symbol(x300, Decl(generatedContextualTyping.ts, 297, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 297, 46))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -2339,6 +2637,7 @@ var x301: { (): Base[]; } = true ? undefined : function() { return [d1, d2] };
 >x301 : Symbol(x301, Decl(generatedContextualTyping.ts, 298, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 298, 46))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -2346,6 +2645,7 @@ var x302: { (): Base[]; } = true ? undefined : function named() { return [d1, d2
 >x302 : Symbol(x302, Decl(generatedContextualTyping.ts, 299, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 299, 46))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 299, 46))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2378,6 +2678,7 @@ var x306: {n: Base[]; }  = true ? undefined : { n: [d1, d2] };
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 303, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
+>{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 303, 45))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 303, 47))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2387,6 +2688,7 @@ var x307: (s: Base[]) => any = true ? undefined : n => { var n: Base[]; return n
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 304, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
+>n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 304, 49))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 304, 49), Decl(generatedContextualTyping.ts, 304, 60))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 304, 49), Decl(generatedContextualTyping.ts, 304, 60))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -2396,7 +2698,9 @@ var x308: Genric<Base> = true ? undefined : { func: n => { return [d1, d2]; } };
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
+>{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 305, 43))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 305, 45))
+>n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 305, 51))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 305, 51))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2404,6 +2708,7 @@ var x308: Genric<Base> = true ? undefined : { func: n => { return [d1, d2]; } };
 var x309: () => Base[] = true ? () => [d1, d2] : undefined;
 >x309 : Symbol(x309, Decl(generatedContextualTyping.ts, 306, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 306, 31))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 >undefined : Symbol(undefined)
@@ -2411,6 +2716,7 @@ var x309: () => Base[] = true ? () => [d1, d2] : undefined;
 var x310: () => Base[] = true ? function() { return [d1, d2] } : undefined;
 >x310 : Symbol(x310, Decl(generatedContextualTyping.ts, 307, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 307, 31))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 >undefined : Symbol(undefined)
@@ -2418,6 +2724,7 @@ var x310: () => Base[] = true ? function() { return [d1, d2] } : undefined;
 var x311: () => Base[] = true ? function named() { return [d1, d2] } : undefined;
 >x311 : Symbol(x311, Decl(generatedContextualTyping.ts, 308, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 308, 31))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 308, 31))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2426,6 +2733,7 @@ var x311: () => Base[] = true ? function named() { return [d1, d2] } : undefined
 var x312: { (): Base[]; } = true ? () => [d1, d2] : undefined;
 >x312 : Symbol(x312, Decl(generatedContextualTyping.ts, 309, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 309, 34))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 >undefined : Symbol(undefined)
@@ -2433,6 +2741,7 @@ var x312: { (): Base[]; } = true ? () => [d1, d2] : undefined;
 var x313: { (): Base[]; } = true ? function() { return [d1, d2] } : undefined;
 >x313 : Symbol(x313, Decl(generatedContextualTyping.ts, 310, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 310, 34))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 >undefined : Symbol(undefined)
@@ -2440,6 +2749,7 @@ var x313: { (): Base[]; } = true ? function() { return [d1, d2] } : undefined;
 var x314: { (): Base[]; } = true ? function named() { return [d1, d2] } : undefined;
 >x314 : Symbol(x314, Decl(generatedContextualTyping.ts, 311, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 311, 34))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 311, 34))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2472,6 +2782,7 @@ var x318: {n: Base[]; }  = true ? { n: [d1, d2] } : undefined;
 >x318 : Symbol(x318, Decl(generatedContextualTyping.ts, 315, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 315, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 315, 33))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 315, 35))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2481,6 +2792,7 @@ var x319: (s: Base[]) => any = true ? n => { var n: Base[]; return null; } : und
 >x319 : Symbol(x319, Decl(generatedContextualTyping.ts, 316, 3))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 316, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 316, 37))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 316, 37), Decl(generatedContextualTyping.ts, 316, 48))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 316, 37), Decl(generatedContextualTyping.ts, 316, 48))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -2490,7 +2802,9 @@ var x320: Genric<Base> = true ? { func: n => { return [d1, d2]; } } : undefined;
 >x320 : Symbol(x320, Decl(generatedContextualTyping.ts, 317, 3))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 317, 31))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 317, 33))
+>n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 317, 39))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 317, 39))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2501,6 +2815,7 @@ function x321(n: () => Base[]) { }; x321(() => [d1, d2]);
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 318, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x321 : Symbol(x321, Decl(generatedContextualTyping.ts, 317, 80))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 318, 41))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -2509,6 +2824,7 @@ function x322(n: () => Base[]) { }; x322(function() { return [d1, d2] });
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 319, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x322 : Symbol(x322, Decl(generatedContextualTyping.ts, 318, 57))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 319, 41))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -2517,6 +2833,7 @@ function x323(n: () => Base[]) { }; x323(function named() { return [d1, d2] });
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 320, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x323 : Symbol(x323, Decl(generatedContextualTyping.ts, 319, 73))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 320, 41))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 320, 41))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2526,6 +2843,7 @@ function x324(n: { (): Base[]; }) { }; x324(() => [d1, d2]);
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 321, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x324 : Symbol(x324, Decl(generatedContextualTyping.ts, 320, 79))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 321, 44))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -2534,6 +2852,7 @@ function x325(n: { (): Base[]; }) { }; x325(function() { return [d1, d2] });
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 322, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x325 : Symbol(x325, Decl(generatedContextualTyping.ts, 321, 60))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 322, 44))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -2542,6 +2861,7 @@ function x326(n: { (): Base[]; }) { }; x326(function named() { return [d1, d2] }
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 323, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x326 : Symbol(x326, Decl(generatedContextualTyping.ts, 322, 76))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 323, 44))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 323, 44))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2578,6 +2898,7 @@ function x330(n: {n: Base[]; } ) { }; x330({ n: [d1, d2] });
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 327, 18))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x330 : Symbol(x330, Decl(generatedContextualTyping.ts, 326, 61))
+>{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 327, 43))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 327, 44))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2588,6 +2909,7 @@ function x331(n: (s: Base[]) => any) { }; x331(n => { var n: Base[]; return null
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 328, 18))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x331 : Symbol(x331, Decl(generatedContextualTyping.ts, 327, 60))
+>n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 328, 47))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 328, 47), Decl(generatedContextualTyping.ts, 328, 57))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 328, 47), Decl(generatedContextualTyping.ts, 328, 57))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -2598,69 +2920,84 @@ function x332(n: Genric<Base>) { }; x332({ func: n => { return [d1, d2]; } });
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x332 : Symbol(x332, Decl(generatedContextualTyping.ts, 328, 85))
+>{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 329, 41))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 329, 42))
+>n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 329, 48))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 329, 48))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x333 = (n: () => Base[]) => n; x333(() => [d1, d2]);
 >x333 : Symbol(x333, Decl(generatedContextualTyping.ts, 330, 3))
+>(n: () => Base[]) => n : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 330, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 330, 12))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 330, 12))
 >x333 : Symbol(x333, Decl(generatedContextualTyping.ts, 330, 3))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 330, 40))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x334 = (n: () => Base[]) => n; x334(function() { return [d1, d2] });
 >x334 : Symbol(x334, Decl(generatedContextualTyping.ts, 331, 3))
+>(n: () => Base[]) => n : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 331, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 331, 12))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 331, 12))
 >x334 : Symbol(x334, Decl(generatedContextualTyping.ts, 331, 3))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 331, 40))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x335 = (n: () => Base[]) => n; x335(function named() { return [d1, d2] });
 >x335 : Symbol(x335, Decl(generatedContextualTyping.ts, 332, 3))
+>(n: () => Base[]) => n : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 332, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 332, 12))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 332, 12))
 >x335 : Symbol(x335, Decl(generatedContextualTyping.ts, 332, 3))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 332, 40))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 332, 40))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x336 = (n: { (): Base[]; }) => n; x336(() => [d1, d2]);
 >x336 : Symbol(x336, Decl(generatedContextualTyping.ts, 333, 3))
+>(n: { (): Base[]; }) => n : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 333, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 333, 12))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 333, 12))
 >x336 : Symbol(x336, Decl(generatedContextualTyping.ts, 333, 3))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 333, 43))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x337 = (n: { (): Base[]; }) => n; x337(function() { return [d1, d2] });
 >x337 : Symbol(x337, Decl(generatedContextualTyping.ts, 334, 3))
+>(n: { (): Base[]; }) => n : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 334, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 334, 12))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 334, 12))
 >x337 : Symbol(x337, Decl(generatedContextualTyping.ts, 334, 3))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 334, 43))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x338 = (n: { (): Base[]; }) => n; x338(function named() { return [d1, d2] });
 >x338 : Symbol(x338, Decl(generatedContextualTyping.ts, 335, 3))
+>(n: { (): Base[]; }) => n : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 335, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 335, 12))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 335, 12))
 >x338 : Symbol(x338, Decl(generatedContextualTyping.ts, 335, 3))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 335, 43))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 335, 43))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x339 = (n: Base[]) => n; x339([d1, d2]);
 >x339 : Symbol(x339, Decl(generatedContextualTyping.ts, 336, 3))
+>(n: Base[]) => n : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 336, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 336, 12))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 336, 12))
@@ -2670,6 +3007,7 @@ var x339 = (n: Base[]) => n; x339([d1, d2]);
 
 var x340 = (n: Array<Base>) => n; x340([d1, d2]);
 >x340 : Symbol(x340, Decl(generatedContextualTyping.ts, 337, 3))
+>(n: Array<Base>) => n : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 337, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 337, 12))
 >Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -2680,6 +3018,7 @@ var x340 = (n: Array<Base>) => n; x340([d1, d2]);
 
 var x341 = (n: { [n: number]: Base; }) => n; x341([d1, d2]);
 >x341 : Symbol(x341, Decl(generatedContextualTyping.ts, 338, 3))
+>(n: { [n: number]: Base; }) => n : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 338, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 338, 12))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 338, 18))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -2690,90 +3029,110 @@ var x341 = (n: { [n: number]: Base; }) => n; x341([d1, d2]);
 
 var x342 = (n: {n: Base[]; } ) => n; x342({ n: [d1, d2] });
 >x342 : Symbol(x342, Decl(generatedContextualTyping.ts, 339, 3))
+>(n: {n: Base[]; } ) => n : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 339, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 339, 12))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 339, 16))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 339, 12))
 >x342 : Symbol(x342, Decl(generatedContextualTyping.ts, 339, 3))
+>{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 339, 42))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 339, 43))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x343 = (n: (s: Base[]) => any) => n; x343(n => { var n: Base[]; return null; });
 >x343 : Symbol(x343, Decl(generatedContextualTyping.ts, 340, 3))
+>(n: (s: Base[]) => any) => n : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 340, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 12))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 340, 16))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 12))
 >x343 : Symbol(x343, Decl(generatedContextualTyping.ts, 340, 3))
+>n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 340, 46))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 46), Decl(generatedContextualTyping.ts, 340, 56))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 46), Decl(generatedContextualTyping.ts, 340, 56))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 
 var x344 = (n: Genric<Base>) => n; x344({ func: n => { return [d1, d2]; } });
 >x344 : Symbol(x344, Decl(generatedContextualTyping.ts, 341, 3))
+>(n: Genric<Base>) => n : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 341, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 341, 12))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 341, 12))
 >x344 : Symbol(x344, Decl(generatedContextualTyping.ts, 341, 3))
+>{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 341, 40))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 341, 41))
+>n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 341, 47))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 341, 47))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x345 = function(n: () => Base[]) { }; x345(() => [d1, d2]);
 >x345 : Symbol(x345, Decl(generatedContextualTyping.ts, 342, 3))
+>function(n: () => Base[]) { } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 342, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 342, 20))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x345 : Symbol(x345, Decl(generatedContextualTyping.ts, 342, 3))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 342, 47))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x346 = function(n: () => Base[]) { }; x346(function() { return [d1, d2] });
 >x346 : Symbol(x346, Decl(generatedContextualTyping.ts, 343, 3))
+>function(n: () => Base[]) { } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 343, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 343, 20))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x346 : Symbol(x346, Decl(generatedContextualTyping.ts, 343, 3))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 343, 47))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x347 = function(n: () => Base[]) { }; x347(function named() { return [d1, d2] });
 >x347 : Symbol(x347, Decl(generatedContextualTyping.ts, 344, 3))
+>function(n: () => Base[]) { } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 344, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 344, 20))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x347 : Symbol(x347, Decl(generatedContextualTyping.ts, 344, 3))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 344, 47))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 344, 47))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x348 = function(n: { (): Base[]; }) { }; x348(() => [d1, d2]);
 >x348 : Symbol(x348, Decl(generatedContextualTyping.ts, 345, 3))
+>function(n: { (): Base[]; }) { } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 345, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 345, 20))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x348 : Symbol(x348, Decl(generatedContextualTyping.ts, 345, 3))
+>() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 345, 50))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x349 = function(n: { (): Base[]; }) { }; x349(function() { return [d1, d2] });
 >x349 : Symbol(x349, Decl(generatedContextualTyping.ts, 346, 3))
+>function(n: { (): Base[]; }) { } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 346, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 346, 20))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x349 : Symbol(x349, Decl(generatedContextualTyping.ts, 346, 3))
+>function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 346, 50))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x350 = function(n: { (): Base[]; }) { }; x350(function named() { return [d1, d2] });
 >x350 : Symbol(x350, Decl(generatedContextualTyping.ts, 347, 3))
+>function(n: { (): Base[]; }) { } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 347, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 347, 20))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x350 : Symbol(x350, Decl(generatedContextualTyping.ts, 347, 3))
+>function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 347, 50))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 347, 50))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x351 = function(n: Base[]) { }; x351([d1, d2]);
 >x351 : Symbol(x351, Decl(generatedContextualTyping.ts, 348, 3))
+>function(n: Base[]) { } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 348, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 348, 20))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x351 : Symbol(x351, Decl(generatedContextualTyping.ts, 348, 3))
@@ -2782,6 +3141,7 @@ var x351 = function(n: Base[]) { }; x351([d1, d2]);
 
 var x352 = function(n: Array<Base>) { }; x352([d1, d2]);
 >x352 : Symbol(x352, Decl(generatedContextualTyping.ts, 349, 3))
+>function(n: Array<Base>) { } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 349, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 349, 20))
 >Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -2791,6 +3151,7 @@ var x352 = function(n: Array<Base>) { }; x352([d1, d2]);
 
 var x353 = function(n: { [n: number]: Base; }) { }; x353([d1, d2]);
 >x353 : Symbol(x353, Decl(generatedContextualTyping.ts, 350, 3))
+>function(n: { [n: number]: Base; }) { } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 350, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 350, 20))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 350, 26))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -2800,31 +3161,38 @@ var x353 = function(n: { [n: number]: Base; }) { }; x353([d1, d2]);
 
 var x354 = function(n: {n: Base[]; } ) { }; x354({ n: [d1, d2] });
 >x354 : Symbol(x354, Decl(generatedContextualTyping.ts, 351, 3))
+>function(n: {n: Base[]; } ) { } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 351, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 351, 20))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 351, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x354 : Symbol(x354, Decl(generatedContextualTyping.ts, 351, 3))
+>{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 351, 49))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 351, 50))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x355 = function(n: (s: Base[]) => any) { }; x355(n => { var n: Base[]; return null; });
 >x355 : Symbol(x355, Decl(generatedContextualTyping.ts, 352, 3))
+>function(n: (s: Base[]) => any) { } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 352, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 352, 20))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 352, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x355 : Symbol(x355, Decl(generatedContextualTyping.ts, 352, 3))
+>n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 352, 53))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 352, 53), Decl(generatedContextualTyping.ts, 352, 63))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 352, 53), Decl(generatedContextualTyping.ts, 352, 63))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 
 var x356 = function(n: Genric<Base>) { }; x356({ func: n => { return [d1, d2]; } });
 >x356 : Symbol(x356, Decl(generatedContextualTyping.ts, 353, 3))
+>function(n: Genric<Base>) { } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 353, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 353, 20))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x356 : Symbol(x356, Decl(generatedContextualTyping.ts, 353, 3))
+>{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 353, 47))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 353, 48))
+>n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 353, 54))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 353, 54))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
diff --git a/tests/baselines/reference/generatorES6_3.symbols b/tests/baselines/reference/generatorES6_3.symbols
index 329c96e6de8ec..0f14389a1559e 100644
--- a/tests/baselines/reference/generatorES6_3.symbols
+++ b/tests/baselines/reference/generatorES6_3.symbols
@@ -1,6 +1,7 @@
 === tests/cases/compiler/generatorES6_3.ts ===
 var v = function*() {
 >v : Symbol(v, Decl(generatorES6_3.ts, 0, 3))
+>function*() {    yield 0} : Symbol((Anonymous function), Decl(generatorES6_3.ts, 0, 7))
 
     yield 0
 }
diff --git a/tests/baselines/reference/generatorES6_4.symbols b/tests/baselines/reference/generatorES6_4.symbols
index fc514dad45f1e..4e6bd9bb40068 100644
--- a/tests/baselines/reference/generatorES6_4.symbols
+++ b/tests/baselines/reference/generatorES6_4.symbols
@@ -1,6 +1,7 @@
 === tests/cases/compiler/generatorES6_4.ts ===
 var v = { 
 >v : Symbol(v, Decl(generatorES6_4.ts, 0, 3))
+>{    *foo() {       yield 0   }} : Symbol(, Decl(generatorES6_4.ts, 0, 7))
 
    *foo() {
 >foo : Symbol(foo, Decl(generatorES6_4.ts, 0, 9))
diff --git a/tests/baselines/reference/generatorTypeCheck26.symbols b/tests/baselines/reference/generatorTypeCheck26.symbols
index 08cc7289ef872..fd9252086dc3a 100644
--- a/tests/baselines/reference/generatorTypeCheck26.symbols
+++ b/tests/baselines/reference/generatorTypeCheck26.symbols
@@ -5,18 +5,21 @@ function* g(): IterableIterator<(x: string) => number> {
 >x : Symbol(x, Decl(generatorTypeCheck26.ts, 0, 33))
 
     yield x => x.length;
+>x => x.length : Symbol((Anonymous function), Decl(generatorTypeCheck26.ts, 1, 9))
 >x : Symbol(x, Decl(generatorTypeCheck26.ts, 1, 9))
 >x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >x : Symbol(x, Decl(generatorTypeCheck26.ts, 1, 9))
 >length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 
     yield *[x => x.length];
+>x => x.length : Symbol((Anonymous function), Decl(generatorTypeCheck26.ts, 2, 12))
 >x : Symbol(x, Decl(generatorTypeCheck26.ts, 2, 12))
 >x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >x : Symbol(x, Decl(generatorTypeCheck26.ts, 2, 12))
 >length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 
     return x => x.length;
+>x => x.length : Symbol((Anonymous function), Decl(generatorTypeCheck26.ts, 3, 10))
 >x : Symbol(x, Decl(generatorTypeCheck26.ts, 3, 10))
 >x : Symbol(x, Decl(generatorTypeCheck26.ts, 3, 10))
 }
diff --git a/tests/baselines/reference/generatorTypeCheck27.symbols b/tests/baselines/reference/generatorTypeCheck27.symbols
index fcee922d1e909..2df08fdf91b38 100644
--- a/tests/baselines/reference/generatorTypeCheck27.symbols
+++ b/tests/baselines/reference/generatorTypeCheck27.symbols
@@ -5,7 +5,10 @@ function* g(): IterableIterator<(x: string) => number> {
 >x : Symbol(x, Decl(generatorTypeCheck27.ts, 0, 33))
 
     yield * function* () {
+>function* () {        yield x => x.length;    } : Symbol((Anonymous function), Decl(generatorTypeCheck27.ts, 1, 11))
+
         yield x => x.length;
+>x => x.length : Symbol((Anonymous function), Decl(generatorTypeCheck27.ts, 2, 13))
 >x : Symbol(x, Decl(generatorTypeCheck27.ts, 2, 13))
 >x : Symbol(x, Decl(generatorTypeCheck27.ts, 2, 13))
 
diff --git a/tests/baselines/reference/generatorTypeCheck28.symbols b/tests/baselines/reference/generatorTypeCheck28.symbols
index 27b246515f603..47cdc8aa32e77 100644
--- a/tests/baselines/reference/generatorTypeCheck28.symbols
+++ b/tests/baselines/reference/generatorTypeCheck28.symbols
@@ -5,12 +5,15 @@ function* g(): IterableIterator<(x: string) => number> {
 >x : Symbol(x, Decl(generatorTypeCheck28.ts, 0, 33))
 
     yield * {
+>{        *[Symbol.iterator]() {            yield x => x.length;        }    } : Symbol(, Decl(generatorTypeCheck28.ts, 1, 11))
+
         *[Symbol.iterator]() {
 >Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31))
 >Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11))
 >iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31))
 
             yield x => x.length;
+>x => x.length : Symbol((Anonymous function), Decl(generatorTypeCheck28.ts, 3, 17))
 >x : Symbol(x, Decl(generatorTypeCheck28.ts, 3, 17))
 >x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >x : Symbol(x, Decl(generatorTypeCheck28.ts, 3, 17))
diff --git a/tests/baselines/reference/generatorTypeCheck29.symbols b/tests/baselines/reference/generatorTypeCheck29.symbols
index 260137dd1cf3a..3ae180d20e681 100644
--- a/tests/baselines/reference/generatorTypeCheck29.symbols
+++ b/tests/baselines/reference/generatorTypeCheck29.symbols
@@ -6,7 +6,10 @@ function* g2(): Iterator<Iterable<(x: string) => number>> {
 >x : Symbol(x, Decl(generatorTypeCheck29.ts, 0, 35))
 
     yield function* () {
+>function* () {        yield x => x.length;    } : Symbol((Anonymous function), Decl(generatorTypeCheck29.ts, 1, 9))
+
         yield x => x.length;
+>x => x.length : Symbol((Anonymous function), Decl(generatorTypeCheck29.ts, 2, 13))
 >x : Symbol(x, Decl(generatorTypeCheck29.ts, 2, 13))
 >x : Symbol(x, Decl(generatorTypeCheck29.ts, 2, 13))
 
diff --git a/tests/baselines/reference/generatorTypeCheck30.symbols b/tests/baselines/reference/generatorTypeCheck30.symbols
index 086c65685a8e3..16b8dba03e121 100644
--- a/tests/baselines/reference/generatorTypeCheck30.symbols
+++ b/tests/baselines/reference/generatorTypeCheck30.symbols
@@ -6,7 +6,10 @@ function* g2(): Iterator<Iterable<(x: string) => number>> {
 >x : Symbol(x, Decl(generatorTypeCheck30.ts, 0, 35))
 
     yield function* () {
+>function* () {        yield x => x.length;    } : Symbol((Anonymous function), Decl(generatorTypeCheck30.ts, 1, 9))
+
         yield x => x.length;
+>x => x.length : Symbol((Anonymous function), Decl(generatorTypeCheck30.ts, 2, 13))
 >x : Symbol(x, Decl(generatorTypeCheck30.ts, 2, 13))
 >x : Symbol(x, Decl(generatorTypeCheck30.ts, 2, 13))
 
diff --git a/tests/baselines/reference/generatorTypeCheck41.symbols b/tests/baselines/reference/generatorTypeCheck41.symbols
index 9111affa87569..42290619120b3 100644
--- a/tests/baselines/reference/generatorTypeCheck41.symbols
+++ b/tests/baselines/reference/generatorTypeCheck41.symbols
@@ -4,6 +4,7 @@ function* g() {
 
     let x = {
 >x : Symbol(x, Decl(generatorTypeCheck41.ts, 1, 7))
+>{        [yield 0]: 0    } : Symbol(, Decl(generatorTypeCheck41.ts, 1, 11))
 
         [yield 0]: 0
     }
diff --git a/tests/baselines/reference/generatorTypeCheck42.symbols b/tests/baselines/reference/generatorTypeCheck42.symbols
index a49534fd21112..eb5a58a1b5cde 100644
--- a/tests/baselines/reference/generatorTypeCheck42.symbols
+++ b/tests/baselines/reference/generatorTypeCheck42.symbols
@@ -4,6 +4,7 @@ function* g() {
 
     let x = {
 >x : Symbol(x, Decl(generatorTypeCheck42.ts, 1, 7))
+>{        [yield 0]() {        }    } : Symbol(, Decl(generatorTypeCheck42.ts, 1, 11))
 
         [yield 0]() {
 
diff --git a/tests/baselines/reference/generatorTypeCheck43.symbols b/tests/baselines/reference/generatorTypeCheck43.symbols
index f5f7b6c359f44..9b119a242c7b2 100644
--- a/tests/baselines/reference/generatorTypeCheck43.symbols
+++ b/tests/baselines/reference/generatorTypeCheck43.symbols
@@ -4,6 +4,7 @@ function* g() {
 
     let x = {
 >x : Symbol(x, Decl(generatorTypeCheck43.ts, 1, 7))
+>{        *[yield 0]() {        }    } : Symbol(, Decl(generatorTypeCheck43.ts, 1, 11))
 
         *[yield 0]() {
 
diff --git a/tests/baselines/reference/generatorTypeCheck44.symbols b/tests/baselines/reference/generatorTypeCheck44.symbols
index b6606064c438a..9c0b41f006774 100644
--- a/tests/baselines/reference/generatorTypeCheck44.symbols
+++ b/tests/baselines/reference/generatorTypeCheck44.symbols
@@ -4,6 +4,7 @@ function* g() {
 
     let x = {
 >x : Symbol(x, Decl(generatorTypeCheck44.ts, 1, 7))
+>{        get [yield 0]() {            return 0;        }    } : Symbol(, Decl(generatorTypeCheck44.ts, 1, 11))
 
         get [yield 0]() {
             return 0;
diff --git a/tests/baselines/reference/generatorTypeCheck45.symbols b/tests/baselines/reference/generatorTypeCheck45.symbols
index 89c01ff020353..202ec8a317a27 100644
--- a/tests/baselines/reference/generatorTypeCheck45.symbols
+++ b/tests/baselines/reference/generatorTypeCheck45.symbols
@@ -18,10 +18,13 @@ declare function foo<T, U>(x: T, fun: () => Iterator<(x: T) => U>, fun2: (y: U)
 
 foo("", function* () { yield x => x.length }, p => undefined); // T is fixed, should be string
 >foo : Symbol(foo, Decl(generatorTypeCheck45.ts, 0, 0))
+>function* () { yield x => x.length } : Symbol((Anonymous function), Decl(generatorTypeCheck45.ts, 2, 7))
+>x => x.length : Symbol((Anonymous function), Decl(generatorTypeCheck45.ts, 2, 28))
 >x : Symbol(x, Decl(generatorTypeCheck45.ts, 2, 28))
 >x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >x : Symbol(x, Decl(generatorTypeCheck45.ts, 2, 28))
 >length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>p => undefined : Symbol((Anonymous function), Decl(generatorTypeCheck45.ts, 2, 45))
 >p : Symbol(p, Decl(generatorTypeCheck45.ts, 2, 45))
 >undefined : Symbol(undefined)
 
diff --git a/tests/baselines/reference/generatorTypeCheck46.symbols b/tests/baselines/reference/generatorTypeCheck46.symbols
index 72d8ebf57a167..d2d3c708f5483 100644
--- a/tests/baselines/reference/generatorTypeCheck46.symbols
+++ b/tests/baselines/reference/generatorTypeCheck46.symbols
@@ -18,14 +18,18 @@ declare function foo<T, U>(x: T, fun: () => Iterable<(x: T) => U>, fun2: (y: U)
 
 foo("", function* () {
 >foo : Symbol(foo, Decl(generatorTypeCheck46.ts, 0, 0))
+>function* () {    yield* {        *[Symbol.iterator]() {            yield x => x.length        }    }} : Symbol((Anonymous function), Decl(generatorTypeCheck46.ts, 2, 7))
 
     yield* {
+>{        *[Symbol.iterator]() {            yield x => x.length        }    } : Symbol(, Decl(generatorTypeCheck46.ts, 3, 10))
+
         *[Symbol.iterator]() {
 >Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31))
 >Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11))
 >iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31))
 
             yield x => x.length
+>x => x.length : Symbol((Anonymous function), Decl(generatorTypeCheck46.ts, 5, 17))
 >x : Symbol(x, Decl(generatorTypeCheck46.ts, 5, 17))
 >x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >x : Symbol(x, Decl(generatorTypeCheck46.ts, 5, 17))
@@ -33,6 +37,7 @@ foo("", function* () {
         }
     }
 }, p => undefined); // T is fixed, should be string
+>p => undefined : Symbol((Anonymous function), Decl(generatorTypeCheck46.ts, 8, 2))
 >p : Symbol(p, Decl(generatorTypeCheck46.ts, 8, 2))
 >undefined : Symbol(undefined)
 
diff --git a/tests/baselines/reference/genericArray1.symbols b/tests/baselines/reference/genericArray1.symbols
index b403bd2b72043..11aad48a16a91 100644
--- a/tests/baselines/reference/genericArray1.symbols
+++ b/tests/baselines/reference/genericArray1.symbols
@@ -15,6 +15,7 @@ var lengths = ["a", "b", "c"].map(x => x.length);
 >lengths : Symbol(lengths, Decl(genericArray1.ts, 12, 3))
 >["a", "b", "c"].map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
 >map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>x => x.length : Symbol((Anonymous function), Decl(genericArray1.ts, 12, 34))
 >x : Symbol(x, Decl(genericArray1.ts, 12, 34))
 >x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >x : Symbol(x, Decl(genericArray1.ts, 12, 34))
diff --git a/tests/baselines/reference/genericBaseClassLiteralProperty2.symbols b/tests/baselines/reference/genericBaseClassLiteralProperty2.symbols
index 5ddccd40e389c..18d0aa15d3ebc 100644
--- a/tests/baselines/reference/genericBaseClassLiteralProperty2.symbols
+++ b/tests/baselines/reference/genericBaseClassLiteralProperty2.symbols
@@ -17,6 +17,7 @@ class BaseCollection2<TItem extends CollectionItem2> {
 >this._itemsByKey : Symbol(_itemsByKey, Decl(genericBaseClassLiteralProperty2.ts, 2, 54))
 >this : Symbol(BaseCollection2, Decl(genericBaseClassLiteralProperty2.ts, 0, 25))
 >_itemsByKey : Symbol(_itemsByKey, Decl(genericBaseClassLiteralProperty2.ts, 2, 54))
+>{} : Symbol(, Decl(genericBaseClassLiteralProperty2.ts, 5, 26))
     }
 }
 
diff --git a/tests/baselines/reference/genericCallWithObjectTypeArgs2.symbols b/tests/baselines/reference/genericCallWithObjectTypeArgs2.symbols
index f567499d4c984..5d41eef1a3f45 100644
--- a/tests/baselines/reference/genericCallWithObjectTypeArgs2.symbols
+++ b/tests/baselines/reference/genericCallWithObjectTypeArgs2.symbols
@@ -45,6 +45,7 @@ function f<T extends Base, U extends Base>(a: { x: T; y: U }) {
 var r = f({ x: new Derived(), y: new Derived2() }); // {}[]
 >r : Symbol(r, Decl(genericCallWithObjectTypeArgs2.ts, 15, 3))
 >f : Symbol(f, Decl(genericCallWithObjectTypeArgs2.ts, 8, 1))
+>{ x: new Derived(), y: new Derived2() } : Symbol(, Decl(genericCallWithObjectTypeArgs2.ts, 15, 10))
 >x : Symbol(x, Decl(genericCallWithObjectTypeArgs2.ts, 15, 11))
 >Derived : Symbol(Derived, Decl(genericCallWithObjectTypeArgs2.ts, 2, 1))
 >y : Symbol(y, Decl(genericCallWithObjectTypeArgs2.ts, 15, 29))
@@ -53,6 +54,7 @@ var r = f({ x: new Derived(), y: new Derived2() }); // {}[]
 var r2 = f({ x: new Base(), y: new Derived2() }); // {}[]
 >r2 : Symbol(r2, Decl(genericCallWithObjectTypeArgs2.ts, 16, 3))
 >f : Symbol(f, Decl(genericCallWithObjectTypeArgs2.ts, 8, 1))
+>{ x: new Base(), y: new Derived2() } : Symbol(, Decl(genericCallWithObjectTypeArgs2.ts, 16, 11))
 >x : Symbol(x, Decl(genericCallWithObjectTypeArgs2.ts, 16, 12))
 >Base : Symbol(Base, Decl(genericCallWithObjectTypeArgs2.ts, 0, 0))
 >y : Symbol(y, Decl(genericCallWithObjectTypeArgs2.ts, 16, 27))
@@ -72,6 +74,7 @@ function f2<T extends Base, U extends Base>(a: { x: T; y: U }) {
 >U : Symbol(U, Decl(genericCallWithObjectTypeArgs2.ts, 19, 27))
 
     return (x: T) => a.y;
+>(x: T) => a.y : Symbol((Anonymous function), Decl(genericCallWithObjectTypeArgs2.ts, 20, 10))
 >x : Symbol(x, Decl(genericCallWithObjectTypeArgs2.ts, 20, 12))
 >T : Symbol(T, Decl(genericCallWithObjectTypeArgs2.ts, 19, 12))
 >a.y : Symbol(y, Decl(genericCallWithObjectTypeArgs2.ts, 19, 54))
@@ -82,6 +85,7 @@ function f2<T extends Base, U extends Base>(a: { x: T; y: U }) {
 var r3 = f2({ x: new Derived(), y: new Derived2() }); // Derived => Derived2
 >r3 : Symbol(r3, Decl(genericCallWithObjectTypeArgs2.ts, 23, 3))
 >f2 : Symbol(f2, Decl(genericCallWithObjectTypeArgs2.ts, 16, 49))
+>{ x: new Derived(), y: new Derived2() } : Symbol(, Decl(genericCallWithObjectTypeArgs2.ts, 23, 12))
 >x : Symbol(x, Decl(genericCallWithObjectTypeArgs2.ts, 23, 13))
 >Derived : Symbol(Derived, Decl(genericCallWithObjectTypeArgs2.ts, 2, 1))
 >y : Symbol(y, Decl(genericCallWithObjectTypeArgs2.ts, 23, 31))
diff --git a/tests/baselines/reference/genericCallWithObjectTypeArgsAndConstraints2.symbols b/tests/baselines/reference/genericCallWithObjectTypeArgsAndConstraints2.symbols
index 864927a3a8c6f..d168eeea133a7 100644
--- a/tests/baselines/reference/genericCallWithObjectTypeArgsAndConstraints2.symbols
+++ b/tests/baselines/reference/genericCallWithObjectTypeArgsAndConstraints2.symbols
@@ -36,6 +36,7 @@ function f<T extends Base>(x: { foo: T; bar: T }) {
 var r = f({ foo: new Base(), bar: new Derived() });
 >r : Symbol(r, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 14, 3))
 >f : Symbol(f, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 8, 1))
+>{ foo: new Base(), bar: new Derived() } : Symbol(, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 14, 10))
 >foo : Symbol(foo, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 14, 11))
 >Base : Symbol(Base, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 0, 0))
 >bar : Symbol(bar, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 14, 28))
@@ -44,6 +45,7 @@ var r = f({ foo: new Base(), bar: new Derived() });
 var r2 = f({ foo: new Derived(), bar: new Derived() });
 >r2 : Symbol(r2, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 15, 3))
 >f : Symbol(f, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 8, 1))
+>{ foo: new Derived(), bar: new Derived() } : Symbol(, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 15, 11))
 >foo : Symbol(foo, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 15, 12))
 >Derived : Symbol(Derived, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 5, 1))
 >bar : Symbol(bar, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 15, 32))
@@ -102,6 +104,7 @@ var r4 = f3(new Base(), x => x);
 >r4 : Symbol(r4, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 32, 3))
 >f3 : Symbol(f3, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 26, 15))
 >Base : Symbol(Base, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 0, 0))
+>x => x : Symbol((Anonymous function), Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 32, 23))
 >x : Symbol(x, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 32, 23))
 >x : Symbol(x, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 32, 23))
 
@@ -109,6 +112,7 @@ var r5 = f3(new Derived(), x => x);
 >r5 : Symbol(r5, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 33, 3))
 >f3 : Symbol(f3, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 26, 15))
 >Derived : Symbol(Derived, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 5, 1))
+>x => x : Symbol((Anonymous function), Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 33, 26))
 >x : Symbol(x, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 33, 26))
 >x : Symbol(x, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 33, 26))
 
@@ -119,6 +123,7 @@ var r6 = f3(null, null); // any
 var r7 = f3(null, x => x); // any
 >r7 : Symbol(r7, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 36, 3))
 >f3 : Symbol(f3, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 26, 15))
+>x => x : Symbol((Anonymous function), Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 36, 17))
 >x : Symbol(x, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 36, 17))
 >x : Symbol(x, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 36, 17))
 
diff --git a/tests/baselines/reference/genericCallWithOverloadedFunctionTypedArguments.symbols b/tests/baselines/reference/genericCallWithOverloadedFunctionTypedArguments.symbols
index 1d32c55fd33e4..553c0e1f07e03 100644
--- a/tests/baselines/reference/genericCallWithOverloadedFunctionTypedArguments.symbols
+++ b/tests/baselines/reference/genericCallWithOverloadedFunctionTypedArguments.symbols
@@ -32,6 +32,7 @@ module NonGenericParameter {
     var r2 = foo4(<T>(x: T) => x);
 >r2 : Symbol(r2, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 14, 7))
 >foo4 : Symbol(foo4, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 7, 5))
+><T>(x: T) => x : Symbol((Anonymous function), Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 14, 18))
 >T : Symbol(T, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 14, 19))
 >x : Symbol(x, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 14, 22))
 >T : Symbol(T, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 14, 19))
@@ -40,6 +41,7 @@ module NonGenericParameter {
     var r4 = foo4(x => x);    
 >r4 : Symbol(r4, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 15, 7))
 >foo4 : Symbol(foo4, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 7, 5))
+>x => x : Symbol((Anonymous function), Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 15, 18))
 >x : Symbol(x, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 15, 18))
 >x : Symbol(x, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 15, 18))
 }
@@ -63,6 +65,7 @@ module GenericParameter {
     var r5 = foo5(x => x); // any => string (+1 overload) [inferences are made for T, but lambda not contextually typed]. T is any
 >r5 : Symbol(r5, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 23, 7))
 >foo5 : Symbol(foo5, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 18, 25))
+>x => x : Symbol((Anonymous function), Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 23, 18))
 >x : Symbol(x, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 23, 18))
 >x : Symbol(x, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 23, 18))
 
@@ -98,12 +101,14 @@ module GenericParameter {
     var r8 = foo6(x => x); // any => string (+1 overload) [inferences are made for T, but lambda not contextually typed]. T is any
 >r8 : Symbol(r8, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 31, 7))
 >foo6 : Symbol(foo6, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 25, 21))
+>x => x : Symbol((Anonymous function), Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 31, 18))
 >x : Symbol(x, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 31, 18))
 >x : Symbol(x, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 31, 18))
 
     var r9 = foo6(<T>(x: T) => ''); // any => string (+1 overload)
 >r9 : Symbol(r9, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 32, 7))
 >foo6 : Symbol(foo6, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 25, 21))
+><T>(x: T) => '' : Symbol((Anonymous function), Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 32, 18))
 >T : Symbol(T, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 32, 19))
 >x : Symbol(x, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 32, 22))
 >T : Symbol(T, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 32, 19))
@@ -111,6 +116,7 @@ module GenericParameter {
     var r11 = foo6(<T>(x: T, y?: T) => ''); // any => string (+1 overload)
 >r11 : Symbol(r11, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 33, 7))
 >foo6 : Symbol(foo6, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 25, 21))
+><T>(x: T, y?: T) => '' : Symbol((Anonymous function), Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 33, 19))
 >T : Symbol(T, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 33, 20))
 >x : Symbol(x, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 33, 23))
 >T : Symbol(T, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 33, 20))
@@ -137,12 +143,14 @@ module GenericParameter {
     var r12 = foo7(1, (x) => x); // any => string (+1 overload) [inferences are made for T, but lambda not contextually typed]
 >r12 : Symbol(r12, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 39, 7))
 >foo7 : Symbol(foo7, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 33, 43))
+>(x) => x : Symbol((Anonymous function), Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 39, 21))
 >x : Symbol(x, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 39, 23))
 >x : Symbol(x, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 39, 23))
 
     var r13 = foo7(1, <T>(x: T) => ''); // any => string (+1 overload) [inferences are made for T, but lambda not contextually typed]
 >r13 : Symbol(r13, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 40, 7))
 >foo7 : Symbol(foo7, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 33, 43))
+><T>(x: T) => '' : Symbol((Anonymous function), Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 40, 21))
 >T : Symbol(T, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 40, 23))
 >x : Symbol(x, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 40, 26))
 >T : Symbol(T, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 40, 23))
diff --git a/tests/baselines/reference/genericCallbacksAndClassHierarchy.symbols b/tests/baselines/reference/genericCallbacksAndClassHierarchy.symbols
index be46c49a9ca09..f4f8f11562655 100644
--- a/tests/baselines/reference/genericCallbacksAndClassHierarchy.symbols
+++ b/tests/baselines/reference/genericCallbacksAndClassHierarchy.symbols
@@ -47,6 +47,7 @@ module M {
 
             var f = (newValue: A<T>) => { };
 >f : Symbol(f, Decl(genericCallbacksAndClassHierarchy.ts, 13, 15))
+>(newValue: A<T>) => { } : Symbol((Anonymous function), Decl(genericCallbacksAndClassHierarchy.ts, 13, 19))
 >newValue : Symbol(newValue, Decl(genericCallbacksAndClassHierarchy.ts, 13, 21))
 >A : Symbol(A, Decl(genericCallbacksAndClassHierarchy.ts, 6, 5))
 >T : Symbol(T, Decl(genericCallbacksAndClassHierarchy.ts, 11, 19))
@@ -71,6 +72,7 @@ module M {
 >v.subscribe : Symbol(I.subscribe, Decl(genericCallbacksAndClassHierarchy.ts, 1, 27))
 >v : Symbol(v, Decl(genericCallbacksAndClassHierarchy.ts, 15, 15))
 >subscribe : Symbol(I.subscribe, Decl(genericCallbacksAndClassHierarchy.ts, 1, 27))
+>(newValue: A<T>) => { } : Symbol((Anonymous function), Decl(genericCallbacksAndClassHierarchy.ts, 19, 24))
 >newValue : Symbol(newValue, Decl(genericCallbacksAndClassHierarchy.ts, 19, 25))
 >A : Symbol(A, Decl(genericCallbacksAndClassHierarchy.ts, 6, 5))
 >T : Symbol(T, Decl(genericCallbacksAndClassHierarchy.ts, 11, 19))
diff --git a/tests/baselines/reference/genericContextualTypingSpecialization.symbols b/tests/baselines/reference/genericContextualTypingSpecialization.symbols
index 05312d889c986..ce17c68901b82 100644
--- a/tests/baselines/reference/genericContextualTypingSpecialization.symbols
+++ b/tests/baselines/reference/genericContextualTypingSpecialization.symbols
@@ -6,6 +6,7 @@ b.reduce<number>((c, d) => c + d, 0); // should not error on '+'
 >b.reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120))
 >b : Symbol(b, Decl(genericContextualTypingSpecialization.ts, 0, 3))
 >reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120))
+>(c, d) => c + d : Symbol((Anonymous function), Decl(genericContextualTypingSpecialization.ts, 1, 17))
 >c : Symbol(c, Decl(genericContextualTypingSpecialization.ts, 1, 18))
 >d : Symbol(d, Decl(genericContextualTypingSpecialization.ts, 1, 20))
 >c : Symbol(c, Decl(genericContextualTypingSpecialization.ts, 1, 18))
diff --git a/tests/baselines/reference/genericFunctionHasFreshTypeArgs.symbols b/tests/baselines/reference/genericFunctionHasFreshTypeArgs.symbols
index 0baf9eda80fcc..a8dc86a423c0f 100644
--- a/tests/baselines/reference/genericFunctionHasFreshTypeArgs.symbols
+++ b/tests/baselines/reference/genericFunctionHasFreshTypeArgs.symbols
@@ -8,8 +8,10 @@ function f(p: <T>(x: T) => void) { };
 
 f(x => f(y => x = y));
 >f : Symbol(f, Decl(genericFunctionHasFreshTypeArgs.ts, 0, 0))
+>x => f(y => x = y) : Symbol((Anonymous function), Decl(genericFunctionHasFreshTypeArgs.ts, 1, 2))
 >x : Symbol(x, Decl(genericFunctionHasFreshTypeArgs.ts, 1, 2))
 >f : Symbol(f, Decl(genericFunctionHasFreshTypeArgs.ts, 0, 0))
+>y => x = y : Symbol((Anonymous function), Decl(genericFunctionHasFreshTypeArgs.ts, 1, 9))
 >y : Symbol(y, Decl(genericFunctionHasFreshTypeArgs.ts, 1, 9))
 >x : Symbol(x, Decl(genericFunctionHasFreshTypeArgs.ts, 1, 2))
 >y : Symbol(y, Decl(genericFunctionHasFreshTypeArgs.ts, 1, 9))
diff --git a/tests/baselines/reference/genericFunctions2.symbols b/tests/baselines/reference/genericFunctions2.symbols
index 59068cbd8dda1..a49787f9212ab 100644
--- a/tests/baselines/reference/genericFunctions2.symbols
+++ b/tests/baselines/reference/genericFunctions2.symbols
@@ -18,6 +18,7 @@ var lengths = map(myItems, x => x.length);
 >lengths : Symbol(lengths, Decl(genericFunctions2.ts, 3, 3))
 >map : Symbol(map, Decl(genericFunctions2.ts, 0, 0))
 >myItems : Symbol(myItems, Decl(genericFunctions2.ts, 2, 3))
+>x => x.length : Symbol((Anonymous function), Decl(genericFunctions2.ts, 3, 26))
 >x : Symbol(x, Decl(genericFunctions2.ts, 3, 26))
 >x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >x : Symbol(x, Decl(genericFunctions2.ts, 3, 26))
diff --git a/tests/baselines/reference/genericFunctionsWithOptionalParameters3.symbols b/tests/baselines/reference/genericFunctionsWithOptionalParameters3.symbols
index 2fe7e295a0d70..3ef1d31ac8542 100644
--- a/tests/baselines/reference/genericFunctionsWithOptionalParameters3.symbols
+++ b/tests/baselines/reference/genericFunctionsWithOptionalParameters3.symbols
@@ -61,7 +61,9 @@ var r3 = utils.mapReduce(c, (x) => { return 1 }, (y) => { return new Date() });
 >utils : Symbol(utils, Decl(genericFunctionsWithOptionalParameters3.ts, 7, 3))
 >mapReduce : Symbol(Utils.mapReduce, Decl(genericFunctionsWithOptionalParameters3.ts, 4, 75))
 >c : Symbol(c, Decl(genericFunctionsWithOptionalParameters3.ts, 8, 3))
+>(x) => { return 1 } : Symbol((Anonymous function), Decl(genericFunctionsWithOptionalParameters3.ts, 9, 27))
 >x : Symbol(x, Decl(genericFunctionsWithOptionalParameters3.ts, 9, 29))
+>(y) => { return new Date() } : Symbol((Anonymous function), Decl(genericFunctionsWithOptionalParameters3.ts, 9, 48))
 >y : Symbol(y, Decl(genericFunctionsWithOptionalParameters3.ts, 9, 50))
 >Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
 
@@ -71,16 +73,20 @@ var r4 = utils.mapReduce(c, (x: string) => { return 1 }, (y: number) => { return
 >utils : Symbol(utils, Decl(genericFunctionsWithOptionalParameters3.ts, 7, 3))
 >mapReduce : Symbol(Utils.mapReduce, Decl(genericFunctionsWithOptionalParameters3.ts, 4, 75))
 >c : Symbol(c, Decl(genericFunctionsWithOptionalParameters3.ts, 8, 3))
+>(x: string) => { return 1 } : Symbol((Anonymous function), Decl(genericFunctionsWithOptionalParameters3.ts, 10, 27))
 >x : Symbol(x, Decl(genericFunctionsWithOptionalParameters3.ts, 10, 29))
+>(y: number) => { return new Date() } : Symbol((Anonymous function), Decl(genericFunctionsWithOptionalParameters3.ts, 10, 56))
 >y : Symbol(y, Decl(genericFunctionsWithOptionalParameters3.ts, 10, 58))
 >Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
 
 var f1 = (x: string) => { return 1 };
 >f1 : Symbol(f1, Decl(genericFunctionsWithOptionalParameters3.ts, 11, 3))
+>(x: string) => { return 1 } : Symbol((Anonymous function), Decl(genericFunctionsWithOptionalParameters3.ts, 11, 8))
 >x : Symbol(x, Decl(genericFunctionsWithOptionalParameters3.ts, 11, 10))
 
 var f2 = (y: number) => { return new Date() };
 >f2 : Symbol(f2, Decl(genericFunctionsWithOptionalParameters3.ts, 12, 3))
+>(y: number) => { return new Date() } : Symbol((Anonymous function), Decl(genericFunctionsWithOptionalParameters3.ts, 12, 8))
 >y : Symbol(y, Decl(genericFunctionsWithOptionalParameters3.ts, 12, 10))
 >Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
 
diff --git a/tests/baselines/reference/genericInference1.symbols b/tests/baselines/reference/genericInference1.symbols
index 6980668c6ebc1..2104ce7ae448b 100644
--- a/tests/baselines/reference/genericInference1.symbols
+++ b/tests/baselines/reference/genericInference1.symbols
@@ -2,6 +2,7 @@
 ['a', 'b', 'c'].map(x => x.length);
 >['a', 'b', 'c'].map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
 >map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>x => x.length : Symbol((Anonymous function), Decl(genericInference1.ts, 0, 20))
 >x : Symbol(x, Decl(genericInference1.ts, 0, 20))
 >x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >x : Symbol(x, Decl(genericInference1.ts, 0, 20))
diff --git a/tests/baselines/reference/genericInference2.symbols b/tests/baselines/reference/genericInference2.symbols
index 83b371005f710..253020927ef27 100644
--- a/tests/baselines/reference/genericInference2.symbols
+++ b/tests/baselines/reference/genericInference2.symbols
@@ -33,6 +33,7 @@
     } 
     var o = { 
 >o : Symbol(o, Decl(genericInference2.ts, 10, 7))
+>{        name: ko.observable("Bob"),        age: ko.observable(37)     } : Symbol(, Decl(genericInference2.ts, 10, 11))
 
        name: ko.observable("Bob"), 
 >name : Symbol(name, Decl(genericInference2.ts, 10, 13))
diff --git a/tests/baselines/reference/genericInterfaceTypeCall.symbols b/tests/baselines/reference/genericInterfaceTypeCall.symbols
index e28ce8f8d80fe..6ad334c6ae42e 100644
--- a/tests/baselines/reference/genericInterfaceTypeCall.symbols
+++ b/tests/baselines/reference/genericInterfaceTypeCall.symbols
@@ -36,6 +36,7 @@ test.fail(arg => foo.reject(arg));
 >test.fail : Symbol(bar.fail, Decl(genericInterfaceTypeCall.ts, 5, 18))
 >test : Symbol(test, Decl(genericInterfaceTypeCall.ts, 9, 3))
 >fail : Symbol(bar.fail, Decl(genericInterfaceTypeCall.ts, 5, 18))
+>arg => foo.reject(arg) : Symbol((Anonymous function), Decl(genericInterfaceTypeCall.ts, 11, 10))
 >arg : Symbol(arg, Decl(genericInterfaceTypeCall.ts, 11, 10))
 >foo.reject : Symbol(Foo.reject, Decl(genericInterfaceTypeCall.ts, 0, 18))
 >foo : Symbol(foo, Decl(genericInterfaceTypeCall.ts, 3, 3))
@@ -46,6 +47,7 @@ test.fail2(arg => foo.reject(arg)); // Error: Supplied parameters do not match a
 >test.fail2 : Symbol(bar.fail2, Decl(genericInterfaceTypeCall.ts, 6, 40))
 >test : Symbol(test, Decl(genericInterfaceTypeCall.ts, 9, 3))
 >fail2 : Symbol(bar.fail2, Decl(genericInterfaceTypeCall.ts, 6, 40))
+>arg => foo.reject(arg) : Symbol((Anonymous function), Decl(genericInterfaceTypeCall.ts, 12, 11))
 >arg : Symbol(arg, Decl(genericInterfaceTypeCall.ts, 12, 11))
 >foo.reject : Symbol(Foo.reject, Decl(genericInterfaceTypeCall.ts, 0, 18))
 >foo : Symbol(foo, Decl(genericInterfaceTypeCall.ts, 3, 3))
diff --git a/tests/baselines/reference/genericMethodOverspecialization.symbols b/tests/baselines/reference/genericMethodOverspecialization.symbols
index 651aced0fcdc0..488838a7837b2 100644
--- a/tests/baselines/reference/genericMethodOverspecialization.symbols
+++ b/tests/baselines/reference/genericMethodOverspecialization.symbols
@@ -30,6 +30,7 @@ var elements = names.map(function (name) {
 >names.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
 >names : Symbol(names, Decl(genericMethodOverspecialization.ts, 0, 3))
 >map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>function (name) {    return document.getElementById(name);} : Symbol((Anonymous function), Decl(genericMethodOverspecialization.ts, 12, 25))
 >name : Symbol(name, Decl(genericMethodOverspecialization.ts, 12, 35))
 
     return document.getElementById(name);
@@ -46,6 +47,7 @@ var xxx = elements.filter(function (e) {
 >elements.filter : Symbol(Array.filter, Decl(lib.d.ts, 1122, 87))
 >elements : Symbol(elements, Decl(genericMethodOverspecialization.ts, 12, 3))
 >filter : Symbol(Array.filter, Decl(lib.d.ts, 1122, 87))
+>function (e) {    return !e.isDisabled;} : Symbol((Anonymous function), Decl(genericMethodOverspecialization.ts, 17, 26))
 >e : Symbol(e, Decl(genericMethodOverspecialization.ts, 17, 36))
 
     return !e.isDisabled;
@@ -60,6 +62,7 @@ var widths:number[] = elements.map(function (e) { // should not error
 >elements.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
 >elements : Symbol(elements, Decl(genericMethodOverspecialization.ts, 12, 3))
 >map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>function (e) { // should not error    return e.clientWidth;} : Symbol((Anonymous function), Decl(genericMethodOverspecialization.ts, 21, 35))
 >e : Symbol(e, Decl(genericMethodOverspecialization.ts, 21, 45))
 
     return e.clientWidth;
diff --git a/tests/baselines/reference/genericObjectLitReturnType.symbols b/tests/baselines/reference/genericObjectLitReturnType.symbols
index f3253bdf81036..982a2474b17e5 100644
--- a/tests/baselines/reference/genericObjectLitReturnType.symbols
+++ b/tests/baselines/reference/genericObjectLitReturnType.symbols
@@ -7,6 +7,7 @@ class X<T>
 >f : Symbol(f, Decl(genericObjectLitReturnType.ts, 1, 1))
 >t : Symbol(t, Decl(genericObjectLitReturnType.ts, 2, 6))
 >T : Symbol(T, Decl(genericObjectLitReturnType.ts, 0, 8))
+>{ a: t } : Symbol(, Decl(genericObjectLitReturnType.ts, 2, 20))
 >a : Symbol(a, Decl(genericObjectLitReturnType.ts, 2, 22))
 >t : Symbol(t, Decl(genericObjectLitReturnType.ts, 2, 6))
 }
diff --git a/tests/baselines/reference/genericParameterAssignability1.symbols b/tests/baselines/reference/genericParameterAssignability1.symbols
index 766190aecabfb..7973fdaf8dc22 100644
--- a/tests/baselines/reference/genericParameterAssignability1.symbols
+++ b/tests/baselines/reference/genericParameterAssignability1.symbols
@@ -8,6 +8,7 @@ function f<T>(x: T): T { return null; }
 
 var r = <T>(x: T) => x;
 >r : Symbol(r, Decl(genericParameterAssignability1.ts, 1, 3))
+><T>(x: T) => x : Symbol((Anonymous function), Decl(genericParameterAssignability1.ts, 1, 7))
 >T : Symbol(T, Decl(genericParameterAssignability1.ts, 1, 9))
 >x : Symbol(x, Decl(genericParameterAssignability1.ts, 1, 12))
 >T : Symbol(T, Decl(genericParameterAssignability1.ts, 1, 9))
diff --git a/tests/baselines/reference/genericTypeAliases.symbols b/tests/baselines/reference/genericTypeAliases.symbols
index 1a1d0e514870e..3d907a02c6d67 100644
--- a/tests/baselines/reference/genericTypeAliases.symbols
+++ b/tests/baselines/reference/genericTypeAliases.symbols
@@ -13,15 +13,18 @@ type Tree<T> = T | { left: Tree<T>, right: Tree<T> };
 var tree: Tree<number> = {
 >tree : Symbol(tree, Decl(genericTypeAliases.ts, 2, 3))
 >Tree : Symbol(Tree, Decl(genericTypeAliases.ts, 0, 0))
+>{    left: {        left: 0,        right: {            left: 1,            right: 2        },    },    right: 3} : Symbol(, Decl(genericTypeAliases.ts, 2, 24))
 
     left: {
 >left : Symbol(left, Decl(genericTypeAliases.ts, 2, 26))
+>{        left: 0,        right: {            left: 1,            right: 2        },    } : Symbol(, Decl(genericTypeAliases.ts, 3, 9))
 
         left: 0,
 >left : Symbol(left, Decl(genericTypeAliases.ts, 3, 11))
 
         right: {
 >right : Symbol(right, Decl(genericTypeAliases.ts, 4, 16))
+>{            left: 1,            right: 2        } : Symbol(, Decl(genericTypeAliases.ts, 5, 14))
 
             left: 1,
 >left : Symbol(left, Decl(genericTypeAliases.ts, 5, 16))
@@ -51,6 +54,7 @@ ls = "eager";
 
 ls = () => "lazy";
 >ls : Symbol(ls, Decl(genericTypeAliases.ts, 15, 3))
+>() => "lazy" : Symbol((Anonymous function), Decl(genericTypeAliases.ts, 17, 4))
 
 type Foo<T> = T | { x: Foo<T> };
 >Foo : Symbol(Foo, Decl(genericTypeAliases.ts, 17, 18))
@@ -90,11 +94,14 @@ x = "string";
 
 x = { x: "hello" };
 >x : Symbol(x, Decl(genericTypeAliases.ts, 23, 3))
+>{ x: "hello" } : Symbol(, Decl(genericTypeAliases.ts, 29, 3))
 >x : Symbol(x, Decl(genericTypeAliases.ts, 29, 5))
 
 x = { x: { x: "world" } };
 >x : Symbol(x, Decl(genericTypeAliases.ts, 23, 3))
+>{ x: { x: "world" } } : Symbol(, Decl(genericTypeAliases.ts, 30, 3))
 >x : Symbol(x, Decl(genericTypeAliases.ts, 30, 5))
+>{ x: "world" } : Symbol(, Decl(genericTypeAliases.ts, 30, 8))
 >x : Symbol(x, Decl(genericTypeAliases.ts, 30, 10))
 
 var z: Foo<number>;
@@ -106,11 +113,14 @@ z = 42;
 
 z = { x: 42 };
 >z : Symbol(z, Decl(genericTypeAliases.ts, 32, 3))
+>{ x: 42 } : Symbol(, Decl(genericTypeAliases.ts, 34, 3))
 >x : Symbol(x, Decl(genericTypeAliases.ts, 34, 5))
 
 z = { x: { x: 42 } };
 >z : Symbol(z, Decl(genericTypeAliases.ts, 32, 3))
+>{ x: { x: 42 } } : Symbol(, Decl(genericTypeAliases.ts, 35, 3))
 >x : Symbol(x, Decl(genericTypeAliases.ts, 35, 5))
+>{ x: 42 } : Symbol(, Decl(genericTypeAliases.ts, 35, 8))
 >x : Symbol(x, Decl(genericTypeAliases.ts, 35, 10))
 
 type Strange<T> = string;  // Type parameter not used
diff --git a/tests/baselines/reference/genericTypeAssertions3.symbols b/tests/baselines/reference/genericTypeAssertions3.symbols
index 4d19f1562005d..52487927757f8 100644
--- a/tests/baselines/reference/genericTypeAssertions3.symbols
+++ b/tests/baselines/reference/genericTypeAssertions3.symbols
@@ -5,6 +5,7 @@ var r = < <T>(x: T) => T > ((x) => { return null; }); // bug was 'could not find
 >x : Symbol(x, Decl(genericTypeAssertions3.ts, 0, 14))
 >T : Symbol(T, Decl(genericTypeAssertions3.ts, 0, 11))
 >T : Symbol(T, Decl(genericTypeAssertions3.ts, 0, 11))
+>(x) => { return null; } : Symbol((Anonymous function), Decl(genericTypeAssertions3.ts, 0, 28))
 >x : Symbol(x, Decl(genericTypeAssertions3.ts, 0, 29))
 
 var s = < <T>(x: T) => T > ((x: any) => { return null; }); // no error
@@ -13,5 +14,6 @@ var s = < <T>(x: T) => T > ((x: any) => { return null; }); // no error
 >x : Symbol(x, Decl(genericTypeAssertions3.ts, 1, 14))
 >T : Symbol(T, Decl(genericTypeAssertions3.ts, 1, 11))
 >T : Symbol(T, Decl(genericTypeAssertions3.ts, 1, 11))
+>(x: any) => { return null; } : Symbol((Anonymous function), Decl(genericTypeAssertions3.ts, 1, 28))
 >x : Symbol(x, Decl(genericTypeAssertions3.ts, 1, 29))
 
diff --git a/tests/baselines/reference/genericTypeParameterEquivalence2.symbols b/tests/baselines/reference/genericTypeParameterEquivalence2.symbols
index 056b4ce96ab73..3db85b7427bb0 100644
--- a/tests/baselines/reference/genericTypeParameterEquivalence2.symbols
+++ b/tests/baselines/reference/genericTypeParameterEquivalence2.symbols
@@ -18,6 +18,7 @@ function compose<A, B, C>(f: (b: B) => C, g: (a:A) => B): (a:A) => C {
 >C : Symbol(C, Decl(genericTypeParameterEquivalence2.ts, 1, 22))
 
     return function (a:A) : C {
+>function (a:A) : C {        return f(g.apply(null, a));    } : Symbol((Anonymous function), Decl(genericTypeParameterEquivalence2.ts, 2, 10))
 >a : Symbol(a, Decl(genericTypeParameterEquivalence2.ts, 2, 21))
 >A : Symbol(A, Decl(genericTypeParameterEquivalence2.ts, 1, 17))
 >C : Symbol(C, Decl(genericTypeParameterEquivalence2.ts, 1, 22))
@@ -76,6 +77,7 @@ function filter<A>(f: (a: A) => boolean, ar: A[]): A[] {
     forEach(ar, (el) => {
 >forEach : Symbol(forEach, Decl(genericTypeParameterEquivalence2.ts, 5, 1))
 >ar : Symbol(ar, Decl(genericTypeParameterEquivalence2.ts, 15, 40))
+>(el) => {        if (f(el)) {            ret.push(el);        }    } : Symbol((Anonymous function), Decl(genericTypeParameterEquivalence2.ts, 17, 15))
 >el : Symbol(el, Decl(genericTypeParameterEquivalence2.ts, 17, 17))
 
         if (f(el)) {
@@ -126,10 +128,12 @@ function curry1<A, B, C>(f: (a: A, b: B) => C): (ax: A) => (bx: B) => C {
 >C : Symbol(C, Decl(genericTypeParameterEquivalence2.ts, 32, 21))
 
     return function (ay: A) {
+>function (ay: A) {        return function (by: B) {            return f(ay, by);        };    } : Symbol((Anonymous function), Decl(genericTypeParameterEquivalence2.ts, 33, 10))
 >ay : Symbol(ay, Decl(genericTypeParameterEquivalence2.ts, 33, 21))
 >A : Symbol(A, Decl(genericTypeParameterEquivalence2.ts, 32, 16))
 
         return function (by: B) {
+>function (by: B) {            return f(ay, by);        } : Symbol((Anonymous function), Decl(genericTypeParameterEquivalence2.ts, 34, 14))
 >by : Symbol(by, Decl(genericTypeParameterEquivalence2.ts, 34, 25))
 >B : Symbol(B, Decl(genericTypeParameterEquivalence2.ts, 32, 18))
 
diff --git a/tests/baselines/reference/genericWithIndexerOfTypeParameterType1.symbols b/tests/baselines/reference/genericWithIndexerOfTypeParameterType1.symbols
index 26918e9ebfb33..8976290deb913 100644
--- a/tests/baselines/reference/genericWithIndexerOfTypeParameterType1.symbols
+++ b/tests/baselines/reference/genericWithIndexerOfTypeParameterType1.symbols
@@ -7,6 +7,7 @@ class LazyArray<T> {
 >objects : Symbol(objects, Decl(genericWithIndexerOfTypeParameterType1.ts, 0, 20))
 >objectId : Symbol(objectId, Decl(genericWithIndexerOfTypeParameterType1.ts, 1, 26))
 >T : Symbol(T, Decl(genericWithIndexerOfTypeParameterType1.ts, 0, 16))
+>{} : Symbol(, Decl(genericWithIndexerOfTypeParameterType1.ts, 1, 50))
 
     array() {
 >array : Symbol(array, Decl(genericWithIndexerOfTypeParameterType1.ts, 1, 53))
diff --git a/tests/baselines/reference/genericsAndHigherOrderFunctions.symbols b/tests/baselines/reference/genericsAndHigherOrderFunctions.symbols
index a9f324278d687..d29b3078b2894 100644
--- a/tests/baselines/reference/genericsAndHigherOrderFunctions.symbols
+++ b/tests/baselines/reference/genericsAndHigherOrderFunctions.symbols
@@ -23,6 +23,7 @@ var combine: <T, S>(f: (_: T) => S) =>
 >S : Symbol(S, Decl(genericsAndHigherOrderFunctions.ts, 2, 16))
 
     = <T, S>(f: (_: T) => S) =>
+><T, S>(f: (_: T) => S) =>        <U>(g: (_: U) => T) =>            (x: U) => f(g(x)) : Symbol((Anonymous function), Decl(genericsAndHigherOrderFunctions.ts, 6, 5))
 >T : Symbol(T, Decl(genericsAndHigherOrderFunctions.ts, 6, 7))
 >S : Symbol(S, Decl(genericsAndHigherOrderFunctions.ts, 6, 9))
 >f : Symbol(f, Decl(genericsAndHigherOrderFunctions.ts, 6, 13))
@@ -31,6 +32,7 @@ var combine: <T, S>(f: (_: T) => S) =>
 >S : Symbol(S, Decl(genericsAndHigherOrderFunctions.ts, 6, 9))
 
         <U>(g: (_: U) => T) =>
+><U>(g: (_: U) => T) =>            (x: U) => f(g(x)) : Symbol((Anonymous function), Decl(genericsAndHigherOrderFunctions.ts, 6, 31))
 >U : Symbol(U, Decl(genericsAndHigherOrderFunctions.ts, 7, 9))
 >g : Symbol(g, Decl(genericsAndHigherOrderFunctions.ts, 7, 12))
 >_ : Symbol(_, Decl(genericsAndHigherOrderFunctions.ts, 7, 16))
@@ -38,6 +40,7 @@ var combine: <T, S>(f: (_: T) => S) =>
 >T : Symbol(T, Decl(genericsAndHigherOrderFunctions.ts, 6, 7))
 
             (x: U) => f(g(x))
+>(x: U) => f(g(x)) : Symbol((Anonymous function), Decl(genericsAndHigherOrderFunctions.ts, 7, 30))
 >x : Symbol(x, Decl(genericsAndHigherOrderFunctions.ts, 8, 13))
 >U : Symbol(U, Decl(genericsAndHigherOrderFunctions.ts, 7, 9))
 >f : Symbol(f, Decl(genericsAndHigherOrderFunctions.ts, 6, 13))
@@ -79,6 +82,7 @@ var foo: <K, N>(g: (x: K) => N) =>
 >R : Symbol(R, Decl(genericsAndHigherOrderFunctions.ts, 12, 5))
 
     = <K, N>(g: (x: K) => N) =>
+><K, N>(g: (x: K) => N) =>        (h: <M>(_: (_: K) => (_: M) => M) => (_: M) => M) =>            <R>(f: (_: N) => (_: R) => R) => h(combine(f)(g)) : Symbol((Anonymous function), Decl(genericsAndHigherOrderFunctions.ts, 14, 5))
 >K : Symbol(K, Decl(genericsAndHigherOrderFunctions.ts, 14, 7))
 >N : Symbol(N, Decl(genericsAndHigherOrderFunctions.ts, 14, 9))
 >g : Symbol(g, Decl(genericsAndHigherOrderFunctions.ts, 14, 13))
@@ -87,6 +91,7 @@ var foo: <K, N>(g: (x: K) => N) =>
 >N : Symbol(N, Decl(genericsAndHigherOrderFunctions.ts, 14, 9))
 
         (h: <M>(_: (_: K) => (_: M) => M) => (_: M) => M) =>
+>(h: <M>(_: (_: K) => (_: M) => M) => (_: M) => M) =>            <R>(f: (_: N) => (_: R) => R) => h(combine(f)(g)) : Symbol((Anonymous function), Decl(genericsAndHigherOrderFunctions.ts, 14, 31))
 >h : Symbol(h, Decl(genericsAndHigherOrderFunctions.ts, 15, 9))
 >M : Symbol(M, Decl(genericsAndHigherOrderFunctions.ts, 15, 13))
 >_ : Symbol(_, Decl(genericsAndHigherOrderFunctions.ts, 15, 16))
@@ -100,6 +105,7 @@ var foo: <K, N>(g: (x: K) => N) =>
 >M : Symbol(M, Decl(genericsAndHigherOrderFunctions.ts, 15, 13))
 
             <R>(f: (_: N) => (_: R) => R) => h(combine(f)(g))
+><R>(f: (_: N) => (_: R) => R) => h(combine(f)(g)) : Symbol((Anonymous function), Decl(genericsAndHigherOrderFunctions.ts, 15, 60))
 >R : Symbol(R, Decl(genericsAndHigherOrderFunctions.ts, 16, 13))
 >f : Symbol(f, Decl(genericsAndHigherOrderFunctions.ts, 16, 16))
 >_ : Symbol(_, Decl(genericsAndHigherOrderFunctions.ts, 16, 20))
diff --git a/tests/baselines/reference/getterSetterNonAccessor.symbols b/tests/baselines/reference/getterSetterNonAccessor.symbols
index 10ffc55480c74..14916e0a348c4 100644
--- a/tests/baselines/reference/getterSetterNonAccessor.symbols
+++ b/tests/baselines/reference/getterSetterNonAccessor.symbols
@@ -10,7 +10,9 @@ Object.defineProperty({}, "0", <PropertyDescriptor>({
 >Object.defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.d.ts, 160, 60))
 >Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
 >defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.d.ts, 160, 60))
+>{} : Symbol(, Decl(getterSetterNonAccessor.ts, 3, 22))
 >PropertyDescriptor : Symbol(PropertyDescriptor, Decl(lib.d.ts, 79, 66))
+>{          get: getFunc,          set: setFunc,          configurable: true      } : Symbol(, Decl(getterSetterNonAccessor.ts, 3, 52))
 
           get: getFunc,
 >get : Symbol(get, Decl(getterSetterNonAccessor.ts, 3, 53))
diff --git a/tests/baselines/reference/globalThisCapture.symbols b/tests/baselines/reference/globalThisCapture.symbols
index bfb7bf147c0a4..8c3ff7e31299c 100644
--- a/tests/baselines/reference/globalThisCapture.symbols
+++ b/tests/baselines/reference/globalThisCapture.symbols
@@ -1,6 +1,7 @@
 === tests/cases/compiler/globalThisCapture.ts ===
 // Add a lambda to ensure global 'this' capture is triggered
 (()=>this.window);
+>()=>this.window : Symbol((Anonymous function), Decl(globalThisCapture.ts, 1, 1))
 
 var parts = [];
 >parts : Symbol(parts, Decl(globalThisCapture.ts, 3, 3))
diff --git a/tests/baselines/reference/heterogeneousArrayLiterals.symbols b/tests/baselines/reference/heterogeneousArrayLiterals.symbols
index c7a73d5641445..d7700318a8204 100644
--- a/tests/baselines/reference/heterogeneousArrayLiterals.symbols
+++ b/tests/baselines/reference/heterogeneousArrayLiterals.symbols
@@ -12,9 +12,11 @@ var c = [1, '', null]; // {}[]
 
 var d = [{}, 1]; // {}[]
 >d : Symbol(d, Decl(heterogeneousArrayLiterals.ts, 5, 3))
+>{} : Symbol(, Decl(heterogeneousArrayLiterals.ts, 5, 9))
 
 var e = [{}, Object]; // {}[]
 >e : Symbol(e, Decl(heterogeneousArrayLiterals.ts, 6, 3))
+>{} : Symbol(, Decl(heterogeneousArrayLiterals.ts, 6, 9))
 >Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
 
 var f = [[], [1]]; // number[][]
@@ -25,30 +27,45 @@ var g = [[1], ['']]; // {}[]
 
 var h = [{ foo: 1, bar: '' }, { foo: 2 }]; // {foo: number}[]
 >h : Symbol(h, Decl(heterogeneousArrayLiterals.ts, 11, 3))
+>{ foo: 1, bar: '' } : Symbol(, Decl(heterogeneousArrayLiterals.ts, 11, 9))
 >foo : Symbol(foo, Decl(heterogeneousArrayLiterals.ts, 11, 10))
 >bar : Symbol(bar, Decl(heterogeneousArrayLiterals.ts, 11, 18))
+>{ foo: 2 } : Symbol(, Decl(heterogeneousArrayLiterals.ts, 11, 29))
 >foo : Symbol(foo, Decl(heterogeneousArrayLiterals.ts, 11, 31))
 
 var i = [{ foo: 1, bar: '' }, { foo: '' }]; // {}[]
 >i : Symbol(i, Decl(heterogeneousArrayLiterals.ts, 12, 3))
+>{ foo: 1, bar: '' } : Symbol(, Decl(heterogeneousArrayLiterals.ts, 12, 9))
 >foo : Symbol(foo, Decl(heterogeneousArrayLiterals.ts, 12, 10))
 >bar : Symbol(bar, Decl(heterogeneousArrayLiterals.ts, 12, 18))
+>{ foo: '' } : Symbol(, Decl(heterogeneousArrayLiterals.ts, 12, 29))
 >foo : Symbol(foo, Decl(heterogeneousArrayLiterals.ts, 12, 31))
 
 var j = [() => 1, () => '']; // {}[]
 >j : Symbol(j, Decl(heterogeneousArrayLiterals.ts, 14, 3))
+>() => 1 : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 14, 9))
+>() => '' : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 14, 17))
 
 var k = [() => 1, () => 1]; // { (): number }[]
 >k : Symbol(k, Decl(heterogeneousArrayLiterals.ts, 15, 3))
+>() => 1 : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 15, 9))
+>() => 1 : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 15, 17))
 
 var l = [() => 1, () => null]; // { (): any }[]
 >l : Symbol(l, Decl(heterogeneousArrayLiterals.ts, 16, 3))
+>() => 1 : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 16, 9))
+>() => null : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 16, 17))
 
 var m = [() => 1, () => '', () => null]; // { (): any }[]
 >m : Symbol(m, Decl(heterogeneousArrayLiterals.ts, 17, 3))
+>() => 1 : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 17, 9))
+>() => '' : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 17, 17))
+>() => null : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 17, 27))
 
 var n = [[() => 1], [() => '']]; // {}[]
 >n : Symbol(n, Decl(heterogeneousArrayLiterals.ts, 18, 3))
+>() => 1 : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 18, 10))
+>() => '' : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 18, 21))
 
 class Base { foo: string; }
 >Base : Symbol(Base, Decl(heterogeneousArrayLiterals.ts, 18, 32))
@@ -81,43 +98,58 @@ module Derived {
 
     var h = [{ foo: base, basear: derived }, { foo: base }]; // {foo: Base}[]
 >h : Symbol(h, Decl(heterogeneousArrayLiterals.ts, 28, 7))
+>{ foo: base, basear: derived } : Symbol(, Decl(heterogeneousArrayLiterals.ts, 28, 13))
 >foo : Symbol(foo, Decl(heterogeneousArrayLiterals.ts, 28, 14))
 >base : Symbol(base, Decl(heterogeneousArrayLiterals.ts, 23, 3))
 >basear : Symbol(basear, Decl(heterogeneousArrayLiterals.ts, 28, 25))
 >derived : Symbol(derived, Decl(heterogeneousArrayLiterals.ts, 24, 3))
+>{ foo: base } : Symbol(, Decl(heterogeneousArrayLiterals.ts, 28, 44))
 >foo : Symbol(foo, Decl(heterogeneousArrayLiterals.ts, 28, 46))
 >base : Symbol(base, Decl(heterogeneousArrayLiterals.ts, 23, 3))
 
     var i = [{ foo: base, basear: derived }, { foo: derived }]; // {foo: Derived}[]
 >i : Symbol(i, Decl(heterogeneousArrayLiterals.ts, 29, 7))
+>{ foo: base, basear: derived } : Symbol(, Decl(heterogeneousArrayLiterals.ts, 29, 13))
 >foo : Symbol(foo, Decl(heterogeneousArrayLiterals.ts, 29, 14))
 >base : Symbol(base, Decl(heterogeneousArrayLiterals.ts, 23, 3))
 >basear : Symbol(basear, Decl(heterogeneousArrayLiterals.ts, 29, 25))
 >derived : Symbol(derived, Decl(heterogeneousArrayLiterals.ts, 24, 3))
+>{ foo: derived } : Symbol(, Decl(heterogeneousArrayLiterals.ts, 29, 44))
 >foo : Symbol(foo, Decl(heterogeneousArrayLiterals.ts, 29, 46))
 >derived : Symbol(derived, Decl(heterogeneousArrayLiterals.ts, 24, 3))
 
     var j = [() => base, () => derived]; // { {}: Base }
 >j : Symbol(j, Decl(heterogeneousArrayLiterals.ts, 31, 7))
+>() => base : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 31, 13))
 >base : Symbol(base, Decl(heterogeneousArrayLiterals.ts, 23, 3))
+>() => derived : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 31, 24))
 >derived : Symbol(derived, Decl(heterogeneousArrayLiterals.ts, 24, 3))
 
     var k = [() => base, () => 1]; // {}[]~
 >k : Symbol(k, Decl(heterogeneousArrayLiterals.ts, 32, 7))
+>() => base : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 32, 13))
 >base : Symbol(base, Decl(heterogeneousArrayLiterals.ts, 23, 3))
+>() => 1 : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 32, 24))
 
     var l = [() => base, () => null]; // { (): any }[]
 >l : Symbol(l, Decl(heterogeneousArrayLiterals.ts, 33, 7))
+>() => base : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 33, 13))
 >base : Symbol(base, Decl(heterogeneousArrayLiterals.ts, 23, 3))
+>() => null : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 33, 24))
 
     var m = [() => base, () => derived, () => null]; // { (): any }[]
 >m : Symbol(m, Decl(heterogeneousArrayLiterals.ts, 34, 7))
+>() => base : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 34, 13))
 >base : Symbol(base, Decl(heterogeneousArrayLiterals.ts, 23, 3))
+>() => derived : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 34, 24))
 >derived : Symbol(derived, Decl(heterogeneousArrayLiterals.ts, 24, 3))
+>() => null : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 34, 39))
 
     var n = [[() => base], [() => derived]]; // { (): Base }[]
 >n : Symbol(n, Decl(heterogeneousArrayLiterals.ts, 35, 7))
+>() => base : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 35, 14))
 >base : Symbol(base, Decl(heterogeneousArrayLiterals.ts, 23, 3))
+>() => derived : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 35, 28))
 >derived : Symbol(derived, Decl(heterogeneousArrayLiterals.ts, 24, 3))
 
     var o = [derived, derived2]; // {}[]
@@ -133,7 +165,9 @@ module Derived {
 
     var q = [[() => derived2], [() => derived]]; // {}[]
 >q : Symbol(q, Decl(heterogeneousArrayLiterals.ts, 38, 7))
+>() => derived2 : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 38, 14))
 >derived2 : Symbol(derived2, Decl(heterogeneousArrayLiterals.ts, 25, 3))
+>() => derived : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 38, 32))
 >derived : Symbol(derived, Decl(heterogeneousArrayLiterals.ts, 24, 3))
 }
 
@@ -158,7 +192,9 @@ module WithContextualType {
     var d: { (): Base }[] = [() => derived, () => derived2];
 >d : Symbol(d, Decl(heterogeneousArrayLiterals.ts, 46, 7))
 >Base : Symbol(Base, Decl(heterogeneousArrayLiterals.ts, 18, 32))
+>() => derived : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 46, 29))
 >derived : Symbol(derived, Decl(heterogeneousArrayLiterals.ts, 24, 3))
+>() => derived2 : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 46, 43))
 >derived2 : Symbol(derived2, Decl(heterogeneousArrayLiterals.ts, 25, 3))
 }
 
@@ -191,13 +227,18 @@ function foo<T, U>(t: T, u: U) {
 
     var e = [() => t, () => u]; // {}[]
 >e : Symbol(e, Decl(heterogeneousArrayLiterals.ts, 54, 7))
+>() => t : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 54, 13))
 >t : Symbol(t, Decl(heterogeneousArrayLiterals.ts, 49, 19))
+>() => u : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 54, 21))
 >u : Symbol(u, Decl(heterogeneousArrayLiterals.ts, 49, 24))
 
     var f = [() => t, () => u, () => null]; // { (): any }[]
 >f : Symbol(f, Decl(heterogeneousArrayLiterals.ts, 55, 7))
+>() => t : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 55, 13))
 >t : Symbol(t, Decl(heterogeneousArrayLiterals.ts, 49, 19))
+>() => u : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 55, 21))
 >u : Symbol(u, Decl(heterogeneousArrayLiterals.ts, 49, 24))
+>() => null : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 55, 30))
 }
 
 function foo2<T extends Base, U extends Derived>(t: T, u: U) {
@@ -231,13 +272,18 @@ function foo2<T extends Base, U extends Derived>(t: T, u: U) {
 
     var e = [() => t, () => u]; // {}[]
 >e : Symbol(e, Decl(heterogeneousArrayLiterals.ts, 63, 7))
+>() => t : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 63, 13))
 >t : Symbol(t, Decl(heterogeneousArrayLiterals.ts, 58, 49))
+>() => u : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 63, 21))
 >u : Symbol(u, Decl(heterogeneousArrayLiterals.ts, 58, 54))
 
     var f = [() => t, () => u, () => null]; // { (): any }[]
 >f : Symbol(f, Decl(heterogeneousArrayLiterals.ts, 64, 7))
+>() => t : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 64, 13))
 >t : Symbol(t, Decl(heterogeneousArrayLiterals.ts, 58, 49))
+>() => u : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 64, 21))
 >u : Symbol(u, Decl(heterogeneousArrayLiterals.ts, 58, 54))
+>() => null : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 64, 30))
 
     var g = [t, base]; // Base[]
 >g : Symbol(g, Decl(heterogeneousArrayLiterals.ts, 66, 7))
@@ -291,13 +337,18 @@ function foo3<T extends Derived, U extends Derived>(t: T, u: U) {
 
     var e = [() => t, () => u]; // {}[]
 >e : Symbol(e, Decl(heterogeneousArrayLiterals.ts, 77, 7))
+>() => t : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 77, 13))
 >t : Symbol(t, Decl(heterogeneousArrayLiterals.ts, 72, 52))
+>() => u : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 77, 21))
 >u : Symbol(u, Decl(heterogeneousArrayLiterals.ts, 72, 57))
 
     var f = [() => t, () => u, () => null]; // { (): any }[]
 >f : Symbol(f, Decl(heterogeneousArrayLiterals.ts, 78, 7))
+>() => t : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 78, 13))
 >t : Symbol(t, Decl(heterogeneousArrayLiterals.ts, 72, 52))
+>() => u : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 78, 21))
 >u : Symbol(u, Decl(heterogeneousArrayLiterals.ts, 72, 57))
+>() => null : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 78, 30))
 
     var g = [t, base]; // Base[]
 >g : Symbol(g, Decl(heterogeneousArrayLiterals.ts, 80, 7))
@@ -351,13 +402,18 @@ function foo4<T extends Base, U extends Base>(t: T, u: U) {
 
     var e = [() => t, () => u]; // {}[]
 >e : Symbol(e, Decl(heterogeneousArrayLiterals.ts, 91, 7))
+>() => t : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 91, 13))
 >t : Symbol(t, Decl(heterogeneousArrayLiterals.ts, 86, 46))
+>() => u : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 91, 21))
 >u : Symbol(u, Decl(heterogeneousArrayLiterals.ts, 86, 51))
 
     var f = [() => t, () => u, () => null]; // { (): any }[]
 >f : Symbol(f, Decl(heterogeneousArrayLiterals.ts, 92, 7))
+>() => t : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 92, 13))
 >t : Symbol(t, Decl(heterogeneousArrayLiterals.ts, 86, 46))
+>() => u : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 92, 21))
 >u : Symbol(u, Decl(heterogeneousArrayLiterals.ts, 86, 51))
+>() => null : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 92, 30))
 
     var g = [t, base]; // Base[]
 >g : Symbol(g, Decl(heterogeneousArrayLiterals.ts, 94, 7))
diff --git a/tests/baselines/reference/ifDoWhileStatements.symbols b/tests/baselines/reference/ifDoWhileStatements.symbols
index 36a990010efe4..49774ec6233a1 100644
--- a/tests/baselines/reference/ifDoWhileStatements.symbols
+++ b/tests/baselines/reference/ifDoWhileStatements.symbols
@@ -133,24 +133,37 @@ while ([1, 2]) { }
 do { }while([1, 2])
 
 if ({}) { }
+>{} : Symbol(, Decl(ifDoWhileStatements.ts, 75, 4))
+
 while ({}) { }
+>{} : Symbol(, Decl(ifDoWhileStatements.ts, 76, 7))
+
 do { }while({})
+>{} : Symbol(, Decl(ifDoWhileStatements.ts, 77, 12))
 
 if ({ x: 1, y: 'a' }) { }
+>{ x: 1, y: 'a' } : Symbol(, Decl(ifDoWhileStatements.ts, 79, 4))
 >x : Symbol(x, Decl(ifDoWhileStatements.ts, 79, 5))
 >y : Symbol(y, Decl(ifDoWhileStatements.ts, 79, 11))
 
 while ({ x: 1, y: 'a' }) { }
+>{ x: 1, y: 'a' } : Symbol(, Decl(ifDoWhileStatements.ts, 80, 7))
 >x : Symbol(x, Decl(ifDoWhileStatements.ts, 80, 8))
 >y : Symbol(y, Decl(ifDoWhileStatements.ts, 80, 14))
 
 do { }while({ x: 1, y: 'a' })
+>{ x: 1, y: 'a' } : Symbol(, Decl(ifDoWhileStatements.ts, 81, 12))
 >x : Symbol(x, Decl(ifDoWhileStatements.ts, 81, 13))
 >y : Symbol(y, Decl(ifDoWhileStatements.ts, 81, 19))
 
 if (() => 43) { }
+>() => 43 : Symbol((Anonymous function), Decl(ifDoWhileStatements.ts, 83, 4))
+
 while (() => 43) { }
+>() => 43 : Symbol((Anonymous function), Decl(ifDoWhileStatements.ts, 84, 7))
+
 do { }while(() => 43)
+>() => 43 : Symbol((Anonymous function), Decl(ifDoWhileStatements.ts, 85, 12))
 
 if (new C()) { }
 >C : Symbol(C, Decl(ifDoWhileStatements.ts, 2, 1))
@@ -285,6 +298,7 @@ do { }while(i)
 
 var j = {};
 >j : Symbol(j, Decl(ifDoWhileStatements.ts, 141, 3))
+>{} : Symbol(, Decl(ifDoWhileStatements.ts, 141, 7))
 
 if (j) { }
 >j : Symbol(j, Decl(ifDoWhileStatements.ts, 141, 3))
@@ -297,6 +311,7 @@ do { }while(j)
 
 var k = { x: 1, y: 'a' };
 >k : Symbol(k, Decl(ifDoWhileStatements.ts, 146, 3))
+>{ x: 1, y: 'a' } : Symbol(, Decl(ifDoWhileStatements.ts, 146, 7))
 >x : Symbol(x, Decl(ifDoWhileStatements.ts, 146, 9))
 >y : Symbol(y, Decl(ifDoWhileStatements.ts, 146, 15))
 
diff --git a/tests/baselines/reference/implicitAnyAnyReturningFunction.symbols b/tests/baselines/reference/implicitAnyAnyReturningFunction.symbols
index 73e91853255bf..c163a2e166845 100644
--- a/tests/baselines/reference/implicitAnyAnyReturningFunction.symbols
+++ b/tests/baselines/reference/implicitAnyAnyReturningFunction.symbols
@@ -10,6 +10,7 @@ function B() {
 
     var someLocal: any = {};
 >someLocal : Symbol(someLocal, Decl(implicitAnyAnyReturningFunction.ts, 5, 7))
+>{} : Symbol(, Decl(implicitAnyAnyReturningFunction.ts, 5, 24))
 
     return someLocal;
 >someLocal : Symbol(someLocal, Decl(implicitAnyAnyReturningFunction.ts, 5, 7))
@@ -29,6 +30,7 @@ class C {
 
         var someLocal: any = {};
 >someLocal : Symbol(someLocal, Decl(implicitAnyAnyReturningFunction.ts, 15, 11))
+>{} : Symbol(, Decl(implicitAnyAnyReturningFunction.ts, 15, 28))
 
         return someLocal;
 >someLocal : Symbol(someLocal, Decl(implicitAnyAnyReturningFunction.ts, 15, 11))
diff --git a/tests/baselines/reference/importAliasIdentifiers.symbols b/tests/baselines/reference/importAliasIdentifiers.symbols
index 3b2ba0ea46abf..d4cf2bd7a87ed 100644
--- a/tests/baselines/reference/importAliasIdentifiers.symbols
+++ b/tests/baselines/reference/importAliasIdentifiers.symbols
@@ -50,6 +50,7 @@ module clodule {
     var Point: Point = { x: 0, y: 0 };
 >Point : Symbol(Point, Decl(importAliasIdentifiers.ts, 16, 16), Decl(importAliasIdentifiers.ts, 20, 7))
 >Point : Symbol(Point, Decl(importAliasIdentifiers.ts, 16, 16))
+>{ x: 0, y: 0 } : Symbol(, Decl(importAliasIdentifiers.ts, 20, 22))
 >x : Symbol(x, Decl(importAliasIdentifiers.ts, 20, 24))
 >y : Symbol(y, Decl(importAliasIdentifiers.ts, 20, 30))
 }
@@ -78,6 +79,7 @@ function fundule() {
 >fundule : Symbol(fundule, Decl(importAliasIdentifiers.ts, 27, 33), Decl(importAliasIdentifiers.ts, 32, 1))
 
     return { x: 0, y: 0 };
+>{ x: 0, y: 0 } : Symbol(, Decl(importAliasIdentifiers.ts, 31, 10))
 >x : Symbol(x, Decl(importAliasIdentifiers.ts, 31, 12))
 >y : Symbol(y, Decl(importAliasIdentifiers.ts, 31, 18))
 }
@@ -95,6 +97,7 @@ module fundule {
     var Point: Point = { x: 0, y: 0 };
 >Point : Symbol(Point, Decl(importAliasIdentifiers.ts, 34, 16), Decl(importAliasIdentifiers.ts, 38, 7))
 >Point : Symbol(Point, Decl(importAliasIdentifiers.ts, 34, 16))
+>{ x: 0, y: 0 } : Symbol(, Decl(importAliasIdentifiers.ts, 38, 22))
 >x : Symbol(x, Decl(importAliasIdentifiers.ts, 38, 24))
 >y : Symbol(y, Decl(importAliasIdentifiers.ts, 38, 30))
 }
diff --git a/tests/baselines/reference/importInTypePosition.symbols b/tests/baselines/reference/importInTypePosition.symbols
index 08f55093c5037..a91e28bac8ec0 100644
--- a/tests/baselines/reference/importInTypePosition.symbols
+++ b/tests/baselines/reference/importInTypePosition.symbols
@@ -41,6 +41,7 @@ module C {
 
     var p = { x: 0, y: 0 };
 >p : Symbol(p, Decl(importInTypePosition.ts, 17, 7), Decl(importInTypePosition.ts, 18, 7))
+>{ x: 0, y: 0 } : Symbol(, Decl(importInTypePosition.ts, 18, 11))
 >x : Symbol(x, Decl(importInTypePosition.ts, 18, 13))
 >y : Symbol(y, Decl(importInTypePosition.ts, 18, 19))
 }
diff --git a/tests/baselines/reference/importStatements.symbols b/tests/baselines/reference/importStatements.symbols
index b160dcf2888b8..62d5a16f5e5ba 100644
--- a/tests/baselines/reference/importStatements.symbols
+++ b/tests/baselines/reference/importStatements.symbols
@@ -43,6 +43,7 @@ module C {
 
     var p = {x:0, y:0 };
 >p : Symbol(p, Decl(importStatements.ts, 17, 7), Decl(importStatements.ts, 18, 7))
+>{x:0, y:0 } : Symbol(, Decl(importStatements.ts, 18, 11))
 >x : Symbol(x, Decl(importStatements.ts, 18, 13))
 >y : Symbol(y, Decl(importStatements.ts, 18, 17))
 }
diff --git a/tests/baselines/reference/inOperatorWithFunction.symbols b/tests/baselines/reference/inOperatorWithFunction.symbols
index 1e915ba107d80..bf30bd3460933 100644
--- a/tests/baselines/reference/inOperatorWithFunction.symbols
+++ b/tests/baselines/reference/inOperatorWithFunction.symbols
@@ -1,9 +1,11 @@
 === tests/cases/compiler/inOperatorWithFunction.ts ===
 var fn = function (val: boolean) { return val; }
 >fn : Symbol(fn, Decl(inOperatorWithFunction.ts, 0, 3))
+>function (val: boolean) { return val; } : Symbol((Anonymous function), Decl(inOperatorWithFunction.ts, 0, 8))
 >val : Symbol(val, Decl(inOperatorWithFunction.ts, 0, 19))
 >val : Symbol(val, Decl(inOperatorWithFunction.ts, 0, 19))
 
 fn("a" in { "a": true });
 >fn : Symbol(fn, Decl(inOperatorWithFunction.ts, 0, 3))
+>{ "a": true } : Symbol(, Decl(inOperatorWithFunction.ts, 1, 9))
 
diff --git a/tests/baselines/reference/inOperatorWithValidOperands.symbols b/tests/baselines/reference/inOperatorWithValidOperands.symbols
index 07e0bd4f6de1b..2752ed91d3a81 100644
--- a/tests/baselines/reference/inOperatorWithValidOperands.symbols
+++ b/tests/baselines/reference/inOperatorWithValidOperands.symbols
@@ -46,6 +46,7 @@ var rb1 = x in b1;
 var rb2 = x in {};
 >rb2 : Symbol(rb2, Decl(inOperatorWithValidOperands.ts, 18, 3))
 >x : Symbol(x, Decl(inOperatorWithValidOperands.ts, 0, 3))
+>{} : Symbol(, Decl(inOperatorWithValidOperands.ts, 18, 14))
 
 function foo<T>(t: T) {
 >foo : Symbol(foo, Decl(inOperatorWithValidOperands.ts, 18, 18))
diff --git a/tests/baselines/reference/incrementOperatorWithAnyOtherType.symbols b/tests/baselines/reference/incrementOperatorWithAnyOtherType.symbols
index d0af700ea8e81..2d855ec719883 100644
--- a/tests/baselines/reference/incrementOperatorWithAnyOtherType.symbols
+++ b/tests/baselines/reference/incrementOperatorWithAnyOtherType.symbols
@@ -12,6 +12,7 @@ var ANY2: any[] = ["", ""];
 
 var obj = {x:1,y:null};
 >obj : Symbol(obj, Decl(incrementOperatorWithAnyOtherType.ts, 5, 3))
+>{x:1,y:null} : Symbol(, Decl(incrementOperatorWithAnyOtherType.ts, 5, 9))
 >x : Symbol(x, Decl(incrementOperatorWithAnyOtherType.ts, 5, 11))
 >y : Symbol(y, Decl(incrementOperatorWithAnyOtherType.ts, 5, 15))
 
diff --git a/tests/baselines/reference/indexSignaturesInferentialTyping.symbols b/tests/baselines/reference/indexSignaturesInferentialTyping.symbols
index a34aa7a5cd186..336a9a2f2a273 100644
--- a/tests/baselines/reference/indexSignaturesInferentialTyping.symbols
+++ b/tests/baselines/reference/indexSignaturesInferentialTyping.symbols
@@ -20,20 +20,24 @@ function bar<T>(items: { [index: string]: T }): T { return undefined; }
 var x1 = foo({ 0: 0, 1: 1 });       // type should be number
 >x1 : Symbol(x1, Decl(indexSignaturesInferentialTyping.ts, 3, 3))
 >foo : Symbol(foo, Decl(indexSignaturesInferentialTyping.ts, 0, 0))
+>{ 0: 0, 1: 1 } : Symbol(, Decl(indexSignaturesInferentialTyping.ts, 3, 13))
 
 var x2 = foo({ zero: 0, one: 1 });
 >x2 : Symbol(x2, Decl(indexSignaturesInferentialTyping.ts, 4, 3))
 >foo : Symbol(foo, Decl(indexSignaturesInferentialTyping.ts, 0, 0))
+>{ zero: 0, one: 1 } : Symbol(, Decl(indexSignaturesInferentialTyping.ts, 4, 13))
 >zero : Symbol(zero, Decl(indexSignaturesInferentialTyping.ts, 4, 14))
 >one : Symbol(one, Decl(indexSignaturesInferentialTyping.ts, 4, 23))
 
 var x3 = bar({ 0: 0, 1: 1 });
 >x3 : Symbol(x3, Decl(indexSignaturesInferentialTyping.ts, 5, 3))
 >bar : Symbol(bar, Decl(indexSignaturesInferentialTyping.ts, 0, 71))
+>{ 0: 0, 1: 1 } : Symbol(, Decl(indexSignaturesInferentialTyping.ts, 5, 13))
 
 var x4 = bar({ zero: 0, one: 1 });  // type should be number
 >x4 : Symbol(x4, Decl(indexSignaturesInferentialTyping.ts, 6, 3))
 >bar : Symbol(bar, Decl(indexSignaturesInferentialTyping.ts, 0, 71))
+>{ zero: 0, one: 1 } : Symbol(, Decl(indexSignaturesInferentialTyping.ts, 6, 13))
 >zero : Symbol(zero, Decl(indexSignaturesInferentialTyping.ts, 6, 14))
 >one : Symbol(one, Decl(indexSignaturesInferentialTyping.ts, 6, 23))
 
diff --git a/tests/baselines/reference/indexer.symbols b/tests/baselines/reference/indexer.symbols
index 409bd8092d674..1abcc566bf1da 100644
--- a/tests/baselines/reference/indexer.symbols
+++ b/tests/baselines/reference/indexer.symbols
@@ -17,7 +17,10 @@ interface JQuery {
 var jq:JQuery={ 0: { id : "a" }, 1: { id : "b" } };
 >jq : Symbol(jq, Decl(indexer.ts, 8, 3))
 >JQuery : Symbol(JQuery, Decl(indexer.ts, 2, 1))
+>{ 0: { id : "a" }, 1: { id : "b" } } : Symbol(, Decl(indexer.ts, 8, 14))
+>{ id : "a" } : Symbol(, Decl(indexer.ts, 8, 18))
 >id : Symbol(id, Decl(indexer.ts, 8, 20))
+>{ id : "b" } : Symbol(, Decl(indexer.ts, 8, 35))
 >id : Symbol(id, Decl(indexer.ts, 8, 37))
 
 jq[0].id;
diff --git a/tests/baselines/reference/indexer2.symbols b/tests/baselines/reference/indexer2.symbols
index c23debb925c90..5533a3f298aee 100644
--- a/tests/baselines/reference/indexer2.symbols
+++ b/tests/baselines/reference/indexer2.symbols
@@ -16,4 +16,5 @@ interface IDirectChildrenMap {
 var directChildrenMap = <IDirectChildrenMap>{}; 
 >directChildrenMap : Symbol(directChildrenMap, Decl(indexer2.ts, 5, 3))
 >IDirectChildrenMap : Symbol(IDirectChildrenMap, Decl(indexer2.ts, 0, 32))
+>{} : Symbol(, Decl(indexer2.ts, 5, 44))
 
diff --git a/tests/baselines/reference/indexer3.symbols b/tests/baselines/reference/indexer3.symbols
index 1de91806faadd..283e7d2dc6204 100644
--- a/tests/baselines/reference/indexer3.symbols
+++ b/tests/baselines/reference/indexer3.symbols
@@ -3,6 +3,7 @@ var dateMap: { [x: string]: Date; } = {}
 >dateMap : Symbol(dateMap, Decl(indexer3.ts, 0, 3))
 >x : Symbol(x, Decl(indexer3.ts, 0, 16))
 >Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>{} : Symbol(, Decl(indexer3.ts, 0, 37))
 
 var r: Date = dateMap["hello"] // result type includes indexer using BCT
 >r : Symbol(r, Decl(indexer3.ts, 1, 3))
diff --git a/tests/baselines/reference/indexerA.symbols b/tests/baselines/reference/indexerA.symbols
index d549c3359d9c5..7bbdabd7df34a 100644
--- a/tests/baselines/reference/indexerA.symbols
+++ b/tests/baselines/reference/indexerA.symbols
@@ -17,7 +17,10 @@ class JQuery {
 var jq:JQuery={ 0: { id : "a" }, 1: { id : "b" } };
 >jq : Symbol(jq, Decl(indexerA.ts, 8, 3))
 >JQuery : Symbol(JQuery, Decl(indexerA.ts, 2, 1))
+>{ 0: { id : "a" }, 1: { id : "b" } } : Symbol(, Decl(indexerA.ts, 8, 14))
+>{ id : "a" } : Symbol(, Decl(indexerA.ts, 8, 18))
 >id : Symbol(id, Decl(indexerA.ts, 8, 20))
+>{ id : "b" } : Symbol(, Decl(indexerA.ts, 8, 35))
 >id : Symbol(id, Decl(indexerA.ts, 8, 37))
 
 jq[0].id;
diff --git a/tests/baselines/reference/inferSecondaryParameter.symbols b/tests/baselines/reference/inferSecondaryParameter.symbols
index c2527ed14b34a..5de50ab71b8cf 100644
--- a/tests/baselines/reference/inferSecondaryParameter.symbols
+++ b/tests/baselines/reference/inferSecondaryParameter.symbols
@@ -11,7 +11,9 @@ interface Ib { m(test: string, fn: Function); }
 var b: Ib = { m: function (test: string, fn: Function) { } };
 >b : Symbol(b, Decl(inferSecondaryParameter.ts, 4, 3))
 >Ib : Symbol(Ib, Decl(inferSecondaryParameter.ts, 0, 0))
+>{ m: function (test: string, fn: Function) { } } : Symbol(, Decl(inferSecondaryParameter.ts, 4, 11))
 >m : Symbol(m, Decl(inferSecondaryParameter.ts, 4, 13))
+>function (test: string, fn: Function) { } : Symbol((Anonymous function), Decl(inferSecondaryParameter.ts, 4, 16))
 >test : Symbol(test, Decl(inferSecondaryParameter.ts, 4, 27))
 >fn : Symbol(fn, Decl(inferSecondaryParameter.ts, 4, 40))
 >Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
@@ -20,6 +22,7 @@ b.m("test", function (bug) {
 >b.m : Symbol(Ib.m, Decl(inferSecondaryParameter.ts, 2, 14))
 >b : Symbol(b, Decl(inferSecondaryParameter.ts, 4, 3))
 >m : Symbol(Ib.m, Decl(inferSecondaryParameter.ts, 2, 14))
+>function (bug) {    var a: number = bug;} : Symbol((Anonymous function), Decl(inferSecondaryParameter.ts, 6, 11))
 >bug : Symbol(bug, Decl(inferSecondaryParameter.ts, 6, 22))
 
     var a: number = bug;
diff --git a/tests/baselines/reference/inferenceFromParameterlessLambda.symbols b/tests/baselines/reference/inferenceFromParameterlessLambda.symbols
index 6170a4d1149db..be5a18e37ffa0 100644
--- a/tests/baselines/reference/inferenceFromParameterlessLambda.symbols
+++ b/tests/baselines/reference/inferenceFromParameterlessLambda.symbols
@@ -27,8 +27,10 @@ interface Take<T> {
 // Infer string from second argument because it isn't context sensitive
 foo(n => n.length, () => 'hi');
 >foo : Symbol(foo, Decl(inferenceFromParameterlessLambda.ts, 0, 0))
+>n => n.length : Symbol((Anonymous function), Decl(inferenceFromParameterlessLambda.ts, 8, 4))
 >n : Symbol(n, Decl(inferenceFromParameterlessLambda.ts, 8, 4))
 >n.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >n : Symbol(n, Decl(inferenceFromParameterlessLambda.ts, 8, 4))
 >length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>() => 'hi' : Symbol((Anonymous function), Decl(inferenceFromParameterlessLambda.ts, 8, 18))
 
diff --git a/tests/baselines/reference/inferentialTypingObjectLiteralMethod1.symbols b/tests/baselines/reference/inferentialTypingObjectLiteralMethod1.symbols
index 3fee48fc837d2..78bcd905864c8 100644
--- a/tests/baselines/reference/inferentialTypingObjectLiteralMethod1.symbols
+++ b/tests/baselines/reference/inferentialTypingObjectLiteralMethod1.symbols
@@ -28,11 +28,13 @@ declare function foo<T, U>(x: T, y: Int<T, U>, z: Int<U, T>): T;
 
 foo("", { method(p1) { return p1.length } }, { method(p2) { return undefined } });
 >foo : Symbol(foo, Decl(inferentialTypingObjectLiteralMethod1.ts, 2, 1))
+>{ method(p1) { return p1.length } } : Symbol(, Decl(inferentialTypingObjectLiteralMethod1.ts, 4, 7))
 >method : Symbol(method, Decl(inferentialTypingObjectLiteralMethod1.ts, 4, 9))
 >p1 : Symbol(p1, Decl(inferentialTypingObjectLiteralMethod1.ts, 4, 17))
 >p1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >p1 : Symbol(p1, Decl(inferentialTypingObjectLiteralMethod1.ts, 4, 17))
 >length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>{ method(p2) { return undefined } } : Symbol(, Decl(inferentialTypingObjectLiteralMethod1.ts, 4, 44))
 >method : Symbol(method, Decl(inferentialTypingObjectLiteralMethod1.ts, 4, 46))
 >p2 : Symbol(p2, Decl(inferentialTypingObjectLiteralMethod1.ts, 4, 54))
 >undefined : Symbol(undefined)
diff --git a/tests/baselines/reference/inferentialTypingObjectLiteralMethod2.symbols b/tests/baselines/reference/inferentialTypingObjectLiteralMethod2.symbols
index fc8d39858b654..5fe57e21763eb 100644
--- a/tests/baselines/reference/inferentialTypingObjectLiteralMethod2.symbols
+++ b/tests/baselines/reference/inferentialTypingObjectLiteralMethod2.symbols
@@ -28,11 +28,13 @@ declare function foo<T, U>(x: T, y: Int<T, U>, z: Int<U, T>): T;
 
 foo("", { method(p1) { return p1.length } }, { method(p2) { return undefined } });
 >foo : Symbol(foo, Decl(inferentialTypingObjectLiteralMethod2.ts, 2, 1))
+>{ method(p1) { return p1.length } } : Symbol(, Decl(inferentialTypingObjectLiteralMethod2.ts, 4, 7))
 >method : Symbol(method, Decl(inferentialTypingObjectLiteralMethod2.ts, 4, 9))
 >p1 : Symbol(p1, Decl(inferentialTypingObjectLiteralMethod2.ts, 4, 17))
 >p1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >p1 : Symbol(p1, Decl(inferentialTypingObjectLiteralMethod2.ts, 4, 17))
 >length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>{ method(p2) { return undefined } } : Symbol(, Decl(inferentialTypingObjectLiteralMethod2.ts, 4, 44))
 >method : Symbol(method, Decl(inferentialTypingObjectLiteralMethod2.ts, 4, 46))
 >p2 : Symbol(p2, Decl(inferentialTypingObjectLiteralMethod2.ts, 4, 54))
 >undefined : Symbol(undefined)
diff --git a/tests/baselines/reference/inferentialTypingWithFunctionTypeNested.symbols b/tests/baselines/reference/inferentialTypingWithFunctionTypeNested.symbols
index ae72021b31bdd..7830e7d2c85cd 100644
--- a/tests/baselines/reference/inferentialTypingWithFunctionTypeNested.symbols
+++ b/tests/baselines/reference/inferentialTypingWithFunctionTypeNested.symbols
@@ -22,6 +22,8 @@ declare function identity<V>(y: V): V;
 var s = map("", () => { return { x: identity }; });
 >s : Symbol(s, Decl(inferentialTypingWithFunctionTypeNested.ts, 3, 3))
 >map : Symbol(map, Decl(inferentialTypingWithFunctionTypeNested.ts, 0, 0))
+>() => { return { x: identity }; } : Symbol((Anonymous function), Decl(inferentialTypingWithFunctionTypeNested.ts, 3, 15))
+>{ x: identity } : Symbol(, Decl(inferentialTypingWithFunctionTypeNested.ts, 3, 30))
 >x : Symbol(x, Decl(inferentialTypingWithFunctionTypeNested.ts, 3, 32))
 >identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeNested.ts, 0, 65))
 
diff --git a/tests/baselines/reference/inferentialTypingWithFunctionTypeSyntacticScenarios.symbols b/tests/baselines/reference/inferentialTypingWithFunctionTypeSyntacticScenarios.symbols
index a9571bc8a388d..a340910a6d997 100644
--- a/tests/baselines/reference/inferentialTypingWithFunctionTypeSyntacticScenarios.symbols
+++ b/tests/baselines/reference/inferentialTypingWithFunctionTypeSyntacticScenarios.symbols
@@ -24,6 +24,7 @@ var s: string;
 // dotted name
 var dottedIdentity = { x: identity };
 >dottedIdentity : Symbol(dottedIdentity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 5, 3))
+>{ x: identity } : Symbol(, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 5, 20))
 >x : Symbol(x, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 5, 22))
 >identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 59))
 
@@ -45,6 +46,7 @@ s = map("", dottedIdentity['x']);
 s = map("", (() => identity)());
 >s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 2, 3))
 >map : Symbol(map, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 0))
+>() => identity : Symbol((Anonymous function), Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 12, 13))
 >identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 59))
 
 // construct
diff --git a/tests/baselines/reference/inheritedFunctionAssignmentCompatibility.symbols b/tests/baselines/reference/inheritedFunctionAssignmentCompatibility.symbols
index a76a4aad7fa0c..b1ba49febc470 100644
--- a/tests/baselines/reference/inheritedFunctionAssignmentCompatibility.symbols
+++ b/tests/baselines/reference/inheritedFunctionAssignmentCompatibility.symbols
@@ -10,11 +10,13 @@ function fn(cb: IResultCallback) { }
 
 fn((a, b) => true);
 >fn : Symbol(fn, Decl(inheritedFunctionAssignmentCompatibility.ts, 0, 46))
+>(a, b) => true : Symbol((Anonymous function), Decl(inheritedFunctionAssignmentCompatibility.ts, 4, 3))
 >a : Symbol(a, Decl(inheritedFunctionAssignmentCompatibility.ts, 4, 4))
 >b : Symbol(b, Decl(inheritedFunctionAssignmentCompatibility.ts, 4, 6))
 
 fn(function (a, b) { return true; })
 >fn : Symbol(fn, Decl(inheritedFunctionAssignmentCompatibility.ts, 0, 46))
+>function (a, b) { return true; } : Symbol((Anonymous function), Decl(inheritedFunctionAssignmentCompatibility.ts, 5, 3))
 >a : Symbol(a, Decl(inheritedFunctionAssignmentCompatibility.ts, 5, 13))
 >b : Symbol(b, Decl(inheritedFunctionAssignmentCompatibility.ts, 5, 15))
 
diff --git a/tests/baselines/reference/initializePropertiesWithRenamedLet.symbols b/tests/baselines/reference/initializePropertiesWithRenamedLet.symbols
index 203508ddf9815..4e2250a794bc3 100644
--- a/tests/baselines/reference/initializePropertiesWithRenamedLet.symbols
+++ b/tests/baselines/reference/initializePropertiesWithRenamedLet.symbols
@@ -9,11 +9,13 @@ if (true) {
 
     var obj1 = { x0: x0 };
 >obj1 : Symbol(obj1, Decl(initializePropertiesWithRenamedLet.ts, 4, 7))
+>{ x0: x0 } : Symbol(, Decl(initializePropertiesWithRenamedLet.ts, 4, 14))
 >x0 : Symbol(x0, Decl(initializePropertiesWithRenamedLet.ts, 4, 16))
 >x0 : Symbol(x0, Decl(initializePropertiesWithRenamedLet.ts, 3, 7))
 
     var obj2 = { x0 };
 >obj2 : Symbol(obj2, Decl(initializePropertiesWithRenamedLet.ts, 5, 7))
+>{ x0 } : Symbol(, Decl(initializePropertiesWithRenamedLet.ts, 5, 14))
 >x0 : Symbol(x0, Decl(initializePropertiesWithRenamedLet.ts, 5, 16))
 }
 
@@ -25,21 +27,27 @@ var x, y, z;
 if (true) {
     let { x: x } = { x: 0 };
 >x : Symbol(x, Decl(initializePropertiesWithRenamedLet.ts, 10, 9))
+>{ x: 0 } : Symbol(, Decl(initializePropertiesWithRenamedLet.ts, 10, 18))
 >x : Symbol(x, Decl(initializePropertiesWithRenamedLet.ts, 10, 20))
 
     let { y } = { y: 0 };
 >y : Symbol(y, Decl(initializePropertiesWithRenamedLet.ts, 11, 9))
+>{ y: 0 } : Symbol(, Decl(initializePropertiesWithRenamedLet.ts, 11, 15))
 >y : Symbol(y, Decl(initializePropertiesWithRenamedLet.ts, 11, 17))
 
     let z;
 >z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 12, 7))
 
     ({ z: z } = { z: 0 });
+>{ z: z } : Symbol(, Decl(initializePropertiesWithRenamedLet.ts, 13, 5))
 >z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 13, 6))
 >z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 12, 7))
+>{ z: 0 } : Symbol(, Decl(initializePropertiesWithRenamedLet.ts, 13, 15))
 >z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 13, 17))
 
     ({ z } = { z: 0 });
+>{ z } : Symbol(, Decl(initializePropertiesWithRenamedLet.ts, 14, 5))
 >z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 14, 6))
+>{ z: 0 } : Symbol(, Decl(initializePropertiesWithRenamedLet.ts, 14, 12))
 >z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 14, 14))
 }
diff --git a/tests/baselines/reference/innerBoundLambdaEmit.symbols b/tests/baselines/reference/innerBoundLambdaEmit.symbols
index 689aa7d075b9e..c4a64a54aa60c 100644
--- a/tests/baselines/reference/innerBoundLambdaEmit.symbols
+++ b/tests/baselines/reference/innerBoundLambdaEmit.symbols
@@ -7,6 +7,7 @@ module M {
     }
     var bar = () => { };
 >bar : Symbol(bar, Decl(innerBoundLambdaEmit.ts, 3, 7))
+>() => { } : Symbol((Anonymous function), Decl(innerBoundLambdaEmit.ts, 3, 13))
 }
 interface Array<T> {
 >Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(innerBoundLambdaEmit.ts, 4, 1))
diff --git a/tests/baselines/reference/instantiatedModule.symbols b/tests/baselines/reference/instantiatedModule.symbols
index 42e0edcd2217f..3779bbdb48d5f 100644
--- a/tests/baselines/reference/instantiatedModule.symbols
+++ b/tests/baselines/reference/instantiatedModule.symbols
@@ -66,6 +66,7 @@ module M2 {
 >Point : Symbol(Point, Decl(instantiatedModule.ts, 20, 11))
 
             return { x: 0, y: 0 };
+>{ x: 0, y: 0 } : Symbol(, Decl(instantiatedModule.ts, 25, 18))
 >x : Symbol(x, Decl(instantiatedModule.ts, 25, 20))
 >y : Symbol(y, Decl(instantiatedModule.ts, 25, 26))
         }
diff --git a/tests/baselines/reference/interface0.symbols b/tests/baselines/reference/interface0.symbols
index 25e12370916df..2bc7f73edf955 100644
--- a/tests/baselines/reference/interface0.symbols
+++ b/tests/baselines/reference/interface0.symbols
@@ -11,5 +11,6 @@ interface Generic<T> {
 var y: Generic<number> = { x: 3 };
 >y : Symbol(y, Decl(interface0.ts, 4, 3))
 >Generic : Symbol(Generic, Decl(interface0.ts, 0, 0))
+>{ x: 3 } : Symbol(, Decl(interface0.ts, 4, 24))
 >x : Symbol(x, Decl(interface0.ts, 4, 26))
 
diff --git a/tests/baselines/reference/interfaceContextualType.symbols b/tests/baselines/reference/interfaceContextualType.symbols
index 3483188043184..10506cbc4c983 100644
--- a/tests/baselines/reference/interfaceContextualType.symbols
+++ b/tests/baselines/reference/interfaceContextualType.symbols
@@ -30,11 +30,13 @@ class Bug {
 >this.values : Symbol(values, Decl(interfaceContextualType.ts, 8, 11))
 >this : Symbol(Bug, Decl(interfaceContextualType.ts, 6, 1))
 >values : Symbol(values, Decl(interfaceContextualType.ts, 8, 11))
+>{} : Symbol(, Decl(interfaceContextualType.ts, 11, 21))
 
         this.values['comments'] = { italic: true };
 >this.values : Symbol(values, Decl(interfaceContextualType.ts, 8, 11))
 >this : Symbol(Bug, Decl(interfaceContextualType.ts, 6, 1))
 >values : Symbol(values, Decl(interfaceContextualType.ts, 8, 11))
+>{ italic: true } : Symbol(, Decl(interfaceContextualType.ts, 12, 33))
 >italic : Symbol(italic, Decl(interfaceContextualType.ts, 12, 35))
     }
     shouldBeOK() {
@@ -44,9 +46,11 @@ class Bug {
 >this.values : Symbol(values, Decl(interfaceContextualType.ts, 8, 11))
 >this : Symbol(Bug, Decl(interfaceContextualType.ts, 6, 1))
 >values : Symbol(values, Decl(interfaceContextualType.ts, 8, 11))
+>{            comments: { italic: true }        } : Symbol(, Decl(interfaceContextualType.ts, 15, 21))
 
             comments: { italic: true }
 >comments : Symbol(comments, Decl(interfaceContextualType.ts, 15, 23))
+>{ italic: true } : Symbol(, Decl(interfaceContextualType.ts, 16, 21))
 >italic : Symbol(italic, Decl(interfaceContextualType.ts, 16, 23))
 
         };
diff --git a/tests/baselines/reference/interfaceWithPropertyOfEveryType.symbols b/tests/baselines/reference/interfaceWithPropertyOfEveryType.symbols
index 46c8e92261ff8..465824cbb179a 100644
--- a/tests/baselines/reference/interfaceWithPropertyOfEveryType.symbols
+++ b/tests/baselines/reference/interfaceWithPropertyOfEveryType.symbols
@@ -79,6 +79,7 @@ interface Foo {
 var a: Foo = {
 >a : Symbol(a, Decl(interfaceWithPropertyOfEveryType.ts, 25, 3))
 >Foo : Symbol(Foo, Decl(interfaceWithPropertyOfEveryType.ts, 5, 12))
+>{    a: 1,    b: '',    c: true,    d: {},    e: null ,    f: [1],    g: {},    h: (x: number) => 1,    i: <T>(x: T) => x,    j: <Foo>null,    k: new C(),    l: f1,    m: M,    n: {},    o: E.A} : Symbol(, Decl(interfaceWithPropertyOfEveryType.ts, 25, 12))
 
     a: 1,
 >a : Symbol(a, Decl(interfaceWithPropertyOfEveryType.ts, 25, 14))
@@ -91,6 +92,7 @@ var a: Foo = {
 
     d: {},
 >d : Symbol(d, Decl(interfaceWithPropertyOfEveryType.ts, 28, 12))
+>{} : Symbol(, Decl(interfaceWithPropertyOfEveryType.ts, 29, 6))
 
     e: null ,
 >e : Symbol(e, Decl(interfaceWithPropertyOfEveryType.ts, 29, 10))
@@ -100,13 +102,16 @@ var a: Foo = {
 
     g: {},
 >g : Symbol(g, Decl(interfaceWithPropertyOfEveryType.ts, 31, 11))
+>{} : Symbol(, Decl(interfaceWithPropertyOfEveryType.ts, 32, 6))
 
     h: (x: number) => 1,
 >h : Symbol(h, Decl(interfaceWithPropertyOfEveryType.ts, 32, 10))
+>(x: number) => 1 : Symbol((Anonymous function), Decl(interfaceWithPropertyOfEveryType.ts, 33, 6))
 >x : Symbol(x, Decl(interfaceWithPropertyOfEveryType.ts, 33, 8))
 
     i: <T>(x: T) => x,
 >i : Symbol(i, Decl(interfaceWithPropertyOfEveryType.ts, 33, 24))
+><T>(x: T) => x : Symbol((Anonymous function), Decl(interfaceWithPropertyOfEveryType.ts, 34, 6))
 >T : Symbol(T, Decl(interfaceWithPropertyOfEveryType.ts, 34, 8))
 >x : Symbol(x, Decl(interfaceWithPropertyOfEveryType.ts, 34, 11))
 >T : Symbol(T, Decl(interfaceWithPropertyOfEveryType.ts, 34, 8))
@@ -130,6 +135,7 @@ var a: Foo = {
 
     n: {},
 >n : Symbol(n, Decl(interfaceWithPropertyOfEveryType.ts, 38, 9))
+>{} : Symbol(, Decl(interfaceWithPropertyOfEveryType.ts, 39, 6))
 
     o: E.A
 >o : Symbol(o, Decl(interfaceWithPropertyOfEveryType.ts, 39, 10))
diff --git a/tests/baselines/reference/invalidUndefinedValues.symbols b/tests/baselines/reference/invalidUndefinedValues.symbols
index 5a9b81fde3104..02b1487e9804f 100644
--- a/tests/baselines/reference/invalidUndefinedValues.symbols
+++ b/tests/baselines/reference/invalidUndefinedValues.symbols
@@ -60,6 +60,7 @@ x = M;
 
 x = { f() { } }
 >x : Symbol(x, Decl(invalidUndefinedValues.ts, 0, 3))
+>{ f() { } } : Symbol(, Decl(invalidUndefinedValues.ts, 21, 3))
 >f : Symbol(f, Decl(invalidUndefinedValues.ts, 21, 5))
 
 function f<T>(a: T) {
diff --git a/tests/baselines/reference/ipromise2.symbols b/tests/baselines/reference/ipromise2.symbols
index be936f4512a27..901c9fbf7088a 100644
--- a/tests/baselines/reference/ipromise2.symbols
+++ b/tests/baselines/reference/ipromise2.symbols
@@ -107,6 +107,7 @@ var p2 = p.then(function (s) {
 >p.then : Symbol(Windows.Foundation.IPromise.then, Decl(ipromise2.ts, 1, 34), Decl(ipromise2.ts, 2, 159), Decl(ipromise2.ts, 3, 149), Decl(ipromise2.ts, 4, 149))
 >p : Symbol(p, Decl(ipromise2.ts, 11, 3))
 >then : Symbol(Windows.Foundation.IPromise.then, Decl(ipromise2.ts, 1, 34), Decl(ipromise2.ts, 2, 159), Decl(ipromise2.ts, 3, 149), Decl(ipromise2.ts, 4, 149))
+>function (s) {    return 34;} : Symbol((Anonymous function), Decl(ipromise2.ts, 13, 16))
 >s : Symbol(s, Decl(ipromise2.ts, 13, 26))
 
     return 34;
diff --git a/tests/baselines/reference/ipromise3.symbols b/tests/baselines/reference/ipromise3.symbols
index 3605a94fc88d3..aef8bd48f3907 100644
--- a/tests/baselines/reference/ipromise3.symbols
+++ b/tests/baselines/reference/ipromise3.symbols
@@ -88,6 +88,7 @@ var p2: IPromise3<string> = p1.then(function (x) {
 >p1.then : Symbol(IPromise3.then, Decl(ipromise3.ts, 0, 24), Decl(ipromise3.ts, 1, 139), Decl(ipromise3.ts, 2, 128), Decl(ipromise3.ts, 3, 128))
 >p1 : Symbol(p1, Decl(ipromise3.ts, 7, 3))
 >then : Symbol(IPromise3.then, Decl(ipromise3.ts, 0, 24), Decl(ipromise3.ts, 1, 139), Decl(ipromise3.ts, 2, 128), Decl(ipromise3.ts, 3, 128))
+>function (x) {    return x;} : Symbol((Anonymous function), Decl(ipromise3.ts, 8, 36))
 >x : Symbol(x, Decl(ipromise3.ts, 8, 46))
 
     return x;
diff --git a/tests/baselines/reference/ipromise4.symbols b/tests/baselines/reference/ipromise4.symbols
index 65ae5f90cfe92..f90a0e50a0fb6 100644
--- a/tests/baselines/reference/ipromise4.symbols
+++ b/tests/baselines/reference/ipromise4.symbols
@@ -102,6 +102,7 @@ p.then(function (x) { } ); // should not error
 >p.then : Symbol(Windows.Foundation.IPromise.then, Decl(ipromise4.ts, 1, 34), Decl(ipromise4.ts, 2, 159), Decl(ipromise4.ts, 3, 149), Decl(ipromise4.ts, 4, 149))
 >p : Symbol(p, Decl(ipromise4.ts, 10, 3))
 >then : Symbol(Windows.Foundation.IPromise.then, Decl(ipromise4.ts, 1, 34), Decl(ipromise4.ts, 2, 159), Decl(ipromise4.ts, 3, 149), Decl(ipromise4.ts, 4, 149))
+>function (x) { } : Symbol((Anonymous function), Decl(ipromise4.ts, 12, 7))
 >x : Symbol(x, Decl(ipromise4.ts, 12, 17))
 
 p.then(function (x) { return "hello"; } ).then(function (x) { return x } ); // should not error
@@ -109,8 +110,10 @@ p.then(function (x) { return "hello"; } ).then(function (x) { return x } ); // s
 >p.then : Symbol(Windows.Foundation.IPromise.then, Decl(ipromise4.ts, 1, 34), Decl(ipromise4.ts, 2, 159), Decl(ipromise4.ts, 3, 149), Decl(ipromise4.ts, 4, 149))
 >p : Symbol(p, Decl(ipromise4.ts, 10, 3))
 >then : Symbol(Windows.Foundation.IPromise.then, Decl(ipromise4.ts, 1, 34), Decl(ipromise4.ts, 2, 159), Decl(ipromise4.ts, 3, 149), Decl(ipromise4.ts, 4, 149))
+>function (x) { return "hello"; } : Symbol((Anonymous function), Decl(ipromise4.ts, 13, 7))
 >x : Symbol(x, Decl(ipromise4.ts, 13, 17))
 >then : Symbol(Windows.Foundation.IPromise.then, Decl(ipromise4.ts, 1, 34), Decl(ipromise4.ts, 2, 159), Decl(ipromise4.ts, 3, 149), Decl(ipromise4.ts, 4, 149))
+>function (x) { return x } : Symbol((Anonymous function), Decl(ipromise4.ts, 13, 47))
 >x : Symbol(x, Decl(ipromise4.ts, 13, 57))
 >x : Symbol(x, Decl(ipromise4.ts, 13, 57))
  
diff --git a/tests/baselines/reference/iterableArrayPattern1.symbols b/tests/baselines/reference/iterableArrayPattern1.symbols
index 3920dc1cef466..a6a944f109e88 100644
--- a/tests/baselines/reference/iterableArrayPattern1.symbols
+++ b/tests/baselines/reference/iterableArrayPattern1.symbols
@@ -11,6 +11,8 @@ class SymbolIterator {
 >next : Symbol(next, Decl(iterableArrayPattern1.ts, 1, 22))
 
         return {
+>{            value: Symbol(),            done: false        } : Symbol(, Decl(iterableArrayPattern1.ts, 3, 14))
+
             value: Symbol(),
 >value : Symbol(value, Decl(iterableArrayPattern1.ts, 3, 16))
 >Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11))
diff --git a/tests/baselines/reference/iterableArrayPattern11.symbols b/tests/baselines/reference/iterableArrayPattern11.symbols
index 06e38c57af41d..99a6f0885c1ae 100644
--- a/tests/baselines/reference/iterableArrayPattern11.symbols
+++ b/tests/baselines/reference/iterableArrayPattern11.symbols
@@ -25,6 +25,8 @@ class FooIterator {
 >next : Symbol(next, Decl(iterableArrayPattern11.ts, 4, 19))
 
         return {
+>{            value: new Foo,            done: false        } : Symbol(, Decl(iterableArrayPattern11.ts, 6, 14))
+
             value: new Foo,
 >value : Symbol(value, Decl(iterableArrayPattern11.ts, 6, 16))
 >Foo : Symbol(Foo, Decl(iterableArrayPattern11.ts, 2, 15))
diff --git a/tests/baselines/reference/iterableArrayPattern12.symbols b/tests/baselines/reference/iterableArrayPattern12.symbols
index e16fe5255e4fd..d35d83efd0471 100644
--- a/tests/baselines/reference/iterableArrayPattern12.symbols
+++ b/tests/baselines/reference/iterableArrayPattern12.symbols
@@ -25,6 +25,8 @@ class FooIterator {
 >next : Symbol(next, Decl(iterableArrayPattern12.ts, 4, 19))
 
         return {
+>{            value: new Foo,            done: false        } : Symbol(, Decl(iterableArrayPattern12.ts, 6, 14))
+
             value: new Foo,
 >value : Symbol(value, Decl(iterableArrayPattern12.ts, 6, 16))
 >Foo : Symbol(Foo, Decl(iterableArrayPattern12.ts, 2, 15))
diff --git a/tests/baselines/reference/iterableArrayPattern13.symbols b/tests/baselines/reference/iterableArrayPattern13.symbols
index b870919782926..bddeb62fdf3a5 100644
--- a/tests/baselines/reference/iterableArrayPattern13.symbols
+++ b/tests/baselines/reference/iterableArrayPattern13.symbols
@@ -24,6 +24,8 @@ class FooIterator {
 >next : Symbol(next, Decl(iterableArrayPattern13.ts, 4, 19))
 
         return {
+>{            value: new Foo,            done: false        } : Symbol(, Decl(iterableArrayPattern13.ts, 6, 14))
+
             value: new Foo,
 >value : Symbol(value, Decl(iterableArrayPattern13.ts, 6, 16))
 >Foo : Symbol(Foo, Decl(iterableArrayPattern13.ts, 2, 15))
diff --git a/tests/baselines/reference/iterableArrayPattern2.symbols b/tests/baselines/reference/iterableArrayPattern2.symbols
index 17ac6a1feacef..832c0719e627b 100644
--- a/tests/baselines/reference/iterableArrayPattern2.symbols
+++ b/tests/baselines/reference/iterableArrayPattern2.symbols
@@ -11,6 +11,8 @@ class SymbolIterator {
 >next : Symbol(next, Decl(iterableArrayPattern2.ts, 1, 22))
 
         return {
+>{            value: Symbol(),            done: false        } : Symbol(, Decl(iterableArrayPattern2.ts, 3, 14))
+
             value: Symbol(),
 >value : Symbol(value, Decl(iterableArrayPattern2.ts, 3, 16))
 >Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11))
diff --git a/tests/baselines/reference/iterableArrayPattern3.symbols b/tests/baselines/reference/iterableArrayPattern3.symbols
index 468866ca32404..1ea5556fccd48 100644
--- a/tests/baselines/reference/iterableArrayPattern3.symbols
+++ b/tests/baselines/reference/iterableArrayPattern3.symbols
@@ -26,6 +26,8 @@ class FooIterator {
 >next : Symbol(next, Decl(iterableArrayPattern3.ts, 4, 19))
 
         return {
+>{            value: new Foo,            done: false        } : Symbol(, Decl(iterableArrayPattern3.ts, 6, 14))
+
             value: new Foo,
 >value : Symbol(value, Decl(iterableArrayPattern3.ts, 6, 16))
 >Foo : Symbol(Foo, Decl(iterableArrayPattern3.ts, 2, 15))
diff --git a/tests/baselines/reference/iterableArrayPattern4.symbols b/tests/baselines/reference/iterableArrayPattern4.symbols
index 10225e183e6cb..a0f4b6ce0b590 100644
--- a/tests/baselines/reference/iterableArrayPattern4.symbols
+++ b/tests/baselines/reference/iterableArrayPattern4.symbols
@@ -26,6 +26,8 @@ class FooIterator {
 >next : Symbol(next, Decl(iterableArrayPattern4.ts, 4, 19))
 
         return {
+>{            value: new Foo,            done: false        } : Symbol(, Decl(iterableArrayPattern4.ts, 6, 14))
+
             value: new Foo,
 >value : Symbol(value, Decl(iterableArrayPattern4.ts, 6, 16))
 >Foo : Symbol(Foo, Decl(iterableArrayPattern4.ts, 2, 15))
diff --git a/tests/baselines/reference/iterableArrayPattern9.symbols b/tests/baselines/reference/iterableArrayPattern9.symbols
index 86c46812688fa..e487b6db88414 100644
--- a/tests/baselines/reference/iterableArrayPattern9.symbols
+++ b/tests/baselines/reference/iterableArrayPattern9.symbols
@@ -21,6 +21,8 @@ class FooIterator {
 >next : Symbol(next, Decl(iterableArrayPattern9.ts, 3, 19))
 
         return {
+>{            value: new Foo,            done: false        } : Symbol(, Decl(iterableArrayPattern9.ts, 5, 14))
+
             value: new Foo,
 >value : Symbol(value, Decl(iterableArrayPattern9.ts, 5, 16))
 >Foo : Symbol(Foo, Decl(iterableArrayPattern9.ts, 1, 15))
diff --git a/tests/baselines/reference/iterableContextualTyping1.symbols b/tests/baselines/reference/iterableContextualTyping1.symbols
index ae99a4b52554e..a969f0fbcd7a8 100644
--- a/tests/baselines/reference/iterableContextualTyping1.symbols
+++ b/tests/baselines/reference/iterableContextualTyping1.symbols
@@ -3,6 +3,7 @@ var iter: Iterable<(x: string) => number> = [s => s.length];
 >iter : Symbol(iter, Decl(iterableContextualTyping1.ts, 0, 3))
 >Iterable : Symbol(Iterable, Decl(lib.d.ts, 1681, 1))
 >x : Symbol(x, Decl(iterableContextualTyping1.ts, 0, 20))
+>s => s.length : Symbol((Anonymous function), Decl(iterableContextualTyping1.ts, 0, 45))
 >s : Symbol(s, Decl(iterableContextualTyping1.ts, 0, 45))
 >s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >s : Symbol(s, Decl(iterableContextualTyping1.ts, 0, 45))
diff --git a/tests/baselines/reference/iteratorSpreadInArray.symbols b/tests/baselines/reference/iteratorSpreadInArray.symbols
index c4a2459e26276..4738ff6e59864 100644
--- a/tests/baselines/reference/iteratorSpreadInArray.symbols
+++ b/tests/baselines/reference/iteratorSpreadInArray.symbols
@@ -10,6 +10,8 @@ class SymbolIterator {
 >next : Symbol(next, Decl(iteratorSpreadInArray.ts, 2, 22))
 
         return {
+>{            value: Symbol(),            done: false        } : Symbol(, Decl(iteratorSpreadInArray.ts, 4, 14))
+
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInArray.ts, 4, 16))
 >Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11))
diff --git a/tests/baselines/reference/iteratorSpreadInArray2.symbols b/tests/baselines/reference/iteratorSpreadInArray2.symbols
index cdc7bb3e2bcb6..579597171fd08 100644
--- a/tests/baselines/reference/iteratorSpreadInArray2.symbols
+++ b/tests/baselines/reference/iteratorSpreadInArray2.symbols
@@ -11,6 +11,8 @@ class SymbolIterator {
 >next : Symbol(next, Decl(iteratorSpreadInArray2.ts, 2, 22))
 
         return {
+>{            value: Symbol(),            done: false        } : Symbol(, Decl(iteratorSpreadInArray2.ts, 4, 14))
+
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInArray2.ts, 4, 16))
 >Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11))
@@ -38,6 +40,8 @@ class NumberIterator {
 >next : Symbol(next, Decl(iteratorSpreadInArray2.ts, 15, 22))
 
         return {
+>{            value: 0,            done: false        } : Symbol(, Decl(iteratorSpreadInArray2.ts, 17, 14))
+
             value: 0,
 >value : Symbol(value, Decl(iteratorSpreadInArray2.ts, 17, 16))
 
diff --git a/tests/baselines/reference/iteratorSpreadInArray3.symbols b/tests/baselines/reference/iteratorSpreadInArray3.symbols
index e4d1b508bb5d4..342671ca07204 100644
--- a/tests/baselines/reference/iteratorSpreadInArray3.symbols
+++ b/tests/baselines/reference/iteratorSpreadInArray3.symbols
@@ -10,6 +10,8 @@ class SymbolIterator {
 >next : Symbol(next, Decl(iteratorSpreadInArray3.ts, 2, 22))
 
         return {
+>{            value: Symbol(),            done: false        } : Symbol(, Decl(iteratorSpreadInArray3.ts, 4, 14))
+
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInArray3.ts, 4, 16))
 >Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11))
diff --git a/tests/baselines/reference/iteratorSpreadInArray4.symbols b/tests/baselines/reference/iteratorSpreadInArray4.symbols
index bd6760dd0aa21..0f0a608fd6b5b 100644
--- a/tests/baselines/reference/iteratorSpreadInArray4.symbols
+++ b/tests/baselines/reference/iteratorSpreadInArray4.symbols
@@ -10,6 +10,8 @@ class SymbolIterator {
 >next : Symbol(next, Decl(iteratorSpreadInArray4.ts, 2, 22))
 
         return {
+>{            value: Symbol(),            done: false        } : Symbol(, Decl(iteratorSpreadInArray4.ts, 4, 14))
+
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInArray4.ts, 4, 16))
 >Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11))
diff --git a/tests/baselines/reference/iteratorSpreadInArray7.symbols b/tests/baselines/reference/iteratorSpreadInArray7.symbols
index d0bc97907526d..e6987a8b738ac 100644
--- a/tests/baselines/reference/iteratorSpreadInArray7.symbols
+++ b/tests/baselines/reference/iteratorSpreadInArray7.symbols
@@ -15,6 +15,8 @@ class SymbolIterator {
 >next : Symbol(next, Decl(iteratorSpreadInArray7.ts, 3, 22))
 
         return {
+>{            value: Symbol(),            done: false        } : Symbol(, Decl(iteratorSpreadInArray7.ts, 5, 14))
+
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInArray7.ts, 5, 16))
 >Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11))
diff --git a/tests/baselines/reference/iteratorSpreadInCall11.symbols b/tests/baselines/reference/iteratorSpreadInCall11.symbols
index a7e5d7b8919f8..c6b3d6c0a3215 100644
--- a/tests/baselines/reference/iteratorSpreadInCall11.symbols
+++ b/tests/baselines/reference/iteratorSpreadInCall11.symbols
@@ -17,6 +17,8 @@ class SymbolIterator {
 >next : Symbol(next, Decl(iteratorSpreadInCall11.ts, 4, 22))
 
         return {
+>{            value: Symbol(),            done: false        } : Symbol(, Decl(iteratorSpreadInCall11.ts, 6, 14))
+
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInCall11.ts, 6, 16))
 >Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11))
diff --git a/tests/baselines/reference/iteratorSpreadInCall12.symbols b/tests/baselines/reference/iteratorSpreadInCall12.symbols
index 67b9e9e500daf..df9a9a0d16aaf 100644
--- a/tests/baselines/reference/iteratorSpreadInCall12.symbols
+++ b/tests/baselines/reference/iteratorSpreadInCall12.symbols
@@ -20,6 +20,8 @@ class SymbolIterator {
 >next : Symbol(next, Decl(iteratorSpreadInCall12.ts, 6, 22))
 
         return {
+>{            value: Symbol(),            done: false        } : Symbol(, Decl(iteratorSpreadInCall12.ts, 8, 14))
+
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInCall12.ts, 8, 16))
 >Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11))
@@ -47,6 +49,8 @@ class StringIterator {
 >next : Symbol(next, Decl(iteratorSpreadInCall12.ts, 19, 22))
 
         return {
+>{            value: "",            done: false        } : Symbol(, Decl(iteratorSpreadInCall12.ts, 21, 14))
+
             value: "",
 >value : Symbol(value, Decl(iteratorSpreadInCall12.ts, 21, 16))
 
diff --git a/tests/baselines/reference/iteratorSpreadInCall3.symbols b/tests/baselines/reference/iteratorSpreadInCall3.symbols
index 0c3c11c84f470..8d59ad37c2133 100644
--- a/tests/baselines/reference/iteratorSpreadInCall3.symbols
+++ b/tests/baselines/reference/iteratorSpreadInCall3.symbols
@@ -14,6 +14,8 @@ class SymbolIterator {
 >next : Symbol(next, Decl(iteratorSpreadInCall3.ts, 3, 22))
 
         return {
+>{            value: Symbol(),            done: false        } : Symbol(, Decl(iteratorSpreadInCall3.ts, 5, 14))
+
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInCall3.ts, 5, 16))
 >Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11))
diff --git a/tests/baselines/reference/iteratorSpreadInCall5.symbols b/tests/baselines/reference/iteratorSpreadInCall5.symbols
index 03faf4b593ea8..7d7e3a063abce 100644
--- a/tests/baselines/reference/iteratorSpreadInCall5.symbols
+++ b/tests/baselines/reference/iteratorSpreadInCall5.symbols
@@ -15,6 +15,8 @@ class SymbolIterator {
 >next : Symbol(next, Decl(iteratorSpreadInCall5.ts, 3, 22))
 
         return {
+>{            value: Symbol(),            done: false        } : Symbol(, Decl(iteratorSpreadInCall5.ts, 5, 14))
+
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInCall5.ts, 5, 16))
 >Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11))
@@ -42,6 +44,8 @@ class StringIterator {
 >next : Symbol(next, Decl(iteratorSpreadInCall5.ts, 16, 22))
 
         return {
+>{            value: "",            done: false        } : Symbol(, Decl(iteratorSpreadInCall5.ts, 18, 14))
+
             value: "",
 >value : Symbol(value, Decl(iteratorSpreadInCall5.ts, 18, 16))
 
diff --git a/tests/baselines/reference/jsxReactTestSuite.symbols b/tests/baselines/reference/jsxReactTestSuite.symbols
index 9e382742f0d4b..beaa08fee69fe 100644
--- a/tests/baselines/reference/jsxReactTestSuite.symbols
+++ b/tests/baselines/reference/jsxReactTestSuite.symbols
@@ -186,6 +186,7 @@ var x =
 >Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11))
 >x : Symbol(unknown)
 >z : Symbol(z, Decl(jsxReactTestSuite.tsx, 11, 11))
+>{ y: 2 } : Symbol(, Decl(jsxReactTestSuite.tsx, 113, 25))
 >y : Symbol(y, Decl(jsxReactTestSuite.tsx, 113, 27))
 >z : Symbol(z, Decl(jsxReactTestSuite.tsx, 11, 11))
 >z : Symbol(unknown)
diff --git a/tests/baselines/reference/keywordField.symbols b/tests/baselines/reference/keywordField.symbols
index 7ea3438d9852d..a7f7554d10f27 100644
--- a/tests/baselines/reference/keywordField.symbols
+++ b/tests/baselines/reference/keywordField.symbols
@@ -1,12 +1,14 @@
 === tests/cases/compiler/keywordField.ts ===
 var obj:any = {};
 >obj : Symbol(obj, Decl(keywordField.ts, 0, 3))
+>{} : Symbol(, Decl(keywordField.ts, 0, 13))
 
 obj.if = 1;
 >obj : Symbol(obj, Decl(keywordField.ts, 0, 3))
 
 var a = { if: "test" }
 >a : Symbol(a, Decl(keywordField.ts, 4, 3))
+>{ if: "test" } : Symbol(, Decl(keywordField.ts, 4, 7))
 >if : Symbol(if, Decl(keywordField.ts, 4, 9))
 
 var n = a.if
diff --git a/tests/baselines/reference/lambdaASIEmit.symbols b/tests/baselines/reference/lambdaASIEmit.symbols
index d33cc16817a3c..8b430026ae25e 100644
--- a/tests/baselines/reference/lambdaASIEmit.symbols
+++ b/tests/baselines/reference/lambdaASIEmit.symbols
@@ -8,6 +8,7 @@ function Foo(x: any)
  
 Foo(() =>
 >Foo : Symbol(Foo, Decl(lambdaASIEmit.ts, 0, 0))
+>() =>    // do something    127 : Symbol((Anonymous function), Decl(lambdaASIEmit.ts, 5, 4))
 
     // do something
     127);
diff --git a/tests/baselines/reference/lambdaExpression.symbols b/tests/baselines/reference/lambdaExpression.symbols
index 48bda5ce07fb0..825baf446b9d8 100644
--- a/tests/baselines/reference/lambdaExpression.symbols
+++ b/tests/baselines/reference/lambdaExpression.symbols
@@ -1,9 +1,13 @@
 === tests/cases/compiler/lambdaExpression.ts ===
 () => 0; // Needs to be wrapped in parens to be a valid expression (not declaration)
+>() => 0 : Symbol((Anonymous function), Decl(lambdaExpression.ts, 0, 0))
+
 var y = 0;
 >y : Symbol(y, Decl(lambdaExpression.ts, 1, 3))
 
 (()=>0);
+>()=>0 : Symbol((Anonymous function), Decl(lambdaExpression.ts, 2, 1))
+
 var x = 0;
 >x : Symbol(x, Decl(lambdaExpression.ts, 3, 3))
 
diff --git a/tests/baselines/reference/letDeclarations-es5.symbols b/tests/baselines/reference/letDeclarations-es5.symbols
index ac2daaaac8933..8fd8c951146ab 100644
--- a/tests/baselines/reference/letDeclarations-es5.symbols
+++ b/tests/baselines/reference/letDeclarations-es5.symbols
@@ -25,6 +25,7 @@ let l9 = 0, l10 :string = "", l11 = null;
 
 for(let l11 in {}) { }
 >l11 : Symbol(l11, Decl(letDeclarations-es5.ts, 9, 7))
+>{} : Symbol(, Decl(letDeclarations-es5.ts, 9, 14))
 
 for(let l12 = 0; l12 < 9; l12++) { }
 >l12 : Symbol(l12, Decl(letDeclarations-es5.ts, 11, 7))
diff --git a/tests/baselines/reference/letDeclarations.symbols b/tests/baselines/reference/letDeclarations.symbols
index dbbaac211ac73..39fea572581fa 100644
--- a/tests/baselines/reference/letDeclarations.symbols
+++ b/tests/baselines/reference/letDeclarations.symbols
@@ -25,6 +25,7 @@ let l9 = 0, l10 :string = "", l11 = null;
 
 for(let l11 in {}) { }
 >l11 : Symbol(l11, Decl(letDeclarations.ts, 9, 7))
+>{} : Symbol(, Decl(letDeclarations.ts, 9, 14))
 
 for(let l12 = 0; l12 < 9; l12++) { }
 >l12 : Symbol(l12, Decl(letDeclarations.ts, 11, 7))
diff --git a/tests/baselines/reference/letInNonStrictMode.symbols b/tests/baselines/reference/letInNonStrictMode.symbols
index 2b854a8c03fb5..51621148aae61 100644
--- a/tests/baselines/reference/letInNonStrictMode.symbols
+++ b/tests/baselines/reference/letInNonStrictMode.symbols
@@ -4,5 +4,6 @@ let [x] = [1];
 
 let {a: y} = {a: 1};
 >y : Symbol(y, Decl(letInNonStrictMode.ts, 1, 5))
+>{a: 1} : Symbol(, Decl(letInNonStrictMode.ts, 1, 12))
 >a : Symbol(a, Decl(letInNonStrictMode.ts, 1, 14))
 
diff --git a/tests/baselines/reference/localTypes1.symbols b/tests/baselines/reference/localTypes1.symbols
index 53d4191ae6197..3dbbb020d5aac 100644
--- a/tests/baselines/reference/localTypes1.symbols
+++ b/tests/baselines/reference/localTypes1.symbols
@@ -191,6 +191,7 @@ function f5() {
 
     var z1 = function () {
 >z1 : Symbol(z1, Decl(localTypes1.ts, 69, 7))
+>function () {        enum E {            A, B, C        }        class C {            x: E;        }        return new C();    } : Symbol((Anonymous function), Decl(localTypes1.ts, 69, 12))
 
         enum E {
 >E : Symbol(E, Decl(localTypes1.ts, 69, 26))
@@ -212,6 +213,7 @@ function f5() {
     }
     var z2 = () => {
 >z2 : Symbol(z2, Decl(localTypes1.ts, 78, 7))
+>() => {        enum E {            A, B, C        }        class C {            x: E;        }        return new C();    } : Symbol((Anonymous function), Decl(localTypes1.ts, 78, 12))
 
         enum E {
 >E : Symbol(E, Decl(localTypes1.ts, 78, 20))
diff --git a/tests/baselines/reference/localTypes5.symbols b/tests/baselines/reference/localTypes5.symbols
index 4ffe53b3e5303..d9300c73d4254 100644
--- a/tests/baselines/reference/localTypes5.symbols
+++ b/tests/baselines/reference/localTypes5.symbols
@@ -12,6 +12,7 @@ function foo<A>() {
 >C : Symbol(C, Decl(localTypes5.ts, 2, 12))
 
             return (function <D>() {
+>function <D>() {                class Y<E> {                }                return new Y<string>();            } : Symbol((Anonymous function), Decl(localTypes5.ts, 3, 20))
 >D : Symbol(D, Decl(localTypes5.ts, 3, 30))
 
                 class Y<E> {
diff --git a/tests/baselines/reference/logicalNotOperatorWithBooleanType.symbols b/tests/baselines/reference/logicalNotOperatorWithBooleanType.symbols
index b42b9d7922ecd..63068f8e301ed 100644
--- a/tests/baselines/reference/logicalNotOperatorWithBooleanType.symbols
+++ b/tests/baselines/reference/logicalNotOperatorWithBooleanType.symbols
@@ -37,6 +37,7 @@ var ResultIsBoolean2 = !true;
 
 var ResultIsBoolean3 = !{ x: true, y: false };
 >ResultIsBoolean3 : Symbol(ResultIsBoolean3, Decl(logicalNotOperatorWithBooleanType.ts, 20, 3))
+>{ x: true, y: false } : Symbol(, Decl(logicalNotOperatorWithBooleanType.ts, 20, 24))
 >x : Symbol(x, Decl(logicalNotOperatorWithBooleanType.ts, 20, 25))
 >y : Symbol(y, Decl(logicalNotOperatorWithBooleanType.ts, 20, 34))
 
diff --git a/tests/baselines/reference/logicalNotOperatorWithNumberType.symbols b/tests/baselines/reference/logicalNotOperatorWithNumberType.symbols
index 4f277a8db54c5..195041dffcf00 100644
--- a/tests/baselines/reference/logicalNotOperatorWithNumberType.symbols
+++ b/tests/baselines/reference/logicalNotOperatorWithNumberType.symbols
@@ -44,13 +44,16 @@ var ResultIsBoolean3 = !1;
 
 var ResultIsBoolean4 = !{ x: 1, y: 2};
 >ResultIsBoolean4 : Symbol(ResultIsBoolean4, Decl(logicalNotOperatorWithNumberType.ts, 22, 3))
+>{ x: 1, y: 2} : Symbol(, Decl(logicalNotOperatorWithNumberType.ts, 22, 24))
 >x : Symbol(x, Decl(logicalNotOperatorWithNumberType.ts, 22, 25))
 >y : Symbol(y, Decl(logicalNotOperatorWithNumberType.ts, 22, 31))
 
 var ResultIsBoolean5 = !{ x: 1, y: (n: number) => { return n; } };
 >ResultIsBoolean5 : Symbol(ResultIsBoolean5, Decl(logicalNotOperatorWithNumberType.ts, 23, 3))
+>{ x: 1, y: (n: number) => { return n; } } : Symbol(, Decl(logicalNotOperatorWithNumberType.ts, 23, 24))
 >x : Symbol(x, Decl(logicalNotOperatorWithNumberType.ts, 23, 25))
 >y : Symbol(y, Decl(logicalNotOperatorWithNumberType.ts, 23, 31))
+>(n: number) => { return n; } : Symbol((Anonymous function), Decl(logicalNotOperatorWithNumberType.ts, 23, 34))
 >n : Symbol(n, Decl(logicalNotOperatorWithNumberType.ts, 23, 36))
 >n : Symbol(n, Decl(logicalNotOperatorWithNumberType.ts, 23, 36))
 
diff --git a/tests/baselines/reference/logicalNotOperatorWithStringType.symbols b/tests/baselines/reference/logicalNotOperatorWithStringType.symbols
index ff266361321b5..cade80cbd70a5 100644
--- a/tests/baselines/reference/logicalNotOperatorWithStringType.symbols
+++ b/tests/baselines/reference/logicalNotOperatorWithStringType.symbols
@@ -44,13 +44,16 @@ var ResultIsBoolean3 = !"";
 
 var ResultIsBoolean4 = !{ x: "", y: "" };
 >ResultIsBoolean4 : Symbol(ResultIsBoolean4, Decl(logicalNotOperatorWithStringType.ts, 22, 3))
+>{ x: "", y: "" } : Symbol(, Decl(logicalNotOperatorWithStringType.ts, 22, 24))
 >x : Symbol(x, Decl(logicalNotOperatorWithStringType.ts, 22, 25))
 >y : Symbol(y, Decl(logicalNotOperatorWithStringType.ts, 22, 32))
 
 var ResultIsBoolean5 = !{ x: "", y: (s: string) => { return s; } };
 >ResultIsBoolean5 : Symbol(ResultIsBoolean5, Decl(logicalNotOperatorWithStringType.ts, 23, 3))
+>{ x: "", y: (s: string) => { return s; } } : Symbol(, Decl(logicalNotOperatorWithStringType.ts, 23, 24))
 >x : Symbol(x, Decl(logicalNotOperatorWithStringType.ts, 23, 25))
 >y : Symbol(y, Decl(logicalNotOperatorWithStringType.ts, 23, 32))
+>(s: string) => { return s; } : Symbol((Anonymous function), Decl(logicalNotOperatorWithStringType.ts, 23, 35))
 >s : Symbol(s, Decl(logicalNotOperatorWithStringType.ts, 23, 37))
 >s : Symbol(s, Decl(logicalNotOperatorWithStringType.ts, 23, 37))
 
diff --git a/tests/baselines/reference/logicalOrExpressionIsContextuallyTyped.symbols b/tests/baselines/reference/logicalOrExpressionIsContextuallyTyped.symbols
index 90fc4ac163ce5..ce7c8c646a955 100644
--- a/tests/baselines/reference/logicalOrExpressionIsContextuallyTyped.symbols
+++ b/tests/baselines/reference/logicalOrExpressionIsContextuallyTyped.symbols
@@ -7,8 +7,10 @@
 var r: { a: string } = { a: '', b: 123 } || { a: '', b: true };
 >r : Symbol(r, Decl(logicalOrExpressionIsContextuallyTyped.ts, 5, 3))
 >a : Symbol(a, Decl(logicalOrExpressionIsContextuallyTyped.ts, 5, 8))
+>{ a: '', b: 123 } : Symbol(, Decl(logicalOrExpressionIsContextuallyTyped.ts, 5, 22))
 >a : Symbol(a, Decl(logicalOrExpressionIsContextuallyTyped.ts, 5, 24))
 >b : Symbol(b, Decl(logicalOrExpressionIsContextuallyTyped.ts, 5, 31))
+>{ a: '', b: true } : Symbol(, Decl(logicalOrExpressionIsContextuallyTyped.ts, 5, 43))
 >a : Symbol(a, Decl(logicalOrExpressionIsContextuallyTyped.ts, 5, 45))
 >b : Symbol(b, Decl(logicalOrExpressionIsContextuallyTyped.ts, 5, 52))
 
diff --git a/tests/baselines/reference/logicalOrExpressionIsNotContextuallyTyped.symbols b/tests/baselines/reference/logicalOrExpressionIsNotContextuallyTyped.symbols
index 6cfbf7ea6b675..f3db9ebde61d9 100644
--- a/tests/baselines/reference/logicalOrExpressionIsNotContextuallyTyped.symbols
+++ b/tests/baselines/reference/logicalOrExpressionIsNotContextuallyTyped.symbols
@@ -13,6 +13,7 @@ var a: (a: string) => string;
 var r = a || ((a) => a.toLowerCase());
 >r : Symbol(r, Decl(logicalOrExpressionIsNotContextuallyTyped.ts, 9, 3))
 >a : Symbol(a, Decl(logicalOrExpressionIsNotContextuallyTyped.ts, 6, 3))
+>(a) => a.toLowerCase() : Symbol((Anonymous function), Decl(logicalOrExpressionIsNotContextuallyTyped.ts, 9, 14))
 >a : Symbol(a, Decl(logicalOrExpressionIsNotContextuallyTyped.ts, 9, 15))
 >a.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51))
 >a : Symbol(a, Decl(logicalOrExpressionIsNotContextuallyTyped.ts, 9, 15))
diff --git a/tests/baselines/reference/logicalOrOperatorWithTypeParameters.symbols b/tests/baselines/reference/logicalOrOperatorWithTypeParameters.symbols
index 05b33a2b185e9..f1c69700e45d7 100644
--- a/tests/baselines/reference/logicalOrOperatorWithTypeParameters.symbols
+++ b/tests/baselines/reference/logicalOrOperatorWithTypeParameters.symbols
@@ -98,6 +98,7 @@ function fn3<T extends { a: string; b: string }, U extends { a: string; b: numbe
     var r3 = t || { a: '' };
 >r3 : Symbol(r3, Decl(logicalOrOperatorWithTypeParameters.ts, 20, 7))
 >t : Symbol(t, Decl(logicalOrOperatorWithTypeParameters.ts, 17, 85))
+>{ a: '' } : Symbol(, Decl(logicalOrOperatorWithTypeParameters.ts, 20, 17))
 >a : Symbol(a, Decl(logicalOrOperatorWithTypeParameters.ts, 20, 19))
 
     var r4: { a: string } = t || u;
diff --git a/tests/baselines/reference/m7Bugs.symbols b/tests/baselines/reference/m7Bugs.symbols
index be6d798a8a532..d05ad7eb9f653 100644
--- a/tests/baselines/reference/m7Bugs.symbols
+++ b/tests/baselines/reference/m7Bugs.symbols
@@ -11,6 +11,7 @@ var s: ISomething = <ISomething>({ });
 >s : Symbol(s, Decl(m7Bugs.ts, 5, 3))
 >ISomething : Symbol(ISomething, Decl(m7Bugs.ts, 0, 0))
 >ISomething : Symbol(ISomething, Decl(m7Bugs.ts, 0, 0))
+>{ } : Symbol(, Decl(m7Bugs.ts, 5, 33))
 
 
 // scenario 2
@@ -26,6 +27,7 @@ var x: B = <B>{ };
 >x : Symbol(x, Decl(m7Bugs.ts, 13, 3))
 >B : Symbol(B, Decl(m7Bugs.ts, 9, 26))
 >B : Symbol(B, Decl(m7Bugs.ts, 9, 26))
+>{ } : Symbol(, Decl(m7Bugs.ts, 13, 14))
 
 class C1 {
 >C1 : Symbol(C1, Decl(m7Bugs.ts, 13, 18))
@@ -53,5 +55,6 @@ var y3: C1 = <C1> {};
 >y3 : Symbol(y3, Decl(m7Bugs.ts, 23, 3))
 >C1 : Symbol(C1, Decl(m7Bugs.ts, 13, 18))
 >C1 : Symbol(C1, Decl(m7Bugs.ts, 13, 18))
+>{} : Symbol(, Decl(m7Bugs.ts, 23, 17))
 
 
diff --git a/tests/baselines/reference/mergedDeclarations1.symbols b/tests/baselines/reference/mergedDeclarations1.symbols
index 733b9c4ee3250..0e6e9165eec12 100644
--- a/tests/baselines/reference/mergedDeclarations1.symbols
+++ b/tests/baselines/reference/mergedDeclarations1.symbols
@@ -15,6 +15,7 @@ function point(x: number, y: number): Point {
 >Point : Symbol(Point, Decl(mergedDeclarations1.ts, 0, 0))
 
     return { x: x, y: y };
+>{ x: x, y: y } : Symbol(, Decl(mergedDeclarations1.ts, 5, 10))
 >x : Symbol(x, Decl(mergedDeclarations1.ts, 5, 12))
 >x : Symbol(x, Decl(mergedDeclarations1.ts, 4, 15))
 >y : Symbol(y, Decl(mergedDeclarations1.ts, 5, 18))
diff --git a/tests/baselines/reference/methodContainingLocalFunction.symbols b/tests/baselines/reference/methodContainingLocalFunction.symbols
index e449d68562f89..7ef55a7684e04 100644
--- a/tests/baselines/reference/methodContainingLocalFunction.symbols
+++ b/tests/baselines/reference/methodContainingLocalFunction.symbols
@@ -70,6 +70,7 @@ class C {
 
         var funcExpr = <U>(u?: U) => { };
 >funcExpr : Symbol(funcExpr, Decl(methodContainingLocalFunction.ts, 28, 11))
+><U>(u?: U) => { } : Symbol((Anonymous function), Decl(methodContainingLocalFunction.ts, 28, 22))
 >U : Symbol(U, Decl(methodContainingLocalFunction.ts, 28, 24))
 >u : Symbol(u, Decl(methodContainingLocalFunction.ts, 28, 27))
 >U : Symbol(U, Decl(methodContainingLocalFunction.ts, 28, 24))
@@ -106,6 +107,7 @@ enum E {
 
     A = (() => {
 >A : Symbol(E.A, Decl(methodContainingLocalFunction.ts, 42, 8))
+>() => {        function localFunction() { }        var x: { (): void; };        x = localFunction;        return 0;    } : Symbol((Anonymous function), Decl(methodContainingLocalFunction.ts, 43, 9))
 
         function localFunction() { }
 >localFunction : Symbol(localFunction, Decl(methodContainingLocalFunction.ts, 43, 16))
diff --git a/tests/baselines/reference/missingSelf.symbols b/tests/baselines/reference/missingSelf.symbols
index b4b5bd0b905b2..271d45147fb96 100644
--- a/tests/baselines/reference/missingSelf.symbols
+++ b/tests/baselines/reference/missingSelf.symbols
@@ -17,6 +17,7 @@ class CalcButton2
 {
     public b() { () => this.onClick(); }
 >b : Symbol(b, Decl(missingSelf.ts, 7, 1))
+>() => this.onClick() : Symbol((Anonymous function), Decl(missingSelf.ts, 8, 16))
 >this.onClick : Symbol(onClick, Decl(missingSelf.ts, 8, 40))
 >this : Symbol(CalcButton2, Decl(missingSelf.ts, 4, 1))
 >onClick : Symbol(onClick, Decl(missingSelf.ts, 8, 40))
diff --git a/tests/baselines/reference/modFunctionCrash.symbols b/tests/baselines/reference/modFunctionCrash.symbols
index b1063a40cd502..739ee6001cd6e 100644
--- a/tests/baselines/reference/modFunctionCrash.symbols
+++ b/tests/baselines/reference/modFunctionCrash.symbols
@@ -12,4 +12,5 @@ Q.f(function() {this;});
 >Q.f : Symbol(Q.f, Decl(modFunctionCrash.ts, 0, 18))
 >Q : Symbol(Q, Decl(modFunctionCrash.ts, 0, 0))
 >f : Symbol(Q.f, Decl(modFunctionCrash.ts, 0, 18))
+>function() {this;} : Symbol((Anonymous function), Decl(modFunctionCrash.ts, 5, 4))
 
diff --git a/tests/baselines/reference/moduleWithStatementsOfEveryKind.symbols b/tests/baselines/reference/moduleWithStatementsOfEveryKind.symbols
index d121e6b5367cc..9c4bc0ca9a836 100644
--- a/tests/baselines/reference/moduleWithStatementsOfEveryKind.symbols
+++ b/tests/baselines/reference/moduleWithStatementsOfEveryKind.symbols
@@ -58,6 +58,7 @@ module A {
 
     var fn = (s: string) => {
 >fn : Symbol(fn, Decl(moduleWithStatementsOfEveryKind.ts, 19, 7))
+>(s: string) => {        return 'hello ' + s;    } : Symbol((Anonymous function), Decl(moduleWithStatementsOfEveryKind.ts, 19, 12))
 >s : Symbol(s, Decl(moduleWithStatementsOfEveryKind.ts, 19, 14))
 
         return 'hello ' + s;
@@ -65,6 +66,7 @@ module A {
     }
     var ol = { s: 'hello', id: 2, isvalid: true };
 >ol : Symbol(ol, Decl(moduleWithStatementsOfEveryKind.ts, 22, 7))
+>{ s: 'hello', id: 2, isvalid: true } : Symbol(, Decl(moduleWithStatementsOfEveryKind.ts, 22, 12))
 >s : Symbol(s, Decl(moduleWithStatementsOfEveryKind.ts, 22, 14))
 >id : Symbol(id, Decl(moduleWithStatementsOfEveryKind.ts, 22, 26))
 >isvalid : Symbol(isvalid, Decl(moduleWithStatementsOfEveryKind.ts, 22, 33))
@@ -136,6 +138,7 @@ module Y {
 
     export var fn = (s: string) => {
 >fn : Symbol(fn, Decl(moduleWithStatementsOfEveryKind.ts, 48, 14))
+>(s: string) => {        return 'hello ' + s;    } : Symbol((Anonymous function), Decl(moduleWithStatementsOfEveryKind.ts, 48, 19))
 >s : Symbol(s, Decl(moduleWithStatementsOfEveryKind.ts, 48, 21))
 
         return 'hello ' + s;
@@ -143,6 +146,7 @@ module Y {
     }
     export var ol = { s: 'hello', id: 2, isvalid: true };
 >ol : Symbol(ol, Decl(moduleWithStatementsOfEveryKind.ts, 51, 14))
+>{ s: 'hello', id: 2, isvalid: true } : Symbol(, Decl(moduleWithStatementsOfEveryKind.ts, 51, 19))
 >s : Symbol(s, Decl(moduleWithStatementsOfEveryKind.ts, 51, 21))
 >id : Symbol(id, Decl(moduleWithStatementsOfEveryKind.ts, 51, 33))
 >isvalid : Symbol(isvalid, Decl(moduleWithStatementsOfEveryKind.ts, 51, 40))
diff --git a/tests/baselines/reference/multiCallOverloads.symbols b/tests/baselines/reference/multiCallOverloads.symbols
index 26b414b463f58..7805792d1de82 100644
--- a/tests/baselines/reference/multiCallOverloads.symbols
+++ b/tests/baselines/reference/multiCallOverloads.symbols
@@ -14,11 +14,13 @@ function load(f: ICallback) {}
 var f1: ICallback = function(z?) {}
 >f1 : Symbol(f1, Decl(multiCallOverloads.ts, 6, 3))
 >ICallback : Symbol(ICallback, Decl(multiCallOverloads.ts, 0, 0))
+>function(z?) {} : Symbol((Anonymous function), Decl(multiCallOverloads.ts, 6, 19))
 >z : Symbol(z, Decl(multiCallOverloads.ts, 6, 29))
 
 var f2: ICallback = function(z?) {}
 >f2 : Symbol(f2, Decl(multiCallOverloads.ts, 7, 3))
 >ICallback : Symbol(ICallback, Decl(multiCallOverloads.ts, 0, 0))
+>function(z?) {} : Symbol((Anonymous function), Decl(multiCallOverloads.ts, 7, 19))
 >z : Symbol(z, Decl(multiCallOverloads.ts, 7, 29))
 
 load(f1) // ok
@@ -31,8 +33,10 @@ load(f2) // ok
 
 load(function() {}) // this shouldn’t be an error
 >load : Symbol(load, Decl(multiCallOverloads.ts, 2, 1))
+>function() {} : Symbol((Anonymous function), Decl(multiCallOverloads.ts, 10, 5))
 
 load(function(z?) {}) // this shouldn't be an error
 >load : Symbol(load, Decl(multiCallOverloads.ts, 2, 1))
+>function(z?) {} : Symbol((Anonymous function), Decl(multiCallOverloads.ts, 11, 5))
 >z : Symbol(z, Decl(multiCallOverloads.ts, 11, 14))
 
diff --git a/tests/baselines/reference/multiImportExport.symbols b/tests/baselines/reference/multiImportExport.symbols
index 6601571aabc65..c9390eef963d3 100644
--- a/tests/baselines/reference/multiImportExport.symbols
+++ b/tests/baselines/reference/multiImportExport.symbols
@@ -20,6 +20,7 @@ import Adder = require('Math/Adder');
 
 var Math = {
 >Math : Symbol(Math, Decl(Math.ts, 2, 3))
+>{    Adder:Adder} : Symbol(, Decl(Math.ts, 2, 10))
 
     Adder:Adder
 >Adder : Symbol(Adder, Decl(Math.ts, 2, 12))
diff --git a/tests/baselines/reference/nameCollisionsInPropertyAssignments.symbols b/tests/baselines/reference/nameCollisionsInPropertyAssignments.symbols
index 2e40d0f8bc51a..53744c9888f95 100644
--- a/tests/baselines/reference/nameCollisionsInPropertyAssignments.symbols
+++ b/tests/baselines/reference/nameCollisionsInPropertyAssignments.symbols
@@ -4,6 +4,7 @@ var x = 1
 
 var y = { x() { x++; } }; 
 >y : Symbol(y, Decl(nameCollisionsInPropertyAssignments.ts, 1, 3))
+>{ x() { x++; } } : Symbol(, Decl(nameCollisionsInPropertyAssignments.ts, 1, 7))
 >x : Symbol(x, Decl(nameCollisionsInPropertyAssignments.ts, 1, 9))
 >x : Symbol(x, Decl(nameCollisionsInPropertyAssignments.ts, 0, 3))
 
diff --git a/tests/baselines/reference/namedFunctionExpressionAssignedToClassProperty.symbols b/tests/baselines/reference/namedFunctionExpressionAssignedToClassProperty.symbols
index 707bc64571f43..d3a6f2ee01fce 100644
--- a/tests/baselines/reference/namedFunctionExpressionAssignedToClassProperty.symbols
+++ b/tests/baselines/reference/namedFunctionExpressionAssignedToClassProperty.symbols
@@ -4,6 +4,7 @@ class Foo{
 
        a = function bar(){
 >a : Symbol(a, Decl(namedFunctionExpressionAssignedToClassProperty.ts, 0, 10))
+>function bar(){       } : Symbol(bar, Decl(namedFunctionExpressionAssignedToClassProperty.ts, 2, 10))
 >bar : Symbol(bar, Decl(namedFunctionExpressionAssignedToClassProperty.ts, 2, 10))
 
        }; // this shouldn't crash the compiler...
diff --git a/tests/baselines/reference/namedFunctionExpressionCall.symbols b/tests/baselines/reference/namedFunctionExpressionCall.symbols
index c4ee0d3db4be7..6932f4c73c412 100644
--- a/tests/baselines/reference/namedFunctionExpressionCall.symbols
+++ b/tests/baselines/reference/namedFunctionExpressionCall.symbols
@@ -1,6 +1,7 @@
 === tests/cases/compiler/namedFunctionExpressionCall.ts ===
 var recurser = function foo() {
 >recurser : Symbol(recurser, Decl(namedFunctionExpressionCall.ts, 0, 3))
+>function foo() {    // using the local name    foo();    // using the globally visible name    recurser();} : Symbol(foo, Decl(namedFunctionExpressionCall.ts, 0, 14))
 >foo : Symbol(foo, Decl(namedFunctionExpressionCall.ts, 0, 14))
 
     // using the local name
@@ -15,6 +16,7 @@ var recurser = function foo() {
 
 
 (function bar() {
+>function bar() {    bar();} : Symbol(bar, Decl(namedFunctionExpressionCall.ts, 9, 1))
 >bar : Symbol(bar, Decl(namedFunctionExpressionCall.ts, 9, 1))
 
     bar();
diff --git a/tests/baselines/reference/namedFunctionExpressionInModule.symbols b/tests/baselines/reference/namedFunctionExpressionInModule.symbols
index 703cce7bf1428..2041fe9c6f978 100644
--- a/tests/baselines/reference/namedFunctionExpressionInModule.symbols
+++ b/tests/baselines/reference/namedFunctionExpressionInModule.symbols
@@ -4,6 +4,7 @@ module Variables{
 
     var x = function bar(a, b, c) {
 >x : Symbol(x, Decl(namedFunctionExpressionInModule.ts, 1, 7))
+>function bar(a, b, c) {    } : Symbol(bar, Decl(namedFunctionExpressionInModule.ts, 1, 11))
 >bar : Symbol(bar, Decl(namedFunctionExpressionInModule.ts, 1, 11))
 >a : Symbol(a, Decl(namedFunctionExpressionInModule.ts, 1, 25))
 >b : Symbol(b, Decl(namedFunctionExpressionInModule.ts, 1, 27))
diff --git a/tests/baselines/reference/negateOperatorWithAnyOtherType.symbols b/tests/baselines/reference/negateOperatorWithAnyOtherType.symbols
index 891fc363dbdcb..5569a6c6a8647 100644
--- a/tests/baselines/reference/negateOperatorWithAnyOtherType.symbols
+++ b/tests/baselines/reference/negateOperatorWithAnyOtherType.symbols
@@ -15,8 +15,10 @@ var obj: () => {}
 
 var obj1 = { x: "", y: () => { }};
 >obj1 : Symbol(obj1, Decl(negateOperatorWithAnyOtherType.ts, 6, 3))
+>{ x: "", y: () => { }} : Symbol(, Decl(negateOperatorWithAnyOtherType.ts, 6, 10))
 >x : Symbol(x, Decl(negateOperatorWithAnyOtherType.ts, 6, 12))
 >y : Symbol(y, Decl(negateOperatorWithAnyOtherType.ts, 6, 19))
+>() => { } : Symbol((Anonymous function), Decl(negateOperatorWithAnyOtherType.ts, 6, 22))
 
 function foo(): any {
 >foo : Symbol(foo, Decl(negateOperatorWithAnyOtherType.ts, 6, 34))
diff --git a/tests/baselines/reference/negateOperatorWithBooleanType.symbols b/tests/baselines/reference/negateOperatorWithBooleanType.symbols
index 55b35026b979c..8199536077a52 100644
--- a/tests/baselines/reference/negateOperatorWithBooleanType.symbols
+++ b/tests/baselines/reference/negateOperatorWithBooleanType.symbols
@@ -37,6 +37,7 @@ var ResultIsNumber2 = -true;
 
 var ResultIsNumber3 = -{ x: true, y: false };
 >ResultIsNumber3 : Symbol(ResultIsNumber3, Decl(negateOperatorWithBooleanType.ts, 20, 3))
+>{ x: true, y: false } : Symbol(, Decl(negateOperatorWithBooleanType.ts, 20, 23))
 >x : Symbol(x, Decl(negateOperatorWithBooleanType.ts, 20, 24))
 >y : Symbol(y, Decl(negateOperatorWithBooleanType.ts, 20, 33))
 
diff --git a/tests/baselines/reference/negateOperatorWithNumberType.symbols b/tests/baselines/reference/negateOperatorWithNumberType.symbols
index 1f75d922b09fe..08dd36a0a755a 100644
--- a/tests/baselines/reference/negateOperatorWithNumberType.symbols
+++ b/tests/baselines/reference/negateOperatorWithNumberType.symbols
@@ -44,13 +44,16 @@ var ResultIsNumber3 = -1;
 
 var ResultIsNumber4 = -{ x: 1, y: 2};
 >ResultIsNumber4 : Symbol(ResultIsNumber4, Decl(negateOperatorWithNumberType.ts, 22, 3))
+>{ x: 1, y: 2} : Symbol(, Decl(negateOperatorWithNumberType.ts, 22, 23))
 >x : Symbol(x, Decl(negateOperatorWithNumberType.ts, 22, 24))
 >y : Symbol(y, Decl(negateOperatorWithNumberType.ts, 22, 30))
 
 var ResultIsNumber5 = -{ x: 1, y: (n: number) => { return n; } };
 >ResultIsNumber5 : Symbol(ResultIsNumber5, Decl(negateOperatorWithNumberType.ts, 23, 3))
+>{ x: 1, y: (n: number) => { return n; } } : Symbol(, Decl(negateOperatorWithNumberType.ts, 23, 23))
 >x : Symbol(x, Decl(negateOperatorWithNumberType.ts, 23, 24))
 >y : Symbol(y, Decl(negateOperatorWithNumberType.ts, 23, 30))
+>(n: number) => { return n; } : Symbol((Anonymous function), Decl(negateOperatorWithNumberType.ts, 23, 33))
 >n : Symbol(n, Decl(negateOperatorWithNumberType.ts, 23, 35))
 >n : Symbol(n, Decl(negateOperatorWithNumberType.ts, 23, 35))
 
diff --git a/tests/baselines/reference/negateOperatorWithStringType.symbols b/tests/baselines/reference/negateOperatorWithStringType.symbols
index 00a90bdf743a6..e5122fed567de 100644
--- a/tests/baselines/reference/negateOperatorWithStringType.symbols
+++ b/tests/baselines/reference/negateOperatorWithStringType.symbols
@@ -44,13 +44,16 @@ var ResultIsNumber3 = -"";
 
 var ResultIsNumber4 = -{ x: "", y: "" };
 >ResultIsNumber4 : Symbol(ResultIsNumber4, Decl(negateOperatorWithStringType.ts, 22, 3))
+>{ x: "", y: "" } : Symbol(, Decl(negateOperatorWithStringType.ts, 22, 23))
 >x : Symbol(x, Decl(negateOperatorWithStringType.ts, 22, 24))
 >y : Symbol(y, Decl(negateOperatorWithStringType.ts, 22, 31))
 
 var ResultIsNumber5 = -{ x: "", y: (s: string) => { return s; } };
 >ResultIsNumber5 : Symbol(ResultIsNumber5, Decl(negateOperatorWithStringType.ts, 23, 3))
+>{ x: "", y: (s: string) => { return s; } } : Symbol(, Decl(negateOperatorWithStringType.ts, 23, 23))
 >x : Symbol(x, Decl(negateOperatorWithStringType.ts, 23, 24))
 >y : Symbol(y, Decl(negateOperatorWithStringType.ts, 23, 31))
+>(s: string) => { return s; } : Symbol((Anonymous function), Decl(negateOperatorWithStringType.ts, 23, 34))
 >s : Symbol(s, Decl(negateOperatorWithStringType.ts, 23, 36))
 >s : Symbol(s, Decl(negateOperatorWithStringType.ts, 23, 36))
 
diff --git a/tests/baselines/reference/nestedModules.symbols b/tests/baselines/reference/nestedModules.symbols
index 7ff4efd30f6de..10bf8f4ba025f 100644
--- a/tests/baselines/reference/nestedModules.symbols
+++ b/tests/baselines/reference/nestedModules.symbols
@@ -25,6 +25,7 @@ module A {
 >Point : Symbol(Point, Decl(nestedModules.ts, 9, 11))
 >C : Symbol(C, Decl(nestedModules.ts, 0, 11))
 >Point : Symbol(C.Point, Decl(nestedModules.ts, 0, 14))
+>{ x: 0, y: 0 } : Symbol(, Decl(nestedModules.ts, 9, 28))
 >x : Symbol(x, Decl(nestedModules.ts, 9, 30))
 >y : Symbol(y, Decl(nestedModules.ts, 9, 36))
     }
diff --git a/tests/baselines/reference/nestedRecursiveLambda.symbols b/tests/baselines/reference/nestedRecursiveLambda.symbols
index b91c1d84ebbee..9da6b3951244c 100644
--- a/tests/baselines/reference/nestedRecursiveLambda.symbols
+++ b/tests/baselines/reference/nestedRecursiveLambda.symbols
@@ -4,23 +4,31 @@ function f(a:any) {
 >a : Symbol(a, Decl(nestedRecursiveLambda.ts, 0, 11))
 
 void (r =>(r => r));
+>r =>(r => r) : Symbol((Anonymous function), Decl(nestedRecursiveLambda.ts, 1, 6))
 >r : Symbol(r, Decl(nestedRecursiveLambda.ts, 1, 6))
+>r => r : Symbol((Anonymous function), Decl(nestedRecursiveLambda.ts, 1, 11))
 >r : Symbol(r, Decl(nestedRecursiveLambda.ts, 1, 11))
 >r : Symbol(r, Decl(nestedRecursiveLambda.ts, 1, 11))
 }
 f((r =>(r => r)));
 >f : Symbol(f, Decl(nestedRecursiveLambda.ts, 0, 0))
+>r =>(r => r) : Symbol((Anonymous function), Decl(nestedRecursiveLambda.ts, 3, 3))
 >r : Symbol(r, Decl(nestedRecursiveLambda.ts, 3, 3))
+>r => r : Symbol((Anonymous function), Decl(nestedRecursiveLambda.ts, 3, 8))
 >r : Symbol(r, Decl(nestedRecursiveLambda.ts, 3, 8))
 >r : Symbol(r, Decl(nestedRecursiveLambda.ts, 3, 8))
 
 void(r =>(r => r));
+>r =>(r => r) : Symbol((Anonymous function), Decl(nestedRecursiveLambda.ts, 4, 5))
 >r : Symbol(r, Decl(nestedRecursiveLambda.ts, 4, 5))
+>r => r : Symbol((Anonymous function), Decl(nestedRecursiveLambda.ts, 4, 10))
 >r : Symbol(r, Decl(nestedRecursiveLambda.ts, 4, 10))
 >r : Symbol(r, Decl(nestedRecursiveLambda.ts, 4, 10))
 
 [(r =>(r => r))]
+>r =>(r => r) : Symbol((Anonymous function), Decl(nestedRecursiveLambda.ts, 5, 2))
 >r : Symbol(r, Decl(nestedRecursiveLambda.ts, 5, 2))
+>r => r : Symbol((Anonymous function), Decl(nestedRecursiveLambda.ts, 5, 7))
 >r : Symbol(r, Decl(nestedRecursiveLambda.ts, 5, 7))
 >r : Symbol(r, Decl(nestedRecursiveLambda.ts, 5, 7))
 
diff --git a/tests/baselines/reference/nestedSelf.symbols b/tests/baselines/reference/nestedSelf.symbols
index 08f41f155d670..9a16cc273b44f 100644
--- a/tests/baselines/reference/nestedSelf.symbols
+++ b/tests/baselines/reference/nestedSelf.symbols
@@ -12,6 +12,7 @@ module M {
 >foo : Symbol(foo, Decl(nestedSelf.ts, 2, 17))
 >[1,2,3].map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
 >map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>(x) => { return this.n * x; } : Symbol((Anonymous function), Decl(nestedSelf.ts, 3, 30))
 >x : Symbol(x, Decl(nestedSelf.ts, 3, 31))
 >this.n : Symbol(n, Decl(nestedSelf.ts, 1, 17))
 >this : Symbol(C, Decl(nestedSelf.ts, 0, 10))
diff --git a/tests/baselines/reference/noCollisionThisExpressionAndClassInGlobal.symbols b/tests/baselines/reference/noCollisionThisExpressionAndClassInGlobal.symbols
index e288a42fae0f6..4d6487e57ab32 100644
--- a/tests/baselines/reference/noCollisionThisExpressionAndClassInGlobal.symbols
+++ b/tests/baselines/reference/noCollisionThisExpressionAndClassInGlobal.symbols
@@ -4,5 +4,6 @@ class _this {
 }
 var f = () => _this;
 >f : Symbol(f, Decl(noCollisionThisExpressionAndClassInGlobal.ts, 2, 3))
+>() => _this : Symbol((Anonymous function), Decl(noCollisionThisExpressionAndClassInGlobal.ts, 2, 7))
 >_this : Symbol(_this, Decl(noCollisionThisExpressionAndClassInGlobal.ts, 0, 0))
 
diff --git a/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInConstructor.symbols b/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInConstructor.symbols
index 298e6f9acc16d..35b71804444c1 100644
--- a/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInConstructor.symbols
+++ b/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInConstructor.symbols
@@ -5,10 +5,13 @@ class class1 {
     constructor() {
         var x2 = {
 >x2 : Symbol(x2, Decl(noCollisionThisExpressionAndLocalVarInConstructor.ts, 2, 11))
+>{            doStuff: (callback) => () => {                var _this = 2;                return callback(_this);            }        } : Symbol(, Decl(noCollisionThisExpressionAndLocalVarInConstructor.ts, 2, 16))
 
             doStuff: (callback) => () => {
 >doStuff : Symbol(doStuff, Decl(noCollisionThisExpressionAndLocalVarInConstructor.ts, 2, 18))
+>(callback) => () => {                var _this = 2;                return callback(_this);            } : Symbol((Anonymous function), Decl(noCollisionThisExpressionAndLocalVarInConstructor.ts, 3, 20))
 >callback : Symbol(callback, Decl(noCollisionThisExpressionAndLocalVarInConstructor.ts, 3, 22))
+>() => {                var _this = 2;                return callback(_this);            } : Symbol((Anonymous function), Decl(noCollisionThisExpressionAndLocalVarInConstructor.ts, 3, 34))
 
                 var _this = 2;
 >_this : Symbol(_this, Decl(noCollisionThisExpressionAndLocalVarInConstructor.ts, 4, 19))
@@ -30,10 +33,13 @@ class class2 {
 
         var x2 = {
 >x2 : Symbol(x2, Decl(noCollisionThisExpressionAndLocalVarInConstructor.ts, 14, 11))
+>{            doStuff: (callback) => () => {                return callback(_this);            }        } : Symbol(, Decl(noCollisionThisExpressionAndLocalVarInConstructor.ts, 14, 16))
 
             doStuff: (callback) => () => {
 >doStuff : Symbol(doStuff, Decl(noCollisionThisExpressionAndLocalVarInConstructor.ts, 14, 18))
+>(callback) => () => {                return callback(_this);            } : Symbol((Anonymous function), Decl(noCollisionThisExpressionAndLocalVarInConstructor.ts, 15, 20))
 >callback : Symbol(callback, Decl(noCollisionThisExpressionAndLocalVarInConstructor.ts, 15, 22))
+>() => {                return callback(_this);            } : Symbol((Anonymous function), Decl(noCollisionThisExpressionAndLocalVarInConstructor.ts, 15, 34))
 
                 return callback(_this);
 >callback : Symbol(callback, Decl(noCollisionThisExpressionAndLocalVarInConstructor.ts, 15, 22))
diff --git a/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInFunction.symbols b/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInFunction.symbols
index 09c99810fea75..7bfab7051d941 100644
--- a/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInFunction.symbols
+++ b/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInFunction.symbols
@@ -13,6 +13,7 @@ function x() {
 >_this : Symbol(_this, Decl(noCollisionThisExpressionAndLocalVarInFunction.ts, 4, 7))
 
     x => { console.log(_this); };
+>x => { console.log(_this); } : Symbol((Anonymous function), Decl(noCollisionThisExpressionAndLocalVarInFunction.ts, 4, 18))
 >x : Symbol(x, Decl(noCollisionThisExpressionAndLocalVarInFunction.ts, 4, 18))
 >console.log : Symbol(log, Decl(noCollisionThisExpressionAndLocalVarInFunction.ts, 0, 14))
 >console : Symbol(console, Decl(noCollisionThisExpressionAndLocalVarInFunction.ts, 0, 3))
diff --git a/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInLambda.symbols b/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInLambda.symbols
index 45115b278ad28..e5e9e75ca09e7 100644
--- a/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInLambda.symbols
+++ b/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInLambda.symbols
@@ -5,10 +5,13 @@ declare function alert(message?: any): void;
 
 var x = {
 >x : Symbol(x, Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 1, 3))
+>{    doStuff: (callback) => () => {        var _this = 2;        return callback(_this);    }} : Symbol(, Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 1, 7))
 
     doStuff: (callback) => () => {
 >doStuff : Symbol(doStuff, Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 1, 9))
+>(callback) => () => {        var _this = 2;        return callback(_this);    } : Symbol((Anonymous function), Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 2, 12))
 >callback : Symbol(callback, Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 2, 14))
+>() => {        var _this = 2;        return callback(_this);    } : Symbol((Anonymous function), Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 2, 26))
 
         var _this = 2;
 >_this : Symbol(_this, Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 3, 11))
@@ -23,6 +26,7 @@ alert(x.doStuff(x => alert(x)));
 >x.doStuff : Symbol(doStuff, Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 1, 9))
 >x : Symbol(x, Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 1, 3))
 >doStuff : Symbol(doStuff, Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 1, 9))
+>x => alert(x) : Symbol((Anonymous function), Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 7, 16))
 >x : Symbol(x, Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 7, 16))
 >alert : Symbol(alert, Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 0, 0))
 >x : Symbol(x, Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 7, 16))
diff --git a/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInMethod.symbols b/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInMethod.symbols
index 72e0d20a9b2de..597efeef6225f 100644
--- a/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInMethod.symbols
+++ b/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInMethod.symbols
@@ -9,9 +9,13 @@ class a {
 >method1 : Symbol(method1, Decl(noCollisionThisExpressionAndLocalVarInMethod.ts, 1, 9))
 
         return {
+>{            doStuff: (callback) => () => {                var _this = 2;                return callback(_this);            }        } : Symbol(, Decl(noCollisionThisExpressionAndLocalVarInMethod.ts, 3, 14))
+
             doStuff: (callback) => () => {
 >doStuff : Symbol(doStuff, Decl(noCollisionThisExpressionAndLocalVarInMethod.ts, 3, 16))
+>(callback) => () => {                var _this = 2;                return callback(_this);            } : Symbol((Anonymous function), Decl(noCollisionThisExpressionAndLocalVarInMethod.ts, 4, 20))
 >callback : Symbol(callback, Decl(noCollisionThisExpressionAndLocalVarInMethod.ts, 4, 22))
+>() => {                var _this = 2;                return callback(_this);            } : Symbol((Anonymous function), Decl(noCollisionThisExpressionAndLocalVarInMethod.ts, 4, 34))
 
                 var _this = 2;
 >_this : Symbol(_this, Decl(noCollisionThisExpressionAndLocalVarInMethod.ts, 5, 19))
@@ -29,9 +33,13 @@ class a {
 >_this : Symbol(_this, Decl(noCollisionThisExpressionAndLocalVarInMethod.ts, 11, 11))
 
         return {
+>{            doStuff: (callback) => () => {                return callback(_this);            }        } : Symbol(, Decl(noCollisionThisExpressionAndLocalVarInMethod.ts, 12, 14))
+
             doStuff: (callback) => () => {
 >doStuff : Symbol(doStuff, Decl(noCollisionThisExpressionAndLocalVarInMethod.ts, 12, 16))
+>(callback) => () => {                return callback(_this);            } : Symbol((Anonymous function), Decl(noCollisionThisExpressionAndLocalVarInMethod.ts, 13, 20))
 >callback : Symbol(callback, Decl(noCollisionThisExpressionAndLocalVarInMethod.ts, 13, 22))
+>() => {                return callback(_this);            } : Symbol((Anonymous function), Decl(noCollisionThisExpressionAndLocalVarInMethod.ts, 13, 34))
 
                 return callback(_this);
 >callback : Symbol(callback, Decl(noCollisionThisExpressionAndLocalVarInMethod.ts, 13, 22))
diff --git a/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInProperty.symbols b/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInProperty.symbols
index 0dc4cf1d84eb5..f9883dfcd2a7c 100644
--- a/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInProperty.symbols
+++ b/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInProperty.symbols
@@ -4,10 +4,13 @@ class class1 {
 
     public prop1 = {
 >prop1 : Symbol(prop1, Decl(noCollisionThisExpressionAndLocalVarInProperty.ts, 0, 14))
+>{        doStuff: (callback) => () => {            var _this = 2;            return callback(_this);        }    } : Symbol(, Decl(noCollisionThisExpressionAndLocalVarInProperty.ts, 1, 18))
 
         doStuff: (callback) => () => {
 >doStuff : Symbol(doStuff, Decl(noCollisionThisExpressionAndLocalVarInProperty.ts, 1, 20))
+>(callback) => () => {            var _this = 2;            return callback(_this);        } : Symbol((Anonymous function), Decl(noCollisionThisExpressionAndLocalVarInProperty.ts, 2, 16))
 >callback : Symbol(callback, Decl(noCollisionThisExpressionAndLocalVarInProperty.ts, 2, 18))
+>() => {            var _this = 2;            return callback(_this);        } : Symbol((Anonymous function), Decl(noCollisionThisExpressionAndLocalVarInProperty.ts, 2, 30))
 
             var _this = 2;
 >_this : Symbol(_this, Decl(noCollisionThisExpressionAndLocalVarInProperty.ts, 3, 15))
@@ -28,10 +31,13 @@ class class2 {
     }
     public prop1 = {
 >prop1 : Symbol(prop1, Decl(noCollisionThisExpressionAndLocalVarInProperty.ts, 12, 5))
+>{        doStuff: (callback) => () => {            return callback(10);        }    } : Symbol(, Decl(noCollisionThisExpressionAndLocalVarInProperty.ts, 13, 18))
 
         doStuff: (callback) => () => {
 >doStuff : Symbol(doStuff, Decl(noCollisionThisExpressionAndLocalVarInProperty.ts, 13, 20))
+>(callback) => () => {            return callback(10);        } : Symbol((Anonymous function), Decl(noCollisionThisExpressionAndLocalVarInProperty.ts, 14, 16))
 >callback : Symbol(callback, Decl(noCollisionThisExpressionAndLocalVarInProperty.ts, 14, 18))
+>() => {            return callback(10);        } : Symbol((Anonymous function), Decl(noCollisionThisExpressionAndLocalVarInProperty.ts, 14, 30))
 
             return callback(10);
 >callback : Symbol(callback, Decl(noCollisionThisExpressionAndLocalVarInProperty.ts, 14, 18))
diff --git a/tests/baselines/reference/noCollisionThisExpressionAndVarInGlobal.symbols b/tests/baselines/reference/noCollisionThisExpressionAndVarInGlobal.symbols
index c3746cbcb8f41..76db83884244e 100644
--- a/tests/baselines/reference/noCollisionThisExpressionAndVarInGlobal.symbols
+++ b/tests/baselines/reference/noCollisionThisExpressionAndVarInGlobal.symbols
@@ -4,5 +4,6 @@ var _this = 1;
 
 var f = () => _this;
 >f : Symbol(f, Decl(noCollisionThisExpressionAndVarInGlobal.ts, 1, 3))
+>() => _this : Symbol((Anonymous function), Decl(noCollisionThisExpressionAndVarInGlobal.ts, 1, 7))
 >_this : Symbol(_this, Decl(noCollisionThisExpressionAndVarInGlobal.ts, 0, 3))
 
diff --git a/tests/baselines/reference/noCollisionThisExpressionInFunctionAndVarInGlobal.symbols b/tests/baselines/reference/noCollisionThisExpressionInFunctionAndVarInGlobal.symbols
index b2f2adbbbb609..d3fdbc9194f16 100644
--- a/tests/baselines/reference/noCollisionThisExpressionInFunctionAndVarInGlobal.symbols
+++ b/tests/baselines/reference/noCollisionThisExpressionInFunctionAndVarInGlobal.symbols
@@ -13,6 +13,7 @@ function x() {
 >x : Symbol(x, Decl(noCollisionThisExpressionInFunctionAndVarInGlobal.ts, 3, 14))
 
     x => { console.log(this); };
+>x => { console.log(this); } : Symbol((Anonymous function), Decl(noCollisionThisExpressionInFunctionAndVarInGlobal.ts, 4, 14))
 >x : Symbol(x, Decl(noCollisionThisExpressionInFunctionAndVarInGlobal.ts, 4, 14))
 >console.log : Symbol(log, Decl(noCollisionThisExpressionInFunctionAndVarInGlobal.ts, 0, 14))
 >console : Symbol(console, Decl(noCollisionThisExpressionInFunctionAndVarInGlobal.ts, 0, 3))
diff --git a/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.symbols b/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.symbols
index 8e9a331a2058f..11cc6c0d23341 100644
--- a/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.symbols
+++ b/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.symbols
@@ -3,6 +3,7 @@
 var x: (a: any) => void = function <T>(x: T) {
 >x : Symbol(x, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 1, 3))
 >a : Symbol(a, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 1, 8))
+>function <T>(x: T) {    return null;} : Symbol((Anonymous function), Decl(noImplicitAnyFunctionExpressionAssignment.ts, 1, 25))
 >T : Symbol(T, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 1, 36))
 >x : Symbol(x, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 1, 39))
 >T : Symbol(T, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 1, 36))
@@ -13,6 +14,7 @@ var x: (a: any) => void = function <T>(x: T) {
 var x2: (a: any) => void = function f<T>(x: T) {
 >x2 : Symbol(x2, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 5, 3))
 >a : Symbol(a, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 5, 9))
+>function f<T>(x: T) {    return null;} : Symbol(f, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 5, 26))
 >f : Symbol(f, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 5, 26))
 >T : Symbol(T, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 5, 38))
 >x : Symbol(x, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 5, 41))
diff --git a/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.symbols b/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.symbols
index 4bddb6a1f71b0..1c838b01eae3f 100644
--- a/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.symbols
+++ b/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.symbols
@@ -7,6 +7,7 @@ regexMatchList.forEach(match => ''.replace(match, ''));
 >regexMatchList.forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
 >regexMatchList : Symbol(regexMatchList, Decl(noImplicitAnyInContextuallyTypesFunctionParamter.ts, 1, 3))
 >forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
+>match => ''.replace(match, '') : Symbol((Anonymous function), Decl(noImplicitAnyInContextuallyTypesFunctionParamter.ts, 2, 23))
 >match : Symbol(match, Decl(noImplicitAnyInContextuallyTypesFunctionParamter.ts, 2, 23))
 >''.replace : Symbol(String.replace, Decl(lib.d.ts, 329, 44), Decl(lib.d.ts, 336, 63), Decl(lib.d.ts, 343, 102), Decl(lib.d.ts, 350, 63))
 >replace : Symbol(String.replace, Decl(lib.d.ts, 329, 44), Decl(lib.d.ts, 336, 63), Decl(lib.d.ts, 343, 102), Decl(lib.d.ts, 350, 63))
diff --git a/tests/baselines/reference/noImplicitAnyIndexingSuppressed.symbols b/tests/baselines/reference/noImplicitAnyIndexingSuppressed.symbols
index 7c8f57795b40e..496c45de3c274 100644
--- a/tests/baselines/reference/noImplicitAnyIndexingSuppressed.symbols
+++ b/tests/baselines/reference/noImplicitAnyIndexingSuppressed.symbols
@@ -35,16 +35,19 @@ var strRepresentation4 = MyEmusEnum["emu"];
 // Should be okay, as we suppress implicit 'any' property access checks
 var x = {}["hi"];
 >x : Symbol(x, Decl(noImplicitAnyIndexingSuppressed.ts, 19, 3))
+>{} : Symbol(, Decl(noImplicitAnyIndexingSuppressed.ts, 19, 7))
 
 // Should be okay, as we suppress implicit 'any' property access checks
 var y = {}[10];
 >y : Symbol(y, Decl(noImplicitAnyIndexingSuppressed.ts, 22, 3))
+>{} : Symbol(, Decl(noImplicitAnyIndexingSuppressed.ts, 22, 7))
 
 var hi: any = "hi";
 >hi : Symbol(hi, Decl(noImplicitAnyIndexingSuppressed.ts, 24, 3))
 
 var emptyObj = {};
 >emptyObj : Symbol(emptyObj, Decl(noImplicitAnyIndexingSuppressed.ts, 26, 3))
+>{} : Symbol(, Decl(noImplicitAnyIndexingSuppressed.ts, 26, 14))
 
 // Should be okay, as we suppress implicit 'any' property access checks
 var z1 = emptyObj[hi];
@@ -69,6 +72,7 @@ interface MyMap<T> {
 var m: MyMap<number> = {
 >m : Symbol(m, Decl(noImplicitAnyIndexingSuppressed.ts, 36, 3))
 >MyMap : Symbol(MyMap, Decl(noImplicitAnyIndexingSuppressed.ts, 30, 29))
+>{    "0": 0,    "1": 1,    "2": 2,    "Okay that's enough for today.": NaN} : Symbol(, Decl(noImplicitAnyIndexingSuppressed.ts, 36, 22))
 
     "0": 0,
     "1": 1,
diff --git a/tests/baselines/reference/nonInstantiatedModule.symbols b/tests/baselines/reference/nonInstantiatedModule.symbols
index 0d67b0318f8e4..484d2b07aadb4 100644
--- a/tests/baselines/reference/nonInstantiatedModule.symbols
+++ b/tests/baselines/reference/nonInstantiatedModule.symbols
@@ -49,6 +49,7 @@ module M2 {
 >Point : Symbol(Point, Decl(nonInstantiatedModule.ts, 15, 11), Decl(nonInstantiatedModule.ts, 20, 5))
 
             return { x: 0, y: 0 };
+>{ x: 0, y: 0 } : Symbol(, Decl(nonInstantiatedModule.ts, 18, 18))
 >x : Symbol(x, Decl(nonInstantiatedModule.ts, 18, 20))
 >y : Symbol(y, Decl(nonInstantiatedModule.ts, 18, 26))
         }
diff --git a/tests/baselines/reference/nonIterableRestElement1.symbols b/tests/baselines/reference/nonIterableRestElement1.symbols
index 352d0c87da45b..5d9b670e41250 100644
--- a/tests/baselines/reference/nonIterableRestElement1.symbols
+++ b/tests/baselines/reference/nonIterableRestElement1.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/destructuring/nonIterableRestElement1.ts ===
 var c = {};
 >c : Symbol(c, Decl(nonIterableRestElement1.ts, 0, 3))
+>{} : Symbol(, Decl(nonIterableRestElement1.ts, 0, 7))
 
 [...c] = ["", 0];
 >c : Symbol(c, Decl(nonIterableRestElement1.ts, 0, 3))
diff --git a/tests/baselines/reference/nonIterableRestElement2.symbols b/tests/baselines/reference/nonIterableRestElement2.symbols
index 766524a408ba2..0ad74b8dd46f6 100644
--- a/tests/baselines/reference/nonIterableRestElement2.symbols
+++ b/tests/baselines/reference/nonIterableRestElement2.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/destructuring/nonIterableRestElement2.ts ===
 var c = {};
 >c : Symbol(c, Decl(nonIterableRestElement2.ts, 0, 3))
+>{} : Symbol(, Decl(nonIterableRestElement2.ts, 0, 7))
 
 [...c] = ["", 0];
 >c : Symbol(c, Decl(nonIterableRestElement2.ts, 0, 3))
diff --git a/tests/baselines/reference/null.symbols b/tests/baselines/reference/null.symbols
index 148cd1586b275..97bc53358e1fd 100644
--- a/tests/baselines/reference/null.symbols
+++ b/tests/baselines/reference/null.symbols
@@ -37,6 +37,7 @@ interface I {
 var w:I={x:null,y:3};
 >w : Symbol(w, Decl(null.ts, 17, 3))
 >I : Symbol(I, Decl(null.ts, 12, 1))
+>{x:null,y:3} : Symbol(, Decl(null.ts, 17, 8))
 >x : Symbol(x, Decl(null.ts, 17, 9))
 >y : Symbol(y, Decl(null.ts, 17, 16))
 
diff --git a/tests/baselines/reference/nullIsSubtypeOfEverythingButUndefined.symbols b/tests/baselines/reference/nullIsSubtypeOfEverythingButUndefined.symbols
index 7f81995c9be07..6e789f7c581b5 100644
--- a/tests/baselines/reference/nullIsSubtypeOfEverythingButUndefined.symbols
+++ b/tests/baselines/reference/nullIsSubtypeOfEverythingButUndefined.symbols
@@ -53,20 +53,25 @@ var r5 = true ? null : /1/;
 
 var r6 = true ? { foo: 1 } : null;
 >r6 : Symbol(r6, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 24, 3), Decl(nullIsSubtypeOfEverythingButUndefined.ts, 25, 3))
+>{ foo: 1 } : Symbol(, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 24, 15))
 >foo : Symbol(foo, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 24, 17))
 
 var r6 = true ? null : { foo: 1 };
 >r6 : Symbol(r6, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 24, 3), Decl(nullIsSubtypeOfEverythingButUndefined.ts, 25, 3))
+>{ foo: 1 } : Symbol(, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 25, 22))
 >foo : Symbol(foo, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 25, 24))
 
 var r7 = true ? () => { } : null;
 >r7 : Symbol(r7, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 27, 3), Decl(nullIsSubtypeOfEverythingButUndefined.ts, 28, 3))
+>() => { } : Symbol((Anonymous function), Decl(nullIsSubtypeOfEverythingButUndefined.ts, 27, 15))
 
 var r7 = true ? null : () => { };
 >r7 : Symbol(r7, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 27, 3), Decl(nullIsSubtypeOfEverythingButUndefined.ts, 28, 3))
+>() => { } : Symbol((Anonymous function), Decl(nullIsSubtypeOfEverythingButUndefined.ts, 28, 22))
 
 var r8 = true ? <T>(x: T) => { return x } : null;
 >r8 : Symbol(r8, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 30, 3))
+><T>(x: T) => { return x } : Symbol((Anonymous function), Decl(nullIsSubtypeOfEverythingButUndefined.ts, 30, 15))
 >T : Symbol(T, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 30, 17))
 >x : Symbol(x, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 30, 20))
 >T : Symbol(T, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 30, 17))
@@ -74,6 +79,7 @@ var r8 = true ? <T>(x: T) => { return x } : null;
 
 var r8b = true ? null : <T>(x: T) => { return x }; // type parameters not identical across declarations
 >r8b : Symbol(r8b, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 31, 3))
+><T>(x: T) => { return x } : Symbol((Anonymous function), Decl(nullIsSubtypeOfEverythingButUndefined.ts, 31, 23))
 >T : Symbol(T, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 31, 25))
 >x : Symbol(x, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 31, 28))
 >T : Symbol(T, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 31, 25))
@@ -241,7 +247,9 @@ var r19 = true ? null : new Object();
 
 var r20 = true ? {} : null;
 >r20 : Symbol(r20, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 88, 3), Decl(nullIsSubtypeOfEverythingButUndefined.ts, 89, 3))
+>{} : Symbol(, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 88, 16))
 
 var r20 = true ? null : {};
 >r20 : Symbol(r20, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 88, 3), Decl(nullIsSubtypeOfEverythingButUndefined.ts, 89, 3))
+>{} : Symbol(, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 89, 23))
 
diff --git a/tests/baselines/reference/numericIndexerConstraint4.symbols b/tests/baselines/reference/numericIndexerConstraint4.symbols
index 63d976ea1b1aa..2b8aba476406d 100644
--- a/tests/baselines/reference/numericIndexerConstraint4.symbols
+++ b/tests/baselines/reference/numericIndexerConstraint4.symbols
@@ -22,6 +22,7 @@ var x: {
 >A : Symbol(A, Decl(numericIndexerConstraint4.ts, 0, 0))
 
 } = { data: new B() }
+>{ data: new B() } : Symbol(, Decl(numericIndexerConstraint4.ts, 10, 3))
 >data : Symbol(data, Decl(numericIndexerConstraint4.ts, 10, 5))
 >B : Symbol(B, Decl(numericIndexerConstraint4.ts, 2, 1))
 
diff --git a/tests/baselines/reference/numericIndexingResults.symbols b/tests/baselines/reference/numericIndexingResults.symbols
index 16a6e9386da45..6fb0d250b3b34 100644
--- a/tests/baselines/reference/numericIndexingResults.symbols
+++ b/tests/baselines/reference/numericIndexingResults.symbols
@@ -124,6 +124,7 @@ var r6 = a[3];
 var b: { [x: number]: string } = { 1: '', "2": '' }
 >b : Symbol(b, Decl(numericIndexingResults.ts, 41, 3))
 >x : Symbol(x, Decl(numericIndexingResults.ts, 41, 10))
+>{ 1: '', "2": '' } : Symbol(, Decl(numericIndexingResults.ts, 41, 32))
 
 var r1a = b['1'];
 >r1a : Symbol(r1a, Decl(numericIndexingResults.ts, 42, 3))
@@ -152,6 +153,7 @@ var r6 = b[3];
 var b2: { [x: number]: string; 1: string; "2": string; } = { 1: '', "2": '' }
 >b2 : Symbol(b2, Decl(numericIndexingResults.ts, 49, 3))
 >x : Symbol(x, Decl(numericIndexingResults.ts, 49, 11))
+>{ 1: '', "2": '' } : Symbol(, Decl(numericIndexingResults.ts, 49, 58))
 
 var r1b = b2['1'];
 >r1b : Symbol(r1b, Decl(numericIndexingResults.ts, 50, 3))
diff --git a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers05.symbols b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers05.symbols
index 5ac9bb815f8f9..66353d703ed58 100644
--- a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers05.symbols
+++ b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers05.symbols
@@ -2,5 +2,6 @@
 
 var { as } = { as: 1 }
 >as : Symbol(as, Decl(objectBindingPatternKeywordIdentifiers05.ts, 1, 5))
+>{ as: 1 } : Symbol(, Decl(objectBindingPatternKeywordIdentifiers05.ts, 1, 12))
 >as : Symbol(as, Decl(objectBindingPatternKeywordIdentifiers05.ts, 1, 14))
 
diff --git a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers06.symbols b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers06.symbols
index 7cee5f3009b12..bba1ada64929d 100644
--- a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers06.symbols
+++ b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers06.symbols
@@ -2,5 +2,6 @@
 
 var { as: as } = { as: 1 }
 >as : Symbol(as, Decl(objectBindingPatternKeywordIdentifiers06.ts, 1, 5))
+>{ as: 1 } : Symbol(, Decl(objectBindingPatternKeywordIdentifiers06.ts, 1, 16))
 >as : Symbol(as, Decl(objectBindingPatternKeywordIdentifiers06.ts, 1, 18))
 
diff --git a/tests/baselines/reference/objectIndexer.symbols b/tests/baselines/reference/objectIndexer.symbols
index 33885a40e2771..b7a8c3746ac38 100644
--- a/tests/baselines/reference/objectIndexer.symbols
+++ b/tests/baselines/reference/objectIndexer.symbols
@@ -26,6 +26,7 @@ class Emitter {
 >this.listeners : Symbol(listeners, Decl(objectIndexer.ts, 8, 15))
 >this : Symbol(Emitter, Decl(objectIndexer.ts, 6, 1))
 >listeners : Symbol(listeners, Decl(objectIndexer.ts, 8, 15))
+>{} : Symbol(, Decl(objectIndexer.ts, 11, 24))
     }
 }
 
diff --git a/tests/baselines/reference/objectLitGetterSetter.symbols b/tests/baselines/reference/objectLitGetterSetter.symbols
index 512e459c8c060..45cd43aa2f5e9 100644
--- a/tests/baselines/reference/objectLitGetterSetter.symbols
+++ b/tests/baselines/reference/objectLitGetterSetter.symbols
@@ -1,6 +1,7 @@
 === tests/cases/compiler/objectLitGetterSetter.ts ===
             var obj = {};
 >obj : Symbol(obj, Decl(objectLitGetterSetter.ts, 0, 15))
+>{} : Symbol(, Decl(objectLitGetterSetter.ts, 0, 21))
 
             Object.defineProperty(obj, "accProperty", <PropertyDescriptor>({
 >Object.defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.d.ts, 160, 60))
@@ -8,9 +9,11 @@
 >defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.d.ts, 160, 60))
 >obj : Symbol(obj, Decl(objectLitGetterSetter.ts, 0, 15))
 >PropertyDescriptor : Symbol(PropertyDescriptor, Decl(lib.d.ts, 79, 66))
+>{                get: function () {                    eval("public = 1;");                    return 11;                },                set: function (v) {                }            } : Symbol(, Decl(objectLitGetterSetter.ts, 1, 75))
 
                 get: function () {
 >get : Symbol(get, Decl(objectLitGetterSetter.ts, 1, 76))
+>function () {                    eval("public = 1;");                    return 11;                } : Symbol((Anonymous function), Decl(objectLitGetterSetter.ts, 2, 20))
 
                     eval("public = 1;");
 >eval : Symbol(eval, Decl(lib.d.ts, 22, 29))
@@ -19,6 +22,7 @@
                 },
                 set: function (v) {
 >set : Symbol(set, Decl(objectLitGetterSetter.ts, 5, 18))
+>function (v) {                } : Symbol((Anonymous function), Decl(objectLitGetterSetter.ts, 6, 20))
 >v : Symbol(v, Decl(objectLitGetterSetter.ts, 6, 31))
                 }
             }))
diff --git a/tests/baselines/reference/objectLiteral1.symbols b/tests/baselines/reference/objectLiteral1.symbols
index 76acb6623bc8b..b5225b95a5818 100644
--- a/tests/baselines/reference/objectLiteral1.symbols
+++ b/tests/baselines/reference/objectLiteral1.symbols
@@ -1,6 +1,7 @@
 === tests/cases/compiler/objectLiteral1.ts ===
 var v30 = {a:1, b:2};
 >v30 : Symbol(v30, Decl(objectLiteral1.ts, 0, 3))
+>{a:1, b:2} : Symbol(, Decl(objectLiteral1.ts, 0, 9))
 >a : Symbol(a, Decl(objectLiteral1.ts, 0, 11))
 >b : Symbol(b, Decl(objectLiteral1.ts, 0, 15))
 
diff --git a/tests/baselines/reference/objectLiteral2.symbols b/tests/baselines/reference/objectLiteral2.symbols
index 6e953fa2c1223..5f85e605df19f 100644
--- a/tests/baselines/reference/objectLiteral2.symbols
+++ b/tests/baselines/reference/objectLiteral2.symbols
@@ -1,6 +1,7 @@
 === tests/cases/compiler/objectLiteral2.ts ===
 var v30 = {a:1, b:2}, v31;
 >v30 : Symbol(v30, Decl(objectLiteral2.ts, 0, 3))
+>{a:1, b:2} : Symbol(, Decl(objectLiteral2.ts, 0, 9))
 >a : Symbol(a, Decl(objectLiteral2.ts, 0, 11))
 >b : Symbol(b, Decl(objectLiteral2.ts, 0, 15))
 >v31 : Symbol(v31, Decl(objectLiteral2.ts, 0, 21))
diff --git a/tests/baselines/reference/objectLiteralArraySpecialization.symbols b/tests/baselines/reference/objectLiteralArraySpecialization.symbols
index 4cc1188dcc451..5dd4114bcc11d 100644
--- a/tests/baselines/reference/objectLiteralArraySpecialization.symbols
+++ b/tests/baselines/reference/objectLiteralArraySpecialization.symbols
@@ -27,8 +27,10 @@ interface MyArrayWrapper<T> {
 var thing = create([ { name: "bob", id: 24 }, { name: "doug", id: 32 } ]); // should not error
 >thing : Symbol(thing, Decl(objectLiteralArraySpecialization.ts, 5, 3))
 >create : Symbol(create, Decl(objectLiteralArraySpecialization.ts, 0, 0))
+>{ name: "bob", id: 24 } : Symbol(, Decl(objectLiteralArraySpecialization.ts, 5, 20))
 >name : Symbol(name, Decl(objectLiteralArraySpecialization.ts, 5, 22))
 >id : Symbol(id, Decl(objectLiteralArraySpecialization.ts, 5, 35))
+>{ name: "doug", id: 32 } : Symbol(, Decl(objectLiteralArraySpecialization.ts, 5, 45))
 >name : Symbol(name, Decl(objectLiteralArraySpecialization.ts, 5, 47))
 >id : Symbol(id, Decl(objectLiteralArraySpecialization.ts, 5, 61))
 
@@ -36,6 +38,7 @@ thing.doSomething((x, y) => x.name === "bob"); // should not error
 >thing.doSomething : Symbol(MyArrayWrapper.doSomething, Decl(objectLiteralArraySpecialization.ts, 2, 33))
 >thing : Symbol(thing, Decl(objectLiteralArraySpecialization.ts, 5, 3))
 >doSomething : Symbol(MyArrayWrapper.doSomething, Decl(objectLiteralArraySpecialization.ts, 2, 33))
+>(x, y) => x.name === "bob" : Symbol((Anonymous function), Decl(objectLiteralArraySpecialization.ts, 6, 18))
 >x : Symbol(x, Decl(objectLiteralArraySpecialization.ts, 6, 19))
 >y : Symbol(y, Decl(objectLiteralArraySpecialization.ts, 6, 21))
 >x.name : Symbol(name, Decl(objectLiteralArraySpecialization.ts, 5, 22))
diff --git a/tests/baselines/reference/objectLiteralContextualTyping.symbols b/tests/baselines/reference/objectLiteralContextualTyping.symbols
index 23a468eac3f66..1d777a55aadbe 100644
--- a/tests/baselines/reference/objectLiteralContextualTyping.symbols
+++ b/tests/baselines/reference/objectLiteralContextualTyping.symbols
@@ -26,6 +26,7 @@ declare function foo(item: any): number;
 var x = foo({ name: "Sprocket" });
 >x : Symbol(x, Decl(objectLiteralContextualTyping.ts, 13, 3), Decl(objectLiteralContextualTyping.ts, 14, 3))
 >foo : Symbol(foo, Decl(objectLiteralContextualTyping.ts, 8, 1), Decl(objectLiteralContextualTyping.ts, 10, 41))
+>{ name: "Sprocket" } : Symbol(, Decl(objectLiteralContextualTyping.ts, 13, 12))
 >name : Symbol(name, Decl(objectLiteralContextualTyping.ts, 13, 13))
 
 var x: string;
@@ -34,6 +35,7 @@ var x: string;
 var y = foo({ name: "Sprocket", description: "Bumpy wheel" });
 >y : Symbol(y, Decl(objectLiteralContextualTyping.ts, 16, 3), Decl(objectLiteralContextualTyping.ts, 17, 3))
 >foo : Symbol(foo, Decl(objectLiteralContextualTyping.ts, 8, 1), Decl(objectLiteralContextualTyping.ts, 10, 41))
+>{ name: "Sprocket", description: "Bumpy wheel" } : Symbol(, Decl(objectLiteralContextualTyping.ts, 16, 12))
 >name : Symbol(name, Decl(objectLiteralContextualTyping.ts, 16, 13))
 >description : Symbol(description, Decl(objectLiteralContextualTyping.ts, 16, 31))
 
@@ -43,6 +45,7 @@ var y: string;
 var z = foo({ name: "Sprocket", description: false });
 >z : Symbol(z, Decl(objectLiteralContextualTyping.ts, 19, 3), Decl(objectLiteralContextualTyping.ts, 20, 3))
 >foo : Symbol(foo, Decl(objectLiteralContextualTyping.ts, 8, 1), Decl(objectLiteralContextualTyping.ts, 10, 41))
+>{ name: "Sprocket", description: false } : Symbol(, Decl(objectLiteralContextualTyping.ts, 19, 12))
 >name : Symbol(name, Decl(objectLiteralContextualTyping.ts, 19, 13))
 >description : Symbol(description, Decl(objectLiteralContextualTyping.ts, 19, 31))
 
@@ -52,6 +55,7 @@ var z: number;
 var w = foo({ a: 10 });
 >w : Symbol(w, Decl(objectLiteralContextualTyping.ts, 22, 3), Decl(objectLiteralContextualTyping.ts, 23, 3))
 >foo : Symbol(foo, Decl(objectLiteralContextualTyping.ts, 8, 1), Decl(objectLiteralContextualTyping.ts, 10, 41))
+>{ a: 10 } : Symbol(, Decl(objectLiteralContextualTyping.ts, 22, 12))
 >a : Symbol(a, Decl(objectLiteralContextualTyping.ts, 22, 13))
 
 var w: number;
@@ -68,6 +72,7 @@ declare function bar<T>(param: { x?: T }): T;
 var b = bar({});
 >b : Symbol(b, Decl(objectLiteralContextualTyping.ts, 27, 3), Decl(objectLiteralContextualTyping.ts, 28, 3))
 >bar : Symbol(bar, Decl(objectLiteralContextualTyping.ts, 23, 14))
+>{} : Symbol(, Decl(objectLiteralContextualTyping.ts, 27, 12))
 
 var b: {};
 >b : Symbol(b, Decl(objectLiteralContextualTyping.ts, 27, 3), Decl(objectLiteralContextualTyping.ts, 28, 3))
diff --git a/tests/baselines/reference/objectLiteralIndexerNoImplicitAny.symbols b/tests/baselines/reference/objectLiteralIndexerNoImplicitAny.symbols
index 2a5545f22642d..7f50cae48cb16 100644
--- a/tests/baselines/reference/objectLiteralIndexerNoImplicitAny.symbols
+++ b/tests/baselines/reference/objectLiteralIndexerNoImplicitAny.symbols
@@ -9,6 +9,7 @@ interface I {
 var x: I = {
 >x : Symbol(x, Decl(objectLiteralIndexerNoImplicitAny.ts, 4, 3))
 >I : Symbol(I, Decl(objectLiteralIndexerNoImplicitAny.ts, 0, 0))
+>{    p: null} : Symbol(, Decl(objectLiteralIndexerNoImplicitAny.ts, 4, 10))
 
     p: null
 >p : Symbol(p, Decl(objectLiteralIndexerNoImplicitAny.ts, 4, 12))
diff --git a/tests/baselines/reference/objectLiteralIndexers.symbols b/tests/baselines/reference/objectLiteralIndexers.symbols
index 424e95be0faa1..f081b86fe4287 100644
--- a/tests/baselines/reference/objectLiteralIndexers.symbols
+++ b/tests/baselines/reference/objectLiteralIndexers.symbols
@@ -31,18 +31,21 @@ var o1: { [s: string]: A;[n: number]: B; } = { x: a, 0: b }; // string indexer i
 >A : Symbol(A, Decl(objectLiteralIndexers.ts, 0, 0))
 >n : Symbol(n, Decl(objectLiteralIndexers.ts, 12, 26))
 >B : Symbol(B, Decl(objectLiteralIndexers.ts, 2, 1))
+>{ x: a, 0: b } : Symbol(, Decl(objectLiteralIndexers.ts, 12, 44))
 >x : Symbol(x, Decl(objectLiteralIndexers.ts, 12, 46))
 >a : Symbol(a, Decl(objectLiteralIndexers.ts, 8, 3))
 >b : Symbol(b, Decl(objectLiteralIndexers.ts, 9, 3))
 
 o1 = { x: b, 0: c }; // both indexers are any
 >o1 : Symbol(o1, Decl(objectLiteralIndexers.ts, 12, 3))
+>{ x: b, 0: c } : Symbol(, Decl(objectLiteralIndexers.ts, 13, 4))
 >x : Symbol(x, Decl(objectLiteralIndexers.ts, 13, 6))
 >b : Symbol(b, Decl(objectLiteralIndexers.ts, 9, 3))
 >c : Symbol(c, Decl(objectLiteralIndexers.ts, 10, 3))
 
 o1 = { x: c, 0: b }; // string indexer is any, number indexer is B
 >o1 : Symbol(o1, Decl(objectLiteralIndexers.ts, 12, 3))
+>{ x: c, 0: b } : Symbol(, Decl(objectLiteralIndexers.ts, 14, 4))
 >x : Symbol(x, Decl(objectLiteralIndexers.ts, 14, 6))
 >c : Symbol(c, Decl(objectLiteralIndexers.ts, 10, 3))
 >b : Symbol(b, Decl(objectLiteralIndexers.ts, 9, 3))
diff --git a/tests/baselines/reference/objectLiteralShorthandProperties.symbols b/tests/baselines/reference/objectLiteralShorthandProperties.symbols
index e75b1d70a1162..93533fa480c2e 100644
--- a/tests/baselines/reference/objectLiteralShorthandProperties.symbols
+++ b/tests/baselines/reference/objectLiteralShorthandProperties.symbols
@@ -6,6 +6,7 @@ var a, b, c;
 
 var x1 = {
 >x1 : Symbol(x1, Decl(objectLiteralShorthandProperties.ts, 2, 3))
+>{    a} : Symbol(, Decl(objectLiteralShorthandProperties.ts, 2, 8))
 
     a
 >a : Symbol(a, Decl(objectLiteralShorthandProperties.ts, 2, 10))
@@ -14,6 +15,7 @@ var x1 = {
 
 var x2 = {
 >x2 : Symbol(x2, Decl(objectLiteralShorthandProperties.ts, 6, 3))
+>{    a,} : Symbol(, Decl(objectLiteralShorthandProperties.ts, 6, 8))
 
     a,
 >a : Symbol(a, Decl(objectLiteralShorthandProperties.ts, 6, 10))
@@ -21,6 +23,7 @@ var x2 = {
 
 var x3 = {
 >x3 : Symbol(x3, Decl(objectLiteralShorthandProperties.ts, 10, 3))
+>{    a: 0,    b,    c,    d() { },    x3,    parent: x3} : Symbol(, Decl(objectLiteralShorthandProperties.ts, 10, 8))
 
     a: 0,
 >a : Symbol(a, Decl(objectLiteralShorthandProperties.ts, 10, 10))
diff --git a/tests/baselines/reference/objectLiteralShorthandPropertiesAssignment.symbols b/tests/baselines/reference/objectLiteralShorthandPropertiesAssignment.symbols
index 6afb48aac498b..91da6b180adc1 100644
--- a/tests/baselines/reference/objectLiteralShorthandPropertiesAssignment.symbols
+++ b/tests/baselines/reference/objectLiteralShorthandPropertiesAssignment.symbols
@@ -9,6 +9,7 @@ var person: { name: string; id: number } = { name, id };
 >person : Symbol(person, Decl(objectLiteralShorthandPropertiesAssignment.ts, 3, 3))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesAssignment.ts, 3, 13))
 >id : Symbol(id, Decl(objectLiteralShorthandPropertiesAssignment.ts, 3, 27))
+>{ name, id } : Symbol(, Decl(objectLiteralShorthandPropertiesAssignment.ts, 3, 42))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesAssignment.ts, 3, 44))
 >id : Symbol(id, Decl(objectLiteralShorthandPropertiesAssignment.ts, 3, 50))
 
@@ -21,6 +22,7 @@ function bar(name: string, id: number) { return { name, id }; }
 >bar : Symbol(bar, Decl(objectLiteralShorthandPropertiesAssignment.ts, 4, 46))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesAssignment.ts, 5, 13))
 >id : Symbol(id, Decl(objectLiteralShorthandPropertiesAssignment.ts, 5, 26))
+>{ name, id } : Symbol(, Decl(objectLiteralShorthandPropertiesAssignment.ts, 5, 47))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesAssignment.ts, 5, 49))
 >id : Symbol(id, Decl(objectLiteralShorthandPropertiesAssignment.ts, 5, 55))
 
@@ -28,6 +30,7 @@ function bar1(name: string, id: number) { return { name }; }
 >bar1 : Symbol(bar1, Decl(objectLiteralShorthandPropertiesAssignment.ts, 5, 63))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesAssignment.ts, 6, 14))
 >id : Symbol(id, Decl(objectLiteralShorthandPropertiesAssignment.ts, 6, 27))
+>{ name } : Symbol(, Decl(objectLiteralShorthandPropertiesAssignment.ts, 6, 48))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesAssignment.ts, 6, 50))
 
 function baz(name: string, id: number): { name: string; id: number } { return { name, id }; }
@@ -36,6 +39,7 @@ function baz(name: string, id: number): { name: string; id: number } { return {
 >id : Symbol(id, Decl(objectLiteralShorthandPropertiesAssignment.ts, 7, 26))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesAssignment.ts, 7, 41))
 >id : Symbol(id, Decl(objectLiteralShorthandPropertiesAssignment.ts, 7, 55))
+>{ name, id } : Symbol(, Decl(objectLiteralShorthandPropertiesAssignment.ts, 7, 77))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesAssignment.ts, 7, 79))
 >id : Symbol(id, Decl(objectLiteralShorthandPropertiesAssignment.ts, 7, 85))
 
diff --git a/tests/baselines/reference/objectLiteralShorthandPropertiesAssignmentES6.symbols b/tests/baselines/reference/objectLiteralShorthandPropertiesAssignmentES6.symbols
index e444d177a798e..ec48a232e0be5 100644
--- a/tests/baselines/reference/objectLiteralShorthandPropertiesAssignmentES6.symbols
+++ b/tests/baselines/reference/objectLiteralShorthandPropertiesAssignmentES6.symbols
@@ -9,6 +9,7 @@ var person: { name: string; id: number } = { name, id };
 >person : Symbol(person, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 3, 3))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 3, 13))
 >id : Symbol(id, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 3, 27))
+>{ name, id } : Symbol(, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 3, 42))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 3, 44))
 >id : Symbol(id, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 3, 50))
 
@@ -21,6 +22,7 @@ function bar(name: string, id: number) { return { name, id }; }
 >bar : Symbol(bar, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 4, 46))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 5, 13))
 >id : Symbol(id, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 5, 26))
+>{ name, id } : Symbol(, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 5, 47))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 5, 49))
 >id : Symbol(id, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 5, 55))
 
@@ -28,6 +30,7 @@ function bar1(name: string, id: number) { return { name }; }
 >bar1 : Symbol(bar1, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 5, 63))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 6, 14))
 >id : Symbol(id, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 6, 27))
+>{ name } : Symbol(, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 6, 48))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 6, 50))
 
 function baz(name: string, id: number): { name: string; id: number } { return { name, id }; }
@@ -36,6 +39,7 @@ function baz(name: string, id: number): { name: string; id: number } { return {
 >id : Symbol(id, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 7, 26))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 7, 41))
 >id : Symbol(id, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 7, 55))
+>{ name, id } : Symbol(, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 7, 77))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 7, 79))
 >id : Symbol(id, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 7, 85))
 
diff --git a/tests/baselines/reference/objectLiteralShorthandPropertiesES6.symbols b/tests/baselines/reference/objectLiteralShorthandPropertiesES6.symbols
index 2f9b50168c118..5e2466b78130e 100644
--- a/tests/baselines/reference/objectLiteralShorthandPropertiesES6.symbols
+++ b/tests/baselines/reference/objectLiteralShorthandPropertiesES6.symbols
@@ -6,6 +6,7 @@ var a, b, c;
 
 var x1 = {
 >x1 : Symbol(x1, Decl(objectLiteralShorthandPropertiesES6.ts, 2, 3))
+>{    a} : Symbol(, Decl(objectLiteralShorthandPropertiesES6.ts, 2, 8))
 
     a
 >a : Symbol(a, Decl(objectLiteralShorthandPropertiesES6.ts, 2, 10))
@@ -14,6 +15,7 @@ var x1 = {
 
 var x2 = {
 >x2 : Symbol(x2, Decl(objectLiteralShorthandPropertiesES6.ts, 6, 3))
+>{    a,} : Symbol(, Decl(objectLiteralShorthandPropertiesES6.ts, 6, 8))
 
     a,
 >a : Symbol(a, Decl(objectLiteralShorthandPropertiesES6.ts, 6, 10))
@@ -21,6 +23,7 @@ var x2 = {
 
 var x3 = {
 >x3 : Symbol(x3, Decl(objectLiteralShorthandPropertiesES6.ts, 10, 3))
+>{    a: 0,    b,    c,    d() { },    x3,    parent: x3} : Symbol(, Decl(objectLiteralShorthandPropertiesES6.ts, 10, 8))
 
     a: 0,
 >a : Symbol(a, Decl(objectLiteralShorthandPropertiesES6.ts, 10, 10))
diff --git a/tests/baselines/reference/objectLiteralShorthandPropertiesFunctionArgument.symbols b/tests/baselines/reference/objectLiteralShorthandPropertiesFunctionArgument.symbols
index ba8b0eeb6a92a..0f76c44d9696c 100644
--- a/tests/baselines/reference/objectLiteralShorthandPropertiesFunctionArgument.symbols
+++ b/tests/baselines/reference/objectLiteralShorthandPropertiesFunctionArgument.symbols
@@ -7,6 +7,7 @@ var name: string = "my name";
 
 var person = { name, id };
 >person : Symbol(person, Decl(objectLiteralShorthandPropertiesFunctionArgument.ts, 3, 3))
+>{ name, id } : Symbol(, Decl(objectLiteralShorthandPropertiesFunctionArgument.ts, 3, 12))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesFunctionArgument.ts, 3, 14))
 >id : Symbol(id, Decl(objectLiteralShorthandPropertiesFunctionArgument.ts, 3, 20))
 
@@ -23,6 +24,7 @@ foo(person);
 
 var obj = { name: name, id: id };
 >obj : Symbol(obj, Decl(objectLiteralShorthandPropertiesFunctionArgument.ts, 9, 3))
+>{ name: name, id: id } : Symbol(, Decl(objectLiteralShorthandPropertiesFunctionArgument.ts, 9, 9))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesFunctionArgument.ts, 9, 11))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesFunctionArgument.ts, 1, 3))
 >id : Symbol(id, Decl(objectLiteralShorthandPropertiesFunctionArgument.ts, 9, 23))
diff --git a/tests/baselines/reference/objectLiteralShorthandPropertiesWithModule.symbols b/tests/baselines/reference/objectLiteralShorthandPropertiesWithModule.symbols
index 681036e2aef82..2cdb9d6fbd4c3 100644
--- a/tests/baselines/reference/objectLiteralShorthandPropertiesWithModule.symbols
+++ b/tests/baselines/reference/objectLiteralShorthandPropertiesWithModule.symbols
@@ -17,6 +17,7 @@ module m {
 
     var y = {
 >y : Symbol(y, Decl(objectLiteralShorthandPropertiesWithModule.ts, 8, 7))
+>{        a: x,        x    } : Symbol(, Decl(objectLiteralShorthandPropertiesWithModule.ts, 8, 11))
 
         a: x,
 >a : Symbol(a, Decl(objectLiteralShorthandPropertiesWithModule.ts, 8, 13))
diff --git a/tests/baselines/reference/objectLiteralShorthandPropertiesWithModuleES6.symbols b/tests/baselines/reference/objectLiteralShorthandPropertiesWithModuleES6.symbols
index bcb69cc9a976c..0964222da3ab2 100644
--- a/tests/baselines/reference/objectLiteralShorthandPropertiesWithModuleES6.symbols
+++ b/tests/baselines/reference/objectLiteralShorthandPropertiesWithModuleES6.symbols
@@ -16,6 +16,7 @@ module m {
 
     var y = {
 >y : Symbol(y, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 7, 7))
+>{        a: x,        x    } : Symbol(, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 7, 11))
 
         a: x,
 >a : Symbol(a, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 7, 13))
diff --git a/tests/baselines/reference/objectLiteralWidened.symbols b/tests/baselines/reference/objectLiteralWidened.symbols
index 0bf077cd9d8a1..57fdb291c2e42 100644
--- a/tests/baselines/reference/objectLiteralWidened.symbols
+++ b/tests/baselines/reference/objectLiteralWidened.symbols
@@ -3,6 +3,7 @@
 
 var x = {
 >x : Symbol(x, Decl(objectLiteralWidened.ts, 2, 3))
+>{    foo: null,    bar: undefined} : Symbol(, Decl(objectLiteralWidened.ts, 2, 7))
 
     foo: null,
 >foo : Symbol(foo, Decl(objectLiteralWidened.ts, 2, 9))
@@ -14,12 +15,14 @@ var x = {
 
 var y = {
 >y : Symbol(y, Decl(objectLiteralWidened.ts, 7, 3))
+>{    foo: null,    bar: {        baz: null,        boo: undefined    }} : Symbol(, Decl(objectLiteralWidened.ts, 7, 7))
 
     foo: null,
 >foo : Symbol(foo, Decl(objectLiteralWidened.ts, 7, 9))
 
     bar: {
 >bar : Symbol(bar, Decl(objectLiteralWidened.ts, 8, 14))
+>{        baz: null,        boo: undefined    } : Symbol(, Decl(objectLiteralWidened.ts, 9, 8))
 
         baz: null,
 >baz : Symbol(baz, Decl(objectLiteralWidened.ts, 9, 10))
diff --git a/tests/baselines/reference/objectTypeHidingMembersOfObject.symbols b/tests/baselines/reference/objectTypeHidingMembersOfObject.symbols
index 5c88d538fdbea..8601706f37162 100644
--- a/tests/baselines/reference/objectTypeHidingMembersOfObject.symbols
+++ b/tests/baselines/reference/objectTypeHidingMembersOfObject.symbols
@@ -37,9 +37,11 @@ var r2: void = i.valueOf();
 
 var a = {
 >a : Symbol(a, Decl(objectTypeHidingMembersOfObject.ts, 16, 3))
+>{    valueOf: () => { }} : Symbol(, Decl(objectTypeHidingMembersOfObject.ts, 16, 7))
 
     valueOf: () => { }
 >valueOf : Symbol(valueOf, Decl(objectTypeHidingMembersOfObject.ts, 16, 9))
+>() => { } : Symbol((Anonymous function), Decl(objectTypeHidingMembersOfObject.ts, 17, 12))
 }
 
 var r3: void = a.valueOf();
diff --git a/tests/baselines/reference/objectTypePropertyAccess.symbols b/tests/baselines/reference/objectTypePropertyAccess.symbols
index 519bf58926096..a42b6cdae7a86 100644
--- a/tests/baselines/reference/objectTypePropertyAccess.symbols
+++ b/tests/baselines/reference/objectTypePropertyAccess.symbols
@@ -67,6 +67,7 @@ var r7 = i['bar'];
 
 var a = {
 >a : Symbol(a, Decl(objectTypePropertyAccess.ts, 20, 3))
+>{    foo: ''} : Symbol(, Decl(objectTypePropertyAccess.ts, 20, 7))
 
     foo: ''
 >foo : Symbol(foo, Decl(objectTypePropertyAccess.ts, 20, 9))
diff --git a/tests/baselines/reference/objectTypeWithNumericProperty.symbols b/tests/baselines/reference/objectTypeWithNumericProperty.symbols
index 20e54fe1c646c..3d51c55f4b0d5 100644
--- a/tests/baselines/reference/objectTypeWithNumericProperty.symbols
+++ b/tests/baselines/reference/objectTypeWithNumericProperty.symbols
@@ -92,6 +92,7 @@ var r4 = a['1.1'];
 
 var b = {
 >b : Symbol(b, Decl(objectTypeWithNumericProperty.ts, 34, 3))
+>{    1: 1,    1.1: ""} : Symbol(, Decl(objectTypeWithNumericProperty.ts, 34, 7))
 
     1: 1,
     1.1: ""
diff --git a/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.symbols b/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.symbols
index c95105a86269a..9e35d6be0d3e4 100644
--- a/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.symbols
+++ b/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.symbols
@@ -320,6 +320,7 @@ var r13 = i[-01]
 
 var b = {
 >b : Symbol(b, Decl(objectTypeWithStringNamedNumericProperty.ts, 97, 3))
+>{    "0.1": <void>null,    ".1": new Object(),    "1": 1,    "1.": "",    "1..": true,    "1.0": new Date(),    "-1.0": /123/,    "-1": Date} : Symbol(, Decl(objectTypeWithStringNamedNumericProperty.ts, 97, 7))
 
     "0.1": <void>null,
     ".1": new Object(),
diff --git a/tests/baselines/reference/objectTypeWithStringNamedPropertyOfIllegalCharacters.symbols b/tests/baselines/reference/objectTypeWithStringNamedPropertyOfIllegalCharacters.symbols
index aa76e7e92c8ac..8ebeece4c0586 100644
--- a/tests/baselines/reference/objectTypeWithStringNamedPropertyOfIllegalCharacters.symbols
+++ b/tests/baselines/reference/objectTypeWithStringNamedPropertyOfIllegalCharacters.symbols
@@ -96,6 +96,7 @@ var r4 = a["~!@#$%^&*()_+{}|:'<>?\/.,`"];
 
 var b = {
 >b : Symbol(b, Decl(objectTypeWithStringNamedPropertyOfIllegalCharacters.ts, 41, 3))
+>{    "   ": 1,    "a   b": "",    "~!@#$%^&*()_+{}|:'<>?\/.,`": 1,} : Symbol(, Decl(objectTypeWithStringNamedPropertyOfIllegalCharacters.ts, 41, 7))
 
     "   ": 1,
     "a   b": "",
diff --git a/tests/baselines/reference/objectTypesIdentity.symbols b/tests/baselines/reference/objectTypesIdentity.symbols
index a39b47acf5564..caf824cc19185 100644
--- a/tests/baselines/reference/objectTypesIdentity.symbols
+++ b/tests/baselines/reference/objectTypesIdentity.symbols
@@ -37,6 +37,7 @@ var a: { foo: string; }
 
 var b = { foo: '' };
 >b : Symbol(b, Decl(objectTypesIdentity.ts, 19, 3))
+>{ foo: '' } : Symbol(, Decl(objectTypesIdentity.ts, 19, 7))
 >foo : Symbol(foo, Decl(objectTypesIdentity.ts, 19, 9))
 
 function foo1(x: A);
diff --git a/tests/baselines/reference/objectTypesIdentity2.symbols b/tests/baselines/reference/objectTypesIdentity2.symbols
index e78def5ca0031..164c767c1fa7c 100644
--- a/tests/baselines/reference/objectTypesIdentity2.symbols
+++ b/tests/baselines/reference/objectTypesIdentity2.symbols
@@ -43,6 +43,7 @@ enum E { A }
 
 var b = { foo: E.A };
 >b : Symbol(b, Decl(objectTypesIdentity2.ts, 20, 3))
+>{ foo: E.A } : Symbol(, Decl(objectTypesIdentity2.ts, 20, 7))
 >foo : Symbol(foo, Decl(objectTypesIdentity2.ts, 20, 9))
 >E.A : Symbol(E.A, Decl(objectTypesIdentity2.ts, 19, 8))
 >E : Symbol(E, Decl(objectTypesIdentity2.ts, 18, 23))
diff --git a/tests/baselines/reference/objectTypesIdentityWithCallSignatures.symbols b/tests/baselines/reference/objectTypesIdentityWithCallSignatures.symbols
index e1131a019c01f..443e960089cfc 100644
--- a/tests/baselines/reference/objectTypesIdentityWithCallSignatures.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithCallSignatures.symbols
@@ -54,6 +54,7 @@ var a: { foo(x: string): string }
 
 var b = { foo(x: string) { return ''; } };
 >b : Symbol(b, Decl(objectTypesIdentityWithCallSignatures.ts, 23, 3))
+>{ foo(x: string) { return ''; } } : Symbol(, Decl(objectTypesIdentityWithCallSignatures.ts, 23, 7))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithCallSignatures.ts, 23, 9))
 >x : Symbol(x, Decl(objectTypesIdentityWithCallSignatures.ts, 23, 14))
 
diff --git a/tests/baselines/reference/objectTypesIdentityWithCallSignatures2.symbols b/tests/baselines/reference/objectTypesIdentityWithCallSignatures2.symbols
index 85c138a8c34b2..e82608f41f7e0 100644
--- a/tests/baselines/reference/objectTypesIdentityWithCallSignatures2.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithCallSignatures2.symbols
@@ -55,6 +55,7 @@ var a: { foo(x: Date): string }
 
 var b = { foo(x: RegExp) { return ''; } };
 >b : Symbol(b, Decl(objectTypesIdentityWithCallSignatures2.ts, 23, 3))
+>{ foo(x: RegExp) { return ''; } } : Symbol(, Decl(objectTypesIdentityWithCallSignatures2.ts, 23, 7))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithCallSignatures2.ts, 23, 9))
 >x : Symbol(x, Decl(objectTypesIdentityWithCallSignatures2.ts, 23, 14))
 >RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
diff --git a/tests/baselines/reference/objectTypesIdentityWithCallSignaturesDifferingParamCounts.symbols b/tests/baselines/reference/objectTypesIdentityWithCallSignaturesDifferingParamCounts.symbols
index 9341ba35c42f5..87b15a995bd90 100644
--- a/tests/baselines/reference/objectTypesIdentityWithCallSignaturesDifferingParamCounts.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithCallSignaturesDifferingParamCounts.symbols
@@ -58,6 +58,7 @@ var a: { foo(x: string, y: string): string }
 
 var b = { foo(x: string) { return ''; } };
 >b : Symbol(b, Decl(objectTypesIdentityWithCallSignaturesDifferingParamCounts.ts, 23, 3))
+>{ foo(x: string) { return ''; } } : Symbol(, Decl(objectTypesIdentityWithCallSignaturesDifferingParamCounts.ts, 23, 7))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithCallSignaturesDifferingParamCounts.ts, 23, 9))
 >x : Symbol(x, Decl(objectTypesIdentityWithCallSignaturesDifferingParamCounts.ts, 23, 14))
 
diff --git a/tests/baselines/reference/objectTypesIdentityWithCallSignaturesWithOverloads.symbols b/tests/baselines/reference/objectTypesIdentityWithCallSignaturesWithOverloads.symbols
index 6575c6787fd0f..929ff6cbf190b 100644
--- a/tests/baselines/reference/objectTypesIdentityWithCallSignaturesWithOverloads.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithCallSignaturesWithOverloads.symbols
@@ -101,6 +101,7 @@ var a: {
 
 var b = {
 >b : Symbol(b, Decl(objectTypesIdentityWithCallSignaturesWithOverloads.ts, 37, 3))
+>{    foo(x: any) { return <any>''; }} : Symbol(, Decl(objectTypesIdentityWithCallSignaturesWithOverloads.ts, 37, 7))
 
     foo(x: any) { return <any>''; }
 >foo : Symbol(foo, Decl(objectTypesIdentityWithCallSignaturesWithOverloads.ts, 37, 9))
diff --git a/tests/baselines/reference/objectTypesIdentityWithConstructSignatures2.symbols b/tests/baselines/reference/objectTypesIdentityWithConstructSignatures2.symbols
index 0d37d7fc97bc6..ed2275e54f25f 100644
--- a/tests/baselines/reference/objectTypesIdentityWithConstructSignatures2.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithConstructSignatures2.symbols
@@ -41,6 +41,7 @@ var a: { new(x: Date): string }
 
 var b = { new(x: RegExp) { return ''; } }; // not a construct signature, function called new
 >b : Symbol(b, Decl(objectTypesIdentityWithConstructSignatures2.ts, 19, 3))
+>{ new(x: RegExp) { return ''; } } : Symbol(, Decl(objectTypesIdentityWithConstructSignatures2.ts, 19, 7))
 >new : Symbol(new, Decl(objectTypesIdentityWithConstructSignatures2.ts, 19, 9))
 >x : Symbol(x, Decl(objectTypesIdentityWithConstructSignatures2.ts, 19, 14))
 >RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
diff --git a/tests/baselines/reference/objectTypesIdentityWithConstructSignaturesDifferingParamCounts.symbols b/tests/baselines/reference/objectTypesIdentityWithConstructSignaturesDifferingParamCounts.symbols
index 0563fe7a2fcb5..f7ee7c9f8bce3 100644
--- a/tests/baselines/reference/objectTypesIdentityWithConstructSignaturesDifferingParamCounts.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithConstructSignaturesDifferingParamCounts.symbols
@@ -44,6 +44,7 @@ var a: { new(x: string, y: string): string }
 
 var b = { new(x: string) { return ''; } }; // not a construct signature, function called new
 >b : Symbol(b, Decl(objectTypesIdentityWithConstructSignaturesDifferingParamCounts.ts, 19, 3))
+>{ new(x: string) { return ''; } } : Symbol(, Decl(objectTypesIdentityWithConstructSignaturesDifferingParamCounts.ts, 19, 7))
 >new : Symbol(new, Decl(objectTypesIdentityWithConstructSignaturesDifferingParamCounts.ts, 19, 9))
 >x : Symbol(x, Decl(objectTypesIdentityWithConstructSignaturesDifferingParamCounts.ts, 19, 14))
 
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignatures.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignatures.symbols
index 8fdebdcccbe8d..b51c7dc314162 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignatures.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignatures.symbols
@@ -66,6 +66,7 @@ var a: { foo<T>(x: T): T }
 
 var b = { foo<T>(x: T) { return x; } };
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericCallSignatures.ts, 23, 3))
+>{ foo<T>(x: T) { return x; } } : Symbol(, Decl(objectTypesIdentityWithGenericCallSignatures.ts, 23, 7))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignatures.ts, 23, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignatures.ts, 23, 14))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignatures.ts, 23, 17))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignatures2.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignatures2.symbols
index 2ca97948a9986..c84d379ee88b4 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignatures2.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignatures2.symbols
@@ -84,6 +84,7 @@ var a: { foo<T, U>(x: T, y: U): T }
 
 var b = { foo<T, U>(x: T, y: U) { return x; } };
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericCallSignatures2.ts, 23, 3))
+>{ foo<T, U>(x: T, y: U) { return x; } } : Symbol(, Decl(objectTypesIdentityWithGenericCallSignatures2.ts, 23, 7))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignatures2.ts, 23, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignatures2.ts, 23, 14))
 >U : Symbol(U, Decl(objectTypesIdentityWithGenericCallSignatures2.ts, 23, 16))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.symbols
index 3b681c55c13ee..68825d911beb4 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.symbols
@@ -68,6 +68,7 @@ var a: { foo<T extends Array<string>>(x: T): string }
 
 var b = { foo<T extends RegExp>(x: T) { return ''; } };
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 25, 3))
+>{ foo<T extends RegExp>(x: T) { return ''; } } : Symbol(, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 25, 7))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 25, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 25, 14))
 >RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.symbols
index a9210b20f3274..23c658ec58876 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.symbols
@@ -65,6 +65,7 @@ var a: { foo<T>(x: T): T }
 
 var b = { foo<T>(x: T) { return null; } };
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.ts, 25, 3))
+>{ foo<T>(x: T) { return null; } } : Symbol(, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.ts, 25, 7))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.ts, 25, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.ts, 25, 14))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.ts, 25, 17))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.symbols
index e1c4e12037056..5b0dbdbb4d80f 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.symbols
@@ -71,6 +71,7 @@ var a: { foo<T extends Date>(x: T): T }
 
 var b = { foo<T extends Date>(x: T) { return null; } };
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 25, 3))
+>{ foo<T extends Date>(x: T) { return null; } } : Symbol(, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 25, 7))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 25, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 25, 14))
 >Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.symbols
index 9b801aa2c6ffd..f60ab98ad2a4f 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.symbols
@@ -79,6 +79,7 @@ var a: { foo<Z, A, B, C, D>(x: Z): Z }
 
 var b = { foo<A, B, C, D, E, F>(x: A) { return x; } };
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 23, 3))
+>{ foo<A, B, C, D, E, F>(x: A) { return x; } } : Symbol(, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 23, 7))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 23, 9))
 >A : Symbol(A, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 23, 14))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 23, 16))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterNames.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterNames.symbols
index 94e6aaf01391a..8c588064beb2e 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterNames.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterNames.symbols
@@ -66,6 +66,7 @@ var a: { foo<Z>(x: Z): Z }
 
 var b = { foo<A>(x: A) { return x; } };
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterNames.ts, 23, 3))
+>{ foo<A>(x: A) { return x; } } : Symbol(, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterNames.ts, 23, 7))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterNames.ts, 23, 9))
 >A : Symbol(A, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterNames.ts, 23, 14))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterNames.ts, 23, 17))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesOptionalParams.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesOptionalParams.symbols
index 0bb008d82be28..67754f9d0e791 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesOptionalParams.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesOptionalParams.symbols
@@ -80,6 +80,7 @@ var a: { foo<T>(x: T, y?: T): T }
 
 var b = { foo<T>(x: T, y?: T) { return x; } };
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericCallSignaturesOptionalParams.ts, 25, 3))
+>{ foo<T>(x: T, y?: T) { return x; } } : Symbol(, Decl(objectTypesIdentityWithGenericCallSignaturesOptionalParams.ts, 25, 7))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesOptionalParams.ts, 25, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesOptionalParams.ts, 25, 14))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesOptionalParams.ts, 25, 17))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesOptionalParams2.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesOptionalParams2.symbols
index 8878d73f5766c..d4ea50d59cfa6 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesOptionalParams2.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesOptionalParams2.symbols
@@ -86,6 +86,7 @@ var a: { foo<T, U>(x: T, y?: U): T }
 
 var b = { foo<T, U>(x: T, y?: U) { return x; } };
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericCallSignaturesOptionalParams2.ts, 25, 3))
+>{ foo<T, U>(x: T, y?: U) { return x; } } : Symbol(, Decl(objectTypesIdentityWithGenericCallSignaturesOptionalParams2.ts, 25, 7))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesOptionalParams2.ts, 25, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesOptionalParams2.ts, 25, 14))
 >U : Symbol(U, Decl(objectTypesIdentityWithGenericCallSignaturesOptionalParams2.ts, 25, 16))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesOptionalParams3.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesOptionalParams3.symbols
index b1cfab012bf90..ef9fac7efab7f 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesOptionalParams3.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesOptionalParams3.symbols
@@ -86,6 +86,7 @@ var a: { foo<T, U>(x: T, y?: U): T }
 
 var b = { foo<T, U>(x: T, y: U) { return x; } };
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericCallSignaturesOptionalParams3.ts, 25, 3))
+>{ foo<T, U>(x: T, y: U) { return x; } } : Symbol(, Decl(objectTypesIdentityWithGenericCallSignaturesOptionalParams3.ts, 25, 7))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesOptionalParams3.ts, 25, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesOptionalParams3.ts, 25, 14))
 >U : Symbol(U, Decl(objectTypesIdentityWithGenericCallSignaturesOptionalParams3.ts, 25, 16))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.symbols
index 6f53dcf17b2d1..940279561cc8d 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.symbols
@@ -52,6 +52,7 @@ var a: { new<T extends Array<string>>(x: T): string }
 
 var b = { new<T extends RegExp>(x: T) { return ''; } }; // not a construct signature, function called new
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 21, 3))
+>{ new<T extends RegExp>(x: T) { return ''; } } : Symbol(, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 21, 7))
 >new : Symbol(new, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 21, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 21, 14))
 >RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.symbols
index 703ee5d3cc498..aea6ba96cc9c9 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.symbols
@@ -50,6 +50,7 @@ var a: { new<T>(x: T): T }
 
 var b = { new<T>(x: T): T { return null; } }; // not a construct signature, function called new
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.ts, 21, 3))
+>{ new<T>(x: T): T { return null; } } : Symbol(, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.ts, 21, 7))
 >new : Symbol(new, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.ts, 21, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.ts, 21, 14))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.ts, 21, 17))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.symbols
index faa0995c2ddd9..ceaf14b16e780 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.symbols
@@ -55,6 +55,7 @@ var a: { new<T extends Date>(x: T): T }
 
 var b = { new<T extends Date>(x: T) { return null; } }; // not a construct signature, function called new
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 21, 3))
+>{ new<T extends Date>(x: T) { return null; } } : Symbol(, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 21, 7))
 >new : Symbol(new, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 21, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 21, 14))
 >Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.symbols
index d7797a833c92f..905ec0c6987b4 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.symbols
@@ -69,6 +69,7 @@ var a: { new <Z, A, B, CC, D>(x: Z): C<Z, A, B>; }
 
 var b = { new<A, B, C, D, E, F>(x: A) { return x; } };
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 19, 3))
+>{ new<A, B, C, D, E, F>(x: A) { return x; } } : Symbol(, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 19, 7))
 >new : Symbol(new, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 19, 9))
 >A : Symbol(A, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 19, 14))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 19, 16))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterNames.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterNames.symbols
index 6e31b7fcc41a4..154e486c8d874 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterNames.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterNames.symbols
@@ -51,6 +51,7 @@ var a: { new<Z>(x: Z): B<Z> }
 
 var b = { new<A>(x: A) { return new C<A>(x); } };
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterNames.ts, 19, 3))
+>{ new<A>(x: A) { return new C<A>(x); } } : Symbol(, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterNames.ts, 19, 7))
 >new : Symbol(new, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterNames.ts, 19, 9))
 >A : Symbol(A, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterNames.ts, 19, 14))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterNames.ts, 19, 17))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesOptionalParams.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesOptionalParams.symbols
index c42a6ae4341dd..179d6bb9f3f9d 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesOptionalParams.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesOptionalParams.symbols
@@ -63,6 +63,7 @@ var a: { new<T>(x: T, y?: T): B<T> }
 
 var b = { new<T>(x: T, y?: T) { return new C<T>(x, y); } }; // not a construct signature, function called new
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericConstructSignaturesOptionalParams.ts, 21, 3))
+>{ new<T>(x: T, y?: T) { return new C<T>(x, y); } } : Symbol(, Decl(objectTypesIdentityWithGenericConstructSignaturesOptionalParams.ts, 21, 7))
 >new : Symbol(new, Decl(objectTypesIdentityWithGenericConstructSignaturesOptionalParams.ts, 21, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesOptionalParams.ts, 21, 14))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesOptionalParams.ts, 21, 17))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesOptionalParams2.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesOptionalParams2.symbols
index 44bc153cd8f93..380afd8e5d364 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesOptionalParams2.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesOptionalParams2.symbols
@@ -71,6 +71,7 @@ var a: { new<T, U>(x: T, y?: U): B<T,U> }
 
 var b = { new<T, U>(x: T, y?: U) { return new C<T, U>(x, y); } }; // not a construct signature, function called new
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericConstructSignaturesOptionalParams2.ts, 21, 3))
+>{ new<T, U>(x: T, y?: U) { return new C<T, U>(x, y); } } : Symbol(, Decl(objectTypesIdentityWithGenericConstructSignaturesOptionalParams2.ts, 21, 7))
 >new : Symbol(new, Decl(objectTypesIdentityWithGenericConstructSignaturesOptionalParams2.ts, 21, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesOptionalParams2.ts, 21, 14))
 >U : Symbol(U, Decl(objectTypesIdentityWithGenericConstructSignaturesOptionalParams2.ts, 21, 16))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesOptionalParams3.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesOptionalParams3.symbols
index 3eb24d1b40092..b189f26abc9e8 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesOptionalParams3.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesOptionalParams3.symbols
@@ -71,6 +71,7 @@ var a: { new <T, U>(x: T, y?: U): B<T, U> };
 
 var b = { new<T, U>(x: T, y: U) { return new C<T, U>(x, y); } }; // not a construct signature, function called new
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericConstructSignaturesOptionalParams3.ts, 21, 3))
+>{ new<T, U>(x: T, y: U) { return new C<T, U>(x, y); } } : Symbol(, Decl(objectTypesIdentityWithGenericConstructSignaturesOptionalParams3.ts, 21, 7))
 >new : Symbol(new, Decl(objectTypesIdentityWithGenericConstructSignaturesOptionalParams3.ts, 21, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesOptionalParams3.ts, 21, 14))
 >U : Symbol(U, Decl(objectTypesIdentityWithGenericConstructSignaturesOptionalParams3.ts, 21, 16))
diff --git a/tests/baselines/reference/objectTypesIdentityWithNumericIndexers1.symbols b/tests/baselines/reference/objectTypesIdentityWithNumericIndexers1.symbols
index 4a2eb1ab2a1e0..20a6365f481af 100644
--- a/tests/baselines/reference/objectTypesIdentityWithNumericIndexers1.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithNumericIndexers1.symbols
@@ -50,6 +50,7 @@ var a: {
 var b: { [x: number]: string; } = { foo: '' };
 >b : Symbol(b, Decl(objectTypesIdentityWithNumericIndexers1.ts, 27, 3))
 >x : Symbol(x, Decl(objectTypesIdentityWithNumericIndexers1.ts, 27, 10))
+>{ foo: '' } : Symbol(, Decl(objectTypesIdentityWithNumericIndexers1.ts, 27, 33))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithNumericIndexers1.ts, 27, 35))
 
 function foo1(x: A);
diff --git a/tests/baselines/reference/objectTypesIdentityWithNumericIndexers2.symbols b/tests/baselines/reference/objectTypesIdentityWithNumericIndexers2.symbols
index 375fff858fb43..15445868f58c6 100644
--- a/tests/baselines/reference/objectTypesIdentityWithNumericIndexers2.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithNumericIndexers2.symbols
@@ -64,6 +64,7 @@ var b: { [x: number]: Derived; } = { foo: <Derived>null };
 >b : Symbol(b, Decl(objectTypesIdentityWithNumericIndexers2.ts, 30, 3))
 >x : Symbol(x, Decl(objectTypesIdentityWithNumericIndexers2.ts, 30, 10))
 >Derived : Symbol(Derived, Decl(objectTypesIdentityWithNumericIndexers2.ts, 2, 27))
+>{ foo: <Derived>null } : Symbol(, Decl(objectTypesIdentityWithNumericIndexers2.ts, 30, 34))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithNumericIndexers2.ts, 30, 36))
 >Derived : Symbol(Derived, Decl(objectTypesIdentityWithNumericIndexers2.ts, 2, 27))
 
diff --git a/tests/baselines/reference/objectTypesIdentityWithNumericIndexers3.symbols b/tests/baselines/reference/objectTypesIdentityWithNumericIndexers3.symbols
index c0bc1b5cf6050..bc7fffbc0bdfc 100644
--- a/tests/baselines/reference/objectTypesIdentityWithNumericIndexers3.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithNumericIndexers3.symbols
@@ -50,6 +50,7 @@ var a: {
 var b: { [x: number]: string; } = { foo: '' };
 >b : Symbol(b, Decl(objectTypesIdentityWithNumericIndexers3.ts, 27, 3))
 >x : Symbol(x, Decl(objectTypesIdentityWithNumericIndexers3.ts, 27, 10))
+>{ foo: '' } : Symbol(, Decl(objectTypesIdentityWithNumericIndexers3.ts, 27, 33))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithNumericIndexers3.ts, 27, 35))
 
 function foo1(x: A);
diff --git a/tests/baselines/reference/objectTypesIdentityWithOptionality.symbols b/tests/baselines/reference/objectTypesIdentityWithOptionality.symbols
index 595295418f592..0807d0e543387 100644
--- a/tests/baselines/reference/objectTypesIdentityWithOptionality.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithOptionality.symbols
@@ -37,6 +37,7 @@ var a: { foo?: string; }
 
 var b = { foo: '' };
 >b : Symbol(b, Decl(objectTypesIdentityWithOptionality.ts, 19, 3))
+>{ foo: '' } : Symbol(, Decl(objectTypesIdentityWithOptionality.ts, 19, 7))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithOptionality.ts, 19, 9))
 
 function foo2(x: I);
diff --git a/tests/baselines/reference/objectTypesIdentityWithPrivates.symbols b/tests/baselines/reference/objectTypesIdentityWithPrivates.symbols
index d7680f7fb91d1..84ac619930ff7 100644
--- a/tests/baselines/reference/objectTypesIdentityWithPrivates.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithPrivates.symbols
@@ -47,6 +47,7 @@ var a: { foo: string; }
 
 var b = { foo: '' };
 >b : Symbol(b, Decl(objectTypesIdentityWithPrivates.ts, 25, 3))
+>{ foo: '' } : Symbol(, Decl(objectTypesIdentityWithPrivates.ts, 25, 7))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithPrivates.ts, 25, 9))
 
 function foo1(x: A);
diff --git a/tests/baselines/reference/objectTypesIdentityWithPublics.symbols b/tests/baselines/reference/objectTypesIdentityWithPublics.symbols
index ebfb52e3d2e4a..5a84e0c96cd53 100644
--- a/tests/baselines/reference/objectTypesIdentityWithPublics.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithPublics.symbols
@@ -37,6 +37,7 @@ var a: { foo: string; }
 
 var b = { foo: '' };
 >b : Symbol(b, Decl(objectTypesIdentityWithPublics.ts, 19, 3))
+>{ foo: '' } : Symbol(, Decl(objectTypesIdentityWithPublics.ts, 19, 7))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithPublics.ts, 19, 9))
 
 function foo1(x: A);
diff --git a/tests/baselines/reference/objectTypesIdentityWithStringIndexers.symbols b/tests/baselines/reference/objectTypesIdentityWithStringIndexers.symbols
index 5a51f1bb0a6e4..a882ca0d63b53 100644
--- a/tests/baselines/reference/objectTypesIdentityWithStringIndexers.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithStringIndexers.symbols
@@ -50,6 +50,7 @@ var a: {
 var b: { [x: string]: string; } = { foo: '' };
 >b : Symbol(b, Decl(objectTypesIdentityWithStringIndexers.ts, 27, 3))
 >x : Symbol(x, Decl(objectTypesIdentityWithStringIndexers.ts, 27, 10))
+>{ foo: '' } : Symbol(, Decl(objectTypesIdentityWithStringIndexers.ts, 27, 33))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithStringIndexers.ts, 27, 35))
 
 function foo1(x: A);
diff --git a/tests/baselines/reference/objectTypesIdentityWithStringIndexers2.symbols b/tests/baselines/reference/objectTypesIdentityWithStringIndexers2.symbols
index 2df0bf01b1d7e..ea9a327c8caa5 100644
--- a/tests/baselines/reference/objectTypesIdentityWithStringIndexers2.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithStringIndexers2.symbols
@@ -64,6 +64,7 @@ var b: { [x: string]: Derived; } = { foo: <Derived>null };
 >b : Symbol(b, Decl(objectTypesIdentityWithStringIndexers2.ts, 30, 3))
 >x : Symbol(x, Decl(objectTypesIdentityWithStringIndexers2.ts, 30, 10))
 >Derived : Symbol(Derived, Decl(objectTypesIdentityWithStringIndexers2.ts, 2, 27))
+>{ foo: <Derived>null } : Symbol(, Decl(objectTypesIdentityWithStringIndexers2.ts, 30, 34))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithStringIndexers2.ts, 30, 36))
 >Derived : Symbol(Derived, Decl(objectTypesIdentityWithStringIndexers2.ts, 2, 27))
 
diff --git a/tests/baselines/reference/octalIntegerLiteral.symbols b/tests/baselines/reference/octalIntegerLiteral.symbols
index 6a4839839aab3..6b26823a49ad6 100644
--- a/tests/baselines/reference/octalIntegerLiteral.symbols
+++ b/tests/baselines/reference/octalIntegerLiteral.symbols
@@ -13,6 +13,7 @@ var oct4 = 0o7777777777777777777777777777777777777777777777777777777777777777777
 
 var obj1 = {
 >obj1 : Symbol(obj1, Decl(octalIntegerLiteral.ts, 5, 3))
+>{    0o45436: "Hello",    a: 0o45436,     b: oct1,    oct1,    0o7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777: true} : Symbol(, Decl(octalIntegerLiteral.ts, 5, 10))
 
     0o45436: "Hello",
     a: 0o45436, 
@@ -30,6 +31,7 @@ var obj1 = {
 
 var obj2 = {
 >obj2 : Symbol(obj2, Decl(octalIntegerLiteral.ts, 13, 3))
+>{    0O45436: "hi",    a: 0O45436,     b: oct2,    oct2,    0o7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777: false,} : Symbol(, Decl(octalIntegerLiteral.ts, 13, 10))
 
     0O45436: "hi",
     a: 0O45436, 
diff --git a/tests/baselines/reference/octalIntegerLiteralES6.symbols b/tests/baselines/reference/octalIntegerLiteralES6.symbols
index ff3f54936cd79..f3fd168f7555f 100644
--- a/tests/baselines/reference/octalIntegerLiteralES6.symbols
+++ b/tests/baselines/reference/octalIntegerLiteralES6.symbols
@@ -13,6 +13,7 @@ var oct4 = 0o7777777777777777777777777777777777777777777777777777777777777777777
 
 var obj1 = {
 >obj1 : Symbol(obj1, Decl(octalIntegerLiteralES6.ts, 5, 3))
+>{    0o45436: "Hello",    a: 0o45436,     b: oct1,    oct1,    0o7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777: true} : Symbol(, Decl(octalIntegerLiteralES6.ts, 5, 10))
 
     0o45436: "Hello",
     a: 0o45436, 
@@ -30,6 +31,7 @@ var obj1 = {
 
 var obj2 = {
 >obj2 : Symbol(obj2, Decl(octalIntegerLiteralES6.ts, 13, 3))
+>{    0O45436: "hi",    a: 0O45436,     b: oct2,    oct2,    0o7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777: false,} : Symbol(, Decl(octalIntegerLiteralES6.ts, 13, 10))
 
     0O45436: "hi",
     a: 0O45436, 
diff --git a/tests/baselines/reference/optionalAccessorsInInterface1.symbols b/tests/baselines/reference/optionalAccessorsInInterface1.symbols
index 6c9c8ab142951..519716e5c0f25 100644
--- a/tests/baselines/reference/optionalAccessorsInInterface1.symbols
+++ b/tests/baselines/reference/optionalAccessorsInInterface1.symbols
@@ -19,7 +19,10 @@ declare function defineMyProperty(o: any, p: string, attributes: MyPropertyDescr
 
 defineMyProperty({}, "name", { get: function () { return 5; } });
 >defineMyProperty : Symbol(defineMyProperty, Decl(optionalAccessorsInInterface1.ts, 3, 1))
+>{} : Symbol(, Decl(optionalAccessorsInInterface1.ts, 6, 17))
+>{ get: function () { return 5; } } : Symbol(, Decl(optionalAccessorsInInterface1.ts, 6, 28))
 >get : Symbol(get, Decl(optionalAccessorsInInterface1.ts, 6, 30))
+>function () { return 5; } : Symbol((Anonymous function), Decl(optionalAccessorsInInterface1.ts, 6, 35))
 
 interface MyPropertyDescriptor2 {
 >MyPropertyDescriptor2 : Symbol(MyPropertyDescriptor2, Decl(optionalAccessorsInInterface1.ts, 6, 65))
@@ -41,5 +44,8 @@ declare function defineMyProperty2(o: any, p: string, attributes: MyPropertyDesc
 
 defineMyProperty2({}, "name", { get: function () { return 5; } });
 >defineMyProperty2 : Symbol(defineMyProperty2, Decl(optionalAccessorsInInterface1.ts, 11, 1))
+>{} : Symbol(, Decl(optionalAccessorsInInterface1.ts, 14, 18))
+>{ get: function () { return 5; } } : Symbol(, Decl(optionalAccessorsInInterface1.ts, 14, 29))
 >get : Symbol(get, Decl(optionalAccessorsInInterface1.ts, 14, 31))
+>function () { return 5; } : Symbol((Anonymous function), Decl(optionalAccessorsInInterface1.ts, 14, 36))
 
diff --git a/tests/baselines/reference/overloadBindingAcrossDeclarationBoundaries.symbols b/tests/baselines/reference/overloadBindingAcrossDeclarationBoundaries.symbols
index 65f64fa891552..80086cb10d98b 100644
--- a/tests/baselines/reference/overloadBindingAcrossDeclarationBoundaries.symbols
+++ b/tests/baselines/reference/overloadBindingAcrossDeclarationBoundaries.symbols
@@ -104,12 +104,15 @@ var a1 = a.a({});
 >a.a : Symbol(A.a, Decl(overloadBindingAcrossDeclarationBoundaries.ts, 12, 13), Decl(overloadBindingAcrossDeclarationBoundaries.ts, 13, 21), Decl(overloadBindingAcrossDeclarationBoundaries.ts, 20, 13), Decl(overloadBindingAcrossDeclarationBoundaries.ts, 21, 21))
 >a : Symbol(a, Decl(overloadBindingAcrossDeclarationBoundaries.ts, 29, 3))
 >a : Symbol(A.a, Decl(overloadBindingAcrossDeclarationBoundaries.ts, 12, 13), Decl(overloadBindingAcrossDeclarationBoundaries.ts, 13, 21), Decl(overloadBindingAcrossDeclarationBoundaries.ts, 20, 13), Decl(overloadBindingAcrossDeclarationBoundaries.ts, 21, 21))
+>{} : Symbol(, Decl(overloadBindingAcrossDeclarationBoundaries.ts, 31, 13))
 
 var a1 = a({});
 >a1 : Symbol(a1, Decl(overloadBindingAcrossDeclarationBoundaries.ts, 31, 3), Decl(overloadBindingAcrossDeclarationBoundaries.ts, 32, 3), Decl(overloadBindingAcrossDeclarationBoundaries.ts, 33, 3))
 >a : Symbol(a, Decl(overloadBindingAcrossDeclarationBoundaries.ts, 29, 3))
+>{} : Symbol(, Decl(overloadBindingAcrossDeclarationBoundaries.ts, 32, 11))
 
 var a1 = new a({});
 >a1 : Symbol(a1, Decl(overloadBindingAcrossDeclarationBoundaries.ts, 31, 3), Decl(overloadBindingAcrossDeclarationBoundaries.ts, 32, 3), Decl(overloadBindingAcrossDeclarationBoundaries.ts, 33, 3))
 >a : Symbol(a, Decl(overloadBindingAcrossDeclarationBoundaries.ts, 29, 3))
+>{} : Symbol(, Decl(overloadBindingAcrossDeclarationBoundaries.ts, 33, 15))
 
diff --git a/tests/baselines/reference/overloadBindingAcrossDeclarationBoundaries2.symbols b/tests/baselines/reference/overloadBindingAcrossDeclarationBoundaries2.symbols
index 534475bcc30ed..f556d5c35fcbd 100644
--- a/tests/baselines/reference/overloadBindingAcrossDeclarationBoundaries2.symbols
+++ b/tests/baselines/reference/overloadBindingAcrossDeclarationBoundaries2.symbols
@@ -107,12 +107,15 @@ var a1 = a.a({});
 >a.a : Symbol(A.a, Decl(overloadBindingAcrossDeclarationBoundaries_file0.ts, 13, 13), Decl(overloadBindingAcrossDeclarationBoundaries_file0.ts, 14, 21), Decl(overloadBindingAcrossDeclarationBoundaries_file1.ts, 0, 13), Decl(overloadBindingAcrossDeclarationBoundaries_file1.ts, 1, 21))
 >a : Symbol(a, Decl(overloadBindingAcrossDeclarationBoundaries_file1.ts, 9, 3))
 >a : Symbol(A.a, Decl(overloadBindingAcrossDeclarationBoundaries_file0.ts, 13, 13), Decl(overloadBindingAcrossDeclarationBoundaries_file0.ts, 14, 21), Decl(overloadBindingAcrossDeclarationBoundaries_file1.ts, 0, 13), Decl(overloadBindingAcrossDeclarationBoundaries_file1.ts, 1, 21))
+>{} : Symbol(, Decl(overloadBindingAcrossDeclarationBoundaries_file1.ts, 11, 13))
 
 var a1 = a({});
 >a1 : Symbol(a1, Decl(overloadBindingAcrossDeclarationBoundaries_file1.ts, 11, 3), Decl(overloadBindingAcrossDeclarationBoundaries_file1.ts, 12, 3), Decl(overloadBindingAcrossDeclarationBoundaries_file1.ts, 13, 3))
 >a : Symbol(a, Decl(overloadBindingAcrossDeclarationBoundaries_file1.ts, 9, 3))
+>{} : Symbol(, Decl(overloadBindingAcrossDeclarationBoundaries_file1.ts, 12, 11))
 
 var a1 = new a({});
 >a1 : Symbol(a1, Decl(overloadBindingAcrossDeclarationBoundaries_file1.ts, 11, 3), Decl(overloadBindingAcrossDeclarationBoundaries_file1.ts, 12, 3), Decl(overloadBindingAcrossDeclarationBoundaries_file1.ts, 13, 3))
 >a : Symbol(a, Decl(overloadBindingAcrossDeclarationBoundaries_file1.ts, 9, 3))
+>{} : Symbol(, Decl(overloadBindingAcrossDeclarationBoundaries_file1.ts, 13, 15))
 
diff --git a/tests/baselines/reference/overloadResolutionOverNonCTLambdas.symbols b/tests/baselines/reference/overloadResolutionOverNonCTLambdas.symbols
index 815f977d60508..87262f14f91a2 100644
--- a/tests/baselines/reference/overloadResolutionOverNonCTLambdas.symbols
+++ b/tests/baselines/reference/overloadResolutionOverNonCTLambdas.symbols
@@ -17,6 +17,7 @@ module Bugs {
 >message.replace : Symbol(String.replace, Decl(lib.d.ts, 329, 44), Decl(lib.d.ts, 336, 63), Decl(lib.d.ts, 343, 102), Decl(lib.d.ts, 350, 63))
 >message : Symbol(message, Decl(overloadResolutionOverNonCTLambdas.ts, 5, 16))
 >replace : Symbol(String.replace, Decl(lib.d.ts, 329, 44), Decl(lib.d.ts, 336, 63), Decl(lib.d.ts, 343, 102), Decl(lib.d.ts, 350, 63))
+>function(match, ...rest) {      var index= rest[0];      return typeof args[index] !== 'undefined'        ? args[index]        : match;    } : Symbol((Anonymous function), Decl(overloadResolutionOverNonCTLambdas.ts, 6, 45))
 >match : Symbol(match, Decl(overloadResolutionOverNonCTLambdas.ts, 6, 55))
 >rest : Symbol(rest, Decl(overloadResolutionOverNonCTLambdas.ts, 6, 61))
 
@@ -58,6 +59,7 @@ bug3(fprime);
 
 bug3(function(x:string):string { return x; });
 >bug3 : Symbol(bug3, Decl(overloadResolutionOverNonCTLambdas.ts, 14, 1))
+>function(x:string):string { return x; } : Symbol((Anonymous function), Decl(overloadResolutionOverNonCTLambdas.ts, 22, 5))
 >x : Symbol(x, Decl(overloadResolutionOverNonCTLambdas.ts, 22, 14))
 >x : Symbol(x, Decl(overloadResolutionOverNonCTLambdas.ts, 22, 14))
 
diff --git a/tests/baselines/reference/overloadResolutionOverNonCTObjectLit.symbols b/tests/baselines/reference/overloadResolutionOverNonCTObjectLit.symbols
index 850f188a58b47..c8d3cb015ad04 100644
--- a/tests/baselines/reference/overloadResolutionOverNonCTObjectLit.symbols
+++ b/tests/baselines/reference/overloadResolutionOverNonCTObjectLit.symbols
@@ -42,6 +42,7 @@ module Bugs {
 >tokens.push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
 >tokens : Symbol(tokens, Decl(overloadResolutionOverNonCTObjectLit.ts, 16, 35))
 >push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
+>{ startIndex: 1, type: '', bracket: 3 } : Symbol(, Decl(overloadResolutionOverNonCTObjectLit.ts, 17, 44))
 >startIndex : Symbol(startIndex, Decl(overloadResolutionOverNonCTObjectLit.ts, 17, 45))
 >type : Symbol(type, Decl(overloadResolutionOverNonCTObjectLit.ts, 17, 60))
 >bracket : Symbol(bracket, Decl(overloadResolutionOverNonCTObjectLit.ts, 17, 70))
@@ -51,6 +52,7 @@ module Bugs {
 >tokens : Symbol(tokens, Decl(overloadResolutionOverNonCTObjectLit.ts, 16, 35))
 >push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
 >IToken : Symbol(IToken, Decl(overloadResolutionOverNonCTObjectLit.ts, 0, 13))
+>{ startIndex: 1, type: '', bracket: 3, state: null, length: 10 } : Symbol(, Decl(overloadResolutionOverNonCTObjectLit.ts, 18, 53))
 >startIndex : Symbol(startIndex, Decl(overloadResolutionOverNonCTObjectLit.ts, 18, 54))
 >type : Symbol(type, Decl(overloadResolutionOverNonCTObjectLit.ts, 18, 69))
 >bracket : Symbol(bracket, Decl(overloadResolutionOverNonCTObjectLit.ts, 18, 79))
diff --git a/tests/baselines/reference/overloadWithCallbacksWithDifferingOptionalityOnArgs.symbols b/tests/baselines/reference/overloadWithCallbacksWithDifferingOptionalityOnArgs.symbols
index 0ae3e488fac6f..cc5898efa6489 100644
--- a/tests/baselines/reference/overloadWithCallbacksWithDifferingOptionalityOnArgs.symbols
+++ b/tests/baselines/reference/overloadWithCallbacksWithDifferingOptionalityOnArgs.symbols
@@ -16,8 +16,10 @@ function x2(callback: (x: any) => number) { }
 
 x2(() => 1);
 >x2 : Symbol(x2, Decl(overloadWithCallbacksWithDifferingOptionalityOnArgs.ts, 0, 0), Decl(overloadWithCallbacksWithDifferingOptionalityOnArgs.ts, 0, 46), Decl(overloadWithCallbacksWithDifferingOptionalityOnArgs.ts, 1, 45))
+>() => 1 : Symbol((Anonymous function), Decl(overloadWithCallbacksWithDifferingOptionalityOnArgs.ts, 3, 3))
 
 x2((x) => 1 );
 >x2 : Symbol(x2, Decl(overloadWithCallbacksWithDifferingOptionalityOnArgs.ts, 0, 0), Decl(overloadWithCallbacksWithDifferingOptionalityOnArgs.ts, 0, 46), Decl(overloadWithCallbacksWithDifferingOptionalityOnArgs.ts, 1, 45))
+>(x) => 1 : Symbol((Anonymous function), Decl(overloadWithCallbacksWithDifferingOptionalityOnArgs.ts, 4, 3))
 >x : Symbol(x, Decl(overloadWithCallbacksWithDifferingOptionalityOnArgs.ts, 4, 4))
 
diff --git a/tests/baselines/reference/parametersWithNoAnnotationAreAny.symbols b/tests/baselines/reference/parametersWithNoAnnotationAreAny.symbols
index 9771d7f05ca8a..3ea8c263bde37 100644
--- a/tests/baselines/reference/parametersWithNoAnnotationAreAny.symbols
+++ b/tests/baselines/reference/parametersWithNoAnnotationAreAny.symbols
@@ -6,17 +6,20 @@ function foo(x) { return x; }
 
 var f = function foo(x) { return x; }
 >f : Symbol(f, Decl(parametersWithNoAnnotationAreAny.ts, 1, 3))
+>function foo(x) { return x; } : Symbol(foo, Decl(parametersWithNoAnnotationAreAny.ts, 1, 7))
 >foo : Symbol(foo, Decl(parametersWithNoAnnotationAreAny.ts, 1, 7))
 >x : Symbol(x, Decl(parametersWithNoAnnotationAreAny.ts, 1, 21))
 >x : Symbol(x, Decl(parametersWithNoAnnotationAreAny.ts, 1, 21))
 
 var f2 = (x) => x;
 >f2 : Symbol(f2, Decl(parametersWithNoAnnotationAreAny.ts, 2, 3))
+>(x) => x : Symbol((Anonymous function), Decl(parametersWithNoAnnotationAreAny.ts, 2, 8))
 >x : Symbol(x, Decl(parametersWithNoAnnotationAreAny.ts, 2, 10))
 >x : Symbol(x, Decl(parametersWithNoAnnotationAreAny.ts, 2, 10))
 
 var f3 = <T>(x) => x;
 >f3 : Symbol(f3, Decl(parametersWithNoAnnotationAreAny.ts, 3, 3))
+><T>(x) => x : Symbol((Anonymous function), Decl(parametersWithNoAnnotationAreAny.ts, 3, 8))
 >T : Symbol(T, Decl(parametersWithNoAnnotationAreAny.ts, 3, 10))
 >x : Symbol(x, Decl(parametersWithNoAnnotationAreAny.ts, 3, 13))
 >x : Symbol(x, Decl(parametersWithNoAnnotationAreAny.ts, 3, 13))
@@ -56,6 +59,7 @@ var a: {
 
 var b = {
 >b : Symbol(b, Decl(parametersWithNoAnnotationAreAny.ts, 20, 3))
+>{    foo(x) {        return x;    },    a: function foo(x) {        return x;    },    b: (x) => x} : Symbol(, Decl(parametersWithNoAnnotationAreAny.ts, 20, 7))
 
     foo(x) {
 >foo : Symbol(foo, Decl(parametersWithNoAnnotationAreAny.ts, 20, 9))
@@ -67,6 +71,7 @@ var b = {
     },
     a: function foo(x) {
 >a : Symbol(a, Decl(parametersWithNoAnnotationAreAny.ts, 23, 6))
+>function foo(x) {        return x;    } : Symbol(foo, Decl(parametersWithNoAnnotationAreAny.ts, 24, 6))
 >foo : Symbol(foo, Decl(parametersWithNoAnnotationAreAny.ts, 24, 6))
 >x : Symbol(x, Decl(parametersWithNoAnnotationAreAny.ts, 24, 20))
 
@@ -76,6 +81,7 @@ var b = {
     },
     b: (x) => x
 >b : Symbol(b, Decl(parametersWithNoAnnotationAreAny.ts, 26, 6))
+>(x) => x : Symbol((Anonymous function), Decl(parametersWithNoAnnotationAreAny.ts, 27, 6))
 >x : Symbol(x, Decl(parametersWithNoAnnotationAreAny.ts, 27, 8))
 >x : Symbol(x, Decl(parametersWithNoAnnotationAreAny.ts, 27, 8))
 }
diff --git a/tests/baselines/reference/parenthesizedContexualTyping1.symbols b/tests/baselines/reference/parenthesizedContexualTyping1.symbols
index 698e26734addf..9639ffd20f955 100644
--- a/tests/baselines/reference/parenthesizedContexualTyping1.symbols
+++ b/tests/baselines/reference/parenthesizedContexualTyping1.symbols
@@ -45,56 +45,68 @@ function fun<T>(g: (x: T) => T, x: T): T {
 var a = fun(x => x, 10);
 >a : Symbol(a, Decl(parenthesizedContexualTyping1.ts, 7, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping1.ts, 0, 0), Decl(parenthesizedContexualTyping1.ts, 1, 41), Decl(parenthesizedContexualTyping1.ts, 2, 57))
+>x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 7, 12))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 7, 12))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 7, 12))
 
 var b = fun((x => x), 10);
 >b : Symbol(b, Decl(parenthesizedContexualTyping1.ts, 8, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping1.ts, 0, 0), Decl(parenthesizedContexualTyping1.ts, 1, 41), Decl(parenthesizedContexualTyping1.ts, 2, 57))
+>x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 8, 13))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 8, 13))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 8, 13))
 
 var c = fun(((x => x)), 10);
 >c : Symbol(c, Decl(parenthesizedContexualTyping1.ts, 9, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping1.ts, 0, 0), Decl(parenthesizedContexualTyping1.ts, 1, 41), Decl(parenthesizedContexualTyping1.ts, 2, 57))
+>x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 9, 14))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 9, 14))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 9, 14))
 
 var d = fun((((x => x))), 10);
 >d : Symbol(d, Decl(parenthesizedContexualTyping1.ts, 10, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping1.ts, 0, 0), Decl(parenthesizedContexualTyping1.ts, 1, 41), Decl(parenthesizedContexualTyping1.ts, 2, 57))
+>x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 10, 15))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 10, 15))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 10, 15))
 
 var e = fun(x => x, x => x, 10);
 >e : Symbol(e, Decl(parenthesizedContexualTyping1.ts, 12, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping1.ts, 0, 0), Decl(parenthesizedContexualTyping1.ts, 1, 41), Decl(parenthesizedContexualTyping1.ts, 2, 57))
+>x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 12, 12))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 12, 12))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 12, 12))
+>x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 12, 19))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 12, 19))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 12, 19))
 
 var f = fun((x => x), (x => x), 10);
 >f : Symbol(f, Decl(parenthesizedContexualTyping1.ts, 13, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping1.ts, 0, 0), Decl(parenthesizedContexualTyping1.ts, 1, 41), Decl(parenthesizedContexualTyping1.ts, 2, 57))
+>x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 13, 13))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 13, 13))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 13, 13))
+>x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 13, 23))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 13, 23))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 13, 23))
 
 var g = fun(((x => x)), ((x => x)), 10);
 >g : Symbol(g, Decl(parenthesizedContexualTyping1.ts, 14, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping1.ts, 0, 0), Decl(parenthesizedContexualTyping1.ts, 1, 41), Decl(parenthesizedContexualTyping1.ts, 2, 57))
+>x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 14, 14))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 14, 14))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 14, 14))
+>x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 14, 26))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 14, 26))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 14, 26))
 
 var h = fun((((x => x))), ((x => x)), 10);
 >h : Symbol(h, Decl(parenthesizedContexualTyping1.ts, 15, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping1.ts, 0, 0), Decl(parenthesizedContexualTyping1.ts, 1, 41), Decl(parenthesizedContexualTyping1.ts, 2, 57))
+>x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 15, 15))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 15, 15))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 15, 15))
+>x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 15, 28))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 15, 28))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 15, 28))
 
@@ -105,8 +117,10 @@ var i = fun((Math.random() < 0.5 ? x => x : x => undefined), 10);
 >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 >Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
+>x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 18, 34))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 18, 34))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 18, 34))
+>x => undefined : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 18, 43))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 18, 43))
 >undefined : Symbol(undefined)
 
@@ -116,8 +130,10 @@ var j = fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), 10);
 >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 >Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
+>x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 19, 36))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 19, 36))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 19, 36))
+>x => undefined : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 19, 47))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 19, 47))
 >undefined : Symbol(undefined)
 
@@ -127,10 +143,13 @@ var k = fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), x => x, 10);
 >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 >Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
+>x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 20, 36))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 20, 36))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 20, 36))
+>x => undefined : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 20, 47))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 20, 47))
 >undefined : Symbol(undefined)
+>x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 20, 64))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 20, 64))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 20, 64))
 
@@ -140,22 +159,27 @@ var l = fun(((Math.random() < 0.5 ? ((x => x)) : ((x => undefined)))), ((x => x)
 >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 >Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
+>x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 21, 38))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 21, 38))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 21, 38))
+>x => undefined : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 21, 51))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 21, 51))
 >undefined : Symbol(undefined)
+>x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 21, 73))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 21, 73))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 21, 73))
 
 var lambda1: (x: number) => number = x => x;
 >lambda1 : Symbol(lambda1, Decl(parenthesizedContexualTyping1.ts, 23, 3))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 23, 14))
+>x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 23, 36))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 23, 36))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 23, 36))
 
 var lambda2: (x: number) => number = (x => x);
 >lambda2 : Symbol(lambda2, Decl(parenthesizedContexualTyping1.ts, 24, 3))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 24, 14))
+>x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 24, 38))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 24, 38))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 24, 38))
 
@@ -169,11 +193,14 @@ type ObjType = { x: (p: number) => string; y: (p: string) => number };
 var obj1: ObjType = { x: x => (x, undefined), y: y => (y, undefined) };
 >obj1 : Symbol(obj1, Decl(parenthesizedContexualTyping1.ts, 27, 3))
 >ObjType : Symbol(ObjType, Decl(parenthesizedContexualTyping1.ts, 24, 46))
+>{ x: x => (x, undefined), y: y => (y, undefined) } : Symbol(, Decl(parenthesizedContexualTyping1.ts, 27, 19))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 27, 21))
+>x => (x, undefined) : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 27, 24))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 27, 24))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 27, 24))
 >undefined : Symbol(undefined)
 >y : Symbol(y, Decl(parenthesizedContexualTyping1.ts, 27, 45))
+>y => (y, undefined) : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 27, 48))
 >y : Symbol(y, Decl(parenthesizedContexualTyping1.ts, 27, 48))
 >y : Symbol(y, Decl(parenthesizedContexualTyping1.ts, 27, 48))
 >undefined : Symbol(undefined)
@@ -181,11 +208,14 @@ var obj1: ObjType = { x: x => (x, undefined), y: y => (y, undefined) };
 var obj2: ObjType = ({ x: x => (x, undefined), y: y => (y, undefined) });
 >obj2 : Symbol(obj2, Decl(parenthesizedContexualTyping1.ts, 28, 3))
 >ObjType : Symbol(ObjType, Decl(parenthesizedContexualTyping1.ts, 24, 46))
+>{ x: x => (x, undefined), y: y => (y, undefined) } : Symbol(, Decl(parenthesizedContexualTyping1.ts, 28, 21))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 28, 22))
+>x => (x, undefined) : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 28, 25))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 28, 25))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 28, 25))
 >undefined : Symbol(undefined)
 >y : Symbol(y, Decl(parenthesizedContexualTyping1.ts, 28, 46))
+>y => (y, undefined) : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 28, 49))
 >y : Symbol(y, Decl(parenthesizedContexualTyping1.ts, 28, 49))
 >y : Symbol(y, Decl(parenthesizedContexualTyping1.ts, 28, 49))
 >undefined : Symbol(undefined)
diff --git a/tests/baselines/reference/parenthesizedContexualTyping2.symbols b/tests/baselines/reference/parenthesizedContexualTyping2.symbols
index f7616f07710d5..ae3aab8443729 100644
--- a/tests/baselines/reference/parenthesizedContexualTyping2.symbols
+++ b/tests/baselines/reference/parenthesizedContexualTyping2.symbols
@@ -47,6 +47,7 @@ function fun<T>(...rest: any[]): T {
 var a = fun(x => { x<number>(undefined); return x; }, 10);
 >a : Symbol(a, Decl(parenthesizedContexualTyping2.ts, 14, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping2.ts, 6, 48), Decl(parenthesizedContexualTyping2.ts, 8, 38), Decl(parenthesizedContexualTyping2.ts, 9, 51))
+>x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 14, 12))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 14, 12))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 14, 12))
 >undefined : Symbol(undefined)
@@ -55,6 +56,7 @@ var a = fun(x => { x<number>(undefined); return x; }, 10);
 var b = fun((x => { x<number>(undefined); return x; }), 10);
 >b : Symbol(b, Decl(parenthesizedContexualTyping2.ts, 15, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping2.ts, 6, 48), Decl(parenthesizedContexualTyping2.ts, 8, 38), Decl(parenthesizedContexualTyping2.ts, 9, 51))
+>x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 15, 13))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 15, 13))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 15, 13))
 >undefined : Symbol(undefined)
@@ -63,6 +65,7 @@ var b = fun((x => { x<number>(undefined); return x; }), 10);
 var c = fun(((x => { x<number>(undefined); return x; })), 10);
 >c : Symbol(c, Decl(parenthesizedContexualTyping2.ts, 16, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping2.ts, 6, 48), Decl(parenthesizedContexualTyping2.ts, 8, 38), Decl(parenthesizedContexualTyping2.ts, 9, 51))
+>x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 16, 14))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 16, 14))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 16, 14))
 >undefined : Symbol(undefined)
@@ -71,6 +74,7 @@ var c = fun(((x => { x<number>(undefined); return x; })), 10);
 var d = fun((((x => { x<number>(undefined); return x; }))), 10);
 >d : Symbol(d, Decl(parenthesizedContexualTyping2.ts, 17, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping2.ts, 6, 48), Decl(parenthesizedContexualTyping2.ts, 8, 38), Decl(parenthesizedContexualTyping2.ts, 9, 51))
+>x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 17, 15))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 17, 15))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 17, 15))
 >undefined : Symbol(undefined)
@@ -79,10 +83,12 @@ var d = fun((((x => { x<number>(undefined); return x; }))), 10);
 var e = fun(x => { x<number>(undefined); return x; }, x => { x<number>(undefined); return x; }, 10);
 >e : Symbol(e, Decl(parenthesizedContexualTyping2.ts, 19, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping2.ts, 6, 48), Decl(parenthesizedContexualTyping2.ts, 8, 38), Decl(parenthesizedContexualTyping2.ts, 9, 51))
+>x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 19, 12))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 19, 12))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 19, 12))
 >undefined : Symbol(undefined)
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 19, 12))
+>x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 19, 53))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 19, 53))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 19, 53))
 >undefined : Symbol(undefined)
@@ -91,10 +97,12 @@ var e = fun(x => { x<number>(undefined); return x; }, x => { x<number>(undefined
 var f = fun((x => { x<number>(undefined); return x; }),(x => { x<number>(undefined); return x; }), 10);
 >f : Symbol(f, Decl(parenthesizedContexualTyping2.ts, 20, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping2.ts, 6, 48), Decl(parenthesizedContexualTyping2.ts, 8, 38), Decl(parenthesizedContexualTyping2.ts, 9, 51))
+>x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 20, 13))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 20, 13))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 20, 13))
 >undefined : Symbol(undefined)
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 20, 13))
+>x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 20, 56))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 20, 56))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 20, 56))
 >undefined : Symbol(undefined)
@@ -103,10 +111,12 @@ var f = fun((x => { x<number>(undefined); return x; }),(x => { x<number>(undefin
 var g = fun(((x => { x<number>(undefined); return x; })),((x => { x<number>(undefined); return x; })), 10);
 >g : Symbol(g, Decl(parenthesizedContexualTyping2.ts, 21, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping2.ts, 6, 48), Decl(parenthesizedContexualTyping2.ts, 8, 38), Decl(parenthesizedContexualTyping2.ts, 9, 51))
+>x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 21, 14))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 21, 14))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 21, 14))
 >undefined : Symbol(undefined)
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 21, 14))
+>x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 21, 59))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 21, 59))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 21, 59))
 >undefined : Symbol(undefined)
@@ -115,10 +125,12 @@ var g = fun(((x => { x<number>(undefined); return x; })),((x => { x<number>(unde
 var h = fun((((x => { x<number>(undefined); return x; }))),((x => { x<number>(undefined); return x; })), 10);
 >h : Symbol(h, Decl(parenthesizedContexualTyping2.ts, 22, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping2.ts, 6, 48), Decl(parenthesizedContexualTyping2.ts, 8, 38), Decl(parenthesizedContexualTyping2.ts, 9, 51))
+>x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 22, 15))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 22, 15))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 22, 15))
 >undefined : Symbol(undefined)
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 22, 15))
+>x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 22, 61))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 22, 61))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 22, 61))
 >undefined : Symbol(undefined)
@@ -131,10 +143,12 @@ var i = fun((Math.random() < 0.5 ? x => { x<number>(undefined); return x; } : x
 >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 >Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
+>x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 25, 34))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 25, 34))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 25, 34))
 >undefined : Symbol(undefined)
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 25, 34))
+>x => undefined : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 25, 77))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 25, 77))
 >undefined : Symbol(undefined)
 
@@ -144,10 +158,12 @@ var j = fun((Math.random() < 0.5 ? (x => { x<number>(undefined); return x; }) :
 >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 >Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
+>x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 26, 36))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 26, 36))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 26, 36))
 >undefined : Symbol(undefined)
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 26, 36))
+>x => undefined : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 26, 81))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 26, 81))
 >undefined : Symbol(undefined)
 
@@ -157,12 +173,15 @@ var k = fun((Math.random() < 0.5 ? (x => { x<number>(undefined); return x; }) :
 >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 >Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
+>x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 27, 36))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 27, 36))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 27, 36))
 >undefined : Symbol(undefined)
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 27, 36))
+>x => undefined : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 27, 81))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 27, 81))
 >undefined : Symbol(undefined)
+>x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 27, 98))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 27, 98))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 27, 98))
 >undefined : Symbol(undefined)
@@ -174,12 +193,15 @@ var l = fun(((Math.random() < 0.5 ? ((x => { x<number>(undefined); return x; }))
 >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 >Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
+>x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 28, 38))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 28, 38))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 28, 38))
 >undefined : Symbol(undefined)
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 28, 38))
+>x => undefined : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 28, 85))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 28, 85))
 >undefined : Symbol(undefined)
+>x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 28, 106))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 28, 106))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 28, 106))
 >undefined : Symbol(undefined)
@@ -188,6 +210,7 @@ var l = fun(((Math.random() < 0.5 ? ((x => { x<number>(undefined); return x; }))
 var lambda1: FuncType = x => { x<number>(undefined); return x; };
 >lambda1 : Symbol(lambda1, Decl(parenthesizedContexualTyping2.ts, 30, 3))
 >FuncType : Symbol(FuncType, Decl(parenthesizedContexualTyping2.ts, 0, 0))
+>x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 30, 23))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 30, 23))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 30, 23))
 >undefined : Symbol(undefined)
@@ -196,6 +219,7 @@ var lambda1: FuncType = x => { x<number>(undefined); return x; };
 var lambda2: FuncType = (x => { x<number>(undefined); return x; });
 >lambda2 : Symbol(lambda2, Decl(parenthesizedContexualTyping2.ts, 31, 3))
 >FuncType : Symbol(FuncType, Decl(parenthesizedContexualTyping2.ts, 0, 0))
+>x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 31, 25))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 31, 25))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 31, 25))
 >undefined : Symbol(undefined)
@@ -211,11 +235,14 @@ type ObjType = { x: (p: number) => string; y: (p: string) => number };
 var obj1: ObjType = { x: x => (x, undefined), y: y => (y, undefined) };
 >obj1 : Symbol(obj1, Decl(parenthesizedContexualTyping2.ts, 34, 3))
 >ObjType : Symbol(ObjType, Decl(parenthesizedContexualTyping2.ts, 31, 67))
+>{ x: x => (x, undefined), y: y => (y, undefined) } : Symbol(, Decl(parenthesizedContexualTyping2.ts, 34, 19))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 34, 21))
+>x => (x, undefined) : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 34, 24))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 34, 24))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 34, 24))
 >undefined : Symbol(undefined)
 >y : Symbol(y, Decl(parenthesizedContexualTyping2.ts, 34, 45))
+>y => (y, undefined) : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 34, 48))
 >y : Symbol(y, Decl(parenthesizedContexualTyping2.ts, 34, 48))
 >y : Symbol(y, Decl(parenthesizedContexualTyping2.ts, 34, 48))
 >undefined : Symbol(undefined)
@@ -223,11 +250,14 @@ var obj1: ObjType = { x: x => (x, undefined), y: y => (y, undefined) };
 var obj2: ObjType = ({ x: x => (x, undefined), y: y => (y, undefined) });
 >obj2 : Symbol(obj2, Decl(parenthesizedContexualTyping2.ts, 35, 3))
 >ObjType : Symbol(ObjType, Decl(parenthesizedContexualTyping2.ts, 31, 67))
+>{ x: x => (x, undefined), y: y => (y, undefined) } : Symbol(, Decl(parenthesizedContexualTyping2.ts, 35, 21))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 35, 22))
+>x => (x, undefined) : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 35, 25))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 35, 25))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 35, 25))
 >undefined : Symbol(undefined)
 >y : Symbol(y, Decl(parenthesizedContexualTyping2.ts, 35, 46))
+>y => (y, undefined) : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 35, 49))
 >y : Symbol(y, Decl(parenthesizedContexualTyping2.ts, 35, 49))
 >y : Symbol(y, Decl(parenthesizedContexualTyping2.ts, 35, 49))
 >undefined : Symbol(undefined)
diff --git a/tests/baselines/reference/parenthesizedContexualTyping3.symbols b/tests/baselines/reference/parenthesizedContexualTyping3.symbols
index b0d696e2d210b..aa6cc2e153011 100644
--- a/tests/baselines/reference/parenthesizedContexualTyping3.symbols
+++ b/tests/baselines/reference/parenthesizedContexualTyping3.symbols
@@ -56,58 +56,71 @@ function tempFun<T>(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T {
 var a = tempFun `${ x => x }  ${ 10 }`
 >a : Symbol(a, Decl(parenthesizedContexualTyping3.ts, 12, 3))
 >tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93))
+>x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping3.ts, 12, 19))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 12, 19))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 12, 19))
 
 var b = tempFun `${ (x => x) }  ${ 10 }`
 >b : Symbol(b, Decl(parenthesizedContexualTyping3.ts, 13, 3))
 >tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93))
+>x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping3.ts, 13, 21))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 13, 21))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 13, 21))
 
 var c = tempFun `${ ((x => x)) } ${ 10 }`
 >c : Symbol(c, Decl(parenthesizedContexualTyping3.ts, 14, 3))
 >tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93))
+>x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping3.ts, 14, 22))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 14, 22))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 14, 22))
 
 var d = tempFun `${ x => x } ${ x => x } ${ 10 }`
 >d : Symbol(d, Decl(parenthesizedContexualTyping3.ts, 15, 3))
 >tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93))
+>x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping3.ts, 15, 19))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 15, 19))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 15, 19))
+>x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping3.ts, 15, 31))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 15, 31))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 15, 31))
 
 var e = tempFun `${ x => x } ${ (x => x) } ${ 10 }`
 >e : Symbol(e, Decl(parenthesizedContexualTyping3.ts, 16, 3))
 >tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93))
+>x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping3.ts, 16, 19))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 16, 19))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 16, 19))
+>x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping3.ts, 16, 33))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 16, 33))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 16, 33))
 
 var f = tempFun `${ x => x } ${ ((x => x)) } ${ 10 }`
 >f : Symbol(f, Decl(parenthesizedContexualTyping3.ts, 17, 3))
 >tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93))
+>x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping3.ts, 17, 19))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 17, 19))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 17, 19))
+>x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping3.ts, 17, 34))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 17, 34))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 17, 34))
 
 var g = tempFun `${ (x => x) } ${ (((x => x))) } ${ 10 }`
 >g : Symbol(g, Decl(parenthesizedContexualTyping3.ts, 18, 3))
 >tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93))
+>x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping3.ts, 18, 21))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 18, 21))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 18, 21))
+>x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping3.ts, 18, 37))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 18, 37))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 18, 37))
 
 var h = tempFun `${ (x => x) } ${ (((x => x))) } ${ undefined }`
 >h : Symbol(h, Decl(parenthesizedContexualTyping3.ts, 19, 3))
 >tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93))
+>x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping3.ts, 19, 21))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 19, 21))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 19, 21))
+>x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping3.ts, 19, 37))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 19, 37))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 19, 37))
 >undefined : Symbol(undefined)
diff --git a/tests/baselines/reference/parserAccessors4.symbols b/tests/baselines/reference/parserAccessors4.symbols
index e5dc9f1ecc3a9..2f35ef8c53ffb 100644
--- a/tests/baselines/reference/parserAccessors4.symbols
+++ b/tests/baselines/reference/parserAccessors4.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/parser/ecmascript5/Accessors/parserAccessors4.ts ===
 var v = { set Foo(a) { } };
 >v : Symbol(v, Decl(parserAccessors4.ts, 0, 3))
+>{ set Foo(a) { } } : Symbol(, Decl(parserAccessors4.ts, 0, 7))
 >Foo : Symbol(Foo, Decl(parserAccessors4.ts, 0, 9))
 >a : Symbol(a, Decl(parserAccessors4.ts, 0, 18))
 
diff --git a/tests/baselines/reference/parserFunctionPropertyAssignment1.symbols b/tests/baselines/reference/parserFunctionPropertyAssignment1.symbols
index 01b555c5e8583..b93b6129b653b 100644
--- a/tests/baselines/reference/parserFunctionPropertyAssignment1.symbols
+++ b/tests/baselines/reference/parserFunctionPropertyAssignment1.symbols
@@ -1,5 +1,6 @@
 === tests/cases/conformance/parser/ecmascript5/PropertyAssignments/parserFunctionPropertyAssignment1.ts ===
 var v = { foo() { } };
 >v : Symbol(v, Decl(parserFunctionPropertyAssignment1.ts, 0, 3))
+>{ foo() { } } : Symbol(, Decl(parserFunctionPropertyAssignment1.ts, 0, 7))
 >foo : Symbol(foo, Decl(parserFunctionPropertyAssignment1.ts, 0, 9))
 
diff --git a/tests/baselines/reference/parserFunctionPropertyAssignment2.symbols b/tests/baselines/reference/parserFunctionPropertyAssignment2.symbols
index 3cd2d8ab32557..fee84294b7190 100644
--- a/tests/baselines/reference/parserFunctionPropertyAssignment2.symbols
+++ b/tests/baselines/reference/parserFunctionPropertyAssignment2.symbols
@@ -1,4 +1,5 @@
 === tests/cases/conformance/parser/ecmascript5/PropertyAssignments/parserFunctionPropertyAssignment2.ts ===
 var v = { 0() { } };
 >v : Symbol(v, Decl(parserFunctionPropertyAssignment2.ts, 0, 3))
+>{ 0() { } } : Symbol(, Decl(parserFunctionPropertyAssignment2.ts, 0, 7))
 
diff --git a/tests/baselines/reference/parserFunctionPropertyAssignment3.symbols b/tests/baselines/reference/parserFunctionPropertyAssignment3.symbols
index 9b3135c5ed029..7d8ebb63ae3ab 100644
--- a/tests/baselines/reference/parserFunctionPropertyAssignment3.symbols
+++ b/tests/baselines/reference/parserFunctionPropertyAssignment3.symbols
@@ -1,4 +1,5 @@
 === tests/cases/conformance/parser/ecmascript5/PropertyAssignments/parserFunctionPropertyAssignment3.ts ===
 var v = { "foo"() { } };
 >v : Symbol(v, Decl(parserFunctionPropertyAssignment3.ts, 0, 3))
+>{ "foo"() { } } : Symbol(, Decl(parserFunctionPropertyAssignment3.ts, 0, 7))
 
diff --git a/tests/baselines/reference/parserFunctionPropertyAssignment4.symbols b/tests/baselines/reference/parserFunctionPropertyAssignment4.symbols
index 2cb8b652e33a8..b560ff6765842 100644
--- a/tests/baselines/reference/parserFunctionPropertyAssignment4.symbols
+++ b/tests/baselines/reference/parserFunctionPropertyAssignment4.symbols
@@ -1,5 +1,6 @@
 === tests/cases/conformance/parser/ecmascript5/PropertyAssignments/parserFunctionPropertyAssignment4.ts ===
 var v = { 0<T>() { } };
 >v : Symbol(v, Decl(parserFunctionPropertyAssignment4.ts, 0, 3))
+>{ 0<T>() { } } : Symbol(, Decl(parserFunctionPropertyAssignment4.ts, 0, 7))
 >T : Symbol(T, Decl(parserFunctionPropertyAssignment4.ts, 0, 12))
 
diff --git a/tests/baselines/reference/parserKeywordsAsIdentifierName1.symbols b/tests/baselines/reference/parserKeywordsAsIdentifierName1.symbols
index 67420930affce..14a4bf4c1f437 100644
--- a/tests/baselines/reference/parserKeywordsAsIdentifierName1.symbols
+++ b/tests/baselines/reference/parserKeywordsAsIdentifierName1.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/parser/ecmascript5/parserKeywordsAsIdentifierName1.ts ===
 var big = {
 >big : Symbol(big, Decl(parserKeywordsAsIdentifierName1.ts, 0, 3))
+>{   break : 0,   super : 0,   const : 0} : Symbol(, Decl(parserKeywordsAsIdentifierName1.ts, 0, 9))
 
    break : 0,
 >break : Symbol(break, Decl(parserKeywordsAsIdentifierName1.ts, 0, 11))
diff --git a/tests/baselines/reference/parserObjectLiterals1.symbols b/tests/baselines/reference/parserObjectLiterals1.symbols
index 602c2dd5a3acd..337171fcd12c2 100644
--- a/tests/baselines/reference/parserObjectLiterals1.symbols
+++ b/tests/baselines/reference/parserObjectLiterals1.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/parser/ecmascript5/ObjectLiterals/parserObjectLiterals1.ts ===
 var v = { a: 1, b: 2 };
 >v : Symbol(v, Decl(parserObjectLiterals1.ts, 0, 3))
+>{ a: 1, b: 2 } : Symbol(, Decl(parserObjectLiterals1.ts, 0, 7))
 >a : Symbol(a, Decl(parserObjectLiterals1.ts, 0, 9))
 >b : Symbol(b, Decl(parserObjectLiterals1.ts, 0, 15))
 
diff --git a/tests/baselines/reference/parserX_ArrowFunction4.symbols b/tests/baselines/reference/parserX_ArrowFunction4.symbols
index bc1838dca4481..522b51de2fb4a 100644
--- a/tests/baselines/reference/parserX_ArrowFunction4.symbols
+++ b/tests/baselines/reference/parserX_ArrowFunction4.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrowFunctions/parserX_ArrowFunction4.ts ===
 var v = (a, b) => {
 >v : Symbol(v, Decl(parserX_ArrowFunction4.ts, 0, 3))
+>(a, b) => {   } : Symbol((Anonymous function), Decl(parserX_ArrowFunction4.ts, 0, 7))
 >a : Symbol(a, Decl(parserX_ArrowFunction4.ts, 0, 9))
 >b : Symbol(b, Decl(parserX_ArrowFunction4.ts, 0, 11))
    
diff --git a/tests/baselines/reference/plusOperatorWithBooleanType.symbols b/tests/baselines/reference/plusOperatorWithBooleanType.symbols
index d8c6beda3bc36..f2771db44b791 100644
--- a/tests/baselines/reference/plusOperatorWithBooleanType.symbols
+++ b/tests/baselines/reference/plusOperatorWithBooleanType.symbols
@@ -37,6 +37,7 @@ var ResultIsNumber2 = +true;
 
 var ResultIsNumber3 = +{ x: true, y: false };
 >ResultIsNumber3 : Symbol(ResultIsNumber3, Decl(plusOperatorWithBooleanType.ts, 20, 3))
+>{ x: true, y: false } : Symbol(, Decl(plusOperatorWithBooleanType.ts, 20, 23))
 >x : Symbol(x, Decl(plusOperatorWithBooleanType.ts, 20, 24))
 >y : Symbol(y, Decl(plusOperatorWithBooleanType.ts, 20, 33))
 
diff --git a/tests/baselines/reference/plusOperatorWithNumberType.symbols b/tests/baselines/reference/plusOperatorWithNumberType.symbols
index fd62582515edd..7eda860a9a421 100644
--- a/tests/baselines/reference/plusOperatorWithNumberType.symbols
+++ b/tests/baselines/reference/plusOperatorWithNumberType.symbols
@@ -44,13 +44,16 @@ var ResultIsNumber3 = +1;
 
 var ResultIsNumber4 = +{ x: 1, y: 2};
 >ResultIsNumber4 : Symbol(ResultIsNumber4, Decl(plusOperatorWithNumberType.ts, 22, 3))
+>{ x: 1, y: 2} : Symbol(, Decl(plusOperatorWithNumberType.ts, 22, 23))
 >x : Symbol(x, Decl(plusOperatorWithNumberType.ts, 22, 24))
 >y : Symbol(y, Decl(plusOperatorWithNumberType.ts, 22, 30))
 
 var ResultIsNumber5 = +{ x: 1, y: (n: number) => { return n; } };
 >ResultIsNumber5 : Symbol(ResultIsNumber5, Decl(plusOperatorWithNumberType.ts, 23, 3))
+>{ x: 1, y: (n: number) => { return n; } } : Symbol(, Decl(plusOperatorWithNumberType.ts, 23, 23))
 >x : Symbol(x, Decl(plusOperatorWithNumberType.ts, 23, 24))
 >y : Symbol(y, Decl(plusOperatorWithNumberType.ts, 23, 30))
+>(n: number) => { return n; } : Symbol((Anonymous function), Decl(plusOperatorWithNumberType.ts, 23, 33))
 >n : Symbol(n, Decl(plusOperatorWithNumberType.ts, 23, 35))
 >n : Symbol(n, Decl(plusOperatorWithNumberType.ts, 23, 35))
 
diff --git a/tests/baselines/reference/plusOperatorWithStringType.symbols b/tests/baselines/reference/plusOperatorWithStringType.symbols
index 1ff2cec5dff7b..c510bb8aa870f 100644
--- a/tests/baselines/reference/plusOperatorWithStringType.symbols
+++ b/tests/baselines/reference/plusOperatorWithStringType.symbols
@@ -44,13 +44,16 @@ var ResultIsNumber3 = +"";
 
 var ResultIsNumber4 = +{ x: "", y: "" };
 >ResultIsNumber4 : Symbol(ResultIsNumber4, Decl(plusOperatorWithStringType.ts, 22, 3))
+>{ x: "", y: "" } : Symbol(, Decl(plusOperatorWithStringType.ts, 22, 23))
 >x : Symbol(x, Decl(plusOperatorWithStringType.ts, 22, 24))
 >y : Symbol(y, Decl(plusOperatorWithStringType.ts, 22, 31))
 
 var ResultIsNumber5 = +{ x: "", y: (s: string) => { return s; } };
 >ResultIsNumber5 : Symbol(ResultIsNumber5, Decl(plusOperatorWithStringType.ts, 23, 3))
+>{ x: "", y: (s: string) => { return s; } } : Symbol(, Decl(plusOperatorWithStringType.ts, 23, 23))
 >x : Symbol(x, Decl(plusOperatorWithStringType.ts, 23, 24))
 >y : Symbol(y, Decl(plusOperatorWithStringType.ts, 23, 31))
+>(s: string) => { return s; } : Symbol((Anonymous function), Decl(plusOperatorWithStringType.ts, 23, 34))
 >s : Symbol(s, Decl(plusOperatorWithStringType.ts, 23, 36))
 >s : Symbol(s, Decl(plusOperatorWithStringType.ts, 23, 36))
 
diff --git a/tests/baselines/reference/prespecializedGenericMembers1.symbols b/tests/baselines/reference/prespecializedGenericMembers1.symbols
index b95432a5fded2..17a8133baea06 100644
--- a/tests/baselines/reference/prespecializedGenericMembers1.symbols
+++ b/tests/baselines/reference/prespecializedGenericMembers1.symbols
@@ -32,6 +32,7 @@ var cat = new Cat<IKitty>();
 
 var catThing = {
 >catThing : Symbol(catThing, Decl(prespecializedGenericMembers1.ts, 16, 3))
+>{    barry: cat} : Symbol(, Decl(prespecializedGenericMembers1.ts, 16, 14))
 
     barry: cat
 >barry : Symbol(barry, Decl(prespecializedGenericMembers1.ts, 16, 16))
diff --git a/tests/baselines/reference/privacyAccessorDeclFile.symbols b/tests/baselines/reference/privacyAccessorDeclFile.symbols
new file mode 100644
index 0000000000000..4437ae0b29919
--- /dev/null
+++ b/tests/baselines/reference/privacyAccessorDeclFile.symbols
@@ -0,0 +1,2217 @@
+=== tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts ===
+
+class privateClass {
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
+}
+
+export class publicClass {
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
+}
+
+export class publicClassWithWithPrivateGetAccessorTypes {
+>publicClassWithWithPrivateGetAccessorTypes : Symbol(publicClassWithWithPrivateGetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 5, 1))
+
+    static get myPublicStaticMethod(): privateClass { // Error
+>myPublicStaticMethod : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 7, 57))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
+
+        return null;
+    }
+    private static get myPrivateStaticMethod(): privateClass {
+>myPrivateStaticMethod : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 10, 5))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
+
+        return null;
+    }
+    get myPublicMethod(): privateClass { // Error
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 13, 5))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
+
+        return null;
+    }
+    private get myPrivateMethod(): privateClass {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 16, 5))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
+
+        return null;
+    }
+    static get myPublicStaticMethod1() { // Error
+>myPublicStaticMethod1 : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 19, 5))
+
+        return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
+    }
+    private static get myPrivateStaticMethod1() {
+>myPrivateStaticMethod1 : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 22, 5))
+
+        return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
+    }
+    get myPublicMethod1() { // Error
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 25, 5))
+
+        return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
+    }
+    private get myPrivateMethod1() {
+>myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 28, 5))
+
+        return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
+    }
+}
+
+export class publicClassWithWithPublicGetAccessorTypes {
+>publicClassWithWithPublicGetAccessorTypes : Symbol(publicClassWithWithPublicGetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 32, 1))
+
+    static get myPublicStaticMethod(): publicClass {
+>myPublicStaticMethod : Symbol(publicClassWithWithPublicGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 34, 56))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
+
+        return null;
+    }
+    private static get myPrivateStaticMethod(): publicClass {
+>myPrivateStaticMethod : Symbol(publicClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 37, 5))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
+
+        return null;
+    }
+    get myPublicMethod(): publicClass {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 40, 5))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
+
+        return null;
+    }
+    private get myPrivateMethod(): publicClass {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 43, 5))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
+
+        return null;
+    }
+    static get myPublicStaticMethod1() {
+>myPublicStaticMethod1 : Symbol(publicClassWithWithPublicGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 46, 5))
+
+        return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
+    }
+    private static get myPrivateStaticMethod1() {
+>myPrivateStaticMethod1 : Symbol(publicClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 49, 5))
+
+        return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
+    }
+    get myPublicMethod1() {
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 52, 5))
+
+        return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
+    }
+    private get myPrivateMethod1() {
+>myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 55, 5))
+
+        return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
+    }
+}
+
+class privateClassWithWithPrivateGetAccessorTypes {
+>privateClassWithWithPrivateGetAccessorTypes : Symbol(privateClassWithWithPrivateGetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 59, 1))
+
+    static get myPublicStaticMethod(): privateClass {
+>myPublicStaticMethod : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 61, 51))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
+
+        return null;
+    }
+    private static get myPrivateStaticMethod(): privateClass {
+>myPrivateStaticMethod : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 64, 5))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
+
+        return null;
+    }
+    get myPublicMethod(): privateClass {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 67, 5))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
+
+        return null;
+    }
+    private get myPrivateMethod(): privateClass {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 70, 5))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
+
+        return null;
+    }
+    static get myPublicStaticMethod1() {
+>myPublicStaticMethod1 : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 73, 5))
+
+        return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
+    }
+    private static get myPrivateStaticMethod1() {
+>myPrivateStaticMethod1 : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 76, 5))
+
+        return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
+    }
+    get myPublicMethod1() {
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 79, 5))
+
+        return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
+    }
+    private get myPrivateMethod1() {
+>myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 82, 5))
+
+        return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
+    }
+}
+
+class privateClassWithWithPublicGetAccessorTypes {
+>privateClassWithWithPublicGetAccessorTypes : Symbol(privateClassWithWithPublicGetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 86, 1))
+
+    static get myPublicStaticMethod(): publicClass {
+>myPublicStaticMethod : Symbol(privateClassWithWithPublicGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 88, 50))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
+
+        return null;
+    }
+    private static get myPrivateStaticMethod(): publicClass {
+>myPrivateStaticMethod : Symbol(privateClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 91, 5))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
+
+        return null;
+    }
+    get myPublicMethod(): publicClass {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 94, 5))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
+
+        return null;
+    }
+    private get myPrivateMethod(): publicClass {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 97, 5))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
+
+        return null;
+    }
+    static get myPublicStaticMethod1() {
+>myPublicStaticMethod1 : Symbol(privateClassWithWithPublicGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 100, 5))
+
+        return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
+    }
+    private static get myPrivateStaticMethod1() {
+>myPrivateStaticMethod1 : Symbol(privateClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 103, 5))
+
+        return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
+    }
+    get myPublicMethod1() {
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 106, 5))
+
+        return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
+    }
+    private get myPrivateMethod1() {
+>myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 109, 5))
+
+        return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
+    }
+}
+
+export class publicClassWithWithPrivateSetAccessorTypes {
+>publicClassWithWithPrivateSetAccessorTypes : Symbol(publicClassWithWithPrivateSetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 113, 1))
+
+    static set myPublicStaticMethod(param: privateClass) { // Error
+>myPublicStaticMethod : Symbol(publicClassWithWithPrivateSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 115, 57))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 116, 36))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
+    }
+    private static set myPrivateStaticMethod(param: privateClass) {
+>myPrivateStaticMethod : Symbol(publicClassWithWithPrivateSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 117, 5))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 118, 45))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
+    }
+    set myPublicMethod(param: privateClass) { // Error
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 119, 5))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 120, 23))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
+    }
+    private set myPrivateMethod(param: privateClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 121, 5))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 122, 32))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
+    }
+}
+
+export class publicClassWithWithPublicSetAccessorTypes {
+>publicClassWithWithPublicSetAccessorTypes : Symbol(publicClassWithWithPublicSetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 124, 1))
+
+    static set myPublicStaticMethod(param: publicClass) {
+>myPublicStaticMethod : Symbol(publicClassWithWithPublicSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 126, 56))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 127, 36))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
+    }
+    private static set myPrivateStaticMethod(param: publicClass) {
+>myPrivateStaticMethod : Symbol(publicClassWithWithPublicSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 128, 5))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 129, 45))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
+    }
+    set myPublicMethod(param: publicClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 130, 5))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 131, 23))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
+    }
+    private set myPrivateMethod(param: publicClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 132, 5))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 133, 32))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
+    }
+}
+
+class privateClassWithWithPrivateSetAccessorTypes {
+>privateClassWithWithPrivateSetAccessorTypes : Symbol(privateClassWithWithPrivateSetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 135, 1))
+
+    static set myPublicStaticMethod(param: privateClass) {
+>myPublicStaticMethod : Symbol(privateClassWithWithPrivateSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 137, 51))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 138, 36))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
+    }
+    private static set myPrivateStaticMethod(param: privateClass) {
+>myPrivateStaticMethod : Symbol(privateClassWithWithPrivateSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 139, 5))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 140, 45))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
+    }
+    set myPublicMethod(param: privateClass) { 
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 141, 5))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 142, 23))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
+    }
+    private set myPrivateMethod(param: privateClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 143, 5))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 144, 32))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
+    }
+}
+
+class privateClassWithWithPublicSetAccessorTypes {
+>privateClassWithWithPublicSetAccessorTypes : Symbol(privateClassWithWithPublicSetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 146, 1))
+
+    static set myPublicStaticMethod(param: publicClass) {
+>myPublicStaticMethod : Symbol(privateClassWithWithPublicSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 148, 50))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 149, 36))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
+    }
+    private static set myPrivateStaticMethod(param: publicClass) {
+>myPrivateStaticMethod : Symbol(privateClassWithWithPublicSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 150, 5))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 151, 45))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
+    }
+    set myPublicMethod(param: publicClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 152, 5))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 153, 23))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
+    }
+    private set myPrivateMethod(param: publicClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 154, 5))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 155, 32))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
+    }
+}
+
+export class publicClassWithPrivateModuleGetAccessorTypes {
+>publicClassWithPrivateModuleGetAccessorTypes : Symbol(publicClassWithPrivateModuleGetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 157, 1))
+
+    static get myPublicStaticMethod(): privateModule.publicClass { // Error
+>myPublicStaticMethod : Symbol(publicClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 159, 59))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+
+        return null;
+    }
+    get myPublicMethod(): privateModule.publicClass { // Error
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 162, 5))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+
+        return null;
+    }
+    static get myPublicStaticMethod1() { // Error
+>myPublicStaticMethod1 : Symbol(publicClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 165, 5))
+
+        return new privateModule.publicClass();
+>privateModule.publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+    }
+    get myPublicMethod1() { // Error
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 168, 5))
+
+        return new privateModule.publicClass();
+>privateModule.publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+    }
+}
+
+export class publicClassWithPrivateModuleSetAccessorTypes {
+>publicClassWithPrivateModuleSetAccessorTypes : Symbol(publicClassWithPrivateModuleSetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 172, 1))
+
+    static set myPublicStaticMethod(param: privateModule.publicClass) { // Error
+>myPublicStaticMethod : Symbol(publicClassWithPrivateModuleSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 174, 59))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 175, 36))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+    }
+    set myPublicMethod(param: privateModule.publicClass) { // Error
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 176, 5))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 177, 23))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+    }
+}
+
+class privateClassWithPrivateModuleGetAccessorTypes {
+>privateClassWithPrivateModuleGetAccessorTypes : Symbol(privateClassWithPrivateModuleGetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 179, 1))
+
+    static get myPublicStaticMethod(): privateModule.publicClass {
+>myPublicStaticMethod : Symbol(privateClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 181, 53))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+
+        return null;
+    }
+    get myPublicMethod(): privateModule.publicClass {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 184, 5))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+
+        return null;
+    }
+    static get myPublicStaticMethod1() {
+>myPublicStaticMethod1 : Symbol(privateClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 187, 5))
+
+        return new privateModule.publicClass();
+>privateModule.publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+    }
+    get myPublicMethod1() {
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 190, 5))
+
+        return new privateModule.publicClass();
+>privateModule.publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+    }
+}
+
+class privateClassWithPrivateModuleSetAccessorTypes {
+>privateClassWithPrivateModuleSetAccessorTypes : Symbol(privateClassWithPrivateModuleSetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 194, 1))
+
+    static set myPublicStaticMethod(param: privateModule.publicClass) {
+>myPublicStaticMethod : Symbol(privateClassWithPrivateModuleSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 196, 53))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 197, 36))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+    }
+    set myPublicMethod(param: privateModule.publicClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 198, 5))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 199, 23))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+    }
+}
+
+export module publicModule {
+>publicModule : Symbol(publicModule, Decl(privacyAccessorDeclFile_externalModule.ts, 201, 1))
+
+    class privateClass {
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
+    }
+
+    export class publicClass {
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
+    }
+    export class publicClassWithWithPrivateGetAccessorTypes {
+>publicClassWithWithPrivateGetAccessorTypes : Symbol(publicClassWithWithPrivateGetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 208, 5))
+
+        static get myPublicStaticMethod(): privateClass { // Error
+>myPublicStaticMethod : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 209, 61))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
+
+            return null;
+        }
+        private static get myPrivateStaticMethod(): privateClass {
+>myPrivateStaticMethod : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 212, 9))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
+
+            return null;
+        }
+        get myPublicMethod(): privateClass { // Error
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 215, 9))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
+
+            return null;
+        }
+        private get myPrivateMethod(): privateClass {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 218, 9))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
+
+            return null;
+        }
+        static get myPublicStaticMethod1() { // Error
+>myPublicStaticMethod1 : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 221, 9))
+
+            return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
+        }
+        private static get myPrivateStaticMethod1() {
+>myPrivateStaticMethod1 : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 224, 9))
+
+            return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
+        }
+        get myPublicMethod1() { // Error
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 227, 9))
+
+            return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
+        }
+        private get myPrivateMethod1() {
+>myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 230, 9))
+
+            return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
+        }
+    }
+
+    export class publicClassWithWithPublicGetAccessorTypes {
+>publicClassWithWithPublicGetAccessorTypes : Symbol(publicClassWithWithPublicGetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 234, 5))
+
+        static get myPublicStaticMethod(): publicClass {
+>myPublicStaticMethod : Symbol(publicClassWithWithPublicGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 236, 60))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
+
+            return null;
+        }
+        private static get myPrivateStaticMethod(): publicClass {
+>myPrivateStaticMethod : Symbol(publicClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 239, 9))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
+
+            return null;
+        }
+        get myPublicMethod(): publicClass {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 242, 9))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
+
+            return null;
+        }
+        private get myPrivateMethod(): publicClass {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 245, 9))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
+
+            return null;
+        }
+        static get myPublicStaticMethod1() {
+>myPublicStaticMethod1 : Symbol(publicClassWithWithPublicGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 248, 9))
+
+            return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
+        }
+        private static get myPrivateStaticMethod1() {
+>myPrivateStaticMethod1 : Symbol(publicClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 251, 9))
+
+            return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
+        }
+        get myPublicMethod1() {
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 254, 9))
+
+            return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
+        }
+        private get myPrivateMethod1() {
+>myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 257, 9))
+
+            return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
+        }
+    }
+
+    class privateClassWithWithPrivateGetAccessorTypes {
+>privateClassWithWithPrivateGetAccessorTypes : Symbol(privateClassWithWithPrivateGetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 261, 5))
+
+        static get myPublicStaticMethod(): privateClass {
+>myPublicStaticMethod : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 263, 55))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
+
+            return null;
+        }
+        private static get myPrivateStaticMethod(): privateClass {
+>myPrivateStaticMethod : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 266, 9))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
+
+            return null;
+        }
+        get myPublicMethod(): privateClass {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 269, 9))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
+
+            return null;
+        }
+        private get myPrivateMethod(): privateClass {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 272, 9))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
+
+            return null;
+        }
+        static get myPublicStaticMethod1() {
+>myPublicStaticMethod1 : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 275, 9))
+
+            return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
+        }
+        private static get myPrivateStaticMethod1() {
+>myPrivateStaticMethod1 : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 278, 9))
+
+            return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
+        }
+        get myPublicMethod1() {
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 281, 9))
+
+            return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
+        }
+        private get myPrivateMethod1() {
+>myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 284, 9))
+
+            return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
+        }
+    }
+
+    class privateClassWithWithPublicGetAccessorTypes {
+>privateClassWithWithPublicGetAccessorTypes : Symbol(privateClassWithWithPublicGetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 288, 5))
+
+        static get myPublicStaticMethod(): publicClass {
+>myPublicStaticMethod : Symbol(privateClassWithWithPublicGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 290, 54))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
+
+            return null;
+        }
+        private static get myPrivateStaticMethod(): publicClass {
+>myPrivateStaticMethod : Symbol(privateClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 293, 9))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
+
+            return null;
+        }
+        get myPublicMethod(): publicClass {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 296, 9))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
+
+            return null;
+        }
+        private get myPrivateMethod(): publicClass {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 299, 9))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
+
+            return null;
+        }
+        static get myPublicStaticMethod1() {
+>myPublicStaticMethod1 : Symbol(privateClassWithWithPublicGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 302, 9))
+
+            return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
+        }
+        private static get myPrivateStaticMethod1() {
+>myPrivateStaticMethod1 : Symbol(privateClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 305, 9))
+
+            return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
+        }
+        get myPublicMethod1() {
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 308, 9))
+
+            return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
+        }
+        private get myPrivateMethod1() {
+>myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 311, 9))
+
+            return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
+        }
+    }
+
+    export class publicClassWithWithPrivateSetAccessorTypes {
+>publicClassWithWithPrivateSetAccessorTypes : Symbol(publicClassWithWithPrivateSetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 315, 5))
+
+        static set myPublicStaticMethod(param: privateClass) { // Error
+>myPublicStaticMethod : Symbol(publicClassWithWithPrivateSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 317, 61))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 318, 40))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
+        }
+        private static set myPrivateStaticMethod(param: privateClass) {
+>myPrivateStaticMethod : Symbol(publicClassWithWithPrivateSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 319, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 320, 49))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
+        }
+        set myPublicMethod(param: privateClass) { // Error
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 321, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 322, 27))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
+        }
+        private set myPrivateMethod(param: privateClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 323, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 324, 36))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
+        }
+    }
+
+    export class publicClassWithWithPublicSetAccessorTypes {
+>publicClassWithWithPublicSetAccessorTypes : Symbol(publicClassWithWithPublicSetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 326, 5))
+
+        static set myPublicStaticMethod(param: publicClass) {
+>myPublicStaticMethod : Symbol(publicClassWithWithPublicSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 328, 60))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 329, 40))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
+        }
+        private static set myPrivateStaticMethod(param: publicClass) {
+>myPrivateStaticMethod : Symbol(publicClassWithWithPublicSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 330, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 331, 49))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
+        }
+        set myPublicMethod(param: publicClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 332, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 333, 27))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
+        }
+        private set myPrivateMethod(param: publicClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 334, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 335, 36))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
+        }
+    }
+
+    class privateClassWithWithPrivateSetAccessorTypes {
+>privateClassWithWithPrivateSetAccessorTypes : Symbol(privateClassWithWithPrivateSetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 337, 5))
+
+        static set myPublicStaticMethod(param: privateClass) {
+>myPublicStaticMethod : Symbol(privateClassWithWithPrivateSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 339, 55))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 340, 40))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
+        }
+        private static set myPrivateStaticMethod(param: privateClass) {
+>myPrivateStaticMethod : Symbol(privateClassWithWithPrivateSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 341, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 342, 49))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
+        }
+        set myPublicMethod(param: privateClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 343, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 344, 27))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
+        }
+        private set myPrivateMethod(param: privateClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 345, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 346, 36))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
+        }
+    }
+
+    class privateClassWithWithPublicSetAccessorTypes {
+>privateClassWithWithPublicSetAccessorTypes : Symbol(privateClassWithWithPublicSetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 348, 5))
+
+        static set myPublicStaticMethod(param: publicClass) {
+>myPublicStaticMethod : Symbol(privateClassWithWithPublicSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 350, 54))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 351, 40))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
+        }
+        private static set myPrivateStaticMethod(param: publicClass) {
+>myPrivateStaticMethod : Symbol(privateClassWithWithPublicSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 352, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 353, 49))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
+        }
+        set myPublicMethod(param: publicClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 354, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 355, 27))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
+        }
+        private set myPrivateMethod(param: publicClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 356, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 357, 36))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
+        }
+    }
+
+    export class publicClassWithPrivateModuleGetAccessorTypes {
+>publicClassWithPrivateModuleGetAccessorTypes : Symbol(publicClassWithPrivateModuleGetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 359, 5))
+
+        static get myPublicStaticMethod(): privateModule.publicClass { // Error
+>myPublicStaticMethod : Symbol(publicClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 361, 63))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+
+            return null;
+        }
+        get myPublicMethod(): privateModule.publicClass { // Error
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 364, 9))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+
+            return null;
+        }
+        static get myPublicStaticMethod1() { // Error
+>myPublicStaticMethod1 : Symbol(publicClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 367, 9))
+
+            return new privateModule.publicClass();
+>privateModule.publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+        }
+        get myPublicMethod1() { // Error
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 370, 9))
+
+            return new privateModule.publicClass();
+>privateModule.publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+        }
+    }
+
+    export class publicClassWithPrivateModuleSetAccessorTypes {
+>publicClassWithPrivateModuleSetAccessorTypes : Symbol(publicClassWithPrivateModuleSetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 374, 5))
+
+        static set myPublicStaticMethod(param: privateModule.publicClass) { // Error
+>myPublicStaticMethod : Symbol(publicClassWithPrivateModuleSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 376, 63))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 377, 40))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+        }
+        set myPublicMethod(param: privateModule.publicClass) { // Error
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 378, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 379, 27))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+        }
+    }
+
+    class privateClassWithPrivateModuleGetAccessorTypes {
+>privateClassWithPrivateModuleGetAccessorTypes : Symbol(privateClassWithPrivateModuleGetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 381, 5))
+
+        static get myPublicStaticMethod(): privateModule.publicClass {
+>myPublicStaticMethod : Symbol(privateClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 383, 57))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+
+            return null;
+        }
+        get myPublicMethod(): privateModule.publicClass {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 386, 9))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+
+            return null;
+        }
+        static get myPublicStaticMethod1() {
+>myPublicStaticMethod1 : Symbol(privateClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 389, 9))
+
+            return new privateModule.publicClass();
+>privateModule.publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+        }
+        get myPublicMethod1() {
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 392, 9))
+
+            return new privateModule.publicClass();
+>privateModule.publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+        }
+    }
+
+    class privateClassWithPrivateModuleSetAccessorTypes {
+>privateClassWithPrivateModuleSetAccessorTypes : Symbol(privateClassWithPrivateModuleSetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 396, 5))
+
+        static set myPublicStaticMethod(param: privateModule.publicClass) {
+>myPublicStaticMethod : Symbol(privateClassWithPrivateModuleSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 398, 57))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 399, 40))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+        }
+        set myPublicMethod(param: privateModule.publicClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 400, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 401, 27))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+        }
+    }
+}
+
+module privateModule {
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
+
+    class privateClass {
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
+    }
+
+    export class publicClass {
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+    }
+    export class publicClassWithWithPrivateGetAccessorTypes {
+>publicClassWithWithPrivateGetAccessorTypes : Symbol(publicClassWithWithPrivateGetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 411, 5))
+
+        static get myPublicStaticMethod(): privateClass { 
+>myPublicStaticMethod : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 412, 61))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
+
+            return null;
+        }
+        private static get myPrivateStaticMethod(): privateClass {
+>myPrivateStaticMethod : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 415, 9))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
+
+            return null;
+        }
+        get myPublicMethod(): privateClass { 
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 418, 9))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
+
+            return null;
+        }
+        private get myPrivateMethod(): privateClass {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 421, 9))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
+
+            return null;
+        }
+        static get myPublicStaticMethod1() { 
+>myPublicStaticMethod1 : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 424, 9))
+
+            return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
+        }
+        private static get myPrivateStaticMethod1() {
+>myPrivateStaticMethod1 : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 427, 9))
+
+            return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
+        }
+        get myPublicMethod1() { 
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 430, 9))
+
+            return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
+        }
+        private get myPrivateMethod1() {
+>myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 433, 9))
+
+            return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
+        }
+    }
+
+    export class publicClassWithWithPublicGetAccessorTypes {
+>publicClassWithWithPublicGetAccessorTypes : Symbol(publicClassWithWithPublicGetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 437, 5))
+
+        static get myPublicStaticMethod(): publicClass {
+>myPublicStaticMethod : Symbol(publicClassWithWithPublicGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 439, 60))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+
+            return null;
+        }
+        private static get myPrivateStaticMethod(): publicClass {
+>myPrivateStaticMethod : Symbol(publicClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 442, 9))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+
+            return null;
+        }
+        get myPublicMethod(): publicClass {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 445, 9))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+
+            return null;
+        }
+        private get myPrivateMethod(): publicClass {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 448, 9))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+
+            return null;
+        }
+        static get myPublicStaticMethod1() {
+>myPublicStaticMethod1 : Symbol(publicClassWithWithPublicGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 451, 9))
+
+            return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+        }
+        private static get myPrivateStaticMethod1() {
+>myPrivateStaticMethod1 : Symbol(publicClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 454, 9))
+
+            return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+        }
+        get myPublicMethod1() {
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 457, 9))
+
+            return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+        }
+        private get myPrivateMethod1() {
+>myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 460, 9))
+
+            return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+        }
+    }
+
+    class privateClassWithWithPrivateGetAccessorTypes {
+>privateClassWithWithPrivateGetAccessorTypes : Symbol(privateClassWithWithPrivateGetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 464, 5))
+
+        static get myPublicStaticMethod(): privateClass {
+>myPublicStaticMethod : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 466, 55))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
+
+            return null;
+        }
+        private static get myPrivateStaticMethod(): privateClass {
+>myPrivateStaticMethod : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 469, 9))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
+
+            return null;
+        }
+        get myPublicMethod(): privateClass {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 472, 9))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
+
+            return null;
+        }
+        private get myPrivateMethod(): privateClass {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 475, 9))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
+
+            return null;
+        }
+        static get myPublicStaticMethod1() {
+>myPublicStaticMethod1 : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 478, 9))
+
+            return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
+        }
+        private static get myPrivateStaticMethod1() {
+>myPrivateStaticMethod1 : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 481, 9))
+
+            return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
+        }
+        get myPublicMethod1() {
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 484, 9))
+
+            return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
+        }
+        private get myPrivateMethod1() {
+>myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 487, 9))
+
+            return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
+        }
+    }
+
+    class privateClassWithWithPublicGetAccessorTypes {
+>privateClassWithWithPublicGetAccessorTypes : Symbol(privateClassWithWithPublicGetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 491, 5))
+
+        static get myPublicStaticMethod(): publicClass {
+>myPublicStaticMethod : Symbol(privateClassWithWithPublicGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 493, 54))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+
+            return null;
+        }
+        private static get myPrivateStaticMethod(): publicClass {
+>myPrivateStaticMethod : Symbol(privateClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 496, 9))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+
+            return null;
+        }
+        get myPublicMethod(): publicClass {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 499, 9))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+
+            return null;
+        }
+        private get myPrivateMethod(): publicClass {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 502, 9))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+
+            return null;
+        }
+        static get myPublicStaticMethod1() {
+>myPublicStaticMethod1 : Symbol(privateClassWithWithPublicGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 505, 9))
+
+            return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+        }
+        private static get myPrivateStaticMethod1() {
+>myPrivateStaticMethod1 : Symbol(privateClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 508, 9))
+
+            return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+        }
+        get myPublicMethod1() {
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 511, 9))
+
+            return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+        }
+        private get myPrivateMethod1() {
+>myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 514, 9))
+
+            return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+        }
+    }
+
+    export class publicClassWithWithPrivateSetAccessorTypes {
+>publicClassWithWithPrivateSetAccessorTypes : Symbol(publicClassWithWithPrivateSetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 518, 5))
+
+        static set myPublicStaticMethod(param: privateClass) { 
+>myPublicStaticMethod : Symbol(publicClassWithWithPrivateSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 520, 61))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 521, 40))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
+        }
+        private static set myPrivateStaticMethod(param: privateClass) {
+>myPrivateStaticMethod : Symbol(publicClassWithWithPrivateSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 522, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 523, 49))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
+        }
+        set myPublicMethod(param: privateClass) { 
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 524, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 525, 27))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
+        }
+        private set myPrivateMethod(param: privateClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 526, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 527, 36))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
+        }
+    }
+
+    export class publicClassWithWithPublicSetAccessorTypes {
+>publicClassWithWithPublicSetAccessorTypes : Symbol(publicClassWithWithPublicSetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 529, 5))
+
+        static set myPublicStaticMethod(param: publicClass) {
+>myPublicStaticMethod : Symbol(publicClassWithWithPublicSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 531, 60))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 532, 40))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+        }
+        private static set myPrivateStaticMethod(param: publicClass) {
+>myPrivateStaticMethod : Symbol(publicClassWithWithPublicSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 533, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 534, 49))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+        }
+        set myPublicMethod(param: publicClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 535, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 536, 27))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+        }
+        private set myPrivateMethod(param: publicClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 537, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 538, 36))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+        }
+    }
+
+    class privateClassWithWithPrivateSetAccessorTypes {
+>privateClassWithWithPrivateSetAccessorTypes : Symbol(privateClassWithWithPrivateSetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 540, 5))
+
+        static set myPublicStaticMethod(param: privateClass) {
+>myPublicStaticMethod : Symbol(privateClassWithWithPrivateSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 542, 55))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 543, 40))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
+        }
+        private static set myPrivateStaticMethod(param: privateClass) {
+>myPrivateStaticMethod : Symbol(privateClassWithWithPrivateSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 544, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 545, 49))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
+        }
+        set myPublicMethod(param: privateClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 546, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 547, 27))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
+        }
+        private set myPrivateMethod(param: privateClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 548, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 549, 36))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
+        }
+    }
+
+    class privateClassWithWithPublicSetAccessorTypes {
+>privateClassWithWithPublicSetAccessorTypes : Symbol(privateClassWithWithPublicSetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 551, 5))
+
+        static set myPublicStaticMethod(param: publicClass) {
+>myPublicStaticMethod : Symbol(privateClassWithWithPublicSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 553, 54))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 554, 40))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+        }
+        private static set myPrivateStaticMethod(param: publicClass) {
+>myPrivateStaticMethod : Symbol(privateClassWithWithPublicSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 555, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 556, 49))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+        }
+        set myPublicMethod(param: publicClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 557, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 558, 27))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+        }
+        private set myPrivateMethod(param: publicClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 559, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 560, 36))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+        }
+    }
+
+    export class publicClassWithPrivateModuleGetAccessorTypes {
+>publicClassWithPrivateModuleGetAccessorTypes : Symbol(publicClassWithPrivateModuleGetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 562, 5))
+
+        static get myPublicStaticMethod(): privateModule.publicClass { 
+>myPublicStaticMethod : Symbol(publicClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 564, 63))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+
+            return null;
+        }
+        get myPublicMethod(): privateModule.publicClass { 
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 567, 9))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+
+            return null;
+        }
+        static get myPublicStaticMethod1() { 
+>myPublicStaticMethod1 : Symbol(publicClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 570, 9))
+
+            return new privateModule.publicClass();
+>privateModule.publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+        }
+        get myPublicMethod1() { 
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 573, 9))
+
+            return new privateModule.publicClass();
+>privateModule.publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+        }
+    }
+
+    export class publicClassWithPrivateModuleSetAccessorTypes {
+>publicClassWithPrivateModuleSetAccessorTypes : Symbol(publicClassWithPrivateModuleSetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 577, 5))
+
+        static set myPublicStaticMethod(param: privateModule.publicClass) { 
+>myPublicStaticMethod : Symbol(publicClassWithPrivateModuleSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 579, 63))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 580, 40))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+        }
+        set myPublicMethod(param: privateModule.publicClass) { 
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 581, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 582, 27))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+        }
+    }
+
+    class privateClassWithPrivateModuleGetAccessorTypes {
+>privateClassWithPrivateModuleGetAccessorTypes : Symbol(privateClassWithPrivateModuleGetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 584, 5))
+
+        static get myPublicStaticMethod(): privateModule.publicClass {
+>myPublicStaticMethod : Symbol(privateClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 586, 57))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+
+            return null;
+        }
+        get myPublicMethod(): privateModule.publicClass {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 589, 9))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+
+            return null;
+        }
+        static get myPublicStaticMethod1() {
+>myPublicStaticMethod1 : Symbol(privateClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 592, 9))
+
+            return new privateModule.publicClass();
+>privateModule.publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+        }
+        get myPublicMethod1() {
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 595, 9))
+
+            return new privateModule.publicClass();
+>privateModule.publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+        }
+    }
+
+    class privateClassWithPrivateModuleSetAccessorTypes {
+>privateClassWithPrivateModuleSetAccessorTypes : Symbol(privateClassWithPrivateModuleSetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 599, 5))
+
+        static set myPublicStaticMethod(param: privateModule.publicClass) {
+>myPublicStaticMethod : Symbol(privateClassWithPrivateModuleSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 601, 57))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 602, 40))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+        }
+        set myPublicMethod(param: privateModule.publicClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 603, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 604, 27))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
+        }
+    }
+}
+
+=== tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts ===
+class publicClassInGlobal {
+>publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyAccessorDeclFile_GlobalFile.ts, 0, 0))
+}
+
+class publicClassInGlobalWithPublicGetAccessorTypes {
+>publicClassInGlobalWithPublicGetAccessorTypes : Symbol(publicClassInGlobalWithPublicGetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 1, 1))
+
+    static get myPublicStaticMethod(): publicClassInGlobal {
+>myPublicStaticMethod : Symbol(publicClassInGlobalWithPublicGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 3, 53))
+>publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyAccessorDeclFile_GlobalFile.ts, 0, 0))
+
+        return null;
+    }
+    private static get myPrivateStaticMethod(): publicClassInGlobal {
+>myPrivateStaticMethod : Symbol(publicClassInGlobalWithPublicGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 6, 5))
+>publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyAccessorDeclFile_GlobalFile.ts, 0, 0))
+
+        return null;
+    }
+    get myPublicMethod(): publicClassInGlobal {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 9, 5))
+>publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyAccessorDeclFile_GlobalFile.ts, 0, 0))
+
+        return null;
+    }
+    private get myPrivateMethod(): publicClassInGlobal {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 12, 5))
+>publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyAccessorDeclFile_GlobalFile.ts, 0, 0))
+
+        return null;
+    }
+    static get myPublicStaticMethod1() {
+>myPublicStaticMethod1 : Symbol(publicClassInGlobalWithPublicGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 15, 5))
+
+        return new publicClassInGlobal();
+>publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyAccessorDeclFile_GlobalFile.ts, 0, 0))
+    }
+    private static get myPrivateStaticMethod1() {
+>myPrivateStaticMethod1 : Symbol(publicClassInGlobalWithPublicGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 18, 5))
+
+        return new publicClassInGlobal();
+>publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyAccessorDeclFile_GlobalFile.ts, 0, 0))
+    }
+    get myPublicMethod1() {
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 21, 5))
+
+        return new publicClassInGlobal();
+>publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyAccessorDeclFile_GlobalFile.ts, 0, 0))
+    }
+    private get myPrivateMethod1() {
+>myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 24, 5))
+
+        return new publicClassInGlobal();
+>publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyAccessorDeclFile_GlobalFile.ts, 0, 0))
+    }
+}
+
+class publicClassInGlobalWithWithPublicSetAccessorTypes {
+>publicClassInGlobalWithWithPublicSetAccessorTypes : Symbol(publicClassInGlobalWithWithPublicSetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 28, 1))
+
+    static set myPublicStaticMethod(param: publicClassInGlobal) {
+>myPublicStaticMethod : Symbol(publicClassInGlobalWithWithPublicSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 30, 57))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 31, 36))
+>publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyAccessorDeclFile_GlobalFile.ts, 0, 0))
+    }
+    private static set myPrivateStaticMethod(param: publicClassInGlobal) {
+>myPrivateStaticMethod : Symbol(publicClassInGlobalWithWithPublicSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 32, 5))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 33, 45))
+>publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyAccessorDeclFile_GlobalFile.ts, 0, 0))
+    }
+    set myPublicMethod(param: publicClassInGlobal) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 34, 5))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 35, 23))
+>publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyAccessorDeclFile_GlobalFile.ts, 0, 0))
+    }
+    private set myPrivateMethod(param: publicClassInGlobal) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 36, 5))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 37, 32))
+>publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyAccessorDeclFile_GlobalFile.ts, 0, 0))
+    }
+}
+
+module publicModuleInGlobal {
+>publicModuleInGlobal : Symbol(publicModuleInGlobal, Decl(privacyAccessorDeclFile_GlobalFile.ts, 39, 1))
+
+    class privateClass {
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
+    }
+
+    export class publicClass {
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
+    }
+
+    module privateModule {
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
+
+        class privateClass {
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
+        }
+
+        export class publicClass {
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+        }
+        export class publicClassWithWithPrivateGetAccessorTypes {
+>publicClassWithWithPrivateGetAccessorTypes : Symbol(publicClassWithWithPrivateGetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 53, 9))
+
+            static get myPublicStaticMethod(): privateClass {
+>myPublicStaticMethod : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 54, 65))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
+
+                return null;
+            }
+            private static get myPrivateStaticMethod(): privateClass {
+>myPrivateStaticMethod : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 57, 13))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
+
+                return null;
+            }
+            get myPublicMethod(): privateClass {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 60, 13))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
+
+                return null;
+            }
+            private get myPrivateMethod(): privateClass {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 63, 13))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
+
+                return null;
+            }
+            static get myPublicStaticMethod1() {
+>myPublicStaticMethod1 : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 66, 13))
+
+                return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
+            }
+            private static get myPrivateStaticMethod1() {
+>myPrivateStaticMethod1 : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 69, 13))
+
+                return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
+            }
+            get myPublicMethod1() {
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 72, 13))
+
+                return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
+            }
+            private get myPrivateMethod1() {
+>myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 75, 13))
+
+                return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
+            }
+        }
+
+        export class publicClassWithWithPublicGetAccessorTypes {
+>publicClassWithWithPublicGetAccessorTypes : Symbol(publicClassWithWithPublicGetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 79, 9))
+
+            static get myPublicStaticMethod(): publicClass {
+>myPublicStaticMethod : Symbol(publicClassWithWithPublicGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 81, 64))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+
+                return null;
+            }
+            private static get myPrivateStaticMethod(): publicClass {
+>myPrivateStaticMethod : Symbol(publicClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 84, 13))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+
+                return null;
+            }
+            get myPublicMethod(): publicClass {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 87, 13))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+
+                return null;
+            }
+            private get myPrivateMethod(): publicClass {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 90, 13))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+
+                return null;
+            }
+            static get myPublicStaticMethod1() {
+>myPublicStaticMethod1 : Symbol(publicClassWithWithPublicGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 93, 13))
+
+                return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+            }
+            private static get myPrivateStaticMethod1() {
+>myPrivateStaticMethod1 : Symbol(publicClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 96, 13))
+
+                return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+            }
+            get myPublicMethod1() {
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 99, 13))
+
+                return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+            }
+            private get myPrivateMethod1() {
+>myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 102, 13))
+
+                return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+            }
+        }
+
+        class privateClassWithWithPrivateGetAccessorTypes {
+>privateClassWithWithPrivateGetAccessorTypes : Symbol(privateClassWithWithPrivateGetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 106, 9))
+
+            static get myPublicStaticMethod(): privateClass {
+>myPublicStaticMethod : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 108, 59))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
+
+                return null;
+            }
+            private static get myPrivateStaticMethod(): privateClass {
+>myPrivateStaticMethod : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 111, 13))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
+
+                return null;
+            }
+            get myPublicMethod(): privateClass {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 114, 13))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
+
+                return null;
+            }
+            private get myPrivateMethod(): privateClass {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 117, 13))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
+
+                return null;
+            }
+            static get myPublicStaticMethod1() {
+>myPublicStaticMethod1 : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 120, 13))
+
+                return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
+            }
+            private static get myPrivateStaticMethod1() {
+>myPrivateStaticMethod1 : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 123, 13))
+
+                return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
+            }
+            get myPublicMethod1() {
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 126, 13))
+
+                return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
+            }
+            private get myPrivateMethod1() {
+>myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 129, 13))
+
+                return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
+            }
+        }
+
+        class privateClassWithWithPublicGetAccessorTypes {
+>privateClassWithWithPublicGetAccessorTypes : Symbol(privateClassWithWithPublicGetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 133, 9))
+
+            static get myPublicStaticMethod(): publicClass {
+>myPublicStaticMethod : Symbol(privateClassWithWithPublicGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 135, 58))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+
+                return null;
+            }
+            private static get myPrivateStaticMethod(): publicClass {
+>myPrivateStaticMethod : Symbol(privateClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 138, 13))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+
+                return null;
+            }
+            get myPublicMethod(): publicClass {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 141, 13))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+
+                return null;
+            }
+            private get myPrivateMethod(): publicClass {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 144, 13))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+
+                return null;
+            }
+            static get myPublicStaticMethod1() {
+>myPublicStaticMethod1 : Symbol(privateClassWithWithPublicGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 147, 13))
+
+                return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+            }
+            private static get myPrivateStaticMethod1() {
+>myPrivateStaticMethod1 : Symbol(privateClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 150, 13))
+
+                return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+            }
+            get myPublicMethod1() {
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 153, 13))
+
+                return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+            }
+            private get myPrivateMethod1() {
+>myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 156, 13))
+
+                return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+            }
+        }
+
+        export class publicClassWithWithPrivateSetAccessorTypes {
+>publicClassWithWithPrivateSetAccessorTypes : Symbol(publicClassWithWithPrivateSetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 160, 9))
+
+            static set myPublicStaticMethod(param: privateClass) {
+>myPublicStaticMethod : Symbol(publicClassWithWithPrivateSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 162, 65))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 163, 44))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
+            }
+            private static set myPrivateStaticMethod(param: privateClass) {
+>myPrivateStaticMethod : Symbol(publicClassWithWithPrivateSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 164, 13))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 165, 53))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
+            }
+            set myPublicMethod(param: privateClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 166, 13))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 167, 31))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
+            }
+            private set myPrivateMethod(param: privateClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 168, 13))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 169, 40))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
+            }
+        }
+
+        export class publicClassWithWithPublicSetAccessorTypes {
+>publicClassWithWithPublicSetAccessorTypes : Symbol(publicClassWithWithPublicSetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 171, 9))
+
+            static set myPublicStaticMethod(param: publicClass) {
+>myPublicStaticMethod : Symbol(publicClassWithWithPublicSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 173, 64))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 174, 44))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+            }
+            private static set myPrivateStaticMethod(param: publicClass) {
+>myPrivateStaticMethod : Symbol(publicClassWithWithPublicSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 175, 13))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 176, 53))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+            }
+            set myPublicMethod(param: publicClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 177, 13))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 178, 31))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+            }
+            private set myPrivateMethod(param: publicClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 179, 13))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 180, 40))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+            }
+        }
+
+        class privateClassWithWithPrivateSetAccessorTypes {
+>privateClassWithWithPrivateSetAccessorTypes : Symbol(privateClassWithWithPrivateSetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 182, 9))
+
+            static set myPublicStaticMethod(param: privateClass) {
+>myPublicStaticMethod : Symbol(privateClassWithWithPrivateSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 184, 59))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 185, 44))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
+            }
+            private static set myPrivateStaticMethod(param: privateClass) {
+>myPrivateStaticMethod : Symbol(privateClassWithWithPrivateSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 186, 13))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 187, 53))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
+            }
+            set myPublicMethod(param: privateClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 188, 13))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 189, 31))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
+            }
+            private set myPrivateMethod(param: privateClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 190, 13))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 191, 40))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
+            }
+        }
+
+        class privateClassWithWithPublicSetAccessorTypes {
+>privateClassWithWithPublicSetAccessorTypes : Symbol(privateClassWithWithPublicSetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 193, 9))
+
+            static set myPublicStaticMethod(param: publicClass) {
+>myPublicStaticMethod : Symbol(privateClassWithWithPublicSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 195, 58))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 196, 44))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+            }
+            private static set myPrivateStaticMethod(param: publicClass) {
+>myPrivateStaticMethod : Symbol(privateClassWithWithPublicSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 197, 13))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 198, 53))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+            }
+            set myPublicMethod(param: publicClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 199, 13))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 200, 31))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+            }
+            private set myPrivateMethod(param: publicClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 201, 13))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 202, 40))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+            }
+        }
+
+        export class publicClassWithPrivateModuleGetAccessorTypes {
+>publicClassWithPrivateModuleGetAccessorTypes : Symbol(publicClassWithPrivateModuleGetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 204, 9))
+
+            static get myPublicStaticMethod(): privateModule.publicClass {
+>myPublicStaticMethod : Symbol(publicClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 206, 67))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+
+                return null;
+            }
+            get myPublicMethod(): privateModule.publicClass {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 209, 13))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+
+                return null;
+            }
+            static get myPublicStaticMethod1() {
+>myPublicStaticMethod1 : Symbol(publicClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 212, 13))
+
+                return new privateModule.publicClass();
+>privateModule.publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+            }
+            get myPublicMethod1() {
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 215, 13))
+
+                return new privateModule.publicClass();
+>privateModule.publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+            }
+        }
+
+        export class publicClassWithPrivateModuleSetAccessorTypes {
+>publicClassWithPrivateModuleSetAccessorTypes : Symbol(publicClassWithPrivateModuleSetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 219, 9))
+
+            static set myPublicStaticMethod(param: privateModule.publicClass) {
+>myPublicStaticMethod : Symbol(publicClassWithPrivateModuleSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 221, 67))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 222, 44))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+            }
+            set myPublicMethod(param: privateModule.publicClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 223, 13))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 224, 31))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+            }
+        }
+
+        class privateClassWithPrivateModuleGetAccessorTypes {
+>privateClassWithPrivateModuleGetAccessorTypes : Symbol(privateClassWithPrivateModuleGetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 226, 9))
+
+            static get myPublicStaticMethod(): privateModule.publicClass {
+>myPublicStaticMethod : Symbol(privateClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 228, 61))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+
+                return null;
+            }
+            get myPublicMethod(): privateModule.publicClass {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 231, 13))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+
+                return null;
+            }
+            static get myPublicStaticMethod1() {
+>myPublicStaticMethod1 : Symbol(privateClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 234, 13))
+
+                return new privateModule.publicClass();
+>privateModule.publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+            }
+            get myPublicMethod1() {
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 237, 13))
+
+                return new privateModule.publicClass();
+>privateModule.publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+            }
+        }
+
+        class privateClassWithPrivateModuleSetAccessorTypes {
+>privateClassWithPrivateModuleSetAccessorTypes : Symbol(privateClassWithPrivateModuleSetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 241, 9))
+
+            static set myPublicStaticMethod(param: privateModule.publicClass) {
+>myPublicStaticMethod : Symbol(privateClassWithPrivateModuleSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 243, 61))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 244, 44))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+            }
+            set myPublicMethod(param: privateModule.publicClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 245, 13))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 246, 31))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+            }
+        }
+    }
+
+    export class publicClassWithWithPrivateGetAccessorTypes {
+>publicClassWithWithPrivateGetAccessorTypes : Symbol(publicClassWithWithPrivateGetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 249, 5))
+
+        static get myPublicStaticMethod(): privateClass { // Error
+>myPublicStaticMethod : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 251, 61))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
+
+            return null;
+        }
+        private static get myPrivateStaticMethod(): privateClass {
+>myPrivateStaticMethod : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 254, 9))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
+
+            return null;
+        }
+        get myPublicMethod(): privateClass { // Error
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 257, 9))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
+
+            return null;
+        }
+        private get myPrivateMethod(): privateClass {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 260, 9))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
+
+            return null;
+        }
+        static get myPublicStaticMethod1() { // Error
+>myPublicStaticMethod1 : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 263, 9))
+
+            return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
+        }
+        private static get myPrivateStaticMethod1() {
+>myPrivateStaticMethod1 : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 266, 9))
+
+            return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
+        }
+        get myPublicMethod1() { // Error
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 269, 9))
+
+            return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
+        }
+        private get myPrivateMethod1() {
+>myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 272, 9))
+
+            return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
+        }
+    }
+
+    export class publicClassWithWithPublicGetAccessorTypes {
+>publicClassWithWithPublicGetAccessorTypes : Symbol(publicClassWithWithPublicGetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 276, 5))
+
+        static get myPublicStaticMethod(): publicClass {
+>myPublicStaticMethod : Symbol(publicClassWithWithPublicGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 278, 60))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
+
+            return null;
+        }
+        private static get myPrivateStaticMethod(): publicClass {
+>myPrivateStaticMethod : Symbol(publicClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 281, 9))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
+
+            return null;
+        }
+        get myPublicMethod(): publicClass {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 284, 9))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
+
+            return null;
+        }
+        private get myPrivateMethod(): publicClass {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 287, 9))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
+
+            return null;
+        }
+        static get myPublicStaticMethod1() {
+>myPublicStaticMethod1 : Symbol(publicClassWithWithPublicGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 290, 9))
+
+            return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
+        }
+        private static get myPrivateStaticMethod1() {
+>myPrivateStaticMethod1 : Symbol(publicClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 293, 9))
+
+            return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
+        }
+        get myPublicMethod1() {
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 296, 9))
+
+            return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
+        }
+        private get myPrivateMethod1() {
+>myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 299, 9))
+
+            return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
+        }
+    }
+
+    class privateClassWithWithPrivateGetAccessorTypes {
+>privateClassWithWithPrivateGetAccessorTypes : Symbol(privateClassWithWithPrivateGetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 303, 5))
+
+        static get myPublicStaticMethod(): privateClass {
+>myPublicStaticMethod : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 305, 55))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
+
+            return null;
+        }
+        private static get myPrivateStaticMethod(): privateClass {
+>myPrivateStaticMethod : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 308, 9))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
+
+            return null;
+        }
+        get myPublicMethod(): privateClass {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 311, 9))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
+
+            return null;
+        }
+        private get myPrivateMethod(): privateClass {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 314, 9))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
+
+            return null;
+        }
+        static get myPublicStaticMethod1() {
+>myPublicStaticMethod1 : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 317, 9))
+
+            return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
+        }
+        private static get myPrivateStaticMethod1() {
+>myPrivateStaticMethod1 : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 320, 9))
+
+            return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
+        }
+        get myPublicMethod1() {
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 323, 9))
+
+            return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
+        }
+        private get myPrivateMethod1() {
+>myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 326, 9))
+
+            return new privateClass();
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
+        }
+    }
+
+    class privateClassWithWithPublicGetAccessorTypes {
+>privateClassWithWithPublicGetAccessorTypes : Symbol(privateClassWithWithPublicGetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 330, 5))
+
+        static get myPublicStaticMethod(): publicClass {
+>myPublicStaticMethod : Symbol(privateClassWithWithPublicGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 332, 54))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
+
+            return null;
+        }
+        private static get myPrivateStaticMethod(): publicClass {
+>myPrivateStaticMethod : Symbol(privateClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 335, 9))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
+
+            return null;
+        }
+        get myPublicMethod(): publicClass {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 338, 9))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
+
+            return null;
+        }
+        private get myPrivateMethod(): publicClass {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 341, 9))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
+
+            return null;
+        }
+        static get myPublicStaticMethod1() {
+>myPublicStaticMethod1 : Symbol(privateClassWithWithPublicGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 344, 9))
+
+            return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
+        }
+        private static get myPrivateStaticMethod1() {
+>myPrivateStaticMethod1 : Symbol(privateClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 347, 9))
+
+            return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
+        }
+        get myPublicMethod1() {
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 350, 9))
+
+            return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
+        }
+        private get myPrivateMethod1() {
+>myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 353, 9))
+
+            return new publicClass();
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
+        }
+    }
+
+    export class publicClassWithWithPrivateSetAccessorTypes {
+>publicClassWithWithPrivateSetAccessorTypes : Symbol(publicClassWithWithPrivateSetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 357, 5))
+
+        static set myPublicStaticMethod(param: privateClass) { // Error
+>myPublicStaticMethod : Symbol(publicClassWithWithPrivateSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 359, 61))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 360, 40))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
+        }
+        private static set myPrivateStaticMethod(param: privateClass) {
+>myPrivateStaticMethod : Symbol(publicClassWithWithPrivateSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 361, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 362, 49))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
+        }
+        set myPublicMethod(param: privateClass) { // Error
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 363, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 364, 27))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
+        }
+        private set myPrivateMethod(param: privateClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 365, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 366, 36))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
+        }
+    }
+
+    export class publicClassWithWithPublicSetAccessorTypes {
+>publicClassWithWithPublicSetAccessorTypes : Symbol(publicClassWithWithPublicSetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 368, 5))
+
+        static set myPublicStaticMethod(param: publicClass) {
+>myPublicStaticMethod : Symbol(publicClassWithWithPublicSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 370, 60))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 371, 40))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
+        }
+        private static set myPrivateStaticMethod(param: publicClass) {
+>myPrivateStaticMethod : Symbol(publicClassWithWithPublicSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 372, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 373, 49))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
+        }
+        set myPublicMethod(param: publicClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 374, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 375, 27))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
+        }
+        private set myPrivateMethod(param: publicClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 376, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 377, 36))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
+        }
+    }
+
+    class privateClassWithWithPrivateSetAccessorTypes {
+>privateClassWithWithPrivateSetAccessorTypes : Symbol(privateClassWithWithPrivateSetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 379, 5))
+
+        static set myPublicStaticMethod(param: privateClass) {
+>myPublicStaticMethod : Symbol(privateClassWithWithPrivateSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 381, 55))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 382, 40))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
+        }
+        private static set myPrivateStaticMethod(param: privateClass) {
+>myPrivateStaticMethod : Symbol(privateClassWithWithPrivateSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 383, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 384, 49))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
+        }
+        set myPublicMethod(param: privateClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 385, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 386, 27))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
+        }
+        private set myPrivateMethod(param: privateClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 387, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 388, 36))
+>privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
+        }
+    }
+
+    class privateClassWithWithPublicSetAccessorTypes {
+>privateClassWithWithPublicSetAccessorTypes : Symbol(privateClassWithWithPublicSetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 390, 5))
+
+        static set myPublicStaticMethod(param: publicClass) {
+>myPublicStaticMethod : Symbol(privateClassWithWithPublicSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 392, 54))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 393, 40))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
+        }
+        private static set myPrivateStaticMethod(param: publicClass) {
+>myPrivateStaticMethod : Symbol(privateClassWithWithPublicSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 394, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 395, 49))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
+        }
+        set myPublicMethod(param: publicClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 396, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 397, 27))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
+        }
+        private set myPrivateMethod(param: publicClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 398, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 399, 36))
+>publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
+        }
+    }
+
+    export class publicClassWithPrivateModuleGetAccessorTypes {
+>publicClassWithPrivateModuleGetAccessorTypes : Symbol(publicClassWithPrivateModuleGetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 401, 5))
+
+        static get myPublicStaticMethod(): privateModule.publicClass { // Error
+>myPublicStaticMethod : Symbol(publicClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 403, 63))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+
+            return null;
+        }
+        get myPublicMethod(): privateModule.publicClass { // Error
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 406, 9))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+
+            return null;
+        }
+        static get myPublicStaticMethod1() { // Error
+>myPublicStaticMethod1 : Symbol(publicClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 409, 9))
+
+            return new privateModule.publicClass();
+>privateModule.publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+        }
+        get myPublicMethod1() { // Error
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 412, 9))
+
+            return new privateModule.publicClass();
+>privateModule.publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+        }
+    }
+
+    export class publicClassWithPrivateModuleSetAccessorTypes {
+>publicClassWithPrivateModuleSetAccessorTypes : Symbol(publicClassWithPrivateModuleSetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 416, 5))
+
+        static set myPublicStaticMethod(param: privateModule.publicClass) { // Error
+>myPublicStaticMethod : Symbol(publicClassWithPrivateModuleSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 418, 63))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 419, 40))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+        }
+        set myPublicMethod(param: privateModule.publicClass) { // Error
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 420, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 421, 27))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+        }
+    }
+
+    class privateClassWithPrivateModuleGetAccessorTypes {
+>privateClassWithPrivateModuleGetAccessorTypes : Symbol(privateClassWithPrivateModuleGetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 423, 5))
+
+        static get myPublicStaticMethod(): privateModule.publicClass {
+>myPublicStaticMethod : Symbol(privateClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 425, 57))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+
+            return null;
+        }
+        get myPublicMethod(): privateModule.publicClass {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 428, 9))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+
+            return null;
+        }
+        static get myPublicStaticMethod1() {
+>myPublicStaticMethod1 : Symbol(privateClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 431, 9))
+
+            return new privateModule.publicClass();
+>privateModule.publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+        }
+        get myPublicMethod1() {
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 434, 9))
+
+            return new privateModule.publicClass();
+>privateModule.publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+        }
+    }
+
+    class privateClassWithPrivateModuleSetAccessorTypes {
+>privateClassWithPrivateModuleSetAccessorTypes : Symbol(privateClassWithPrivateModuleSetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 438, 5))
+
+        static set myPublicStaticMethod(param: privateModule.publicClass) {
+>myPublicStaticMethod : Symbol(privateClassWithPrivateModuleSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 440, 57))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 441, 40))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+        }
+        set myPublicMethod(param: privateModule.publicClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 442, 9))
+>param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 443, 27))
+>privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
+        }
+    }
+}
diff --git a/tests/baselines/reference/privacyCannotNameAccessorDeclFile.symbols b/tests/baselines/reference/privacyCannotNameAccessorDeclFile.symbols
new file mode 100644
index 0000000000000..b705d92652f05
--- /dev/null
+++ b/tests/baselines/reference/privacyCannotNameAccessorDeclFile.symbols
@@ -0,0 +1,319 @@
+=== tests/cases/compiler/privacyCannotNameAccessorDeclFile_consumer.ts ===
+import exporter = require("privacyCannotNameAccessorDeclFile_exporter");
+>exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
+
+export class publicClassWithWithPrivateGetAccessorTypes {
+>publicClassWithWithPrivateGetAccessorTypes : Symbol(publicClassWithWithPrivateGetAccessorTypes, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 72))
+
+    static get myPublicStaticMethod() { // Error
+>myPublicStaticMethod : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 1, 57))
+
+        return exporter.createExportedWidget1();
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 2, 43))
+    }
+    private static get myPrivateStaticMethod() {
+>myPrivateStaticMethod : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 4, 5))
+
+        return exporter.createExportedWidget1();
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 2, 43))
+    }
+    get myPublicMethod() { // Error
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 7, 5))
+
+        return exporter.createExportedWidget1();
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 2, 43))
+    }
+    private get myPrivateMethod() {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 10, 5))
+
+        return exporter.createExportedWidget1();
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 2, 43))
+    }
+    static get myPublicStaticMethod1() { // Error
+>myPublicStaticMethod1 : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod1, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 13, 5))
+
+        return exporter.createExportedWidget3();
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 8, 1))
+    }
+    private static get myPrivateStaticMethod1() {
+>myPrivateStaticMethod1 : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 16, 5))
+
+        return exporter.createExportedWidget3();
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 8, 1))
+    }
+    get myPublicMethod1() { // Error
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 19, 5))
+
+        return exporter.createExportedWidget3();
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 8, 1))
+    }
+    private get myPrivateMethod1() {
+>myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 22, 5))
+
+        return exporter.createExportedWidget3();
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 8, 1))
+    }
+}
+
+class privateClassWithWithPrivateGetAccessorTypes {
+>privateClassWithWithPrivateGetAccessorTypes : Symbol(privateClassWithWithPrivateGetAccessorTypes, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 26, 1))
+
+    static get myPublicStaticMethod() { 
+>myPublicStaticMethod : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 28, 51))
+
+        return exporter.createExportedWidget1();
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 2, 43))
+    }
+    private static get myPrivateStaticMethod() {
+>myPrivateStaticMethod : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 31, 5))
+
+        return exporter.createExportedWidget1();
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 2, 43))
+    }
+    get myPublicMethod() { 
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 34, 5))
+
+        return exporter.createExportedWidget1();
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 2, 43))
+    }
+    private get myPrivateMethod() {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 37, 5))
+
+        return exporter.createExportedWidget1();
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 2, 43))
+    }
+    static get myPublicStaticMethod1() { 
+>myPublicStaticMethod1 : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod1, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 40, 5))
+
+        return exporter.createExportedWidget3();
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 8, 1))
+    }
+    private static get myPrivateStaticMethod1() {
+>myPrivateStaticMethod1 : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 43, 5))
+
+        return exporter.createExportedWidget3();
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 8, 1))
+    }
+    get myPublicMethod1() { 
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 46, 5))
+
+        return exporter.createExportedWidget3();
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 8, 1))
+    }
+    private get myPrivateMethod1() {
+>myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 49, 5))
+
+        return exporter.createExportedWidget3();
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 8, 1))
+    }
+}
+
+export class publicClassWithPrivateModuleGetAccessorTypes {
+>publicClassWithPrivateModuleGetAccessorTypes : Symbol(publicClassWithPrivateModuleGetAccessorTypes, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 53, 1))
+
+    static get myPublicStaticMethod() { // Error
+>myPublicStaticMethod : Symbol(publicClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 55, 59))
+
+        return exporter.createExportedWidget2();
+>exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 5, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
+>createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 5, 1))
+    }
+    get myPublicMethod() { // Error
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 58, 5))
+
+        return exporter.createExportedWidget2();
+>exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 5, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
+>createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 5, 1))
+    }
+    static get myPublicStaticMethod1() { // Error
+>myPublicStaticMethod1 : Symbol(publicClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod1, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 61, 5))
+
+        return exporter.createExportedWidget4();
+>exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 11, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
+>createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 11, 1))
+    }
+    get myPublicMethod1() { // Error
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 64, 5))
+
+        return exporter.createExportedWidget4();
+>exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 11, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
+>createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 11, 1))
+    }
+}
+
+class privateClassWithPrivateModuleGetAccessorTypes {
+>privateClassWithPrivateModuleGetAccessorTypes : Symbol(privateClassWithPrivateModuleGetAccessorTypes, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 68, 1))
+
+    static get myPublicStaticMethod() { 
+>myPublicStaticMethod : Symbol(privateClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 70, 53))
+
+        return exporter.createExportedWidget2();
+>exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 5, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
+>createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 5, 1))
+    }
+    get myPublicMethod() { 
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 73, 5))
+
+        return exporter.createExportedWidget2();
+>exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 5, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
+>createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 5, 1))
+    }
+    static get myPublicStaticMethod1() { 
+>myPublicStaticMethod1 : Symbol(privateClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod1, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 76, 5))
+
+        return exporter.createExportedWidget4();
+>exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 11, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
+>createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 11, 1))
+    }
+    get myPublicMethod1() { 
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 79, 5))
+
+        return exporter.createExportedWidget4();
+>exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 11, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
+>createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 11, 1))
+    }
+}
+=== tests/cases/compiler/privacyCannotNameAccessorDeclFile_GlobalWidgets.ts ===
+
+declare module "GlobalWidgets" {
+    export class Widget3 {
+>Widget3 : Symbol(Widget3, Decl(privacyCannotNameAccessorDeclFile_GlobalWidgets.ts, 1, 32))
+
+        name: string;
+>name : Symbol(name, Decl(privacyCannotNameAccessorDeclFile_GlobalWidgets.ts, 2, 26))
+    }
+    export function createWidget3(): Widget3;
+>createWidget3 : Symbol(createWidget3, Decl(privacyCannotNameAccessorDeclFile_GlobalWidgets.ts, 4, 5))
+>Widget3 : Symbol(Widget3, Decl(privacyCannotNameAccessorDeclFile_GlobalWidgets.ts, 1, 32))
+
+    export module SpecializedGlobalWidget {
+>SpecializedGlobalWidget : Symbol(SpecializedGlobalWidget, Decl(privacyCannotNameAccessorDeclFile_GlobalWidgets.ts, 5, 45))
+
+        export class Widget4 {
+>Widget4 : Symbol(Widget4, Decl(privacyCannotNameAccessorDeclFile_GlobalWidgets.ts, 7, 43))
+
+            name: string;
+>name : Symbol(name, Decl(privacyCannotNameAccessorDeclFile_GlobalWidgets.ts, 8, 30))
+        }
+        function createWidget4(): Widget4;
+>createWidget4 : Symbol(createWidget4, Decl(privacyCannotNameAccessorDeclFile_GlobalWidgets.ts, 10, 9))
+>Widget4 : Symbol(Widget4, Decl(privacyCannotNameAccessorDeclFile_GlobalWidgets.ts, 7, 43))
+    }
+}
+
+=== tests/cases/compiler/privacyCannotNameAccessorDeclFile_Widgets.ts ===
+export class Widget1 {
+>Widget1 : Symbol(Widget1, Decl(privacyCannotNameAccessorDeclFile_Widgets.ts, 0, 0))
+
+    name = 'one';
+>name : Symbol(name, Decl(privacyCannotNameAccessorDeclFile_Widgets.ts, 0, 22))
+}
+export function createWidget1() {
+>createWidget1 : Symbol(createWidget1, Decl(privacyCannotNameAccessorDeclFile_Widgets.ts, 2, 1))
+
+    return new Widget1();
+>Widget1 : Symbol(Widget1, Decl(privacyCannotNameAccessorDeclFile_Widgets.ts, 0, 0))
+}
+
+export module SpecializedWidget {
+>SpecializedWidget : Symbol(SpecializedWidget, Decl(privacyCannotNameAccessorDeclFile_Widgets.ts, 5, 1))
+
+    export class Widget2 {
+>Widget2 : Symbol(Widget2, Decl(privacyCannotNameAccessorDeclFile_Widgets.ts, 7, 33))
+
+        name = 'one';
+>name : Symbol(name, Decl(privacyCannotNameAccessorDeclFile_Widgets.ts, 8, 26))
+    }
+    export function createWidget2() {
+>createWidget2 : Symbol(createWidget2, Decl(privacyCannotNameAccessorDeclFile_Widgets.ts, 10, 5))
+
+        return new Widget2();
+>Widget2 : Symbol(Widget2, Decl(privacyCannotNameAccessorDeclFile_Widgets.ts, 7, 33))
+    }
+}
+
+=== tests/cases/compiler/privacyCannotNameAccessorDeclFile_exporter.ts ===
+///<reference path='privacyCannotNameAccessorDeclFile_GlobalWidgets.ts'/>
+import Widgets = require("privacyCannotNameAccessorDeclFile_Widgets");
+>Widgets : Symbol(Widgets, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 0, 0))
+
+import Widgets1 = require("GlobalWidgets");
+>Widgets1 : Symbol(Widgets1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 1, 70))
+
+export function createExportedWidget1() {
+>createExportedWidget1 : Symbol(createExportedWidget1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 2, 43))
+
+    return Widgets.createWidget1();
+>Widgets.createWidget1 : Symbol(Widgets.createWidget1, Decl(privacyCannotNameAccessorDeclFile_Widgets.ts, 2, 1))
+>Widgets : Symbol(Widgets, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 0, 0))
+>createWidget1 : Symbol(Widgets.createWidget1, Decl(privacyCannotNameAccessorDeclFile_Widgets.ts, 2, 1))
+}
+export function createExportedWidget2() {
+>createExportedWidget2 : Symbol(createExportedWidget2, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 5, 1))
+
+    return Widgets.SpecializedWidget.createWidget2();
+>Widgets.SpecializedWidget.createWidget2 : Symbol(Widgets.SpecializedWidget.createWidget2, Decl(privacyCannotNameAccessorDeclFile_Widgets.ts, 10, 5))
+>Widgets.SpecializedWidget : Symbol(Widgets.SpecializedWidget, Decl(privacyCannotNameAccessorDeclFile_Widgets.ts, 5, 1))
+>Widgets : Symbol(Widgets, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 0, 0))
+>SpecializedWidget : Symbol(Widgets.SpecializedWidget, Decl(privacyCannotNameAccessorDeclFile_Widgets.ts, 5, 1))
+>createWidget2 : Symbol(Widgets.SpecializedWidget.createWidget2, Decl(privacyCannotNameAccessorDeclFile_Widgets.ts, 10, 5))
+}
+export function createExportedWidget3() {
+>createExportedWidget3 : Symbol(createExportedWidget3, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 8, 1))
+
+    return Widgets1.createWidget3();
+>Widgets1.createWidget3 : Symbol(Widgets1.createWidget3, Decl(privacyCannotNameAccessorDeclFile_GlobalWidgets.ts, 4, 5))
+>Widgets1 : Symbol(Widgets1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 1, 70))
+>createWidget3 : Symbol(Widgets1.createWidget3, Decl(privacyCannotNameAccessorDeclFile_GlobalWidgets.ts, 4, 5))
+}
+export function createExportedWidget4() {
+>createExportedWidget4 : Symbol(createExportedWidget4, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 11, 1))
+
+    return Widgets1.SpecializedGlobalWidget.createWidget4();
+>Widgets1.SpecializedGlobalWidget.createWidget4 : Symbol(Widgets1.SpecializedGlobalWidget.createWidget4, Decl(privacyCannotNameAccessorDeclFile_GlobalWidgets.ts, 10, 9))
+>Widgets1.SpecializedGlobalWidget : Symbol(Widgets1.SpecializedGlobalWidget, Decl(privacyCannotNameAccessorDeclFile_GlobalWidgets.ts, 5, 45))
+>Widgets1 : Symbol(Widgets1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 1, 70))
+>SpecializedGlobalWidget : Symbol(Widgets1.SpecializedGlobalWidget, Decl(privacyCannotNameAccessorDeclFile_GlobalWidgets.ts, 5, 45))
+>createWidget4 : Symbol(Widgets1.SpecializedGlobalWidget.createWidget4, Decl(privacyCannotNameAccessorDeclFile_GlobalWidgets.ts, 10, 9))
+}
+
diff --git a/tests/baselines/reference/privacyCannotNameVarTypeDeclFile.symbols b/tests/baselines/reference/privacyCannotNameVarTypeDeclFile.symbols
new file mode 100644
index 0000000000000..416e44c4ddccb
--- /dev/null
+++ b/tests/baselines/reference/privacyCannotNameVarTypeDeclFile.symbols
@@ -0,0 +1,315 @@
+=== tests/cases/compiler/privacyCannotNameVarTypeDeclFile_consumer.ts ===
+import exporter = require("privacyCannotNameVarTypeDeclFile_exporter");
+>exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
+
+export class publicClassWithWithPrivatePropertyTypes {
+>publicClassWithWithPrivatePropertyTypes : Symbol(publicClassWithWithPrivatePropertyTypes, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 71))
+
+    static myPublicStaticProperty = exporter.createExportedWidget1(); // Error
+>myPublicStaticProperty : Symbol(publicClassWithWithPrivatePropertyTypes.myPublicStaticProperty, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 1, 54))
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
+
+    private static myPrivateStaticProperty = exporter.createExportedWidget1();
+>myPrivateStaticProperty : Symbol(publicClassWithWithPrivatePropertyTypes.myPrivateStaticProperty, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 2, 69))
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
+
+    myPublicProperty = exporter.createExportedWidget1(); // Error
+>myPublicProperty : Symbol(myPublicProperty, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 3, 78))
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
+
+    private myPrivateProperty = exporter.createExportedWidget1();
+>myPrivateProperty : Symbol(myPrivateProperty, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 4, 56))
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
+
+    static myPublicStaticProperty1 = exporter.createExportedWidget3(); // Error
+>myPublicStaticProperty1 : Symbol(publicClassWithWithPrivatePropertyTypes.myPublicStaticProperty1, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 5, 65))
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
+
+    private static myPrivateStaticProperty1 = exporter.createExportedWidget3();
+>myPrivateStaticProperty1 : Symbol(publicClassWithWithPrivatePropertyTypes.myPrivateStaticProperty1, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 7, 70))
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
+
+    myPublicProperty1 = exporter.createExportedWidget3(); // Error
+>myPublicProperty1 : Symbol(myPublicProperty1, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 8, 79))
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
+
+    private myPrivateProperty1 = exporter.createExportedWidget3();
+>myPrivateProperty1 : Symbol(myPrivateProperty1, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 9, 57))
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
+}
+
+class privateClassWithWithPrivatePropertyTypes {
+>privateClassWithWithPrivatePropertyTypes : Symbol(privateClassWithWithPrivatePropertyTypes, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 11, 1))
+
+    static myPublicStaticProperty = exporter.createExportedWidget1(); 
+>myPublicStaticProperty : Symbol(privateClassWithWithPrivatePropertyTypes.myPublicStaticProperty, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 13, 48))
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
+
+    private static myPrivateStaticProperty = exporter.createExportedWidget1();
+>myPrivateStaticProperty : Symbol(privateClassWithWithPrivatePropertyTypes.myPrivateStaticProperty, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 14, 69))
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
+
+    myPublicProperty = exporter.createExportedWidget1(); 
+>myPublicProperty : Symbol(myPublicProperty, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 15, 78))
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
+
+    private myPrivateProperty = exporter.createExportedWidget1();
+>myPrivateProperty : Symbol(myPrivateProperty, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 16, 56))
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
+
+    static myPublicStaticProperty1 = exporter.createExportedWidget3(); 
+>myPublicStaticProperty1 : Symbol(privateClassWithWithPrivatePropertyTypes.myPublicStaticProperty1, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 17, 65))
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
+
+    private static myPrivateStaticProperty1 = exporter.createExportedWidget3();
+>myPrivateStaticProperty1 : Symbol(privateClassWithWithPrivatePropertyTypes.myPrivateStaticProperty1, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 19, 70))
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
+
+    myPublicProperty1 = exporter.createExportedWidget3(); 
+>myPublicProperty1 : Symbol(myPublicProperty1, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 20, 79))
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
+
+    private myPrivateProperty1 = exporter.createExportedWidget3();
+>myPrivateProperty1 : Symbol(myPrivateProperty1, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 21, 57))
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
+}
+
+export var publicVarWithPrivatePropertyTypes= exporter.createExportedWidget1(); // Error
+>publicVarWithPrivatePropertyTypes : Symbol(publicVarWithPrivatePropertyTypes, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 25, 10))
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
+
+var privateVarWithPrivatePropertyTypes= exporter.createExportedWidget1();
+>privateVarWithPrivatePropertyTypes : Symbol(privateVarWithPrivatePropertyTypes, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 26, 3))
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
+
+export var publicVarWithPrivatePropertyTypes1 = exporter.createExportedWidget3(); // Error
+>publicVarWithPrivatePropertyTypes1 : Symbol(publicVarWithPrivatePropertyTypes1, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 27, 10))
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
+
+var privateVarWithPrivatePropertyTypes1 = exporter.createExportedWidget3();
+>privateVarWithPrivatePropertyTypes1 : Symbol(privateVarWithPrivatePropertyTypes1, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 28, 3))
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
+
+export class publicClassWithPrivateModulePropertyTypes {
+>publicClassWithPrivateModulePropertyTypes : Symbol(publicClassWithPrivateModulePropertyTypes, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 28, 75))
+
+    static myPublicStaticProperty= exporter.createExportedWidget2(); // Error
+>myPublicStaticProperty : Symbol(publicClassWithPrivateModulePropertyTypes.myPublicStaticProperty, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 30, 56))
+>exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 5, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 5, 1))
+
+    myPublicProperty = exporter.createExportedWidget2(); // Error
+>myPublicProperty : Symbol(myPublicProperty, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 31, 68))
+>exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 5, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 5, 1))
+
+    static myPublicStaticProperty1 = exporter.createExportedWidget4(); // Error
+>myPublicStaticProperty1 : Symbol(publicClassWithPrivateModulePropertyTypes.myPublicStaticProperty1, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 32, 56))
+>exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 11, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 11, 1))
+
+    myPublicProperty1 = exporter.createExportedWidget4(); // Error
+>myPublicProperty1 : Symbol(myPublicProperty1, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 33, 70))
+>exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 11, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 11, 1))
+}
+export var publicVarWithPrivateModulePropertyTypes= exporter.createExportedWidget2(); // Error
+>publicVarWithPrivateModulePropertyTypes : Symbol(publicVarWithPrivateModulePropertyTypes, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 36, 10))
+>exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 5, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 5, 1))
+
+export var publicVarWithPrivateModulePropertyTypes1 = exporter.createExportedWidget4(); // Error
+>publicVarWithPrivateModulePropertyTypes1 : Symbol(publicVarWithPrivateModulePropertyTypes1, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 37, 10))
+>exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 11, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 11, 1))
+
+class privateClassWithPrivateModulePropertyTypes {
+>privateClassWithPrivateModulePropertyTypes : Symbol(privateClassWithPrivateModulePropertyTypes, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 37, 87))
+
+    static myPublicStaticProperty= exporter.createExportedWidget2();
+>myPublicStaticProperty : Symbol(privateClassWithPrivateModulePropertyTypes.myPublicStaticProperty, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 39, 50))
+>exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 5, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 5, 1))
+
+    myPublicProperty= exporter.createExportedWidget2();
+>myPublicProperty : Symbol(myPublicProperty, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 40, 68))
+>exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 5, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 5, 1))
+
+    static myPublicStaticProperty1 = exporter.createExportedWidget4();
+>myPublicStaticProperty1 : Symbol(privateClassWithPrivateModulePropertyTypes.myPublicStaticProperty1, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 41, 55))
+>exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 11, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 11, 1))
+
+    myPublicProperty1 = exporter.createExportedWidget4();
+>myPublicProperty1 : Symbol(myPublicProperty1, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 42, 70))
+>exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 11, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 11, 1))
+}
+var privateVarWithPrivateModulePropertyTypes= exporter.createExportedWidget2();
+>privateVarWithPrivateModulePropertyTypes : Symbol(privateVarWithPrivateModulePropertyTypes, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 45, 3))
+>exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 5, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 5, 1))
+
+var privateVarWithPrivateModulePropertyTypes1 = exporter.createExportedWidget4();
+>privateVarWithPrivateModulePropertyTypes1 : Symbol(privateVarWithPrivateModulePropertyTypes1, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 46, 3))
+>exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 11, 1))
+>exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 11, 1))
+
+=== tests/cases/compiler/privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts ===
+
+
+declare module "GlobalWidgets" {
+    export class Widget3 {
+>Widget3 : Symbol(Widget3, Decl(privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts, 2, 32))
+
+        name: string;
+>name : Symbol(name, Decl(privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts, 3, 26))
+    }
+    export function createWidget3(): Widget3;
+>createWidget3 : Symbol(createWidget3, Decl(privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts, 5, 5))
+>Widget3 : Symbol(Widget3, Decl(privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts, 2, 32))
+
+    export module SpecializedGlobalWidget {
+>SpecializedGlobalWidget : Symbol(SpecializedGlobalWidget, Decl(privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts, 6, 45))
+
+        export class Widget4 {
+>Widget4 : Symbol(Widget4, Decl(privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts, 8, 43))
+
+            name: string;
+>name : Symbol(name, Decl(privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts, 9, 30))
+        }
+        function createWidget4(): Widget4;
+>createWidget4 : Symbol(createWidget4, Decl(privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts, 11, 9))
+>Widget4 : Symbol(Widget4, Decl(privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts, 8, 43))
+    }
+}
+
+=== tests/cases/compiler/privacyCannotNameVarTypeDeclFile_Widgets.ts ===
+export class Widget1 {
+>Widget1 : Symbol(Widget1, Decl(privacyCannotNameVarTypeDeclFile_Widgets.ts, 0, 0))
+
+    name = 'one';
+>name : Symbol(name, Decl(privacyCannotNameVarTypeDeclFile_Widgets.ts, 0, 22))
+}
+export function createWidget1() {
+>createWidget1 : Symbol(createWidget1, Decl(privacyCannotNameVarTypeDeclFile_Widgets.ts, 2, 1))
+
+    return new Widget1();
+>Widget1 : Symbol(Widget1, Decl(privacyCannotNameVarTypeDeclFile_Widgets.ts, 0, 0))
+}
+
+export module SpecializedWidget {
+>SpecializedWidget : Symbol(SpecializedWidget, Decl(privacyCannotNameVarTypeDeclFile_Widgets.ts, 5, 1))
+
+    export class Widget2 {
+>Widget2 : Symbol(Widget2, Decl(privacyCannotNameVarTypeDeclFile_Widgets.ts, 7, 33))
+
+        name = 'one';
+>name : Symbol(name, Decl(privacyCannotNameVarTypeDeclFile_Widgets.ts, 8, 26))
+    }
+    export function createWidget2() {
+>createWidget2 : Symbol(createWidget2, Decl(privacyCannotNameVarTypeDeclFile_Widgets.ts, 10, 5))
+
+        return new Widget2();
+>Widget2 : Symbol(Widget2, Decl(privacyCannotNameVarTypeDeclFile_Widgets.ts, 7, 33))
+    }
+}
+
+=== tests/cases/compiler/privacyCannotNameVarTypeDeclFile_exporter.ts ===
+///<reference path='privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts'/>
+import Widgets = require("privacyCannotNameVarTypeDeclFile_Widgets");
+>Widgets : Symbol(Widgets, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 0, 0))
+
+import Widgets1 = require("GlobalWidgets");
+>Widgets1 : Symbol(Widgets1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 1, 69))
+
+export function createExportedWidget1() {
+>createExportedWidget1 : Symbol(createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
+
+    return Widgets.createWidget1();
+>Widgets.createWidget1 : Symbol(Widgets.createWidget1, Decl(privacyCannotNameVarTypeDeclFile_Widgets.ts, 2, 1))
+>Widgets : Symbol(Widgets, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 0, 0))
+>createWidget1 : Symbol(Widgets.createWidget1, Decl(privacyCannotNameVarTypeDeclFile_Widgets.ts, 2, 1))
+}
+export function createExportedWidget2() {
+>createExportedWidget2 : Symbol(createExportedWidget2, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 5, 1))
+
+    return Widgets.SpecializedWidget.createWidget2();
+>Widgets.SpecializedWidget.createWidget2 : Symbol(Widgets.SpecializedWidget.createWidget2, Decl(privacyCannotNameVarTypeDeclFile_Widgets.ts, 10, 5))
+>Widgets.SpecializedWidget : Symbol(Widgets.SpecializedWidget, Decl(privacyCannotNameVarTypeDeclFile_Widgets.ts, 5, 1))
+>Widgets : Symbol(Widgets, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 0, 0))
+>SpecializedWidget : Symbol(Widgets.SpecializedWidget, Decl(privacyCannotNameVarTypeDeclFile_Widgets.ts, 5, 1))
+>createWidget2 : Symbol(Widgets.SpecializedWidget.createWidget2, Decl(privacyCannotNameVarTypeDeclFile_Widgets.ts, 10, 5))
+}
+export function createExportedWidget3() {
+>createExportedWidget3 : Symbol(createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
+
+    return Widgets1.createWidget3();
+>Widgets1.createWidget3 : Symbol(Widgets1.createWidget3, Decl(privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts, 5, 5))
+>Widgets1 : Symbol(Widgets1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 1, 69))
+>createWidget3 : Symbol(Widgets1.createWidget3, Decl(privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts, 5, 5))
+}
+export function createExportedWidget4() {
+>createExportedWidget4 : Symbol(createExportedWidget4, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 11, 1))
+
+    return Widgets1.SpecializedGlobalWidget.createWidget4();
+>Widgets1.SpecializedGlobalWidget.createWidget4 : Symbol(Widgets1.SpecializedGlobalWidget.createWidget4, Decl(privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts, 11, 9))
+>Widgets1.SpecializedGlobalWidget : Symbol(Widgets1.SpecializedGlobalWidget, Decl(privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts, 6, 45))
+>Widgets1 : Symbol(Widgets1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 1, 69))
+>SpecializedGlobalWidget : Symbol(Widgets1.SpecializedGlobalWidget, Decl(privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts, 6, 45))
+>createWidget4 : Symbol(Widgets1.SpecializedGlobalWidget.createWidget4, Decl(privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts, 11, 9))
+}
+
diff --git a/tests/baselines/reference/privacyCheckAnonymousFunctionParameter.symbols b/tests/baselines/reference/privacyCheckAnonymousFunctionParameter.symbols
index 38415655b1e19..e2dcf58c5266f 100644
--- a/tests/baselines/reference/privacyCheckAnonymousFunctionParameter.symbols
+++ b/tests/baselines/reference/privacyCheckAnonymousFunctionParameter.symbols
@@ -28,6 +28,7 @@ module Query {
 
         return fromDoWhile(test => {
 >fromDoWhile : Symbol(fromDoWhile, Decl(privacyCheckAnonymousFunctionParameter.ts, 4, 14))
+>test => {            return true;        } : Symbol((Anonymous function), Decl(privacyCheckAnonymousFunctionParameter.ts, 10, 27))
 >test : Symbol(test, Decl(privacyCheckAnonymousFunctionParameter.ts, 10, 27))
 
             return true;
diff --git a/tests/baselines/reference/privacyClassExtendsClauseDeclFile.symbols b/tests/baselines/reference/privacyClassExtendsClauseDeclFile.symbols
new file mode 100644
index 0000000000000..e59fda3751921
--- /dev/null
+++ b/tests/baselines/reference/privacyClassExtendsClauseDeclFile.symbols
@@ -0,0 +1,177 @@
+=== tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts ===
+
+export module publicModule {
+>publicModule : Symbol(publicModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 0, 0))
+
+    export class publicClassInPublicModule {
+>publicClassInPublicModule : Symbol(publicClassInPublicModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 1, 28))
+
+        private f1() {
+>f1 : Symbol(f1, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 2, 44))
+        }
+    }
+
+    class privateClassInPublicModule {
+>privateClassInPublicModule : Symbol(privateClassInPublicModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 5, 5))
+    }
+
+    class privateClassExtendingPublicClassInModule extends publicClassInPublicModule {
+>privateClassExtendingPublicClassInModule : Symbol(privateClassExtendingPublicClassInModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 8, 5))
+>publicClassInPublicModule : Symbol(publicClassInPublicModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 1, 28))
+    }
+    class privateClassExtendingPrivateClassInModule extends privateClassInPublicModule {
+>privateClassExtendingPrivateClassInModule : Symbol(privateClassExtendingPrivateClassInModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 11, 5))
+>privateClassInPublicModule : Symbol(privateClassInPublicModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 5, 5))
+    }
+    export class publicClassExtendingPublicClassInModule extends publicClassInPublicModule {
+>publicClassExtendingPublicClassInModule : Symbol(publicClassExtendingPublicClassInModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 13, 5))
+>publicClassInPublicModule : Symbol(publicClassInPublicModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 1, 28))
+    }
+    export class publicClassExtendingPrivateClassInModule extends privateClassInPublicModule { // Should error
+>publicClassExtendingPrivateClassInModule : Symbol(publicClassExtendingPrivateClassInModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 15, 5))
+>privateClassInPublicModule : Symbol(privateClassInPublicModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 5, 5))
+    }
+
+    class privateClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule {
+>privateClassExtendingFromPrivateModuleClass : Symbol(privateClassExtendingFromPrivateModuleClass, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 17, 5))
+>privateModule.publicClassInPrivateModule : Symbol(privateModule.publicClassInPrivateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 25, 22))
+>privateModule : Symbol(privateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 23, 1))
+>publicClassInPrivateModule : Symbol(privateModule.publicClassInPrivateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 25, 22))
+    }
+    export class publicClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule { // Should error
+>publicClassExtendingFromPrivateModuleClass : Symbol(publicClassExtendingFromPrivateModuleClass, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 20, 5))
+>privateModule.publicClassInPrivateModule : Symbol(privateModule.publicClassInPrivateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 25, 22))
+>privateModule : Symbol(privateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 23, 1))
+>publicClassInPrivateModule : Symbol(privateModule.publicClassInPrivateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 25, 22))
+    }
+}
+
+module privateModule {
+>privateModule : Symbol(privateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 23, 1))
+
+    export class publicClassInPrivateModule {
+>publicClassInPrivateModule : Symbol(publicClassInPrivateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 25, 22))
+
+        private f1() {
+>f1 : Symbol(f1, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 26, 45))
+        }
+    }
+
+    class privateClassInPrivateModule {
+>privateClassInPrivateModule : Symbol(privateClassInPrivateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 29, 5))
+    }
+
+    class privateClassExtendingPublicClassInModule extends publicClassInPrivateModule {
+>privateClassExtendingPublicClassInModule : Symbol(privateClassExtendingPublicClassInModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 32, 5))
+>publicClassInPrivateModule : Symbol(publicClassInPrivateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 25, 22))
+    }
+    class privateClassExtendingPrivateClassInModule extends privateClassInPrivateModule {
+>privateClassExtendingPrivateClassInModule : Symbol(privateClassExtendingPrivateClassInModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 35, 5))
+>privateClassInPrivateModule : Symbol(privateClassInPrivateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 29, 5))
+    }
+    export class publicClassExtendingPublicClassInModule extends publicClassInPrivateModule {
+>publicClassExtendingPublicClassInModule : Symbol(publicClassExtendingPublicClassInModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 37, 5))
+>publicClassInPrivateModule : Symbol(publicClassInPrivateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 25, 22))
+    }
+    export class publicClassExtendingPrivateClassInModule extends privateClassInPrivateModule { 
+>publicClassExtendingPrivateClassInModule : Symbol(publicClassExtendingPrivateClassInModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 39, 5))
+>privateClassInPrivateModule : Symbol(privateClassInPrivateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 29, 5))
+    }
+
+    class privateClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule {
+>privateClassExtendingFromPrivateModuleClass : Symbol(privateClassExtendingFromPrivateModuleClass, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 41, 5))
+>privateModule.publicClassInPrivateModule : Symbol(publicClassInPrivateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 25, 22))
+>privateModule : Symbol(privateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 23, 1))
+>publicClassInPrivateModule : Symbol(publicClassInPrivateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 25, 22))
+    }
+    export class publicClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule {
+>publicClassExtendingFromPrivateModuleClass : Symbol(publicClassExtendingFromPrivateModuleClass, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 44, 5))
+>privateModule.publicClassInPrivateModule : Symbol(publicClassInPrivateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 25, 22))
+>privateModule : Symbol(privateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 23, 1))
+>publicClassInPrivateModule : Symbol(publicClassInPrivateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 25, 22))
+    }
+}
+
+export class publicClass {
+>publicClass : Symbol(publicClass, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 47, 1))
+
+    private f1() {
+>f1 : Symbol(f1, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 49, 26))
+    }
+}
+
+class privateClass {
+>privateClass : Symbol(privateClass, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 52, 1))
+}
+
+class privateClassExtendingPublicClass extends publicClass {
+>privateClassExtendingPublicClass : Symbol(privateClassExtendingPublicClass, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 55, 1))
+>publicClass : Symbol(publicClass, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 47, 1))
+}
+class privateClassExtendingPrivateClassInModule extends privateClass {
+>privateClassExtendingPrivateClassInModule : Symbol(privateClassExtendingPrivateClassInModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 58, 1))
+>privateClass : Symbol(privateClass, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 52, 1))
+}
+export class publicClassExtendingPublicClass extends publicClass {
+>publicClassExtendingPublicClass : Symbol(publicClassExtendingPublicClass, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 60, 1))
+>publicClass : Symbol(publicClass, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 47, 1))
+}
+export class publicClassExtendingPrivateClass extends privateClass { // Should error
+>publicClassExtendingPrivateClass : Symbol(publicClassExtendingPrivateClass, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 62, 1))
+>privateClass : Symbol(privateClass, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 52, 1))
+}
+
+class privateClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule {
+>privateClassExtendingFromPrivateModuleClass : Symbol(privateClassExtendingFromPrivateModuleClass, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 64, 1))
+>privateModule.publicClassInPrivateModule : Symbol(privateModule.publicClassInPrivateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 25, 22))
+>privateModule : Symbol(privateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 23, 1))
+>publicClassInPrivateModule : Symbol(privateModule.publicClassInPrivateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 25, 22))
+}
+export class publicClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule { // Should error
+>publicClassExtendingFromPrivateModuleClass : Symbol(publicClassExtendingFromPrivateModuleClass, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 67, 1))
+>privateModule.publicClassInPrivateModule : Symbol(privateModule.publicClassInPrivateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 25, 22))
+>privateModule : Symbol(privateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 23, 1))
+>publicClassInPrivateModule : Symbol(privateModule.publicClassInPrivateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 25, 22))
+}
+
+=== tests/cases/compiler/privacyClassExtendsClauseDeclFile_GlobalFile.ts ===
+module publicModuleInGlobal {
+>publicModuleInGlobal : Symbol(publicModuleInGlobal, Decl(privacyClassExtendsClauseDeclFile_GlobalFile.ts, 0, 0))
+
+    export class publicClassInPublicModule {
+>publicClassInPublicModule : Symbol(publicClassInPublicModule, Decl(privacyClassExtendsClauseDeclFile_GlobalFile.ts, 0, 29))
+
+        private f1() {
+>f1 : Symbol(f1, Decl(privacyClassExtendsClauseDeclFile_GlobalFile.ts, 1, 44))
+        }
+    }
+
+    class privateClassInPublicModule {
+>privateClassInPublicModule : Symbol(privateClassInPublicModule, Decl(privacyClassExtendsClauseDeclFile_GlobalFile.ts, 4, 5))
+    }
+
+    class privateClassExtendingPublicClassInModule extends publicClassInPublicModule {
+>privateClassExtendingPublicClassInModule : Symbol(privateClassExtendingPublicClassInModule, Decl(privacyClassExtendsClauseDeclFile_GlobalFile.ts, 7, 5))
+>publicClassInPublicModule : Symbol(publicClassInPublicModule, Decl(privacyClassExtendsClauseDeclFile_GlobalFile.ts, 0, 29))
+    }
+    class privateClassExtendingPrivateClassInModule extends privateClassInPublicModule {
+>privateClassExtendingPrivateClassInModule : Symbol(privateClassExtendingPrivateClassInModule, Decl(privacyClassExtendsClauseDeclFile_GlobalFile.ts, 10, 5))
+>privateClassInPublicModule : Symbol(privateClassInPublicModule, Decl(privacyClassExtendsClauseDeclFile_GlobalFile.ts, 4, 5))
+    }
+    export class publicClassExtendingPublicClassInModule extends publicClassInPublicModule {
+>publicClassExtendingPublicClassInModule : Symbol(publicClassExtendingPublicClassInModule, Decl(privacyClassExtendsClauseDeclFile_GlobalFile.ts, 12, 5))
+>publicClassInPublicModule : Symbol(publicClassInPublicModule, Decl(privacyClassExtendsClauseDeclFile_GlobalFile.ts, 0, 29))
+    }
+    export class publicClassExtendingPrivateClassInModule extends privateClassInPublicModule { // Should error
+>publicClassExtendingPrivateClassInModule : Symbol(publicClassExtendingPrivateClassInModule, Decl(privacyClassExtendsClauseDeclFile_GlobalFile.ts, 14, 5))
+>privateClassInPublicModule : Symbol(privateClassInPublicModule, Decl(privacyClassExtendsClauseDeclFile_GlobalFile.ts, 4, 5))
+    }
+}
+class publicClassInGlobal {
+>publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyClassExtendsClauseDeclFile_GlobalFile.ts, 17, 1))
+}
+class publicClassExtendingPublicClassInGlobal extends publicClassInGlobal {
+>publicClassExtendingPublicClassInGlobal : Symbol(publicClassExtendingPublicClassInGlobal, Decl(privacyClassExtendsClauseDeclFile_GlobalFile.ts, 19, 1))
+>publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyClassExtendsClauseDeclFile_GlobalFile.ts, 17, 1))
+}
+
diff --git a/tests/baselines/reference/privacyClassImplementsClauseDeclFile.symbols b/tests/baselines/reference/privacyClassImplementsClauseDeclFile.symbols
new file mode 100644
index 0000000000000..1d8dd4fec8301
--- /dev/null
+++ b/tests/baselines/reference/privacyClassImplementsClauseDeclFile.symbols
@@ -0,0 +1,169 @@
+=== tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts ===
+
+export module publicModule {
+>publicModule : Symbol(publicModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 0, 0))
+
+    export interface publicInterfaceInPublicModule {
+>publicInterfaceInPublicModule : Symbol(publicInterfaceInPublicModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 1, 28))
+    }
+
+    interface privateInterfaceInPublicModule {
+>privateInterfaceInPublicModule : Symbol(privateInterfaceInPublicModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 3, 5))
+    }
+
+    class privateClassImplementingPublicInterfaceInModule implements publicInterfaceInPublicModule {
+>privateClassImplementingPublicInterfaceInModule : Symbol(privateClassImplementingPublicInterfaceInModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 6, 5))
+>publicInterfaceInPublicModule : Symbol(publicInterfaceInPublicModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 1, 28))
+    }
+    class privateClassImplementingPrivateInterfaceInModule implements privateInterfaceInPublicModule {
+>privateClassImplementingPrivateInterfaceInModule : Symbol(privateClassImplementingPrivateInterfaceInModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 9, 5))
+>privateInterfaceInPublicModule : Symbol(privateInterfaceInPublicModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 3, 5))
+    }
+    export class publicClassImplementingPublicInterfaceInModule implements publicInterfaceInPublicModule {
+>publicClassImplementingPublicInterfaceInModule : Symbol(publicClassImplementingPublicInterfaceInModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 11, 5))
+>publicInterfaceInPublicModule : Symbol(publicInterfaceInPublicModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 1, 28))
+    }
+    export class publicClassImplementingPrivateInterfaceInModule implements privateInterfaceInPublicModule { // Should error
+>publicClassImplementingPrivateInterfaceInModule : Symbol(publicClassImplementingPrivateInterfaceInModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 13, 5))
+>privateInterfaceInPublicModule : Symbol(privateInterfaceInPublicModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 3, 5))
+    }
+
+    class privateClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule {
+>privateClassImplementingFromPrivateModuleInterface : Symbol(privateClassImplementingFromPrivateModuleInterface, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 15, 5))
+>privateModule.publicInterfaceInPrivateModule : Symbol(privateModule.publicInterfaceInPrivateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 26, 22))
+>privateModule : Symbol(privateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 24, 1))
+>publicInterfaceInPrivateModule : Symbol(privateModule.publicInterfaceInPrivateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 26, 22))
+    }
+    export class publicClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule { // Should error
+>publicClassImplementingFromPrivateModuleInterface : Symbol(publicClassImplementingFromPrivateModuleInterface, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 18, 5))
+>privateModule.publicInterfaceInPrivateModule : Symbol(privateModule.publicInterfaceInPrivateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 26, 22))
+>privateModule : Symbol(privateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 24, 1))
+>publicInterfaceInPrivateModule : Symbol(privateModule.publicInterfaceInPrivateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 26, 22))
+    }
+
+    export class publicClassImplementingPrivateAndPublicInterface implements privateInterfaceInPublicModule, publicInterfaceInPublicModule { // Should error
+>publicClassImplementingPrivateAndPublicInterface : Symbol(publicClassImplementingPrivateAndPublicInterface, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 20, 5))
+>privateInterfaceInPublicModule : Symbol(privateInterfaceInPublicModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 3, 5))
+>publicInterfaceInPublicModule : Symbol(publicInterfaceInPublicModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 1, 28))
+    }
+}
+
+module privateModule {
+>privateModule : Symbol(privateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 24, 1))
+
+    export interface publicInterfaceInPrivateModule {
+>publicInterfaceInPrivateModule : Symbol(publicInterfaceInPrivateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 26, 22))
+
+    }
+
+    interface privateInterfaceInPrivateModule {
+>privateInterfaceInPrivateModule : Symbol(privateInterfaceInPrivateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 29, 5))
+    }
+
+    class privateClassImplementingPublicInterfaceInModule implements publicInterfaceInPrivateModule {
+>privateClassImplementingPublicInterfaceInModule : Symbol(privateClassImplementingPublicInterfaceInModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 32, 5))
+>publicInterfaceInPrivateModule : Symbol(publicInterfaceInPrivateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 26, 22))
+    }
+    class privateClassImplementingPrivateInterfaceInModule implements privateInterfaceInPrivateModule {
+>privateClassImplementingPrivateInterfaceInModule : Symbol(privateClassImplementingPrivateInterfaceInModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 35, 5))
+>privateInterfaceInPrivateModule : Symbol(privateInterfaceInPrivateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 29, 5))
+    }
+    export class publicClassImplementingPublicInterfaceInModule implements publicInterfaceInPrivateModule {
+>publicClassImplementingPublicInterfaceInModule : Symbol(publicClassImplementingPublicInterfaceInModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 37, 5))
+>publicInterfaceInPrivateModule : Symbol(publicInterfaceInPrivateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 26, 22))
+    }
+    export class publicClassImplementingPrivateInterfaceInModule implements privateInterfaceInPrivateModule { 
+>publicClassImplementingPrivateInterfaceInModule : Symbol(publicClassImplementingPrivateInterfaceInModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 39, 5))
+>privateInterfaceInPrivateModule : Symbol(privateInterfaceInPrivateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 29, 5))
+    }
+
+    class privateClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule {
+>privateClassImplementingFromPrivateModuleInterface : Symbol(privateClassImplementingFromPrivateModuleInterface, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 41, 5))
+>privateModule.publicInterfaceInPrivateModule : Symbol(publicInterfaceInPrivateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 26, 22))
+>privateModule : Symbol(privateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 24, 1))
+>publicInterfaceInPrivateModule : Symbol(publicInterfaceInPrivateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 26, 22))
+    }
+    export class publicClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule {
+>publicClassImplementingFromPrivateModuleInterface : Symbol(publicClassImplementingFromPrivateModuleInterface, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 44, 5))
+>privateModule.publicInterfaceInPrivateModule : Symbol(publicInterfaceInPrivateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 26, 22))
+>privateModule : Symbol(privateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 24, 1))
+>publicInterfaceInPrivateModule : Symbol(publicInterfaceInPrivateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 26, 22))
+    }
+}
+
+export interface publicInterface {
+>publicInterface : Symbol(publicInterface, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 47, 1))
+
+}
+
+interface privateInterface {
+>privateInterface : Symbol(privateInterface, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 51, 1))
+}
+
+class privateClassImplementingPublicInterface implements publicInterface {
+>privateClassImplementingPublicInterface : Symbol(privateClassImplementingPublicInterface, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 54, 1))
+>publicInterface : Symbol(publicInterface, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 47, 1))
+}
+class privateClassImplementingPrivateInterfaceInModule implements privateInterface {
+>privateClassImplementingPrivateInterfaceInModule : Symbol(privateClassImplementingPrivateInterfaceInModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 57, 1))
+>privateInterface : Symbol(privateInterface, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 51, 1))
+}
+export class publicClassImplementingPublicInterface implements publicInterface {
+>publicClassImplementingPublicInterface : Symbol(publicClassImplementingPublicInterface, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 59, 1))
+>publicInterface : Symbol(publicInterface, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 47, 1))
+}
+export class publicClassImplementingPrivateInterface implements privateInterface { // Should error
+>publicClassImplementingPrivateInterface : Symbol(publicClassImplementingPrivateInterface, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 61, 1))
+>privateInterface : Symbol(privateInterface, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 51, 1))
+}
+
+class privateClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule {
+>privateClassImplementingFromPrivateModuleInterface : Symbol(privateClassImplementingFromPrivateModuleInterface, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 63, 1))
+>privateModule.publicInterfaceInPrivateModule : Symbol(privateModule.publicInterfaceInPrivateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 26, 22))
+>privateModule : Symbol(privateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 24, 1))
+>publicInterfaceInPrivateModule : Symbol(privateModule.publicInterfaceInPrivateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 26, 22))
+}
+export class publicClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule { // Should error
+>publicClassImplementingFromPrivateModuleInterface : Symbol(publicClassImplementingFromPrivateModuleInterface, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 66, 1))
+>privateModule.publicInterfaceInPrivateModule : Symbol(privateModule.publicInterfaceInPrivateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 26, 22))
+>privateModule : Symbol(privateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 24, 1))
+>publicInterfaceInPrivateModule : Symbol(privateModule.publicInterfaceInPrivateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 26, 22))
+}
+
+=== tests/cases/compiler/privacyClassImplementsClauseDeclFile_GlobalFile.ts ===
+module publicModuleInGlobal {
+>publicModuleInGlobal : Symbol(publicModuleInGlobal, Decl(privacyClassImplementsClauseDeclFile_GlobalFile.ts, 0, 0))
+
+    export interface publicInterfaceInPublicModule {
+>publicInterfaceInPublicModule : Symbol(publicInterfaceInPublicModule, Decl(privacyClassImplementsClauseDeclFile_GlobalFile.ts, 0, 29))
+    }
+
+    interface privateInterfaceInPublicModule {
+>privateInterfaceInPublicModule : Symbol(privateInterfaceInPublicModule, Decl(privacyClassImplementsClauseDeclFile_GlobalFile.ts, 2, 5))
+    }
+
+    class privateClassImplementingPublicInterfaceInModule implements publicInterfaceInPublicModule {
+>privateClassImplementingPublicInterfaceInModule : Symbol(privateClassImplementingPublicInterfaceInModule, Decl(privacyClassImplementsClauseDeclFile_GlobalFile.ts, 5, 5))
+>publicInterfaceInPublicModule : Symbol(publicInterfaceInPublicModule, Decl(privacyClassImplementsClauseDeclFile_GlobalFile.ts, 0, 29))
+    }
+    class privateClassImplementingPrivateInterfaceInModule implements privateInterfaceInPublicModule {
+>privateClassImplementingPrivateInterfaceInModule : Symbol(privateClassImplementingPrivateInterfaceInModule, Decl(privacyClassImplementsClauseDeclFile_GlobalFile.ts, 8, 5))
+>privateInterfaceInPublicModule : Symbol(privateInterfaceInPublicModule, Decl(privacyClassImplementsClauseDeclFile_GlobalFile.ts, 2, 5))
+    }
+    export class publicClassImplementingPublicInterfaceInModule implements publicInterfaceInPublicModule {
+>publicClassImplementingPublicInterfaceInModule : Symbol(publicClassImplementingPublicInterfaceInModule, Decl(privacyClassImplementsClauseDeclFile_GlobalFile.ts, 10, 5))
+>publicInterfaceInPublicModule : Symbol(publicInterfaceInPublicModule, Decl(privacyClassImplementsClauseDeclFile_GlobalFile.ts, 0, 29))
+    }
+    export class publicClassImplementingPrivateInterfaceInModule implements privateInterfaceInPublicModule { // Should error
+>publicClassImplementingPrivateInterfaceInModule : Symbol(publicClassImplementingPrivateInterfaceInModule, Decl(privacyClassImplementsClauseDeclFile_GlobalFile.ts, 12, 5))
+>privateInterfaceInPublicModule : Symbol(privateInterfaceInPublicModule, Decl(privacyClassImplementsClauseDeclFile_GlobalFile.ts, 2, 5))
+    }
+}
+interface publicInterfaceInGlobal {
+>publicInterfaceInGlobal : Symbol(publicInterfaceInGlobal, Decl(privacyClassImplementsClauseDeclFile_GlobalFile.ts, 15, 1))
+}
+class publicClassImplementingPublicInterfaceInGlobal implements publicInterfaceInGlobal {
+>publicClassImplementingPublicInterfaceInGlobal : Symbol(publicClassImplementingPublicInterfaceInGlobal, Decl(privacyClassImplementsClauseDeclFile_GlobalFile.ts, 17, 1))
+>publicInterfaceInGlobal : Symbol(publicInterfaceInGlobal, Decl(privacyClassImplementsClauseDeclFile_GlobalFile.ts, 15, 1))
+}
+
diff --git a/tests/baselines/reference/privacyFunctionCannotNameParameterTypeDeclFile.symbols b/tests/baselines/reference/privacyFunctionCannotNameParameterTypeDeclFile.symbols
new file mode 100644
index 0000000000000..ea5ddf28d8099
--- /dev/null
+++ b/tests/baselines/reference/privacyFunctionCannotNameParameterTypeDeclFile.symbols
@@ -0,0 +1,483 @@
+=== tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts ===
+import exporter = require("privacyFunctionCannotNameParameterTypeDeclFile_exporter");
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+
+export class publicClassWithWithPrivateParmeterTypes {
+>publicClassWithWithPrivateParmeterTypes : Symbol(publicClassWithWithPrivateParmeterTypes, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 85))
+
+    static myPublicStaticMethod(param = exporter.createExportedWidget1()) { // Error
+>myPublicStaticMethod : Symbol(publicClassWithWithPrivateParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 1, 54))
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 2, 32))
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
+    }
+    private static myPrivateStaticMethod(param = exporter.createExportedWidget1()) {
+>myPrivateStaticMethod : Symbol(publicClassWithWithPrivateParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 3, 5))
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 4, 41))
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
+    }
+    myPublicMethod(param  = exporter.createExportedWidget1()) { // Error
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 5, 5))
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 6, 19))
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
+    }
+    private myPrivateMethod(param = exporter.createExportedWidget1()) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 7, 5))
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 8, 28))
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
+    }
+    constructor(param = exporter.createExportedWidget1(), private param1 = exporter.createExportedWidget1(), public param2 = exporter.createExportedWidget1()) { // Error
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 10, 16))
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
+>param1 : Symbol(param1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 10, 57))
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
+>param2 : Symbol(param2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 10, 108))
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
+    }
+}
+export class publicClassWithWithPrivateParmeterTypes1 {
+>publicClassWithWithPrivateParmeterTypes1 : Symbol(publicClassWithWithPrivateParmeterTypes1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 12, 1))
+
+    static myPublicStaticMethod(param = exporter.createExportedWidget3()) { // Error
+>myPublicStaticMethod : Symbol(publicClassWithWithPrivateParmeterTypes1.myPublicStaticMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 13, 55))
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 14, 32))
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
+    }
+    private static myPrivateStaticMethod(param = exporter.createExportedWidget3()) {
+>myPrivateStaticMethod : Symbol(publicClassWithWithPrivateParmeterTypes1.myPrivateStaticMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 15, 5))
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 16, 41))
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
+    }
+    myPublicMethod(param  = exporter.createExportedWidget3()) { // Error
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 17, 5))
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 18, 19))
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
+    }
+    private myPrivateMethod(param = exporter.createExportedWidget3()) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 19, 5))
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 20, 28))
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
+    }
+    constructor(param = exporter.createExportedWidget3(), private param1 = exporter.createExportedWidget3(), public param2 = exporter.createExportedWidget3()) { // Error
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 22, 16))
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
+>param1 : Symbol(param1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 22, 57))
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
+>param2 : Symbol(param2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 22, 108))
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
+    }
+}
+
+class privateClassWithWithPrivateParmeterTypes {
+>privateClassWithWithPrivateParmeterTypes : Symbol(privateClassWithWithPrivateParmeterTypes, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 24, 1))
+
+    static myPublicStaticMethod(param = exporter.createExportedWidget1()) {
+>myPublicStaticMethod : Symbol(privateClassWithWithPrivateParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 26, 48))
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 27, 32))
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
+    }
+    private static myPrivateStaticMethod(param = exporter.createExportedWidget1()) {
+>myPrivateStaticMethod : Symbol(privateClassWithWithPrivateParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 28, 5))
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 29, 41))
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
+    }
+    myPublicMethod(param  = exporter.createExportedWidget1()) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 30, 5))
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 31, 19))
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
+    }
+    private myPrivateMethod(param = exporter.createExportedWidget1()) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 32, 5))
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 33, 28))
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
+    }
+    constructor(param = exporter.createExportedWidget1(), private param1 = exporter.createExportedWidget1(), public param2 = exporter.createExportedWidget1()) {
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 35, 16))
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
+>param1 : Symbol(param1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 35, 57))
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
+>param2 : Symbol(param2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 35, 108))
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
+    }
+}
+class privateClassWithWithPrivateParmeterTypes2 {
+>privateClassWithWithPrivateParmeterTypes2 : Symbol(privateClassWithWithPrivateParmeterTypes2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 37, 1))
+
+    static myPublicStaticMethod(param = exporter.createExportedWidget3()) {
+>myPublicStaticMethod : Symbol(privateClassWithWithPrivateParmeterTypes2.myPublicStaticMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 38, 49))
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 39, 32))
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
+    }
+    private static myPrivateStaticMethod(param = exporter.createExportedWidget3()) {
+>myPrivateStaticMethod : Symbol(privateClassWithWithPrivateParmeterTypes2.myPrivateStaticMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 40, 5))
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 41, 41))
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
+    }
+    myPublicMethod(param  = exporter.createExportedWidget3()) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 42, 5))
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 43, 19))
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
+    }
+    private myPrivateMethod(param = exporter.createExportedWidget3()) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 44, 5))
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 45, 28))
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
+    }
+    constructor(param = exporter.createExportedWidget3(), private param1 = exporter.createExportedWidget3(), public param2 = exporter.createExportedWidget3()) {
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 47, 16))
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
+>param1 : Symbol(param1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 47, 57))
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
+>param2 : Symbol(param2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 47, 108))
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
+    }
+}
+
+export function publicFunctionWithPrivateParmeterTypes(param = exporter.createExportedWidget1()) { // Error
+>publicFunctionWithPrivateParmeterTypes : Symbol(publicFunctionWithPrivateParmeterTypes, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 49, 1))
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 51, 55))
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
+}
+function privateFunctionWithPrivateParmeterTypes(param = exporter.createExportedWidget1()) {
+>privateFunctionWithPrivateParmeterTypes : Symbol(privateFunctionWithPrivateParmeterTypes, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 52, 1))
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 53, 49))
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
+}
+export function publicFunctionWithPrivateParmeterTypes1(param = exporter.createExportedWidget3()) { // Error
+>publicFunctionWithPrivateParmeterTypes1 : Symbol(publicFunctionWithPrivateParmeterTypes1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 54, 1))
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 55, 56))
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
+}
+function privateFunctionWithPrivateParmeterTypes1(param = exporter.createExportedWidget3()) {
+>privateFunctionWithPrivateParmeterTypes1 : Symbol(privateFunctionWithPrivateParmeterTypes1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 56, 1))
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 57, 50))
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
+}
+
+
+export class publicClassWithPrivateModuleParameterTypes {
+>publicClassWithPrivateModuleParameterTypes : Symbol(publicClassWithPrivateModuleParameterTypes, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 58, 1))
+
+    static myPublicStaticMethod(param= exporter.createExportedWidget2()) { // Error
+>myPublicStaticMethod : Symbol(publicClassWithPrivateModuleParameterTypes.myPublicStaticMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 61, 57))
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 62, 32))
+>exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
+    }
+    myPublicMethod(param= exporter.createExportedWidget2()) { // Error
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 63, 5))
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 64, 19))
+>exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
+    }
+    constructor(param= exporter.createExportedWidget2(), private param1= exporter.createExportedWidget2(), public param2= exporter.createExportedWidget2()) { // Error
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 66, 16))
+>exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
+>param1 : Symbol(param1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 66, 56))
+>exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
+>param2 : Symbol(param2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 66, 106))
+>exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
+    }
+}
+export class publicClassWithPrivateModuleParameterTypes2 {
+>publicClassWithPrivateModuleParameterTypes2 : Symbol(publicClassWithPrivateModuleParameterTypes2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 68, 1))
+
+    static myPublicStaticMethod(param= exporter.createExportedWidget4()) { // Error
+>myPublicStaticMethod : Symbol(publicClassWithPrivateModuleParameterTypes2.myPublicStaticMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 69, 58))
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 70, 32))
+>exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
+    }
+    myPublicMethod(param= exporter.createExportedWidget4()) { // Error
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 71, 5))
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 72, 19))
+>exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
+    }
+    constructor(param= exporter.createExportedWidget4(), private param1= exporter.createExportedWidget4(), public param2= exporter.createExportedWidget4()) { // Error
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 74, 16))
+>exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
+>param1 : Symbol(param1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 74, 56))
+>exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
+>param2 : Symbol(param2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 74, 106))
+>exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
+    }
+}
+export function publicFunctionWithPrivateModuleParameterTypes(param= exporter.createExportedWidget2()) { // Error
+>publicFunctionWithPrivateModuleParameterTypes : Symbol(publicFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 76, 1))
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 77, 62))
+>exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
+}
+export function publicFunctionWithPrivateModuleParameterTypes1(param= exporter.createExportedWidget4()) { // Error
+>publicFunctionWithPrivateModuleParameterTypes1 : Symbol(publicFunctionWithPrivateModuleParameterTypes1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 78, 1))
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 79, 63))
+>exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
+}
+
+
+class privateClassWithPrivateModuleParameterTypes {
+>privateClassWithPrivateModuleParameterTypes : Symbol(privateClassWithPrivateModuleParameterTypes, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 80, 1))
+
+    static myPublicStaticMethod(param= exporter.createExportedWidget2()) {
+>myPublicStaticMethod : Symbol(privateClassWithPrivateModuleParameterTypes.myPublicStaticMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 83, 51))
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 84, 32))
+>exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
+    }
+    myPublicMethod(param= exporter.createExportedWidget2()) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 85, 5))
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 86, 19))
+>exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
+    }
+    constructor(param= exporter.createExportedWidget2(), private param1= exporter.createExportedWidget2(), public param2= exporter.createExportedWidget2()) {
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 88, 16))
+>exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
+>param1 : Symbol(param1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 88, 56))
+>exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
+>param2 : Symbol(param2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 88, 106))
+>exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
+    }
+}
+class privateClassWithPrivateModuleParameterTypes1 {
+>privateClassWithPrivateModuleParameterTypes1 : Symbol(privateClassWithPrivateModuleParameterTypes1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 90, 1))
+
+    static myPublicStaticMethod(param= exporter.createExportedWidget4()) {
+>myPublicStaticMethod : Symbol(privateClassWithPrivateModuleParameterTypes1.myPublicStaticMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 91, 52))
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 92, 32))
+>exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
+    }
+    myPublicMethod(param= exporter.createExportedWidget4()) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 93, 5))
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 94, 19))
+>exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
+    }
+    constructor(param= exporter.createExportedWidget4(), private param1= exporter.createExportedWidget4(), public param2= exporter.createExportedWidget4()) {
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 96, 16))
+>exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
+>param1 : Symbol(param1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 96, 56))
+>exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
+>param2 : Symbol(param2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 96, 106))
+>exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
+    }
+}
+function privateFunctionWithPrivateModuleParameterTypes(param= exporter.createExportedWidget2()) {
+>privateFunctionWithPrivateModuleParameterTypes : Symbol(privateFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 98, 1))
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 99, 56))
+>exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
+}
+function privateFunctionWithPrivateModuleParameterTypes1(param= exporter.createExportedWidget4()) {
+>privateFunctionWithPrivateModuleParameterTypes1 : Symbol(privateFunctionWithPrivateModuleParameterTypes1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 100, 1))
+>param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 101, 57))
+>exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
+}
+=== tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts ===
+
+
+declare module "GlobalWidgets" {
+    export class Widget3 {
+>Widget3 : Symbol(Widget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts, 2, 32))
+
+        name: string;
+>name : Symbol(name, Decl(privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts, 3, 26))
+    }
+    export function createWidget3(): Widget3;
+>createWidget3 : Symbol(createWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts, 5, 5))
+>Widget3 : Symbol(Widget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts, 2, 32))
+
+    export module SpecializedGlobalWidget {
+>SpecializedGlobalWidget : Symbol(SpecializedGlobalWidget, Decl(privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts, 6, 45))
+
+        export class Widget4 {
+>Widget4 : Symbol(Widget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts, 8, 43))
+
+            name: string;
+>name : Symbol(name, Decl(privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts, 9, 30))
+        }
+        function createWidget4(): Widget4;
+>createWidget4 : Symbol(createWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts, 11, 9))
+>Widget4 : Symbol(Widget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts, 8, 43))
+    }
+}
+
+=== tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_Widgets.ts ===
+export class Widget1 {
+>Widget1 : Symbol(Widget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_Widgets.ts, 0, 0))
+
+    name = 'one';
+>name : Symbol(name, Decl(privacyFunctionCannotNameParameterTypeDeclFile_Widgets.ts, 0, 22))
+}
+export function createWidget1() {
+>createWidget1 : Symbol(createWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_Widgets.ts, 2, 1))
+
+    return new Widget1();
+>Widget1 : Symbol(Widget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_Widgets.ts, 0, 0))
+}
+
+export module SpecializedWidget {
+>SpecializedWidget : Symbol(SpecializedWidget, Decl(privacyFunctionCannotNameParameterTypeDeclFile_Widgets.ts, 5, 1))
+
+    export class Widget2 {
+>Widget2 : Symbol(Widget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_Widgets.ts, 7, 33))
+
+        name = 'one';
+>name : Symbol(name, Decl(privacyFunctionCannotNameParameterTypeDeclFile_Widgets.ts, 8, 26))
+    }
+    export function createWidget2() {
+>createWidget2 : Symbol(createWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_Widgets.ts, 10, 5))
+
+        return new Widget2();
+>Widget2 : Symbol(Widget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_Widgets.ts, 7, 33))
+    }
+}
+
+=== tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts ===
+///<reference path='privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts'/>
+import Widgets = require("privacyFunctionCannotNameParameterTypeDeclFile_Widgets");
+>Widgets : Symbol(Widgets, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 0, 0))
+
+import Widgets1 = require("GlobalWidgets");
+>Widgets1 : Symbol(Widgets1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 1, 83))
+
+export function createExportedWidget1() {
+>createExportedWidget1 : Symbol(createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
+
+    return Widgets.createWidget1();
+>Widgets.createWidget1 : Symbol(Widgets.createWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_Widgets.ts, 2, 1))
+>Widgets : Symbol(Widgets, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 0, 0))
+>createWidget1 : Symbol(Widgets.createWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_Widgets.ts, 2, 1))
+}
+export function createExportedWidget2() {
+>createExportedWidget2 : Symbol(createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
+
+    return Widgets.SpecializedWidget.createWidget2();
+>Widgets.SpecializedWidget.createWidget2 : Symbol(Widgets.SpecializedWidget.createWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_Widgets.ts, 10, 5))
+>Widgets.SpecializedWidget : Symbol(Widgets.SpecializedWidget, Decl(privacyFunctionCannotNameParameterTypeDeclFile_Widgets.ts, 5, 1))
+>Widgets : Symbol(Widgets, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 0, 0))
+>SpecializedWidget : Symbol(Widgets.SpecializedWidget, Decl(privacyFunctionCannotNameParameterTypeDeclFile_Widgets.ts, 5, 1))
+>createWidget2 : Symbol(Widgets.SpecializedWidget.createWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_Widgets.ts, 10, 5))
+}
+export function createExportedWidget3() {
+>createExportedWidget3 : Symbol(createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
+
+    return Widgets1.createWidget3();
+>Widgets1.createWidget3 : Symbol(Widgets1.createWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts, 5, 5))
+>Widgets1 : Symbol(Widgets1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 1, 83))
+>createWidget3 : Symbol(Widgets1.createWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts, 5, 5))
+}
+export function createExportedWidget4() {
+>createExportedWidget4 : Symbol(createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
+
+    return Widgets1.SpecializedGlobalWidget.createWidget4();
+>Widgets1.SpecializedGlobalWidget.createWidget4 : Symbol(Widgets1.SpecializedGlobalWidget.createWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts, 11, 9))
+>Widgets1.SpecializedGlobalWidget : Symbol(Widgets1.SpecializedGlobalWidget, Decl(privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts, 6, 45))
+>Widgets1 : Symbol(Widgets1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 1, 83))
+>SpecializedGlobalWidget : Symbol(Widgets1.SpecializedGlobalWidget, Decl(privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts, 6, 45))
+>createWidget4 : Symbol(Widgets1.SpecializedGlobalWidget.createWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts, 11, 9))
+}
+
diff --git a/tests/baselines/reference/privacyFunctionCannotNameReturnTypeDeclFile.symbols b/tests/baselines/reference/privacyFunctionCannotNameReturnTypeDeclFile.symbols
new file mode 100644
index 0000000000000..11bacd1923f10
--- /dev/null
+++ b/tests/baselines/reference/privacyFunctionCannotNameReturnTypeDeclFile.symbols
@@ -0,0 +1,386 @@
+=== tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts ===
+import exporter = require("privacyFunctionReturnTypeDeclFile_exporter");
+>exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
+
+export class publicClassWithWithPrivateParmeterTypes {
+>publicClassWithWithPrivateParmeterTypes : Symbol(publicClassWithWithPrivateParmeterTypes, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 72))
+
+    static myPublicStaticMethod() { // Error
+>myPublicStaticMethod : Symbol(publicClassWithWithPrivateParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 1, 54))
+
+        return exporter.createExportedWidget1();
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
+    }
+    private static myPrivateStaticMethod() {
+>myPrivateStaticMethod : Symbol(publicClassWithWithPrivateParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 4, 5))
+
+        return exporter.createExportedWidget1();;
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
+    }
+    myPublicMethod() { // Error
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 7, 5))
+
+        return exporter.createExportedWidget1();;
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
+    }
+    private myPrivateMethod() {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 10, 5))
+
+        return exporter.createExportedWidget1();;
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
+    }
+    static myPublicStaticMethod1() { // Error
+>myPublicStaticMethod1 : Symbol(publicClassWithWithPrivateParmeterTypes.myPublicStaticMethod1, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 13, 5))
+
+        return exporter.createExportedWidget3();
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
+    }
+    private static myPrivateStaticMethod1() {
+>myPrivateStaticMethod1 : Symbol(publicClassWithWithPrivateParmeterTypes.myPrivateStaticMethod1, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 16, 5))
+
+        return exporter.createExportedWidget3();;
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
+    }
+    myPublicMethod1() { // Error
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 19, 5))
+
+        return exporter.createExportedWidget3();;
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
+    }
+    private myPrivateMethod1() {
+>myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 22, 5))
+
+        return exporter.createExportedWidget3();;
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
+    }
+}
+
+class privateClassWithWithPrivateParmeterTypes {
+>privateClassWithWithPrivateParmeterTypes : Symbol(privateClassWithWithPrivateParmeterTypes, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 26, 1))
+
+    static myPublicStaticMethod() { 
+>myPublicStaticMethod : Symbol(privateClassWithWithPrivateParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 28, 48))
+
+        return exporter.createExportedWidget1();
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
+    }
+    private static myPrivateStaticMethod() {
+>myPrivateStaticMethod : Symbol(privateClassWithWithPrivateParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 31, 5))
+
+        return exporter.createExportedWidget1();;
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
+    }
+    myPublicMethod() { 
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 34, 5))
+
+        return exporter.createExportedWidget1();;
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
+    }
+    private myPrivateMethod() {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 37, 5))
+
+        return exporter.createExportedWidget1();;
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
+    }
+    static myPublicStaticMethod1() { 
+>myPublicStaticMethod1 : Symbol(privateClassWithWithPrivateParmeterTypes.myPublicStaticMethod1, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 40, 5))
+
+        return exporter.createExportedWidget3();
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
+    }
+    private static myPrivateStaticMethod1() {
+>myPrivateStaticMethod1 : Symbol(privateClassWithWithPrivateParmeterTypes.myPrivateStaticMethod1, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 43, 5))
+
+        return exporter.createExportedWidget3();;
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
+    }
+    myPublicMethod1() { 
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 46, 5))
+
+        return exporter.createExportedWidget3();;
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
+    }
+    private myPrivateMethod1() {
+>myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 49, 5))
+
+        return exporter.createExportedWidget3();;
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
+    }
+}
+
+export function publicFunctionWithPrivateParmeterTypes() { // Error
+>publicFunctionWithPrivateParmeterTypes : Symbol(publicFunctionWithPrivateParmeterTypes, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 53, 1))
+
+    return exporter.createExportedWidget1();
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
+}
+function privateFunctionWithPrivateParmeterTypes()   {
+>privateFunctionWithPrivateParmeterTypes : Symbol(privateFunctionWithPrivateParmeterTypes, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 57, 1))
+
+    return exporter.createExportedWidget1();
+>exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
+>exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
+}
+export function publicFunctionWithPrivateParmeterTypes1() { // Error
+>publicFunctionWithPrivateParmeterTypes1 : Symbol(publicFunctionWithPrivateParmeterTypes1, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 60, 1))
+
+    return exporter.createExportedWidget3();
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
+}
+function privateFunctionWithPrivateParmeterTypes1() {
+>privateFunctionWithPrivateParmeterTypes1 : Symbol(privateFunctionWithPrivateParmeterTypes1, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 63, 1))
+
+    return exporter.createExportedWidget3();
+>exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
+}
+
+export class publicClassWithPrivateModuleReturnTypes {
+>publicClassWithPrivateModuleReturnTypes : Symbol(publicClassWithPrivateModuleReturnTypes, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 66, 1))
+
+    static myPublicStaticMethod() { // Error
+>myPublicStaticMethod : Symbol(publicClassWithPrivateModuleReturnTypes.myPublicStaticMethod, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 68, 54))
+
+        return exporter.createExportedWidget2();
+>exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 5, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 5, 1))
+    }
+    myPublicMethod() { // Error
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 71, 5))
+
+        return exporter.createExportedWidget2();
+>exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 5, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 5, 1))
+    }
+    static myPublicStaticMethod1() { // Error
+>myPublicStaticMethod1 : Symbol(publicClassWithPrivateModuleReturnTypes.myPublicStaticMethod1, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 74, 5))
+
+        return exporter.createExportedWidget4();
+>exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 11, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 11, 1))
+    }
+    myPublicMethod1() { // Error
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 77, 5))
+
+        return exporter.createExportedWidget4();
+>exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 11, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 11, 1))
+    }
+}
+export function publicFunctionWithPrivateModuleReturnTypes() { // Error
+>publicFunctionWithPrivateModuleReturnTypes : Symbol(publicFunctionWithPrivateModuleReturnTypes, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 81, 1))
+
+    return exporter.createExportedWidget2();
+>exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 5, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 5, 1))
+}
+export function publicFunctionWithPrivateModuleReturnTypes1() { // Error
+>publicFunctionWithPrivateModuleReturnTypes1 : Symbol(publicFunctionWithPrivateModuleReturnTypes1, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 84, 1))
+
+    return exporter.createExportedWidget4();
+>exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 11, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 11, 1))
+}
+
+class privateClassWithPrivateModuleReturnTypes {
+>privateClassWithPrivateModuleReturnTypes : Symbol(privateClassWithPrivateModuleReturnTypes, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 87, 1))
+
+    static myPublicStaticMethod() { 
+>myPublicStaticMethod : Symbol(privateClassWithPrivateModuleReturnTypes.myPublicStaticMethod, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 89, 48))
+
+        return exporter.createExportedWidget2();
+>exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 5, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 5, 1))
+    }
+    myPublicMethod() { 
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 92, 5))
+
+        return exporter.createExportedWidget2();
+>exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 5, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 5, 1))
+    }
+    static myPublicStaticMethod1() { // Error
+>myPublicStaticMethod1 : Symbol(privateClassWithPrivateModuleReturnTypes.myPublicStaticMethod1, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 95, 5))
+
+        return exporter.createExportedWidget4();
+>exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 11, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 11, 1))
+    }
+    myPublicMethod1() { // Error
+>myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 98, 5))
+
+        return exporter.createExportedWidget4();
+>exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 11, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 11, 1))
+    }
+}
+function privateFunctionWithPrivateModuleReturnTypes() { 
+>privateFunctionWithPrivateModuleReturnTypes : Symbol(privateFunctionWithPrivateModuleReturnTypes, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 102, 1))
+
+    return exporter.createExportedWidget2();
+>exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 5, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 5, 1))
+}
+function privateFunctionWithPrivateModuleReturnTypes1() {
+>privateFunctionWithPrivateModuleReturnTypes1 : Symbol(privateFunctionWithPrivateModuleReturnTypes1, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 105, 1))
+
+    return exporter.createExportedWidget4();
+>exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 11, 1))
+>exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
+>createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 11, 1))
+}
+
+=== tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts ===
+
+
+declare module "GlobalWidgets" {
+    export class Widget3 {
+>Widget3 : Symbol(Widget3, Decl(privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts, 2, 32))
+
+        name: string;
+>name : Symbol(name, Decl(privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts, 3, 26))
+    }
+    export function createWidget3(): Widget3;
+>createWidget3 : Symbol(createWidget3, Decl(privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts, 5, 5))
+>Widget3 : Symbol(Widget3, Decl(privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts, 2, 32))
+
+    export module SpecializedGlobalWidget {
+>SpecializedGlobalWidget : Symbol(SpecializedGlobalWidget, Decl(privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts, 6, 45))
+
+        export class Widget4 {
+>Widget4 : Symbol(Widget4, Decl(privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts, 8, 43))
+
+            name: string;
+>name : Symbol(name, Decl(privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts, 9, 30))
+        }
+        function createWidget4(): Widget4;
+>createWidget4 : Symbol(createWidget4, Decl(privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts, 11, 9))
+>Widget4 : Symbol(Widget4, Decl(privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts, 8, 43))
+    }
+}
+
+=== tests/cases/compiler/privacyFunctionReturnTypeDeclFile_Widgets.ts ===
+export class Widget1 {
+>Widget1 : Symbol(Widget1, Decl(privacyFunctionReturnTypeDeclFile_Widgets.ts, 0, 0))
+
+    name = 'one';
+>name : Symbol(name, Decl(privacyFunctionReturnTypeDeclFile_Widgets.ts, 0, 22))
+}
+export function createWidget1() {
+>createWidget1 : Symbol(createWidget1, Decl(privacyFunctionReturnTypeDeclFile_Widgets.ts, 2, 1))
+
+    return new Widget1();
+>Widget1 : Symbol(Widget1, Decl(privacyFunctionReturnTypeDeclFile_Widgets.ts, 0, 0))
+}
+
+export module SpecializedWidget {
+>SpecializedWidget : Symbol(SpecializedWidget, Decl(privacyFunctionReturnTypeDeclFile_Widgets.ts, 5, 1))
+
+    export class Widget2 {
+>Widget2 : Symbol(Widget2, Decl(privacyFunctionReturnTypeDeclFile_Widgets.ts, 7, 33))
+
+        name = 'one';
+>name : Symbol(name, Decl(privacyFunctionReturnTypeDeclFile_Widgets.ts, 8, 26))
+    }
+    export function createWidget2() {
+>createWidget2 : Symbol(createWidget2, Decl(privacyFunctionReturnTypeDeclFile_Widgets.ts, 10, 5))
+
+        return new Widget2();
+>Widget2 : Symbol(Widget2, Decl(privacyFunctionReturnTypeDeclFile_Widgets.ts, 7, 33))
+    }
+}
+
+=== tests/cases/compiler/privacyFunctionReturnTypeDeclFile_exporter.ts ===
+///<reference path='privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts'/>
+import Widgets = require("privacyFunctionReturnTypeDeclFile_Widgets");
+>Widgets : Symbol(Widgets, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 0, 0))
+
+import Widgets1 = require("GlobalWidgets");
+>Widgets1 : Symbol(Widgets1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 1, 70))
+
+export function createExportedWidget1() {
+>createExportedWidget1 : Symbol(createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
+
+    return Widgets.createWidget1();
+>Widgets.createWidget1 : Symbol(Widgets.createWidget1, Decl(privacyFunctionReturnTypeDeclFile_Widgets.ts, 2, 1))
+>Widgets : Symbol(Widgets, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 0, 0))
+>createWidget1 : Symbol(Widgets.createWidget1, Decl(privacyFunctionReturnTypeDeclFile_Widgets.ts, 2, 1))
+}
+export function createExportedWidget2() {
+>createExportedWidget2 : Symbol(createExportedWidget2, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 5, 1))
+
+    return Widgets.SpecializedWidget.createWidget2();
+>Widgets.SpecializedWidget.createWidget2 : Symbol(Widgets.SpecializedWidget.createWidget2, Decl(privacyFunctionReturnTypeDeclFile_Widgets.ts, 10, 5))
+>Widgets.SpecializedWidget : Symbol(Widgets.SpecializedWidget, Decl(privacyFunctionReturnTypeDeclFile_Widgets.ts, 5, 1))
+>Widgets : Symbol(Widgets, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 0, 0))
+>SpecializedWidget : Symbol(Widgets.SpecializedWidget, Decl(privacyFunctionReturnTypeDeclFile_Widgets.ts, 5, 1))
+>createWidget2 : Symbol(Widgets.SpecializedWidget.createWidget2, Decl(privacyFunctionReturnTypeDeclFile_Widgets.ts, 10, 5))
+}
+export function createExportedWidget3() {
+>createExportedWidget3 : Symbol(createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
+
+    return Widgets1.createWidget3();
+>Widgets1.createWidget3 : Symbol(Widgets1.createWidget3, Decl(privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts, 5, 5))
+>Widgets1 : Symbol(Widgets1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 1, 70))
+>createWidget3 : Symbol(Widgets1.createWidget3, Decl(privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts, 5, 5))
+}
+export function createExportedWidget4() {
+>createExportedWidget4 : Symbol(createExportedWidget4, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 11, 1))
+
+    return Widgets1.SpecializedGlobalWidget.createWidget4();
+>Widgets1.SpecializedGlobalWidget.createWidget4 : Symbol(Widgets1.SpecializedGlobalWidget.createWidget4, Decl(privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts, 11, 9))
+>Widgets1.SpecializedGlobalWidget : Symbol(Widgets1.SpecializedGlobalWidget, Decl(privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts, 6, 45))
+>Widgets1 : Symbol(Widgets1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 1, 70))
+>SpecializedGlobalWidget : Symbol(Widgets1.SpecializedGlobalWidget, Decl(privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts, 6, 45))
+>createWidget4 : Symbol(Widgets1.SpecializedGlobalWidget.createWidget4, Decl(privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts, 11, 9))
+}
+
diff --git a/tests/baselines/reference/privacyFunctionParameterDeclFile.symbols b/tests/baselines/reference/privacyFunctionParameterDeclFile.symbols
new file mode 100644
index 0000000000000..21373545d2a2a
--- /dev/null
+++ b/tests/baselines/reference/privacyFunctionParameterDeclFile.symbols
@@ -0,0 +1,1968 @@
+=== tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts ===
+
+class privateClass {
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
+}
+
+export class publicClass {
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
+}
+
+export interface publicInterfaceWithPrivateParmeterTypes {
+>publicInterfaceWithPrivateParmeterTypes : Symbol(publicInterfaceWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 5, 1))
+
+    new (param: privateClass): publicClass; // Error
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 8, 9))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
+
+    (param: privateClass): publicClass; // Error
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 9, 5))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
+
+    myMethod(param: privateClass): void; // Error
+>myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 9, 39))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 10, 13))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
+}
+
+export interface publicInterfaceWithPublicParmeterTypes {
+>publicInterfaceWithPublicParmeterTypes : Symbol(publicInterfaceWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 11, 1))
+
+    new (param: publicClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 14, 9))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
+
+    (param: publicClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 15, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
+
+    myMethod(param: publicClass): void;
+>myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 15, 38))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 16, 13))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
+}
+
+interface privateInterfaceWithPrivateParmeterTypes {
+>privateInterfaceWithPrivateParmeterTypes : Symbol(privateInterfaceWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 17, 1))
+
+    new (param: privateClass): privateClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 20, 9))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
+
+    (param: privateClass): privateClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 21, 5))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
+
+    myMethod(param: privateClass): void;
+>myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 21, 40))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 22, 13))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
+}
+
+interface privateInterfaceWithPublicParmeterTypes {
+>privateInterfaceWithPublicParmeterTypes : Symbol(privateInterfaceWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 23, 1))
+
+    new (param: publicClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 26, 9))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
+
+    (param: publicClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 27, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
+
+    myMethod(param: publicClass): void;
+>myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 27, 38))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 28, 13))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
+}
+
+export class publicClassWithWithPrivateParmeterTypes {
+>publicClassWithWithPrivateParmeterTypes : Symbol(publicClassWithWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 29, 1))
+
+    static myPublicStaticMethod(param: privateClass) { // Error
+>myPublicStaticMethod : Symbol(publicClassWithWithPrivateParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 31, 54))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 32, 32))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
+    }
+    private static myPrivateStaticMethod(param: privateClass) {
+>myPrivateStaticMethod : Symbol(publicClassWithWithPrivateParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 33, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 34, 41))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
+    }
+    myPublicMethod(param: privateClass) { // Error
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 35, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 36, 19))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
+    }
+    private myPrivateMethod(param: privateClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 37, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 38, 28))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
+    }
+    constructor(param: privateClass, private param1: privateClass, public param2: privateClass) { // Error
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 40, 16))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
+>param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 40, 36))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
+>param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 40, 66))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
+    }
+}
+
+export class publicClassWithWithPublicParmeterTypes {
+>publicClassWithWithPublicParmeterTypes : Symbol(publicClassWithWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 42, 1))
+
+    static myPublicStaticMethod(param: publicClass) {
+>myPublicStaticMethod : Symbol(publicClassWithWithPublicParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 44, 53))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 45, 32))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
+    }
+    private static myPrivateStaticMethod(param: publicClass) {
+>myPrivateStaticMethod : Symbol(publicClassWithWithPublicParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 46, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 47, 41))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
+    }
+    myPublicMethod(param: publicClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 48, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 49, 19))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
+    }
+    private myPrivateMethod(param: publicClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 50, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 51, 28))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
+    }
+    constructor(param: publicClass, private param1: publicClass, public param2: publicClass) {
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 53, 16))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
+>param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 53, 35))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
+>param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 53, 64))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
+    }
+}
+
+class privateClassWithWithPrivateParmeterTypes {
+>privateClassWithWithPrivateParmeterTypes : Symbol(privateClassWithWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 55, 1))
+
+    static myPublicStaticMethod(param: privateClass) {
+>myPublicStaticMethod : Symbol(privateClassWithWithPrivateParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 57, 48))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 58, 32))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
+    }
+    private static myPrivateStaticMethod(param: privateClass) {
+>myPrivateStaticMethod : Symbol(privateClassWithWithPrivateParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 59, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 60, 41))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
+    }
+    myPublicMethod(param: privateClass) { 
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 61, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 62, 19))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
+    }
+    private myPrivateMethod(param: privateClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 63, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 64, 28))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
+    }
+    constructor(param: privateClass, private param1: privateClass, public param2: privateClass) {
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 66, 16))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
+>param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 66, 36))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
+>param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 66, 66))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
+    }
+}
+
+class privateClassWithWithPublicParmeterTypes {
+>privateClassWithWithPublicParmeterTypes : Symbol(privateClassWithWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 68, 1))
+
+    static myPublicStaticMethod(param: publicClass) {
+>myPublicStaticMethod : Symbol(privateClassWithWithPublicParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 70, 47))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 71, 32))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
+    }
+    private static myPrivateStaticMethod(param: publicClass) {
+>myPrivateStaticMethod : Symbol(privateClassWithWithPublicParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 72, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 73, 41))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
+    }
+    myPublicMethod(param: publicClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 74, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 75, 19))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
+    }
+    private myPrivateMethod(param: publicClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 76, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 77, 28))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
+    }
+    constructor(param: publicClass, private param1: publicClass, public param2: publicClass) {
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 79, 16))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
+>param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 79, 35))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
+>param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 79, 64))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
+    }
+}
+
+export function publicFunctionWithPrivateParmeterTypes(param: privateClass) { // Error
+>publicFunctionWithPrivateParmeterTypes : Symbol(publicFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 81, 1))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 83, 55))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
+}
+export function publicFunctionWithPublicParmeterTypes(param: publicClass) {
+>publicFunctionWithPublicParmeterTypes : Symbol(publicFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 84, 1))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 85, 54))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
+}
+function privateFunctionWithPrivateParmeterTypes(param: privateClass) {
+>privateFunctionWithPrivateParmeterTypes : Symbol(privateFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 86, 1))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 87, 49))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
+}
+function privateFunctionWithPublicParmeterTypes(param: publicClass) {
+>privateFunctionWithPublicParmeterTypes : Symbol(privateFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 88, 1))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 89, 48))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
+}
+
+export declare function publicAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void; // Error
+>publicAmbientFunctionWithPrivateParmeterTypes : Symbol(publicAmbientFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 90, 1))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 92, 70))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
+
+export declare function publicAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
+>publicAmbientFunctionWithPublicParmeterTypes : Symbol(publicAmbientFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 92, 97))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 93, 69))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
+
+declare function privateAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void;
+>privateAmbientFunctionWithPrivateParmeterTypes : Symbol(privateAmbientFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 93, 95))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 94, 64))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
+
+declare function privateAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
+>privateAmbientFunctionWithPublicParmeterTypes : Symbol(privateAmbientFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 94, 91))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 95, 63))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
+
+export interface publicInterfaceWithPrivateModuleParameterTypes {
+>publicInterfaceWithPrivateModuleParameterTypes : Symbol(publicInterfaceWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 95, 89))
+
+    new (param: privateModule.publicClass): publicClass; // Error
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 98, 9))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
+
+    (param: privateModule.publicClass): publicClass; // Error
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 99, 5))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
+
+    myMethod(param: privateModule.publicClass): void; // Error
+>myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 99, 52))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 100, 13))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+}
+export class publicClassWithPrivateModuleParameterTypes {
+>publicClassWithPrivateModuleParameterTypes : Symbol(publicClassWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 101, 1))
+
+    static myPublicStaticMethod(param: privateModule.publicClass) { // Error
+>myPublicStaticMethod : Symbol(publicClassWithPrivateModuleParameterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 102, 57))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 103, 32))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+    }
+    myPublicMethod(param: privateModule.publicClass) { // Error
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 104, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 105, 19))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+    }
+    constructor(param: privateModule.publicClass, private param1: privateModule.publicClass, public param2: privateModule.publicClass) { // Error
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 107, 16))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+>param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 107, 49))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+>param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 107, 92))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+    }
+}
+export function publicFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass) { // Error
+>publicFunctionWithPrivateModuleParameterTypes : Symbol(publicFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 109, 1))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 110, 62))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+}
+export declare function publicAmbientFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass): void; // Error
+>publicAmbientFunctionWithPrivateModuleParameterTypes : Symbol(publicAmbientFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 111, 1))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 112, 77))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+
+interface privateInterfaceWithPrivateModuleParameterTypes {
+>privateInterfaceWithPrivateModuleParameterTypes : Symbol(privateInterfaceWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 112, 117))
+
+    new (param: privateModule.publicClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 115, 9))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
+
+    (param: privateModule.publicClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 116, 5))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
+
+    myMethod(param: privateModule.publicClass): void;
+>myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 116, 52))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 117, 13))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+}
+class privateClassWithPrivateModuleParameterTypes {
+>privateClassWithPrivateModuleParameterTypes : Symbol(privateClassWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 118, 1))
+
+    static myPublicStaticMethod(param: privateModule.publicClass) {
+>myPublicStaticMethod : Symbol(privateClassWithPrivateModuleParameterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 119, 51))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 120, 32))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+    }
+    myPublicMethod(param: privateModule.publicClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 121, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 122, 19))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+    }
+    constructor(param: privateModule.publicClass, private param1: privateModule.publicClass, public param2: privateModule.publicClass) {
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 124, 16))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+>param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 124, 49))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+>param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 124, 92))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+    }
+}
+function privateFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass) {
+>privateFunctionWithPrivateModuleParameterTypes : Symbol(privateFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 126, 1))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 127, 56))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+}
+declare function privateAmbientFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass): void;
+>privateAmbientFunctionWithPrivateModuleParameterTypes : Symbol(privateAmbientFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 128, 1))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 129, 71))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+
+export module publicModule {
+>publicModule : Symbol(publicModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 129, 111))
+
+    class privateClass {
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
+    }
+
+    export class publicClass {
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
+    }
+
+
+    export interface publicInterfaceWithPrivateParmeterTypes {
+>publicInterfaceWithPrivateParmeterTypes : Symbol(publicInterfaceWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 136, 5))
+
+        new (param: privateClass): publicClass; // Error
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 140, 13))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
+
+        (param: privateClass): publicClass; // Error
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 141, 9))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
+
+        myMethod(param: privateClass): void; // Error
+>myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 141, 43))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 142, 17))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
+    }
+
+    export interface publicInterfaceWithPublicParmeterTypes {
+>publicInterfaceWithPublicParmeterTypes : Symbol(publicInterfaceWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 143, 5))
+
+        new (param: publicClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 146, 13))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
+
+        (param: publicClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 147, 9))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
+
+        myMethod(param: publicClass): void;
+>myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 147, 42))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 148, 17))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
+    }
+
+    interface privateInterfaceWithPrivateParmeterTypes {
+>privateInterfaceWithPrivateParmeterTypes : Symbol(privateInterfaceWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 149, 5))
+
+        new (param: privateClass): privateClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 152, 13))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
+
+        (param: privateClass): privateClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 153, 9))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
+
+        myMethod(param: privateClass): void;
+>myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 153, 44))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 154, 17))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
+    }
+
+    interface privateInterfaceWithPublicParmeterTypes {
+>privateInterfaceWithPublicParmeterTypes : Symbol(privateInterfaceWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 155, 5))
+
+        new (param: publicClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 158, 13))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
+
+        (param: publicClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 159, 9))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
+
+        myMethod(param: publicClass): void;
+>myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 159, 42))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 160, 17))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
+    }
+
+    export class publicClassWithWithPrivateParmeterTypes {
+>publicClassWithWithPrivateParmeterTypes : Symbol(publicClassWithWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 161, 5))
+
+        static myPublicStaticMethod(param: privateClass) { // Error
+>myPublicStaticMethod : Symbol(publicClassWithWithPrivateParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 163, 58))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 164, 36))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
+        }
+        private static myPrivateStaticMethod(param: privateClass) {
+>myPrivateStaticMethod : Symbol(publicClassWithWithPrivateParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 165, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 166, 45))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
+        }
+        myPublicMethod(param: privateClass) { // Error
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 167, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 168, 23))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
+        }
+        private myPrivateMethod(param: privateClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 169, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 170, 32))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
+        }
+        constructor(param: privateClass, private param1: privateClass, public param2: privateClass) { // Error
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 172, 20))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
+>param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 172, 40))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
+>param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 172, 70))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
+        }
+    }
+
+    export class publicClassWithWithPublicParmeterTypes {
+>publicClassWithWithPublicParmeterTypes : Symbol(publicClassWithWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 174, 5))
+
+        static myPublicStaticMethod(param: publicClass) {
+>myPublicStaticMethod : Symbol(publicClassWithWithPublicParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 176, 57))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 177, 36))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
+        }
+        private static myPrivateStaticMethod(param: publicClass) {
+>myPrivateStaticMethod : Symbol(publicClassWithWithPublicParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 178, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 179, 45))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
+        }
+        myPublicMethod(param: publicClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 180, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 181, 23))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
+        }
+        private myPrivateMethod(param: publicClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 182, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 183, 32))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
+        }
+        constructor(param: publicClass, private param1: publicClass, public param2: publicClass) {
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 185, 20))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
+>param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 185, 39))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
+>param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 185, 68))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
+        }
+    }
+
+    class privateClassWithWithPrivateParmeterTypes {
+>privateClassWithWithPrivateParmeterTypes : Symbol(privateClassWithWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 187, 5))
+
+        static myPublicStaticMethod(param: privateClass) {
+>myPublicStaticMethod : Symbol(privateClassWithWithPrivateParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 189, 52))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 190, 36))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
+        }
+        private static myPrivateStaticMethod(param: privateClass) {
+>myPrivateStaticMethod : Symbol(privateClassWithWithPrivateParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 191, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 192, 45))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
+        }
+        myPublicMethod(param: privateClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 193, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 194, 23))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
+        }
+        private myPrivateMethod(param: privateClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 195, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 196, 32))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
+        }
+        constructor(param: privateClass, private param1: privateClass, public param2: privateClass) {
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 198, 20))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
+>param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 198, 40))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
+>param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 198, 70))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
+        }
+    }
+
+    class privateClassWithWithPublicParmeterTypes {
+>privateClassWithWithPublicParmeterTypes : Symbol(privateClassWithWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 200, 5))
+
+        static myPublicStaticMethod(param: publicClass) {
+>myPublicStaticMethod : Symbol(privateClassWithWithPublicParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 202, 51))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 203, 36))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
+        }
+        private static myPrivateStaticMethod(param: publicClass) {
+>myPrivateStaticMethod : Symbol(privateClassWithWithPublicParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 204, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 205, 45))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
+        }
+        myPublicMethod(param: publicClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 206, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 207, 23))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
+        }
+        private myPrivateMethod(param: publicClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 208, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 209, 32))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
+        }
+        constructor(param: publicClass, private param1: publicClass, public param2: publicClass) {
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 211, 20))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
+>param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 211, 39))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
+>param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 211, 68))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
+        }
+    }
+
+    export function publicFunctionWithPrivateParmeterTypes(param: privateClass) { // Error
+>publicFunctionWithPrivateParmeterTypes : Symbol(publicFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 213, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 215, 59))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
+    }
+    export function publicFunctionWithPublicParmeterTypes(param: publicClass) {
+>publicFunctionWithPublicParmeterTypes : Symbol(publicFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 216, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 217, 58))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
+    }
+    function privateFunctionWithPrivateParmeterTypes(param: privateClass) {
+>privateFunctionWithPrivateParmeterTypes : Symbol(privateFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 218, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 219, 53))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
+    }
+    function privateFunctionWithPublicParmeterTypes(param: publicClass) {
+>privateFunctionWithPublicParmeterTypes : Symbol(privateFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 220, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 221, 52))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
+    }
+
+    export declare function publicAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void; // Error
+>publicAmbientFunctionWithPrivateParmeterTypes : Symbol(publicAmbientFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 222, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 224, 74))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
+
+    export declare function publicAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
+>publicAmbientFunctionWithPublicParmeterTypes : Symbol(publicAmbientFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 224, 101))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 225, 73))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
+
+    declare function privateAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void;
+>privateAmbientFunctionWithPrivateParmeterTypes : Symbol(privateAmbientFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 225, 99))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 226, 68))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
+
+    declare function privateAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
+>privateAmbientFunctionWithPublicParmeterTypes : Symbol(privateAmbientFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 226, 95))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 227, 67))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
+
+    export interface publicInterfaceWithPrivateModuleParameterTypes {
+>publicInterfaceWithPrivateModuleParameterTypes : Symbol(publicInterfaceWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 227, 93))
+
+        new (param: privateModule.publicClass): publicClass; // Error
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 230, 13))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
+
+        (param: privateModule.publicClass): publicClass; // Error
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 231, 9))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
+
+        myMethod(param: privateModule.publicClass): void; // Error
+>myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 231, 56))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 232, 17))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+    }
+    export class publicClassWithPrivateModuleParameterTypes {
+>publicClassWithPrivateModuleParameterTypes : Symbol(publicClassWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 233, 5))
+
+        static myPublicStaticMethod(param: privateModule.publicClass) { // Error
+>myPublicStaticMethod : Symbol(publicClassWithPrivateModuleParameterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 234, 61))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 235, 36))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+        }
+        myPublicMethod(param: privateModule.publicClass) { // Error
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 236, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 237, 23))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+        }
+        constructor(param: privateModule.publicClass, private param1: privateModule.publicClass, public param2: privateModule.publicClass) { // Error
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 239, 20))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+>param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 239, 53))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+>param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 239, 96))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+        }
+    }
+    export function publicFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass) { // Error
+>publicFunctionWithPrivateModuleParameterTypes : Symbol(publicFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 241, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 242, 66))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+    }
+    export declare function publicAmbientFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass): void; // Error
+>publicAmbientFunctionWithPrivateModuleParameterTypes : Symbol(publicAmbientFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 243, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 244, 81))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+
+    interface privateInterfaceWithPrivateModuleParameterTypes {
+>privateInterfaceWithPrivateModuleParameterTypes : Symbol(privateInterfaceWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 244, 121))
+
+        new (param: privateModule.publicClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 247, 13))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
+
+        (param: privateModule.publicClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 248, 9))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
+
+        myMethod(param: privateModule.publicClass): void;
+>myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 248, 56))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 249, 17))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+    }
+    class privateClassWithPrivateModuleParameterTypes {
+>privateClassWithPrivateModuleParameterTypes : Symbol(privateClassWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 250, 5))
+
+        static myPublicStaticMethod(param: privateModule.publicClass) {
+>myPublicStaticMethod : Symbol(privateClassWithPrivateModuleParameterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 251, 55))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 252, 36))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+        }
+        myPublicMethod(param: privateModule.publicClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 253, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 254, 23))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+        }
+        constructor(param: privateModule.publicClass, private param1: privateModule.publicClass, public param2: privateModule.publicClass) {
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 256, 20))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+>param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 256, 53))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+>param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 256, 96))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+        }
+    }
+    function privateFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass) {
+>privateFunctionWithPrivateModuleParameterTypes : Symbol(privateFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 258, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 259, 60))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+    }
+    declare function privateAmbientFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass): void;
+>privateAmbientFunctionWithPrivateModuleParameterTypes : Symbol(privateAmbientFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 260, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 261, 75))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+
+}
+
+module privateModule {
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+
+    class privateClass {
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
+    }
+
+    export class publicClass {
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+    }
+
+    export interface publicInterfaceWithPrivateParmeterTypes {
+>publicInterfaceWithPrivateParmeterTypes : Symbol(publicInterfaceWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 270, 5))
+
+        new (param: privateClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 273, 13))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+
+        (param: privateClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 274, 9))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+
+        myMethod(param: privateClass): void;
+>myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 274, 43))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 275, 17))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
+    }
+
+    export interface publicInterfaceWithPublicParmeterTypes {
+>publicInterfaceWithPublicParmeterTypes : Symbol(publicInterfaceWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 276, 5))
+
+        new (param: publicClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 279, 13))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+
+        (param: publicClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 280, 9))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+
+        myMethod(param: publicClass): void;
+>myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 280, 42))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 281, 17))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+    }
+
+    interface privateInterfaceWithPrivateParmeterTypes {
+>privateInterfaceWithPrivateParmeterTypes : Symbol(privateInterfaceWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 282, 5))
+
+        new (param: privateClass): privateClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 285, 13))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
+
+        (param: privateClass): privateClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 286, 9))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
+
+        myMethod(param: privateClass): void;
+>myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 286, 44))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 287, 17))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
+    }
+
+    interface privateInterfaceWithPublicParmeterTypes {
+>privateInterfaceWithPublicParmeterTypes : Symbol(privateInterfaceWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 288, 5))
+
+        new (param: publicClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 291, 13))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+
+        (param: publicClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 292, 9))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+
+        myMethod(param: publicClass): void;
+>myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 292, 42))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 293, 17))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+    }
+
+    export class publicClassWithWithPrivateParmeterTypes {
+>publicClassWithWithPrivateParmeterTypes : Symbol(publicClassWithWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 294, 5))
+
+        static myPublicStaticMethod(param: privateClass) {
+>myPublicStaticMethod : Symbol(publicClassWithWithPrivateParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 296, 58))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 297, 36))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
+        }
+        private static myPrivateStaticMethod(param: privateClass) {
+>myPrivateStaticMethod : Symbol(publicClassWithWithPrivateParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 298, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 299, 45))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
+        }
+        myPublicMethod(param: privateClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 300, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 301, 23))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
+        }
+        private myPrivateMethod(param: privateClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 302, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 303, 32))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
+        }
+        constructor(param: privateClass, private param1: privateClass, public param2: privateClass) {
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 305, 20))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
+>param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 305, 40))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
+>param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 305, 70))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
+        }
+    }
+
+    export class publicClassWithWithPublicParmeterTypes {
+>publicClassWithWithPublicParmeterTypes : Symbol(publicClassWithWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 307, 5))
+
+        static myPublicStaticMethod(param: publicClass) {
+>myPublicStaticMethod : Symbol(publicClassWithWithPublicParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 309, 57))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 310, 36))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+        }
+        private static myPrivateStaticMethod(param: publicClass) {
+>myPrivateStaticMethod : Symbol(publicClassWithWithPublicParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 311, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 312, 45))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+        }
+        myPublicMethod(param: publicClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 313, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 314, 23))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+        }
+        private myPrivateMethod(param: publicClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 315, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 316, 32))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+        }
+        constructor(param: publicClass, private param1: publicClass, public param2: publicClass) {
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 318, 20))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+>param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 318, 39))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+>param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 318, 68))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+        }
+    }
+
+    class privateClassWithWithPrivateParmeterTypes {
+>privateClassWithWithPrivateParmeterTypes : Symbol(privateClassWithWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 320, 5))
+
+        static myPublicStaticMethod(param: privateClass) {
+>myPublicStaticMethod : Symbol(privateClassWithWithPrivateParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 322, 52))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 323, 36))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
+        }
+        private static myPrivateStaticMethod(param: privateClass) {
+>myPrivateStaticMethod : Symbol(privateClassWithWithPrivateParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 324, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 325, 45))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
+        }
+        myPublicMethod(param: privateClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 326, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 327, 23))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
+        }
+        private myPrivateMethod(param: privateClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 328, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 329, 32))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
+        }
+        constructor(param: privateClass, private param1: privateClass, public param2: privateClass) {
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 331, 20))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
+>param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 331, 40))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
+>param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 331, 70))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
+        }
+    }
+
+    class privateClassWithWithPublicParmeterTypes {
+>privateClassWithWithPublicParmeterTypes : Symbol(privateClassWithWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 333, 5))
+
+        static myPublicStaticMethod(param: publicClass) {
+>myPublicStaticMethod : Symbol(privateClassWithWithPublicParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 335, 51))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 336, 36))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+        }
+        private static myPrivateStaticMethod(param: publicClass) {
+>myPrivateStaticMethod : Symbol(privateClassWithWithPublicParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 337, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 338, 45))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+        }
+        myPublicMethod(param: publicClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 339, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 340, 23))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+        }
+        private myPrivateMethod(param: publicClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 341, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 342, 32))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+        }
+        constructor(param: publicClass, private param1: publicClass, public param2: publicClass) {
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 344, 20))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+>param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 344, 39))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+>param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 344, 68))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+        }
+    }
+
+    export function publicFunctionWithPrivateParmeterTypes(param: privateClass) {
+>publicFunctionWithPrivateParmeterTypes : Symbol(publicFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 346, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 348, 59))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
+    }
+    export function publicFunctionWithPublicParmeterTypes(param: publicClass) {
+>publicFunctionWithPublicParmeterTypes : Symbol(publicFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 349, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 350, 58))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+    }
+    function privateFunctionWithPrivateParmeterTypes(param: privateClass) {
+>privateFunctionWithPrivateParmeterTypes : Symbol(privateFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 351, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 352, 53))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
+    }
+    function privateFunctionWithPublicParmeterTypes(param: publicClass) {
+>privateFunctionWithPublicParmeterTypes : Symbol(privateFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 353, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 354, 52))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+    }
+
+    export declare function publicAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void;
+>publicAmbientFunctionWithPrivateParmeterTypes : Symbol(publicAmbientFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 355, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 357, 74))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
+
+    export declare function publicAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
+>publicAmbientFunctionWithPublicParmeterTypes : Symbol(publicAmbientFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 357, 101))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 358, 73))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+
+    declare function privateAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void;
+>privateAmbientFunctionWithPrivateParmeterTypes : Symbol(privateAmbientFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 358, 99))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 359, 68))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
+
+    declare function privateAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
+>privateAmbientFunctionWithPublicParmeterTypes : Symbol(privateAmbientFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 359, 95))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 360, 67))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+
+    export interface publicInterfaceWithPrivateModuleParameterTypes {
+>publicInterfaceWithPrivateModuleParameterTypes : Symbol(publicInterfaceWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 360, 93))
+
+        new (param: privateModule.publicClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 363, 13))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+
+        (param: privateModule.publicClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 364, 9))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+
+        myMethod(param: privateModule.publicClass): void;
+>myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 364, 56))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 365, 17))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+    }
+    export class publicClassWithPrivateModuleParameterTypes {
+>publicClassWithPrivateModuleParameterTypes : Symbol(publicClassWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 366, 5))
+
+        static myPublicStaticMethod(param: privateModule.publicClass) {
+>myPublicStaticMethod : Symbol(publicClassWithPrivateModuleParameterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 367, 61))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 368, 36))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+        }
+        myPublicMethod(param: privateModule.publicClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 369, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 370, 23))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+        }
+        constructor(param: privateModule.publicClass, private param1: privateModule.publicClass, public param2: privateModule.publicClass) {
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 372, 20))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+>param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 372, 53))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+>param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 372, 96))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+        }
+    }
+    export function publicFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass) {
+>publicFunctionWithPrivateModuleParameterTypes : Symbol(publicFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 374, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 375, 66))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+    }
+    export declare function publicAmbientFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass): void;
+>publicAmbientFunctionWithPrivateModuleParameterTypes : Symbol(publicAmbientFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 376, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 377, 81))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+
+    interface privateInterfaceWithPrivateModuleParameterTypes {
+>privateInterfaceWithPrivateModuleParameterTypes : Symbol(privateInterfaceWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 377, 121))
+
+        new (param: privateModule.publicClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 380, 13))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+
+        (param: privateModule.publicClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 381, 9))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+
+        myMethod(param: privateModule.publicClass): void;
+>myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 381, 56))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 382, 17))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+    }
+    class privateClassWithPrivateModuleParameterTypes {
+>privateClassWithPrivateModuleParameterTypes : Symbol(privateClassWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 383, 5))
+
+        static myPublicStaticMethod(param: privateModule.publicClass) {
+>myPublicStaticMethod : Symbol(privateClassWithPrivateModuleParameterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 384, 55))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 385, 36))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+        }
+        myPublicMethod(param: privateModule.publicClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 386, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 387, 23))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+        }
+        constructor(param: privateModule.publicClass, private param1: privateModule.publicClass, public param2: privateModule.publicClass) {
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 389, 20))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+>param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 389, 53))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+>param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 389, 96))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+        }
+    }
+    function privateFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass) {
+>privateFunctionWithPrivateModuleParameterTypes : Symbol(privateFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 391, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 392, 60))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+    }
+    declare function privateAmbientFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass): void;
+>privateAmbientFunctionWithPrivateModuleParameterTypes : Symbol(privateAmbientFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 393, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 394, 75))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
+}
+
+=== tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts ===
+class publicClassInGlobal {
+>publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 0, 0))
+}
+interface publicInterfaceWithPublicParmeterTypesInGlobal {
+>publicInterfaceWithPublicParmeterTypesInGlobal : Symbol(publicInterfaceWithPublicParmeterTypesInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 1, 1))
+
+    new (param: publicClassInGlobal): publicClassInGlobal;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 3, 9))
+>publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 0, 0))
+>publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 0, 0))
+
+    (param: publicClassInGlobal): publicClassInGlobal;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 4, 5))
+>publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 0, 0))
+>publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 0, 0))
+
+    myMethod(param: publicClassInGlobal): void;
+>myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 4, 54))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 5, 13))
+>publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 0, 0))
+}
+class publicClassWithWithPublicParmeterTypesInGlobal {
+>publicClassWithWithPublicParmeterTypesInGlobal : Symbol(publicClassWithWithPublicParmeterTypesInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 6, 1))
+
+    static myPublicStaticMethod(param: publicClassInGlobal) {
+>myPublicStaticMethod : Symbol(publicClassWithWithPublicParmeterTypesInGlobal.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 7, 54))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 8, 32))
+>publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 0, 0))
+    }
+    private static myPrivateStaticMethod(param: publicClassInGlobal) {
+>myPrivateStaticMethod : Symbol(publicClassWithWithPublicParmeterTypesInGlobal.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 9, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 10, 41))
+>publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 0, 0))
+    }
+    myPublicMethod(param: publicClassInGlobal) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 11, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 12, 19))
+>publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 0, 0))
+    }
+    private myPrivateMethod(param: publicClassInGlobal) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 13, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 14, 28))
+>publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 0, 0))
+    }
+    constructor(param: publicClassInGlobal, private param1: publicClassInGlobal, public param2: publicClassInGlobal) {
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 16, 16))
+>publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 0, 0))
+>param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 16, 43))
+>publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 0, 0))
+>param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 16, 80))
+>publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 0, 0))
+    }
+}
+function publicFunctionWithPublicParmeterTypesInGlobal(param: publicClassInGlobal) {
+>publicFunctionWithPublicParmeterTypesInGlobal : Symbol(publicFunctionWithPublicParmeterTypesInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 18, 1))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 19, 55))
+>publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 0, 0))
+}
+declare function publicAmbientFunctionWithPublicParmeterTypesInGlobal(param: publicClassInGlobal): void;
+>publicAmbientFunctionWithPublicParmeterTypesInGlobal : Symbol(publicAmbientFunctionWithPublicParmeterTypesInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 20, 1))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 21, 70))
+>publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 0, 0))
+
+module publicModuleInGlobal {
+>publicModuleInGlobal : Symbol(publicModuleInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 21, 104))
+
+    class privateClass {
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
+    }
+
+    export class publicClass {
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
+    }
+
+    module privateModule {
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+
+        class privateClass {
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
+        }
+
+        export class publicClass {
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+        }
+
+        export interface publicInterfaceWithPrivateParmeterTypes {
+>publicInterfaceWithPrivateParmeterTypes : Symbol(publicInterfaceWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 35, 9))
+
+            new (param: privateClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 38, 17))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+
+            (param: privateClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 39, 13))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+
+            myMethod(param: privateClass): void;
+>myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 39, 47))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 40, 21))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
+        }
+
+        export interface publicInterfaceWithPublicParmeterTypes {
+>publicInterfaceWithPublicParmeterTypes : Symbol(publicInterfaceWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 41, 9))
+
+            new (param: publicClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 44, 17))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+
+            (param: publicClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 45, 13))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+
+            myMethod(param: publicClass): void;
+>myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 45, 46))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 46, 21))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+        }
+
+        interface privateInterfaceWithPrivateParmeterTypes {
+>privateInterfaceWithPrivateParmeterTypes : Symbol(privateInterfaceWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 47, 9))
+
+            new (param: privateClass): privateClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 50, 17))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
+
+            (param: privateClass): privateClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 51, 13))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
+
+            myMethod(param: privateClass): void;
+>myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 51, 48))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 52, 21))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
+        }
+
+        interface privateInterfaceWithPublicParmeterTypes {
+>privateInterfaceWithPublicParmeterTypes : Symbol(privateInterfaceWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 53, 9))
+
+            new (param: publicClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 56, 17))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+
+            (param: publicClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 57, 13))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+
+            myMethod(param: publicClass): void;
+>myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 57, 46))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 58, 21))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+        }
+
+        export class publicClassWithWithPrivateParmeterTypes {
+>publicClassWithWithPrivateParmeterTypes : Symbol(publicClassWithWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 59, 9))
+
+            static myPublicStaticMethod(param: privateClass) {
+>myPublicStaticMethod : Symbol(publicClassWithWithPrivateParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 61, 62))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 62, 40))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
+            }
+            private static myPrivateStaticMethod(param: privateClass) {
+>myPrivateStaticMethod : Symbol(publicClassWithWithPrivateParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 63, 13))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 64, 49))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
+            }
+            myPublicMethod(param: privateClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 65, 13))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 66, 27))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
+            }
+            private myPrivateMethod(param: privateClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 67, 13))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 68, 36))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
+            }
+            constructor(param: privateClass, private param1: privateClass, public param2: privateClass) {
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 70, 24))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
+>param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 70, 44))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
+>param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 70, 74))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
+            }
+        }
+
+        export class publicClassWithWithPublicParmeterTypes {
+>publicClassWithWithPublicParmeterTypes : Symbol(publicClassWithWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 72, 9))
+
+            static myPublicStaticMethod(param: publicClass) {
+>myPublicStaticMethod : Symbol(publicClassWithWithPublicParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 74, 61))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 75, 40))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+            }
+            private static myPrivateStaticMethod(param: publicClass) {
+>myPrivateStaticMethod : Symbol(publicClassWithWithPublicParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 76, 13))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 77, 49))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+            }
+            myPublicMethod(param: publicClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 78, 13))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 79, 27))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+            }
+            private myPrivateMethod(param: publicClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 80, 13))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 81, 36))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+            }
+            constructor(param: publicClass, private param1: publicClass, public param2: publicClass) {
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 83, 24))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+>param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 83, 43))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+>param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 83, 72))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+            }
+        }
+
+        class privateClassWithWithPrivateParmeterTypes {
+>privateClassWithWithPrivateParmeterTypes : Symbol(privateClassWithWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 85, 9))
+
+            static myPublicStaticMethod(param: privateClass) {
+>myPublicStaticMethod : Symbol(privateClassWithWithPrivateParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 87, 56))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 88, 40))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
+            }
+            private static myPrivateStaticMethod(param: privateClass) {
+>myPrivateStaticMethod : Symbol(privateClassWithWithPrivateParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 89, 13))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 90, 49))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
+            }
+            myPublicMethod(param: privateClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 91, 13))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 92, 27))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
+            }
+            private myPrivateMethod(param: privateClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 93, 13))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 94, 36))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
+            }
+            constructor(param: privateClass, private param1: privateClass, public param2: privateClass) {
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 96, 24))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
+>param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 96, 44))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
+>param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 96, 74))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
+            }
+        }
+
+        class privateClassWithWithPublicParmeterTypes {
+>privateClassWithWithPublicParmeterTypes : Symbol(privateClassWithWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 98, 9))
+
+            static myPublicStaticMethod(param: publicClass) {
+>myPublicStaticMethod : Symbol(privateClassWithWithPublicParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 100, 55))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 101, 40))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+            }
+            private static myPrivateStaticMethod(param: publicClass) {
+>myPrivateStaticMethod : Symbol(privateClassWithWithPublicParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 102, 13))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 103, 49))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+            }
+            myPublicMethod(param: publicClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 104, 13))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 105, 27))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+            }
+            private myPrivateMethod(param: publicClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 106, 13))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 107, 36))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+            }
+            constructor(param: publicClass, private param1: publicClass, public param2: publicClass) {
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 109, 24))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+>param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 109, 43))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+>param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 109, 72))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+            }
+        }
+
+        export function publicFunctionWithPrivateParmeterTypes(param: privateClass) {
+>publicFunctionWithPrivateParmeterTypes : Symbol(publicFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 111, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 113, 63))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
+        }
+        export function publicFunctionWithPublicParmeterTypes(param: publicClass) {
+>publicFunctionWithPublicParmeterTypes : Symbol(publicFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 114, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 115, 62))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+        }
+        function privateFunctionWithPrivateParmeterTypes(param: privateClass) {
+>privateFunctionWithPrivateParmeterTypes : Symbol(privateFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 116, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 117, 57))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
+        }
+        function privateFunctionWithPublicParmeterTypes(param: publicClass) {
+>privateFunctionWithPublicParmeterTypes : Symbol(privateFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 118, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 119, 56))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+        }
+
+        export declare function publicAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void;
+>publicAmbientFunctionWithPrivateParmeterTypes : Symbol(publicAmbientFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 120, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 122, 78))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
+
+        export declare function publicAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
+>publicAmbientFunctionWithPublicParmeterTypes : Symbol(publicAmbientFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 122, 105))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 123, 77))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+
+        declare function privateAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void;
+>privateAmbientFunctionWithPrivateParmeterTypes : Symbol(privateAmbientFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 123, 103))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 124, 72))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
+
+        declare function privateAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
+>privateAmbientFunctionWithPublicParmeterTypes : Symbol(privateAmbientFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 124, 99))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 125, 71))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+
+        export interface publicInterfaceWithPrivateModuleParameterTypes {
+>publicInterfaceWithPrivateModuleParameterTypes : Symbol(publicInterfaceWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 125, 97))
+
+            new (param: privateModule.publicClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 128, 17))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+
+            (param: privateModule.publicClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 129, 13))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+
+            myMethod(param: privateModule.publicClass): void;
+>myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 129, 60))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 130, 21))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+        }
+        export class publicClassWithPrivateModuleParameterTypes {
+>publicClassWithPrivateModuleParameterTypes : Symbol(publicClassWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 131, 9))
+
+            static myPublicStaticMethod(param: privateModule.publicClass) {
+>myPublicStaticMethod : Symbol(publicClassWithPrivateModuleParameterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 132, 65))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 133, 40))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+            }
+            myPublicMethod(param: privateModule.publicClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 134, 13))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 135, 27))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+            }
+            constructor(param: privateModule.publicClass, private param1: privateModule.publicClass, public param2: privateModule.publicClass) {
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 137, 24))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+>param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 137, 57))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+>param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 137, 100))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+            }
+        }
+        export function publicFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass) {
+>publicFunctionWithPrivateModuleParameterTypes : Symbol(publicFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 139, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 140, 70))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+        }
+        export declare function publicAmbientFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass): void;
+>publicAmbientFunctionWithPrivateModuleParameterTypes : Symbol(publicAmbientFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 141, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 142, 85))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+
+        interface privateInterfaceWithPrivateModuleParameterTypes {
+>privateInterfaceWithPrivateModuleParameterTypes : Symbol(privateInterfaceWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 142, 125))
+
+            new (param: privateModule.publicClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 145, 17))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+
+            (param: privateModule.publicClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 146, 13))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+
+            myMethod(param: privateModule.publicClass): void;
+>myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 146, 60))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 147, 21))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+        }
+        class privateClassWithPrivateModuleParameterTypes {
+>privateClassWithPrivateModuleParameterTypes : Symbol(privateClassWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 148, 9))
+
+            static myPublicStaticMethod(param: privateModule.publicClass) {
+>myPublicStaticMethod : Symbol(privateClassWithPrivateModuleParameterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 149, 59))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 150, 40))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+            }
+            myPublicMethod(param: privateModule.publicClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 151, 13))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 152, 27))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+            }
+            constructor(param: privateModule.publicClass, private param1: privateModule.publicClass, public param2: privateModule.publicClass) {
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 154, 24))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+>param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 154, 57))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+>param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 154, 100))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+            }
+        }
+        function privateFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass) {
+>privateFunctionWithPrivateModuleParameterTypes : Symbol(privateFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 156, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 157, 64))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+        }
+        declare function privateAmbientFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass): void;
+>privateAmbientFunctionWithPrivateModuleParameterTypes : Symbol(privateAmbientFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 158, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 159, 79))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+    }
+
+    export interface publicInterfaceWithPrivateParmeterTypes {
+>publicInterfaceWithPrivateParmeterTypes : Symbol(publicInterfaceWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 160, 5))
+
+        new (param: privateClass): publicClass; // Error
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 163, 13))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
+
+        (param: privateClass): publicClass; // Error
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 164, 9))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
+
+        myMethod(param: privateClass): void; // Error
+>myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 164, 43))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 165, 17))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
+    }
+
+    export interface publicInterfaceWithPublicParmeterTypes {
+>publicInterfaceWithPublicParmeterTypes : Symbol(publicInterfaceWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 166, 5))
+
+        new (param: publicClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 169, 13))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
+
+        (param: publicClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 170, 9))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
+
+        myMethod(param: publicClass): void;
+>myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 170, 42))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 171, 17))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
+    }
+
+    interface privateInterfaceWithPrivateParmeterTypes {
+>privateInterfaceWithPrivateParmeterTypes : Symbol(privateInterfaceWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 172, 5))
+
+        new (param: privateClass): privateClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 175, 13))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
+
+        (param: privateClass): privateClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 176, 9))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
+
+        myMethod(param: privateClass): void;
+>myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 176, 44))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 177, 17))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
+    }
+
+    interface privateInterfaceWithPublicParmeterTypes {
+>privateInterfaceWithPublicParmeterTypes : Symbol(privateInterfaceWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 178, 5))
+
+        new (param: publicClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 181, 13))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
+
+        (param: publicClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 182, 9))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
+
+        myMethod(param: publicClass): void;
+>myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 182, 42))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 183, 17))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
+    }
+
+    export class publicClassWithWithPrivateParmeterTypes {
+>publicClassWithWithPrivateParmeterTypes : Symbol(publicClassWithWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 184, 5))
+
+        static myPublicStaticMethod(param: privateClass) { // Error
+>myPublicStaticMethod : Symbol(publicClassWithWithPrivateParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 186, 58))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 187, 36))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
+        }
+        private static myPrivateStaticMethod(param: privateClass) {
+>myPrivateStaticMethod : Symbol(publicClassWithWithPrivateParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 188, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 189, 45))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
+        }
+        myPublicMethod(param: privateClass) { // Error
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 190, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 191, 23))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
+        }
+        private myPrivateMethod(param: privateClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 192, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 193, 32))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
+        }
+        constructor(param: privateClass, private param1: privateClass, public param2: privateClass) { // Error
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 195, 20))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
+>param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 195, 40))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
+>param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 195, 70))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
+        }
+    }
+
+    export class publicClassWithWithPublicParmeterTypes {
+>publicClassWithWithPublicParmeterTypes : Symbol(publicClassWithWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 197, 5))
+
+        static myPublicStaticMethod(param: publicClass) {
+>myPublicStaticMethod : Symbol(publicClassWithWithPublicParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 199, 57))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 200, 36))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
+        }
+        private static myPrivateStaticMethod(param: publicClass) {
+>myPrivateStaticMethod : Symbol(publicClassWithWithPublicParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 201, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 202, 45))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
+        }
+        myPublicMethod(param: publicClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 203, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 204, 23))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
+        }
+        private myPrivateMethod(param: publicClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 205, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 206, 32))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
+        }
+        constructor(param: publicClass, private param1: publicClass, public param2: publicClass) {
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 208, 20))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
+>param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 208, 39))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
+>param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 208, 68))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
+        }
+    }
+
+    class privateClassWithWithPrivateParmeterTypes {
+>privateClassWithWithPrivateParmeterTypes : Symbol(privateClassWithWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 210, 5))
+
+        static myPublicStaticMethod(param: privateClass) {
+>myPublicStaticMethod : Symbol(privateClassWithWithPrivateParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 212, 52))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 213, 36))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
+        }
+        private static myPrivateStaticMethod(param: privateClass) {
+>myPrivateStaticMethod : Symbol(privateClassWithWithPrivateParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 214, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 215, 45))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
+        }
+        myPublicMethod(param: privateClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 216, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 217, 23))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
+        }
+        private myPrivateMethod(param: privateClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 218, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 219, 32))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
+        }
+        constructor(param: privateClass, private param1: privateClass, public param2: privateClass) {
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 221, 20))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
+>param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 221, 40))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
+>param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 221, 70))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
+        }
+    }
+
+    class privateClassWithWithPublicParmeterTypes {
+>privateClassWithWithPublicParmeterTypes : Symbol(privateClassWithWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 223, 5))
+
+        static myPublicStaticMethod(param: publicClass) {
+>myPublicStaticMethod : Symbol(privateClassWithWithPublicParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 225, 51))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 226, 36))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
+        }
+        private static myPrivateStaticMethod(param: publicClass) {
+>myPrivateStaticMethod : Symbol(privateClassWithWithPublicParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 227, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 228, 45))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
+        }
+        myPublicMethod(param: publicClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 229, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 230, 23))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
+        }
+        private myPrivateMethod(param: publicClass) {
+>myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 231, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 232, 32))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
+        }
+        constructor(param: publicClass, private param1: publicClass, public param2: publicClass) {
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 234, 20))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
+>param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 234, 39))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
+>param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 234, 68))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
+        }
+    }
+
+    export function publicFunctionWithPrivateParmeterTypes(param: privateClass) { // Error
+>publicFunctionWithPrivateParmeterTypes : Symbol(publicFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 236, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 238, 59))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
+    }
+    export function publicFunctionWithPublicParmeterTypes(param: publicClass) {
+>publicFunctionWithPublicParmeterTypes : Symbol(publicFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 239, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 240, 58))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
+    }
+    function privateFunctionWithPrivateParmeterTypes(param: privateClass) {
+>privateFunctionWithPrivateParmeterTypes : Symbol(privateFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 241, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 242, 53))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
+    }
+    function privateFunctionWithPublicParmeterTypes(param: publicClass) {
+>privateFunctionWithPublicParmeterTypes : Symbol(privateFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 243, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 244, 52))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
+    }
+
+    export declare function publicAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void; // Error
+>publicAmbientFunctionWithPrivateParmeterTypes : Symbol(publicAmbientFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 245, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 247, 74))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
+
+    export declare function publicAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
+>publicAmbientFunctionWithPublicParmeterTypes : Symbol(publicAmbientFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 247, 101))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 248, 73))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
+
+    declare function privateAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void;
+>privateAmbientFunctionWithPrivateParmeterTypes : Symbol(privateAmbientFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 248, 99))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 249, 68))
+>privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
+
+    declare function privateAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
+>privateAmbientFunctionWithPublicParmeterTypes : Symbol(privateAmbientFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 249, 95))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 250, 67))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
+
+    export interface publicInterfaceWithPrivateModuleParameterTypes {
+>publicInterfaceWithPrivateModuleParameterTypes : Symbol(publicInterfaceWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 250, 93))
+
+        new (param: privateModule.publicClass): publicClass; // Error
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 253, 13))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
+
+        (param: privateModule.publicClass): publicClass; // Error
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 254, 9))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
+
+        myMethod(param: privateModule.publicClass): void; // Error
+>myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 254, 56))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 255, 17))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+    }
+    export class publicClassWithPrivateModuleParameterTypes {
+>publicClassWithPrivateModuleParameterTypes : Symbol(publicClassWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 256, 5))
+
+        static myPublicStaticMethod(param: privateModule.publicClass) { // Error
+>myPublicStaticMethod : Symbol(publicClassWithPrivateModuleParameterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 257, 61))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 258, 36))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+        }
+        myPublicMethod(param: privateModule.publicClass) { // Error
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 259, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 260, 23))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+        }
+        constructor(param: privateModule.publicClass, private param1: privateModule.publicClass, public param2: privateModule.publicClass) { // Error
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 262, 20))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+>param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 262, 53))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+>param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 262, 96))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+        }
+    }
+    export function publicFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass) { // Error
+>publicFunctionWithPrivateModuleParameterTypes : Symbol(publicFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 264, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 265, 66))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+    }
+    export declare function publicAmbientFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass): void; // Error
+>publicAmbientFunctionWithPrivateModuleParameterTypes : Symbol(publicAmbientFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 266, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 267, 81))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+
+    interface privateInterfaceWithPrivateModuleParameterTypes {
+>privateInterfaceWithPrivateModuleParameterTypes : Symbol(privateInterfaceWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 267, 121))
+
+        new (param: privateModule.publicClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 270, 13))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
+
+        (param: privateModule.publicClass): publicClass;
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 271, 9))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+>publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
+
+        myMethod(param: privateModule.publicClass): void;
+>myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 271, 56))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 272, 17))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+    }
+    class privateClassWithPrivateModuleParameterTypes {
+>privateClassWithPrivateModuleParameterTypes : Symbol(privateClassWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 273, 5))
+
+        static myPublicStaticMethod(param: privateModule.publicClass) {
+>myPublicStaticMethod : Symbol(privateClassWithPrivateModuleParameterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 274, 55))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 275, 36))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+        }
+        myPublicMethod(param: privateModule.publicClass) {
+>myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 276, 9))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 277, 23))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+        }
+        constructor(param: privateModule.publicClass, private param1: privateModule.publicClass, public param2: privateModule.publicClass) {
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 279, 20))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+>param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 279, 53))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+>param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 279, 96))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+        }
+    }
+    function privateFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass) {
+>privateFunctionWithPrivateModuleParameterTypes : Symbol(privateFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 281, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 282, 60))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+    }
+    declare function privateAmbientFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass): void;
+>privateAmbientFunctionWithPrivateModuleParameterTypes : Symbol(privateAmbientFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 283, 5))
+>param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 284, 75))
+>privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
+>publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
+}
diff --git a/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.symbols b/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.symbols
new file mode 100644
index 0000000000000..eb17ccffe4421
--- /dev/null
+++ b/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.symbols
@@ -0,0 +1,169 @@
+=== tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts ===
+
+export module publicModule {
+>publicModule : Symbol(publicModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 0, 0))
+
+    export interface publicInterfaceInPublicModule {
+>publicInterfaceInPublicModule : Symbol(publicInterfaceInPublicModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 1, 28))
+    }
+
+    interface privateInterfaceInPublicModule {
+>privateInterfaceInPublicModule : Symbol(privateInterfaceInPublicModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 3, 5))
+    }
+
+    interface privateInterfaceImplementingPublicInterfaceInModule extends publicInterfaceInPublicModule {
+>privateInterfaceImplementingPublicInterfaceInModule : Symbol(privateInterfaceImplementingPublicInterfaceInModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 6, 5))
+>publicInterfaceInPublicModule : Symbol(publicInterfaceInPublicModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 1, 28))
+    }
+    interface privateInterfaceImplementingPrivateInterfaceInModule extends privateInterfaceInPublicModule {
+>privateInterfaceImplementingPrivateInterfaceInModule : Symbol(privateInterfaceImplementingPrivateInterfaceInModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 9, 5))
+>privateInterfaceInPublicModule : Symbol(privateInterfaceInPublicModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 3, 5))
+    }
+    export interface publicInterfaceImplementingPublicInterfaceInModule extends publicInterfaceInPublicModule {
+>publicInterfaceImplementingPublicInterfaceInModule : Symbol(publicInterfaceImplementingPublicInterfaceInModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 11, 5))
+>publicInterfaceInPublicModule : Symbol(publicInterfaceInPublicModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 1, 28))
+    }
+    export interface publicInterfaceImplementingPrivateInterfaceInModule extends privateInterfaceInPublicModule { // Should error
+>publicInterfaceImplementingPrivateInterfaceInModule : Symbol(publicInterfaceImplementingPrivateInterfaceInModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 13, 5))
+>privateInterfaceInPublicModule : Symbol(privateInterfaceInPublicModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 3, 5))
+    }
+
+    interface privateInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule {
+>privateInterfaceImplementingFromPrivateModuleInterface : Symbol(privateInterfaceImplementingFromPrivateModuleInterface, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 15, 5))
+>privateModule.publicInterfaceInPrivateModule : Symbol(privateModule.publicInterfaceInPrivateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 26, 22))
+>privateModule : Symbol(privateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 24, 1))
+>publicInterfaceInPrivateModule : Symbol(privateModule.publicInterfaceInPrivateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 26, 22))
+    }
+    export interface publicInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule { // Should error
+>publicInterfaceImplementingFromPrivateModuleInterface : Symbol(publicInterfaceImplementingFromPrivateModuleInterface, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 18, 5))
+>privateModule.publicInterfaceInPrivateModule : Symbol(privateModule.publicInterfaceInPrivateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 26, 22))
+>privateModule : Symbol(privateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 24, 1))
+>publicInterfaceInPrivateModule : Symbol(privateModule.publicInterfaceInPrivateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 26, 22))
+    }
+
+    export interface publicInterfaceImplementingPrivateAndPublicInterface extends privateInterfaceInPublicModule, publicInterfaceInPublicModule { // Should error
+>publicInterfaceImplementingPrivateAndPublicInterface : Symbol(publicInterfaceImplementingPrivateAndPublicInterface, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 20, 5))
+>privateInterfaceInPublicModule : Symbol(privateInterfaceInPublicModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 3, 5))
+>publicInterfaceInPublicModule : Symbol(publicInterfaceInPublicModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 1, 28))
+    }
+}
+
+module privateModule {
+>privateModule : Symbol(privateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 24, 1))
+
+    export interface publicInterfaceInPrivateModule {
+>publicInterfaceInPrivateModule : Symbol(publicInterfaceInPrivateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 26, 22))
+
+    }
+
+    interface privateInterfaceInPrivateModule {
+>privateInterfaceInPrivateModule : Symbol(privateInterfaceInPrivateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 29, 5))
+    }
+
+    interface privateInterfaceImplementingPublicInterfaceInModule extends publicInterfaceInPrivateModule {
+>privateInterfaceImplementingPublicInterfaceInModule : Symbol(privateInterfaceImplementingPublicInterfaceInModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 32, 5))
+>publicInterfaceInPrivateModule : Symbol(publicInterfaceInPrivateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 26, 22))
+    }
+    interface privateInterfaceImplementingPrivateInterfaceInModule extends privateInterfaceInPrivateModule {
+>privateInterfaceImplementingPrivateInterfaceInModule : Symbol(privateInterfaceImplementingPrivateInterfaceInModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 35, 5))
+>privateInterfaceInPrivateModule : Symbol(privateInterfaceInPrivateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 29, 5))
+    }
+    export interface publicInterfaceImplementingPublicInterfaceInModule extends publicInterfaceInPrivateModule {
+>publicInterfaceImplementingPublicInterfaceInModule : Symbol(publicInterfaceImplementingPublicInterfaceInModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 37, 5))
+>publicInterfaceInPrivateModule : Symbol(publicInterfaceInPrivateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 26, 22))
+    }
+    export interface publicInterfaceImplementingPrivateInterfaceInModule extends privateInterfaceInPrivateModule {
+>publicInterfaceImplementingPrivateInterfaceInModule : Symbol(publicInterfaceImplementingPrivateInterfaceInModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 39, 5))
+>privateInterfaceInPrivateModule : Symbol(privateInterfaceInPrivateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 29, 5))
+    }
+
+    interface privateInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule {
+>privateInterfaceImplementingFromPrivateModuleInterface : Symbol(privateInterfaceImplementingFromPrivateModuleInterface, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 41, 5))
+>privateModule.publicInterfaceInPrivateModule : Symbol(publicInterfaceInPrivateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 26, 22))
+>privateModule : Symbol(privateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 24, 1))
+>publicInterfaceInPrivateModule : Symbol(publicInterfaceInPrivateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 26, 22))
+    }
+    export interface publicInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule {
+>publicInterfaceImplementingFromPrivateModuleInterface : Symbol(publicInterfaceImplementingFromPrivateModuleInterface, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 44, 5))
+>privateModule.publicInterfaceInPrivateModule : Symbol(publicInterfaceInPrivateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 26, 22))
+>privateModule : Symbol(privateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 24, 1))
+>publicInterfaceInPrivateModule : Symbol(publicInterfaceInPrivateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 26, 22))
+    }
+}
+
+export interface publicInterface {
+>publicInterface : Symbol(publicInterface, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 47, 1))
+
+}
+
+interface privateInterface {
+>privateInterface : Symbol(privateInterface, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 51, 1))
+}
+
+interface privateInterfaceImplementingPublicInterface extends publicInterface {
+>privateInterfaceImplementingPublicInterface : Symbol(privateInterfaceImplementingPublicInterface, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 54, 1))
+>publicInterface : Symbol(publicInterface, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 47, 1))
+}
+interface privateInterfaceImplementingPrivateInterfaceInModule extends privateInterface {
+>privateInterfaceImplementingPrivateInterfaceInModule : Symbol(privateInterfaceImplementingPrivateInterfaceInModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 57, 1))
+>privateInterface : Symbol(privateInterface, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 51, 1))
+}
+export interface publicInterfaceImplementingPublicInterface extends publicInterface {
+>publicInterfaceImplementingPublicInterface : Symbol(publicInterfaceImplementingPublicInterface, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 59, 1))
+>publicInterface : Symbol(publicInterface, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 47, 1))
+}
+export interface publicInterfaceImplementingPrivateInterface extends privateInterface { // Should error
+>publicInterfaceImplementingPrivateInterface : Symbol(publicInterfaceImplementingPrivateInterface, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 61, 1))
+>privateInterface : Symbol(privateInterface, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 51, 1))
+}
+
+interface privateInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule {
+>privateInterfaceImplementingFromPrivateModuleInterface : Symbol(privateInterfaceImplementingFromPrivateModuleInterface, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 63, 1))
+>privateModule.publicInterfaceInPrivateModule : Symbol(privateModule.publicInterfaceInPrivateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 26, 22))
+>privateModule : Symbol(privateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 24, 1))
+>publicInterfaceInPrivateModule : Symbol(privateModule.publicInterfaceInPrivateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 26, 22))
+}
+export interface publicInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule { // Should error
+>publicInterfaceImplementingFromPrivateModuleInterface : Symbol(publicInterfaceImplementingFromPrivateModuleInterface, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 66, 1))
+>privateModule.publicInterfaceInPrivateModule : Symbol(privateModule.publicInterfaceInPrivateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 26, 22))
+>privateModule : Symbol(privateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 24, 1))
+>publicInterfaceInPrivateModule : Symbol(privateModule.publicInterfaceInPrivateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 26, 22))
+}
+
+=== tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts ===
+module publicModuleInGlobal {
+>publicModuleInGlobal : Symbol(publicModuleInGlobal, Decl(privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts, 0, 0))
+
+    export interface publicInterfaceInPublicModule {
+>publicInterfaceInPublicModule : Symbol(publicInterfaceInPublicModule, Decl(privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts, 0, 29))
+    }
+
+    interface privateInterfaceInPublicModule {
+>privateInterfaceInPublicModule : Symbol(privateInterfaceInPublicModule, Decl(privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts, 2, 5))
+    }
+
+    interface privateInterfaceImplementingPublicInterfaceInModule extends publicInterfaceInPublicModule {
+>privateInterfaceImplementingPublicInterfaceInModule : Symbol(privateInterfaceImplementingPublicInterfaceInModule, Decl(privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts, 5, 5))
+>publicInterfaceInPublicModule : Symbol(publicInterfaceInPublicModule, Decl(privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts, 0, 29))
+    }
+    interface privateInterfaceImplementingPrivateInterfaceInModule extends privateInterfaceInPublicModule {
+>privateInterfaceImplementingPrivateInterfaceInModule : Symbol(privateInterfaceImplementingPrivateInterfaceInModule, Decl(privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts, 8, 5))
+>privateInterfaceInPublicModule : Symbol(privateInterfaceInPublicModule, Decl(privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts, 2, 5))
+    }
+    export interface publicInterfaceImplementingPublicInterfaceInModule extends publicInterfaceInPublicModule {
+>publicInterfaceImplementingPublicInterfaceInModule : Symbol(publicInterfaceImplementingPublicInterfaceInModule, Decl(privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts, 10, 5))
+>publicInterfaceInPublicModule : Symbol(publicInterfaceInPublicModule, Decl(privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts, 0, 29))
+    }
+    export interface publicInterfaceImplementingPrivateInterfaceInModule extends privateInterfaceInPublicModule { // Should error
+>publicInterfaceImplementingPrivateInterfaceInModule : Symbol(publicInterfaceImplementingPrivateInterfaceInModule, Decl(privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts, 12, 5))
+>privateInterfaceInPublicModule : Symbol(privateInterfaceInPublicModule, Decl(privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts, 2, 5))
+    }
+}
+interface publicInterfaceInGlobal {
+>publicInterfaceInGlobal : Symbol(publicInterfaceInGlobal, Decl(privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts, 15, 1))
+}
+interface publicInterfaceImplementingPublicInterfaceInGlobal extends publicInterfaceInGlobal {
+>publicInterfaceImplementingPublicInterfaceInGlobal : Symbol(publicInterfaceImplementingPublicInterfaceInGlobal, Decl(privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts, 17, 1))
+>publicInterfaceInGlobal : Symbol(publicInterfaceInGlobal, Decl(privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts, 15, 1))
+}
+
diff --git a/tests/baselines/reference/privacyLocalInternalReferenceImportWithExport.symbols b/tests/baselines/reference/privacyLocalInternalReferenceImportWithExport.symbols
new file mode 100644
index 0000000000000..ab5f1540ef9a6
--- /dev/null
+++ b/tests/baselines/reference/privacyLocalInternalReferenceImportWithExport.symbols
@@ -0,0 +1,510 @@
+=== tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts ===
+// private elements
+module m_private {
+>m_private : Symbol(m_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 0, 0))
+
+    export class c_private {
+>c_private : Symbol(c_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 1, 18))
+    }
+    export enum e_private {
+>e_private : Symbol(e_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 3, 5))
+
+        Happy,
+>Happy : Symbol(e_private.Happy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 4, 27))
+
+        Grumpy
+>Grumpy : Symbol(e_private.Grumpy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 5, 14))
+    }
+    export function f_private() {
+>f_private : Symbol(f_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 7, 5))
+
+        return new c_private();
+>c_private : Symbol(c_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 1, 18))
+    }
+    export var v_private = new c_private();
+>v_private : Symbol(v_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 11, 14))
+>c_private : Symbol(c_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 1, 18))
+
+    export interface i_private {
+>i_private : Symbol(i_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 11, 43))
+    }
+    export module mi_private {
+>mi_private : Symbol(mi_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 13, 5))
+
+        export class c {
+>c : Symbol(c, Decl(privacyLocalInternalReferenceImportWithExport.ts, 14, 30))
+        }
+    }
+    export module mu_private {
+>mu_private : Symbol(mu_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 17, 5))
+
+        export interface i {
+>i : Symbol(i, Decl(privacyLocalInternalReferenceImportWithExport.ts, 18, 30))
+        }
+    }
+}
+
+// Public elements
+export module m_public {
+>m_public : Symbol(m_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 22, 1))
+
+    export class c_public {
+>c_public : Symbol(c_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 25, 24))
+    }
+    export enum e_public {
+>e_public : Symbol(e_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 27, 5))
+
+        Happy,
+>Happy : Symbol(e_public.Happy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 28, 26))
+
+        Grumpy
+>Grumpy : Symbol(e_public.Grumpy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 29, 14))
+    }
+    export function f_public() {
+>f_public : Symbol(f_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 31, 5))
+
+        return new c_public();
+>c_public : Symbol(c_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 25, 24))
+    }
+    export var v_public = 10;
+>v_public : Symbol(v_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 35, 14))
+
+    export interface i_public {
+>i_public : Symbol(i_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 35, 29))
+    }
+    export module mi_public {
+>mi_public : Symbol(mi_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 37, 5))
+
+        export class c {
+>c : Symbol(c, Decl(privacyLocalInternalReferenceImportWithExport.ts, 38, 29))
+        }
+    }
+    export module mu_public {
+>mu_public : Symbol(mu_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 41, 5))
+
+        export interface i {
+>i : Symbol(i, Decl(privacyLocalInternalReferenceImportWithExport.ts, 42, 29))
+        }
+    }
+}
+
+export module import_public {
+>import_public : Symbol(import_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 46, 1))
+
+    // Privacy errors - importing private elements
+    export import im_public_c_private = m_private.c_private;
+>im_public_c_private : Symbol(im_public_c_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 48, 29))
+>m_private : Symbol(m_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 0, 0))
+>c_private : Symbol(im_public_c_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 1, 18))
+
+    export import im_public_e_private = m_private.e_private;
+>im_public_e_private : Symbol(im_public_e_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 50, 60))
+>m_private : Symbol(m_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 0, 0))
+>e_private : Symbol(im_public_e_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 3, 5))
+
+    export import im_public_f_private = m_private.f_private;
+>im_public_f_private : Symbol(im_public_f_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 51, 60))
+>m_private : Symbol(m_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 0, 0))
+>f_private : Symbol(im_public_f_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 7, 5))
+
+    export import im_public_v_private = m_private.v_private;
+>im_public_v_private : Symbol(im_public_v_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 52, 60))
+>m_private : Symbol(m_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 0, 0))
+>v_private : Symbol(im_public_v_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 11, 14))
+
+    export import im_public_i_private = m_private.i_private;
+>im_public_i_private : Symbol(im_public_i_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 53, 60))
+>m_private : Symbol(m_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 0, 0))
+>i_private : Symbol(im_public_i_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 11, 43))
+
+    export import im_public_mi_private = m_private.mi_private;
+>im_public_mi_private : Symbol(im_public_mi_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 54, 60))
+>m_private : Symbol(m_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 0, 0))
+>mi_private : Symbol(im_public_mi_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 13, 5))
+
+    export import im_public_mu_private = m_private.mu_private;
+>im_public_mu_private : Symbol(im_public_mu_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 55, 62))
+>m_private : Symbol(m_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 0, 0))
+>mu_private : Symbol(im_public_mu_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 17, 5))
+
+    // Usage of privacy error imports
+    var privateUse_im_public_c_private = new im_public_c_private();
+>privateUse_im_public_c_private : Symbol(privateUse_im_public_c_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 59, 7))
+>im_public_c_private : Symbol(im_public_c_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 48, 29))
+
+    export var publicUse_im_public_c_private = new im_public_c_private();
+>publicUse_im_public_c_private : Symbol(publicUse_im_public_c_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 60, 14))
+>im_public_c_private : Symbol(im_public_c_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 48, 29))
+
+    var privateUse_im_public_e_private = im_public_e_private.Happy;
+>privateUse_im_public_e_private : Symbol(privateUse_im_public_e_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 61, 7))
+>im_public_e_private.Happy : Symbol(im_public_e_private.Happy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 4, 27))
+>im_public_e_private : Symbol(im_public_e_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 50, 60))
+>Happy : Symbol(im_public_e_private.Happy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 4, 27))
+
+    export var publicUse_im_public_e_private = im_public_e_private.Grumpy;
+>publicUse_im_public_e_private : Symbol(publicUse_im_public_e_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 62, 14))
+>im_public_e_private.Grumpy : Symbol(im_public_e_private.Grumpy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 5, 14))
+>im_public_e_private : Symbol(im_public_e_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 50, 60))
+>Grumpy : Symbol(im_public_e_private.Grumpy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 5, 14))
+
+    var privateUse_im_public_f_private = im_public_f_private();
+>privateUse_im_public_f_private : Symbol(privateUse_im_public_f_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 63, 7))
+>im_public_f_private : Symbol(im_public_f_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 51, 60))
+
+    export var publicUse_im_public_f_private = im_public_f_private();
+>publicUse_im_public_f_private : Symbol(publicUse_im_public_f_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 64, 14))
+>im_public_f_private : Symbol(im_public_f_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 51, 60))
+
+    var privateUse_im_public_v_private = im_public_v_private;
+>privateUse_im_public_v_private : Symbol(privateUse_im_public_v_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 65, 7))
+>im_public_v_private : Symbol(im_public_v_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 52, 60))
+
+    export var publicUse_im_public_v_private = im_public_v_private;
+>publicUse_im_public_v_private : Symbol(publicUse_im_public_v_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 66, 14))
+>im_public_v_private : Symbol(im_public_v_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 52, 60))
+
+    var privateUse_im_public_i_private: im_public_i_private;
+>privateUse_im_public_i_private : Symbol(privateUse_im_public_i_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 67, 7))
+>im_public_i_private : Symbol(im_public_i_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 53, 60))
+
+    export var publicUse_im_public_i_private: im_public_i_private;
+>publicUse_im_public_i_private : Symbol(publicUse_im_public_i_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 68, 14))
+>im_public_i_private : Symbol(im_public_i_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 53, 60))
+
+    var privateUse_im_public_mi_private = new im_public_mi_private.c();
+>privateUse_im_public_mi_private : Symbol(privateUse_im_public_mi_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 69, 7))
+>im_public_mi_private.c : Symbol(im_public_mi_private.c, Decl(privacyLocalInternalReferenceImportWithExport.ts, 14, 30))
+>im_public_mi_private : Symbol(im_public_mi_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 54, 60))
+>c : Symbol(im_public_mi_private.c, Decl(privacyLocalInternalReferenceImportWithExport.ts, 14, 30))
+
+    export var publicUse_im_public_mi_private = new im_public_mi_private.c();
+>publicUse_im_public_mi_private : Symbol(publicUse_im_public_mi_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 70, 14))
+>im_public_mi_private.c : Symbol(im_public_mi_private.c, Decl(privacyLocalInternalReferenceImportWithExport.ts, 14, 30))
+>im_public_mi_private : Symbol(im_public_mi_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 54, 60))
+>c : Symbol(im_public_mi_private.c, Decl(privacyLocalInternalReferenceImportWithExport.ts, 14, 30))
+
+    var privateUse_im_public_mu_private: im_public_mu_private.i;
+>privateUse_im_public_mu_private : Symbol(privateUse_im_public_mu_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 71, 7))
+>im_public_mu_private : Symbol(im_public_mu_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 55, 62))
+>i : Symbol(im_public_mu_private.i, Decl(privacyLocalInternalReferenceImportWithExport.ts, 18, 30))
+
+    export var publicUse_im_public_mu_private: im_public_mu_private.i;
+>publicUse_im_public_mu_private : Symbol(publicUse_im_public_mu_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 72, 14))
+>im_public_mu_private : Symbol(im_public_mu_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 55, 62))
+>i : Symbol(im_public_mu_private.i, Decl(privacyLocalInternalReferenceImportWithExport.ts, 18, 30))
+
+
+    // No Privacy errors - importing public elements
+    export import im_public_c_public = m_public.c_public;
+>im_public_c_public : Symbol(im_public_c_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 72, 70))
+>m_public : Symbol(m_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 22, 1))
+>c_public : Symbol(im_public_c_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 25, 24))
+
+    export import im_public_e_public = m_public.e_public;
+>im_public_e_public : Symbol(im_public_e_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 76, 57))
+>m_public : Symbol(m_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 22, 1))
+>e_public : Symbol(im_public_e_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 27, 5))
+
+    export import im_public_f_public = m_public.f_public;
+>im_public_f_public : Symbol(im_public_f_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 77, 57))
+>m_public : Symbol(m_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 22, 1))
+>f_public : Symbol(im_public_f_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 31, 5))
+
+    export import im_public_v_public = m_public.v_public;
+>im_public_v_public : Symbol(im_public_v_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 78, 57))
+>m_public : Symbol(m_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 22, 1))
+>v_public : Symbol(im_public_v_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 35, 14))
+
+    export import im_public_i_public = m_public.i_public;
+>im_public_i_public : Symbol(im_public_i_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 79, 57))
+>m_public : Symbol(m_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 22, 1))
+>i_public : Symbol(im_public_i_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 35, 29))
+
+    export import im_public_mi_public = m_public.mi_public;
+>im_public_mi_public : Symbol(im_public_mi_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 80, 57))
+>m_public : Symbol(m_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 22, 1))
+>mi_public : Symbol(im_public_mi_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 37, 5))
+
+    export import im_public_mu_public = m_public.mu_public;
+>im_public_mu_public : Symbol(im_public_mu_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 81, 59))
+>m_public : Symbol(m_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 22, 1))
+>mu_public : Symbol(im_public_mu_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 41, 5))
+
+    // Usage of above
+    var privateUse_im_public_c_public = new im_public_c_public();
+>privateUse_im_public_c_public : Symbol(privateUse_im_public_c_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 85, 7))
+>im_public_c_public : Symbol(im_public_c_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 72, 70))
+
+    export var publicUse_im_public_c_public = new im_public_c_public();
+>publicUse_im_public_c_public : Symbol(publicUse_im_public_c_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 86, 14))
+>im_public_c_public : Symbol(im_public_c_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 72, 70))
+
+    var privateUse_im_public_e_public = im_public_e_public.Happy;
+>privateUse_im_public_e_public : Symbol(privateUse_im_public_e_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 87, 7))
+>im_public_e_public.Happy : Symbol(im_public_e_public.Happy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 28, 26))
+>im_public_e_public : Symbol(im_public_e_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 76, 57))
+>Happy : Symbol(im_public_e_public.Happy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 28, 26))
+
+    export var publicUse_im_public_e_public = im_public_e_public.Grumpy;
+>publicUse_im_public_e_public : Symbol(publicUse_im_public_e_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 88, 14))
+>im_public_e_public.Grumpy : Symbol(im_public_e_public.Grumpy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 29, 14))
+>im_public_e_public : Symbol(im_public_e_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 76, 57))
+>Grumpy : Symbol(im_public_e_public.Grumpy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 29, 14))
+
+    var privateUse_im_public_f_public = im_public_f_public();
+>privateUse_im_public_f_public : Symbol(privateUse_im_public_f_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 89, 7))
+>im_public_f_public : Symbol(im_public_f_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 77, 57))
+
+    export var publicUse_im_public_f_public = im_public_f_public();
+>publicUse_im_public_f_public : Symbol(publicUse_im_public_f_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 90, 14))
+>im_public_f_public : Symbol(im_public_f_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 77, 57))
+
+    var privateUse_im_public_v_public = im_public_v_public;
+>privateUse_im_public_v_public : Symbol(privateUse_im_public_v_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 91, 7))
+>im_public_v_public : Symbol(im_public_v_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 78, 57))
+
+    export var publicUse_im_public_v_public = im_public_v_public;
+>publicUse_im_public_v_public : Symbol(publicUse_im_public_v_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 92, 14))
+>im_public_v_public : Symbol(im_public_v_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 78, 57))
+
+    var privateUse_im_public_i_public: im_public_i_public;
+>privateUse_im_public_i_public : Symbol(privateUse_im_public_i_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 93, 7))
+>im_public_i_public : Symbol(im_public_i_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 79, 57))
+
+    export var publicUse_im_public_i_public: im_public_i_public;
+>publicUse_im_public_i_public : Symbol(publicUse_im_public_i_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 94, 14))
+>im_public_i_public : Symbol(im_public_i_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 79, 57))
+
+    var privateUse_im_public_mi_public = new im_public_mi_public.c();
+>privateUse_im_public_mi_public : Symbol(privateUse_im_public_mi_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 95, 7))
+>im_public_mi_public.c : Symbol(im_public_mi_public.c, Decl(privacyLocalInternalReferenceImportWithExport.ts, 38, 29))
+>im_public_mi_public : Symbol(im_public_mi_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 80, 57))
+>c : Symbol(im_public_mi_public.c, Decl(privacyLocalInternalReferenceImportWithExport.ts, 38, 29))
+
+    export var publicUse_im_public_mi_public = new im_public_mi_public.c();
+>publicUse_im_public_mi_public : Symbol(publicUse_im_public_mi_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 96, 14))
+>im_public_mi_public.c : Symbol(im_public_mi_public.c, Decl(privacyLocalInternalReferenceImportWithExport.ts, 38, 29))
+>im_public_mi_public : Symbol(im_public_mi_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 80, 57))
+>c : Symbol(im_public_mi_public.c, Decl(privacyLocalInternalReferenceImportWithExport.ts, 38, 29))
+
+    var privateUse_im_public_mu_public: im_public_mu_public.i;
+>privateUse_im_public_mu_public : Symbol(privateUse_im_public_mu_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 97, 7))
+>im_public_mu_public : Symbol(im_public_mu_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 81, 59))
+>i : Symbol(im_public_mu_public.i, Decl(privacyLocalInternalReferenceImportWithExport.ts, 42, 29))
+
+    export var publicUse_im_public_mu_public: im_public_mu_public.i;
+>publicUse_im_public_mu_public : Symbol(publicUse_im_public_mu_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 98, 14))
+>im_public_mu_public : Symbol(im_public_mu_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 81, 59))
+>i : Symbol(im_public_mu_public.i, Decl(privacyLocalInternalReferenceImportWithExport.ts, 42, 29))
+}
+
+module import_private {
+>import_private : Symbol(import_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 99, 1))
+
+    // No Privacy errors - importing private elements
+    export import im_private_c_private = m_private.c_private;
+>im_private_c_private : Symbol(im_private_c_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 101, 23))
+>m_private : Symbol(m_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 0, 0))
+>c_private : Symbol(im_private_c_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 1, 18))
+
+    export import im_private_e_private = m_private.e_private;
+>im_private_e_private : Symbol(im_private_e_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 103, 61))
+>m_private : Symbol(m_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 0, 0))
+>e_private : Symbol(im_private_e_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 3, 5))
+
+    export import im_private_f_private = m_private.f_private;
+>im_private_f_private : Symbol(im_private_f_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 104, 61))
+>m_private : Symbol(m_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 0, 0))
+>f_private : Symbol(im_private_f_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 7, 5))
+
+    export import im_private_v_private = m_private.v_private;
+>im_private_v_private : Symbol(im_private_v_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 105, 61))
+>m_private : Symbol(m_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 0, 0))
+>v_private : Symbol(im_private_v_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 11, 14))
+
+    export import im_private_i_private = m_private.i_private;
+>im_private_i_private : Symbol(im_private_i_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 106, 61))
+>m_private : Symbol(m_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 0, 0))
+>i_private : Symbol(im_private_i_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 11, 43))
+
+    export import im_private_mi_private = m_private.mi_private;
+>im_private_mi_private : Symbol(im_private_mi_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 107, 61))
+>m_private : Symbol(m_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 0, 0))
+>mi_private : Symbol(im_private_mi_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 13, 5))
+
+    export import im_private_mu_private = m_private.mu_private;
+>im_private_mu_private : Symbol(im_private_mu_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 108, 63))
+>m_private : Symbol(m_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 0, 0))
+>mu_private : Symbol(im_private_mu_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 17, 5))
+
+    // Usage of above decls
+    var privateUse_im_private_c_private = new im_private_c_private();
+>privateUse_im_private_c_private : Symbol(privateUse_im_private_c_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 112, 7))
+>im_private_c_private : Symbol(im_private_c_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 101, 23))
+
+    export var publicUse_im_private_c_private = new im_private_c_private();
+>publicUse_im_private_c_private : Symbol(publicUse_im_private_c_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 113, 14))
+>im_private_c_private : Symbol(im_private_c_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 101, 23))
+
+    var privateUse_im_private_e_private = im_private_e_private.Happy;
+>privateUse_im_private_e_private : Symbol(privateUse_im_private_e_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 114, 7))
+>im_private_e_private.Happy : Symbol(im_private_e_private.Happy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 4, 27))
+>im_private_e_private : Symbol(im_private_e_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 103, 61))
+>Happy : Symbol(im_private_e_private.Happy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 4, 27))
+
+    export var publicUse_im_private_e_private = im_private_e_private.Grumpy;
+>publicUse_im_private_e_private : Symbol(publicUse_im_private_e_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 115, 14))
+>im_private_e_private.Grumpy : Symbol(im_private_e_private.Grumpy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 5, 14))
+>im_private_e_private : Symbol(im_private_e_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 103, 61))
+>Grumpy : Symbol(im_private_e_private.Grumpy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 5, 14))
+
+    var privateUse_im_private_f_private = im_private_f_private();
+>privateUse_im_private_f_private : Symbol(privateUse_im_private_f_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 116, 7))
+>im_private_f_private : Symbol(im_private_f_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 104, 61))
+
+    export var publicUse_im_private_f_private = im_private_f_private();
+>publicUse_im_private_f_private : Symbol(publicUse_im_private_f_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 117, 14))
+>im_private_f_private : Symbol(im_private_f_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 104, 61))
+
+    var privateUse_im_private_v_private = im_private_v_private;
+>privateUse_im_private_v_private : Symbol(privateUse_im_private_v_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 118, 7))
+>im_private_v_private : Symbol(im_private_v_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 105, 61))
+
+    export var publicUse_im_private_v_private = im_private_v_private;
+>publicUse_im_private_v_private : Symbol(publicUse_im_private_v_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 119, 14))
+>im_private_v_private : Symbol(im_private_v_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 105, 61))
+
+    var privateUse_im_private_i_private: im_private_i_private;
+>privateUse_im_private_i_private : Symbol(privateUse_im_private_i_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 120, 7))
+>im_private_i_private : Symbol(im_private_i_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 106, 61))
+
+    export var publicUse_im_private_i_private: im_private_i_private;
+>publicUse_im_private_i_private : Symbol(publicUse_im_private_i_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 121, 14))
+>im_private_i_private : Symbol(im_private_i_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 106, 61))
+
+    var privateUse_im_private_mi_private = new im_private_mi_private.c();
+>privateUse_im_private_mi_private : Symbol(privateUse_im_private_mi_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 122, 7))
+>im_private_mi_private.c : Symbol(im_private_mi_private.c, Decl(privacyLocalInternalReferenceImportWithExport.ts, 14, 30))
+>im_private_mi_private : Symbol(im_private_mi_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 107, 61))
+>c : Symbol(im_private_mi_private.c, Decl(privacyLocalInternalReferenceImportWithExport.ts, 14, 30))
+
+    export var publicUse_im_private_mi_private = new im_private_mi_private.c();
+>publicUse_im_private_mi_private : Symbol(publicUse_im_private_mi_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 123, 14))
+>im_private_mi_private.c : Symbol(im_private_mi_private.c, Decl(privacyLocalInternalReferenceImportWithExport.ts, 14, 30))
+>im_private_mi_private : Symbol(im_private_mi_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 107, 61))
+>c : Symbol(im_private_mi_private.c, Decl(privacyLocalInternalReferenceImportWithExport.ts, 14, 30))
+
+    var privateUse_im_private_mu_private: im_private_mu_private.i;
+>privateUse_im_private_mu_private : Symbol(privateUse_im_private_mu_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 124, 7))
+>im_private_mu_private : Symbol(im_private_mu_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 108, 63))
+>i : Symbol(im_private_mu_private.i, Decl(privacyLocalInternalReferenceImportWithExport.ts, 18, 30))
+
+    export var publicUse_im_private_mu_private: im_private_mu_private.i;
+>publicUse_im_private_mu_private : Symbol(publicUse_im_private_mu_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 125, 14))
+>im_private_mu_private : Symbol(im_private_mu_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 108, 63))
+>i : Symbol(im_private_mu_private.i, Decl(privacyLocalInternalReferenceImportWithExport.ts, 18, 30))
+
+    // No privacy Error - importing public elements
+    export import im_private_c_public = m_public.c_public;
+>im_private_c_public : Symbol(im_private_c_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 125, 72))
+>m_public : Symbol(m_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 22, 1))
+>c_public : Symbol(im_private_c_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 25, 24))
+
+    export import im_private_e_public = m_public.e_public;
+>im_private_e_public : Symbol(im_private_e_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 128, 58))
+>m_public : Symbol(m_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 22, 1))
+>e_public : Symbol(im_private_e_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 27, 5))
+
+    export import im_private_f_public = m_public.f_public;
+>im_private_f_public : Symbol(im_private_f_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 129, 58))
+>m_public : Symbol(m_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 22, 1))
+>f_public : Symbol(im_private_f_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 31, 5))
+
+    export import im_private_v_public = m_public.v_public;
+>im_private_v_public : Symbol(im_private_v_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 130, 58))
+>m_public : Symbol(m_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 22, 1))
+>v_public : Symbol(im_private_v_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 35, 14))
+
+    export import im_private_i_public = m_public.i_public;
+>im_private_i_public : Symbol(im_private_i_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 131, 58))
+>m_public : Symbol(m_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 22, 1))
+>i_public : Symbol(im_private_i_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 35, 29))
+
+    export import im_private_mi_public = m_public.mi_public;
+>im_private_mi_public : Symbol(im_private_mi_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 132, 58))
+>m_public : Symbol(m_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 22, 1))
+>mi_public : Symbol(im_private_mi_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 37, 5))
+
+    export import im_private_mu_public = m_public.mu_public;
+>im_private_mu_public : Symbol(im_private_mu_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 133, 60))
+>m_public : Symbol(m_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 22, 1))
+>mu_public : Symbol(im_private_mu_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 41, 5))
+
+    // Usage of no privacy error imports
+    var privateUse_im_private_c_public = new im_private_c_public();
+>privateUse_im_private_c_public : Symbol(privateUse_im_private_c_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 137, 7))
+>im_private_c_public : Symbol(im_private_c_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 125, 72))
+
+    export var publicUse_im_private_c_public = new im_private_c_public();
+>publicUse_im_private_c_public : Symbol(publicUse_im_private_c_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 138, 14))
+>im_private_c_public : Symbol(im_private_c_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 125, 72))
+
+    var privateUse_im_private_e_public = im_private_e_public.Happy;
+>privateUse_im_private_e_public : Symbol(privateUse_im_private_e_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 139, 7))
+>im_private_e_public.Happy : Symbol(im_private_e_public.Happy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 28, 26))
+>im_private_e_public : Symbol(im_private_e_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 128, 58))
+>Happy : Symbol(im_private_e_public.Happy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 28, 26))
+
+    export var publicUse_im_private_e_public = im_private_e_public.Grumpy;
+>publicUse_im_private_e_public : Symbol(publicUse_im_private_e_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 140, 14))
+>im_private_e_public.Grumpy : Symbol(im_private_e_public.Grumpy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 29, 14))
+>im_private_e_public : Symbol(im_private_e_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 128, 58))
+>Grumpy : Symbol(im_private_e_public.Grumpy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 29, 14))
+
+    var privateUse_im_private_f_public = im_private_f_public();
+>privateUse_im_private_f_public : Symbol(privateUse_im_private_f_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 141, 7))
+>im_private_f_public : Symbol(im_private_f_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 129, 58))
+
+    export var publicUse_im_private_f_public = im_private_f_public();
+>publicUse_im_private_f_public : Symbol(publicUse_im_private_f_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 142, 14))
+>im_private_f_public : Symbol(im_private_f_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 129, 58))
+
+    var privateUse_im_private_v_public = im_private_v_public;
+>privateUse_im_private_v_public : Symbol(privateUse_im_private_v_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 143, 7))
+>im_private_v_public : Symbol(im_private_v_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 130, 58))
+
+    export var publicUse_im_private_v_public = im_private_v_public;
+>publicUse_im_private_v_public : Symbol(publicUse_im_private_v_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 144, 14))
+>im_private_v_public : Symbol(im_private_v_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 130, 58))
+
+    var privateUse_im_private_i_public: im_private_i_public;
+>privateUse_im_private_i_public : Symbol(privateUse_im_private_i_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 145, 7))
+>im_private_i_public : Symbol(im_private_i_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 131, 58))
+
+    export var publicUse_im_private_i_public: im_private_i_public;
+>publicUse_im_private_i_public : Symbol(publicUse_im_private_i_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 146, 14))
+>im_private_i_public : Symbol(im_private_i_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 131, 58))
+
+    var privateUse_im_private_mi_public = new im_private_mi_public.c();
+>privateUse_im_private_mi_public : Symbol(privateUse_im_private_mi_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 147, 7))
+>im_private_mi_public.c : Symbol(im_private_mi_public.c, Decl(privacyLocalInternalReferenceImportWithExport.ts, 38, 29))
+>im_private_mi_public : Symbol(im_private_mi_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 132, 58))
+>c : Symbol(im_private_mi_public.c, Decl(privacyLocalInternalReferenceImportWithExport.ts, 38, 29))
+
+    export var publicUse_im_private_mi_public = new im_private_mi_public.c();
+>publicUse_im_private_mi_public : Symbol(publicUse_im_private_mi_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 148, 14))
+>im_private_mi_public.c : Symbol(im_private_mi_public.c, Decl(privacyLocalInternalReferenceImportWithExport.ts, 38, 29))
+>im_private_mi_public : Symbol(im_private_mi_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 132, 58))
+>c : Symbol(im_private_mi_public.c, Decl(privacyLocalInternalReferenceImportWithExport.ts, 38, 29))
+
+    var privateUse_im_private_mu_public: im_private_mu_public.i;
+>privateUse_im_private_mu_public : Symbol(privateUse_im_private_mu_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 149, 7))
+>im_private_mu_public : Symbol(im_private_mu_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 133, 60))
+>i : Symbol(im_private_mu_public.i, Decl(privacyLocalInternalReferenceImportWithExport.ts, 42, 29))
+
+    export var publicUse_im_private_mu_public: im_private_mu_public.i;
+>publicUse_im_private_mu_public : Symbol(publicUse_im_private_mu_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 150, 14))
+>im_private_mu_public : Symbol(im_private_mu_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 133, 60))
+>i : Symbol(im_private_mu_public.i, Decl(privacyLocalInternalReferenceImportWithExport.ts, 42, 29))
+}
diff --git a/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithExport.symbols b/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithExport.symbols
new file mode 100644
index 0000000000000..7d6e732ce247f
--- /dev/null
+++ b/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithExport.symbols
@@ -0,0 +1,297 @@
+=== tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts ===
+// private elements
+module m_private {
+>m_private : Symbol(m_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 0, 0))
+
+    export class c_private {
+>c_private : Symbol(c_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 1, 18))
+    }
+    export enum e_private {
+>e_private : Symbol(e_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 3, 5))
+
+        Happy,
+>Happy : Symbol(im_public_e_private.Happy, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 4, 27))
+
+        Grumpy
+>Grumpy : Symbol(im_public_e_private.Grumpy, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 5, 14))
+    }
+    export function f_private() {
+>f_private : Symbol(f_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 7, 5))
+
+        return new c_private();
+>c_private : Symbol(c_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 1, 18))
+    }
+    export var v_private = new c_private();
+>v_private : Symbol(v_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 11, 14))
+>c_private : Symbol(c_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 1, 18))
+
+    export interface i_private {
+>i_private : Symbol(i_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 11, 43))
+    }
+    export module mi_private {
+>mi_private : Symbol(mi_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 13, 5))
+
+        export class c {
+>c : Symbol(c, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 14, 30))
+        }
+    }
+    export module mu_private {
+>mu_private : Symbol(mu_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 17, 5))
+
+        export interface i {
+>i : Symbol(i, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 18, 30))
+        }
+    }
+}
+
+// Public elements
+export module m_public {
+>m_public : Symbol(m_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 22, 1))
+
+    export class c_public {
+>c_public : Symbol(c_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 25, 24))
+    }
+    export enum e_public {
+>e_public : Symbol(e_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 27, 5))
+
+        Happy,
+>Happy : Symbol(im_public_e_public.Happy, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 28, 26))
+
+        Grumpy
+>Grumpy : Symbol(im_public_e_public.Grumpy, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 29, 14))
+    }
+    export function f_public() {
+>f_public : Symbol(f_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 31, 5))
+
+        return new c_public();
+>c_public : Symbol(c_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 25, 24))
+    }
+    export var v_public = 10;
+>v_public : Symbol(v_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 35, 14))
+
+    export interface i_public {
+>i_public : Symbol(i_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 35, 29))
+    }
+    export module mi_public {
+>mi_public : Symbol(mi_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 37, 5))
+
+        export class c {
+>c : Symbol(c, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 38, 29))
+        }
+    }
+    export module mu_public {
+>mu_public : Symbol(mu_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 41, 5))
+
+        export interface i {
+>i : Symbol(i, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 42, 29))
+        }
+    }
+}
+
+// Privacy errors - importing private elements
+export import im_public_c_private = m_private.c_private;
+>im_public_c_private : Symbol(im_public_c_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 46, 1))
+>m_private : Symbol(m_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 0, 0))
+>c_private : Symbol(im_public_c_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 1, 18))
+
+export import im_public_e_private = m_private.e_private;
+>im_public_e_private : Symbol(im_public_e_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 49, 56))
+>m_private : Symbol(m_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 0, 0))
+>e_private : Symbol(im_public_e_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 3, 5))
+
+export import im_public_f_private = m_private.f_private;
+>im_public_f_private : Symbol(im_public_f_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 50, 56))
+>m_private : Symbol(m_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 0, 0))
+>f_private : Symbol(im_public_f_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 7, 5))
+
+export import im_public_v_private = m_private.v_private;
+>im_public_v_private : Symbol(im_public_v_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 51, 56))
+>m_private : Symbol(m_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 0, 0))
+>v_private : Symbol(im_public_v_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 11, 14))
+
+export import im_public_i_private = m_private.i_private;
+>im_public_i_private : Symbol(im_public_i_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 52, 56))
+>m_private : Symbol(m_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 0, 0))
+>i_private : Symbol(im_public_i_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 11, 43))
+
+export import im_public_mi_private = m_private.mi_private;
+>im_public_mi_private : Symbol(im_public_mi_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 53, 56))
+>m_private : Symbol(m_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 0, 0))
+>mi_private : Symbol(im_public_mi_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 13, 5))
+
+export import im_public_mu_private = m_private.mu_private;
+>im_public_mu_private : Symbol(im_public_mu_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 54, 58))
+>m_private : Symbol(m_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 0, 0))
+>mu_private : Symbol(im_public_mu_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 17, 5))
+
+// Usage of privacy error imports
+var privateUse_im_public_c_private = new im_public_c_private();
+>privateUse_im_public_c_private : Symbol(privateUse_im_public_c_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 58, 3))
+>im_public_c_private : Symbol(im_public_c_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 46, 1))
+
+export var publicUse_im_public_c_private = new im_public_c_private();
+>publicUse_im_public_c_private : Symbol(publicUse_im_public_c_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 59, 10))
+>im_public_c_private : Symbol(im_public_c_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 46, 1))
+
+var privateUse_im_public_e_private = im_public_e_private.Happy;
+>privateUse_im_public_e_private : Symbol(privateUse_im_public_e_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 60, 3))
+>im_public_e_private.Happy : Symbol(im_public_e_private.Happy, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 4, 27))
+>im_public_e_private : Symbol(im_public_e_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 49, 56))
+>Happy : Symbol(im_public_e_private.Happy, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 4, 27))
+
+export var publicUse_im_public_e_private = im_public_e_private.Grumpy;
+>publicUse_im_public_e_private : Symbol(publicUse_im_public_e_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 61, 10))
+>im_public_e_private.Grumpy : Symbol(im_public_e_private.Grumpy, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 5, 14))
+>im_public_e_private : Symbol(im_public_e_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 49, 56))
+>Grumpy : Symbol(im_public_e_private.Grumpy, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 5, 14))
+
+var privateUse_im_public_f_private = im_public_f_private();
+>privateUse_im_public_f_private : Symbol(privateUse_im_public_f_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 62, 3))
+>im_public_f_private : Symbol(im_public_f_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 50, 56))
+
+export var publicUse_im_public_f_private = im_public_f_private();
+>publicUse_im_public_f_private : Symbol(publicUse_im_public_f_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 63, 10))
+>im_public_f_private : Symbol(im_public_f_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 50, 56))
+
+var privateUse_im_public_v_private = im_public_v_private;
+>privateUse_im_public_v_private : Symbol(privateUse_im_public_v_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 64, 3))
+>im_public_v_private : Symbol(im_public_v_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 51, 56))
+
+export var publicUse_im_public_v_private = im_public_v_private;
+>publicUse_im_public_v_private : Symbol(publicUse_im_public_v_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 65, 10))
+>im_public_v_private : Symbol(im_public_v_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 51, 56))
+
+var privateUse_im_public_i_private: im_public_i_private;
+>privateUse_im_public_i_private : Symbol(privateUse_im_public_i_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 66, 3))
+>im_public_i_private : Symbol(im_public_i_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 52, 56))
+
+export var publicUse_im_public_i_private: im_public_i_private;
+>publicUse_im_public_i_private : Symbol(publicUse_im_public_i_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 67, 10))
+>im_public_i_private : Symbol(im_public_i_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 52, 56))
+
+var privateUse_im_public_mi_private = new im_public_mi_private.c();
+>privateUse_im_public_mi_private : Symbol(privateUse_im_public_mi_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 68, 3))
+>im_public_mi_private.c : Symbol(im_public_mi_private.c, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 14, 30))
+>im_public_mi_private : Symbol(im_public_mi_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 53, 56))
+>c : Symbol(im_public_mi_private.c, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 14, 30))
+
+export var publicUse_im_public_mi_private = new im_public_mi_private.c();
+>publicUse_im_public_mi_private : Symbol(publicUse_im_public_mi_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 69, 10))
+>im_public_mi_private.c : Symbol(im_public_mi_private.c, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 14, 30))
+>im_public_mi_private : Symbol(im_public_mi_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 53, 56))
+>c : Symbol(im_public_mi_private.c, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 14, 30))
+
+var privateUse_im_public_mu_private: im_public_mu_private.i;
+>privateUse_im_public_mu_private : Symbol(privateUse_im_public_mu_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 70, 3))
+>im_public_mu_private : Symbol(im_public_mu_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 54, 58))
+>i : Symbol(im_public_mu_private.i, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 18, 30))
+
+export var publicUse_im_public_mu_private: im_public_mu_private.i;
+>publicUse_im_public_mu_private : Symbol(publicUse_im_public_mu_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 71, 10))
+>im_public_mu_private : Symbol(im_public_mu_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 54, 58))
+>i : Symbol(im_public_mu_private.i, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 18, 30))
+
+
+// No Privacy errors - importing public elements
+export import im_public_c_public = m_public.c_public;
+>im_public_c_public : Symbol(im_public_c_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 71, 66))
+>m_public : Symbol(m_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 22, 1))
+>c_public : Symbol(im_public_c_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 25, 24))
+
+export import im_public_e_public = m_public.e_public;
+>im_public_e_public : Symbol(im_public_e_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 75, 53))
+>m_public : Symbol(m_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 22, 1))
+>e_public : Symbol(im_public_e_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 27, 5))
+
+export import im_public_f_public = m_public.f_public;
+>im_public_f_public : Symbol(im_public_f_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 76, 53))
+>m_public : Symbol(m_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 22, 1))
+>f_public : Symbol(im_public_f_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 31, 5))
+
+export import im_public_v_public = m_public.v_public;
+>im_public_v_public : Symbol(im_public_v_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 77, 53))
+>m_public : Symbol(m_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 22, 1))
+>v_public : Symbol(im_public_v_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 35, 14))
+
+export import im_public_i_public = m_public.i_public;
+>im_public_i_public : Symbol(im_public_i_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 78, 53))
+>m_public : Symbol(m_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 22, 1))
+>i_public : Symbol(im_public_i_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 35, 29))
+
+export import im_public_mi_public = m_public.mi_public;
+>im_public_mi_public : Symbol(im_public_mi_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 79, 53))
+>m_public : Symbol(m_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 22, 1))
+>mi_public : Symbol(im_public_mi_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 37, 5))
+
+export import im_public_mu_public = m_public.mu_public;
+>im_public_mu_public : Symbol(im_public_mu_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 80, 55))
+>m_public : Symbol(m_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 22, 1))
+>mu_public : Symbol(im_public_mu_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 41, 5))
+
+// Usage of above decls
+var privateUse_im_public_c_public = new im_public_c_public();
+>privateUse_im_public_c_public : Symbol(privateUse_im_public_c_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 84, 3))
+>im_public_c_public : Symbol(im_public_c_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 71, 66))
+
+export var publicUse_im_public_c_public = new im_public_c_public();
+>publicUse_im_public_c_public : Symbol(publicUse_im_public_c_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 85, 10))
+>im_public_c_public : Symbol(im_public_c_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 71, 66))
+
+var privateUse_im_public_e_public = im_public_e_public.Happy;
+>privateUse_im_public_e_public : Symbol(privateUse_im_public_e_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 86, 3))
+>im_public_e_public.Happy : Symbol(im_public_e_public.Happy, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 28, 26))
+>im_public_e_public : Symbol(im_public_e_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 75, 53))
+>Happy : Symbol(im_public_e_public.Happy, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 28, 26))
+
+export var publicUse_im_public_e_public = im_public_e_public.Grumpy;
+>publicUse_im_public_e_public : Symbol(publicUse_im_public_e_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 87, 10))
+>im_public_e_public.Grumpy : Symbol(im_public_e_public.Grumpy, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 29, 14))
+>im_public_e_public : Symbol(im_public_e_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 75, 53))
+>Grumpy : Symbol(im_public_e_public.Grumpy, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 29, 14))
+
+var privateUse_im_public_f_public = im_public_f_public();
+>privateUse_im_public_f_public : Symbol(privateUse_im_public_f_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 88, 3))
+>im_public_f_public : Symbol(im_public_f_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 76, 53))
+
+export var publicUse_im_public_f_public = im_public_f_public();
+>publicUse_im_public_f_public : Symbol(publicUse_im_public_f_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 89, 10))
+>im_public_f_public : Symbol(im_public_f_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 76, 53))
+
+var privateUse_im_public_v_public = im_public_v_public;
+>privateUse_im_public_v_public : Symbol(privateUse_im_public_v_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 90, 3))
+>im_public_v_public : Symbol(im_public_v_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 77, 53))
+
+export var publicUse_im_public_v_public = im_public_v_public;
+>publicUse_im_public_v_public : Symbol(publicUse_im_public_v_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 91, 10))
+>im_public_v_public : Symbol(im_public_v_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 77, 53))
+
+var privateUse_im_public_i_public: im_public_i_public;
+>privateUse_im_public_i_public : Symbol(privateUse_im_public_i_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 92, 3))
+>im_public_i_public : Symbol(im_public_i_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 78, 53))
+
+export var publicUse_im_public_i_public: im_public_i_public;
+>publicUse_im_public_i_public : Symbol(publicUse_im_public_i_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 93, 10))
+>im_public_i_public : Symbol(im_public_i_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 78, 53))
+
+var privateUse_im_public_mi_public = new im_public_mi_public.c();
+>privateUse_im_public_mi_public : Symbol(privateUse_im_public_mi_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 94, 3))
+>im_public_mi_public.c : Symbol(im_public_mi_public.c, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 38, 29))
+>im_public_mi_public : Symbol(im_public_mi_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 79, 53))
+>c : Symbol(im_public_mi_public.c, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 38, 29))
+
+export var publicUse_im_public_mi_public = new im_public_mi_public.c();
+>publicUse_im_public_mi_public : Symbol(publicUse_im_public_mi_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 95, 10))
+>im_public_mi_public.c : Symbol(im_public_mi_public.c, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 38, 29))
+>im_public_mi_public : Symbol(im_public_mi_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 79, 53))
+>c : Symbol(im_public_mi_public.c, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 38, 29))
+
+var privateUse_im_public_mu_public: im_public_mu_public.i;
+>privateUse_im_public_mu_public : Symbol(privateUse_im_public_mu_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 96, 3))
+>im_public_mu_public : Symbol(im_public_mu_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 80, 55))
+>i : Symbol(im_public_mu_public.i, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 42, 29))
+
+export var publicUse_im_public_mu_public: im_public_mu_public.i;
+>publicUse_im_public_mu_public : Symbol(publicUse_im_public_mu_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 97, 10))
+>im_public_mu_public : Symbol(im_public_mu_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 80, 55))
+>i : Symbol(im_public_mu_public.i, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 42, 29))
+
diff --git a/tests/baselines/reference/promiseChaining.symbols b/tests/baselines/reference/promiseChaining.symbols
index 1ad7044faaecc..5e30294c0731e 100644
--- a/tests/baselines/reference/promiseChaining.symbols
+++ b/tests/baselines/reference/promiseChaining.symbols
@@ -32,11 +32,14 @@ class Chain<T> {
 >this.then : Symbol(then, Decl(promiseChaining.ts, 1, 36))
 >this : Symbol(Chain, Decl(promiseChaining.ts, 0, 0))
 >then : Symbol(then, Decl(promiseChaining.ts, 1, 36))
+>x => result : Symbol((Anonymous function), Decl(promiseChaining.ts, 5, 26))
 >x : Symbol(x, Decl(promiseChaining.ts, 5, 26))
 >result : Symbol(result, Decl(promiseChaining.ts, 3, 11))
 >then : Symbol(Chain.then, Decl(promiseChaining.ts, 1, 36))
+>x => "abc" : Symbol((Anonymous function), Decl(promiseChaining.ts, 5, 49))
 >x : Symbol(x, Decl(promiseChaining.ts, 5, 49))
 >then : Symbol(Chain.then, Decl(promiseChaining.ts, 1, 36))
+>x => x.length : Symbol((Anonymous function), Decl(promiseChaining.ts, 5, 76))
 >x : Symbol(x, Decl(promiseChaining.ts, 5, 76))
 >x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >x : Symbol(x, Decl(promiseChaining.ts, 5, 76))
diff --git a/tests/baselines/reference/promiseTest.symbols b/tests/baselines/reference/promiseTest.symbols
index 229d3e089d0d5..b09c801e3e71f 100644
--- a/tests/baselines/reference/promiseTest.symbols
+++ b/tests/baselines/reference/promiseTest.symbols
@@ -39,6 +39,7 @@ var p2 = p.then(function (x) {
 >p.then : Symbol(Promise.then, Decl(promiseTest.ts, 1, 22), Decl(promiseTest.ts, 2, 60))
 >p : Symbol(p, Decl(promiseTest.ts, 7, 3))
 >then : Symbol(Promise.then, Decl(promiseTest.ts, 1, 22), Decl(promiseTest.ts, 2, 60))
+>function (x) {    return p;} : Symbol((Anonymous function), Decl(promiseTest.ts, 8, 16))
 >x : Symbol(x, Decl(promiseTest.ts, 8, 26))
 
     return p;
diff --git a/tests/baselines/reference/promiseTypeInference.symbols b/tests/baselines/reference/promiseTypeInference.symbols
index 14a77b9cdf242..8669449a3911b 100644
--- a/tests/baselines/reference/promiseTypeInference.symbols
+++ b/tests/baselines/reference/promiseTypeInference.symbols
@@ -44,6 +44,7 @@ var $$x = load("something").then(s => convert(s));
 >load("something").then : Symbol(Promise.then, Decl(promiseTypeInference.ts, 0, 26))
 >load : Symbol(load, Decl(promiseTypeInference.ts, 5, 1))
 >then : Symbol(Promise.then, Decl(promiseTypeInference.ts, 0, 26))
+>s => convert(s) : Symbol((Anonymous function), Decl(promiseTypeInference.ts, 9, 33))
 >s : Symbol(s, Decl(promiseTypeInference.ts, 9, 33))
 >convert : Symbol(convert, Decl(promiseTypeInference.ts, 6, 53))
 >s : Symbol(s, Decl(promiseTypeInference.ts, 9, 33))
diff --git a/tests/baselines/reference/promiseVoidErrorCallback.symbols b/tests/baselines/reference/promiseVoidErrorCallback.symbols
index 27e7df62ab1a0..8b45a4cc67927 100644
--- a/tests/baselines/reference/promiseVoidErrorCallback.symbols
+++ b/tests/baselines/reference/promiseVoidErrorCallback.symbols
@@ -26,9 +26,16 @@ function f1(): Promise<T1> {
 >T1 : Symbol(T1, Decl(promiseVoidErrorCallback.ts, 0, 0))
 
     return Promise.resolve({ __t1: "foo_t1" });
+<<<<<<< HEAD
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 4840, 39), Decl(lib.d.ts, 4847, 54))
 >Promise : Symbol(Promise, Decl(lib.d.ts, 4772, 1), Decl(lib.d.ts, 4858, 11))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 4840, 39), Decl(lib.d.ts, 4847, 54))
+=======
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 4837, 39), Decl(lib.d.ts, 4844, 54))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 4837, 39), Decl(lib.d.ts, 4844, 54))
+>{ __t1: "foo_t1" } : Symbol(, Decl(promiseVoidErrorCallback.ts, 13, 27))
+>>>>>>> Accept symbol baselines
 >__t1 : Symbol(__t1, Decl(promiseVoidErrorCallback.ts, 13, 28))
 }
 
@@ -39,6 +46,7 @@ function f2(x: T1): T2 {
 >T2 : Symbol(T2, Decl(promiseVoidErrorCallback.ts, 2, 1))
 
     return { __t2: x.__t1 + ":foo_21" };
+>{ __t2: x.__t1 + ":foo_21" } : Symbol(, Decl(promiseVoidErrorCallback.ts, 17, 10))
 >__t2 : Symbol(__t2, Decl(promiseVoidErrorCallback.ts, 17, 12))
 >x.__t1 : Symbol(T1.__t1, Decl(promiseVoidErrorCallback.ts, 0, 14))
 >x : Symbol(x, Decl(promiseVoidErrorCallback.ts, 16, 12))
@@ -54,6 +62,7 @@ var x3 = f1()
     .then(f2, (e: Error) => {
 >then : Symbol(Promise.then, Decl(lib.d.ts, 4777, 22), Decl(lib.d.ts, 4784, 158))
 >f2 : Symbol(f2, Decl(promiseVoidErrorCallback.ts, 14, 1))
+>(e: Error) => {    throw e;} : Symbol((Anonymous function), Decl(promiseVoidErrorCallback.ts, 21, 13))
 >e : Symbol(e, Decl(promiseVoidErrorCallback.ts, 21, 15))
 >Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11))
 
@@ -62,11 +71,17 @@ var x3 = f1()
 
 })
     .then((x: T2) => {
+<<<<<<< HEAD
 >then : Symbol(Promise.then, Decl(lib.d.ts, 4777, 22), Decl(lib.d.ts, 4784, 158))
+=======
+>then : Symbol(Promise.then, Decl(lib.d.ts, 4775, 22), Decl(lib.d.ts, 4782, 158))
+>(x: T2) => {    return { __t3: x.__t2 + "bar" };} : Symbol((Anonymous function), Decl(promiseVoidErrorCallback.ts, 24, 10))
+>>>>>>> Accept symbol baselines
 >x : Symbol(x, Decl(promiseVoidErrorCallback.ts, 24, 11))
 >T2 : Symbol(T2, Decl(promiseVoidErrorCallback.ts, 2, 1))
 
     return { __t3: x.__t2 + "bar" };
+>{ __t3: x.__t2 + "bar" } : Symbol(, Decl(promiseVoidErrorCallback.ts, 25, 10))
 >__t3 : Symbol(__t3, Decl(promiseVoidErrorCallback.ts, 25, 12))
 >x.__t2 : Symbol(T2.__t2, Decl(promiseVoidErrorCallback.ts, 4, 14))
 >x : Symbol(x, Decl(promiseVoidErrorCallback.ts, 24, 11))
diff --git a/tests/baselines/reference/propagationOfPromiseInitialization.symbols b/tests/baselines/reference/propagationOfPromiseInitialization.symbols
index 2289c175168e7..a2621f3b0c627 100644
--- a/tests/baselines/reference/propagationOfPromiseInitialization.symbols
+++ b/tests/baselines/reference/propagationOfPromiseInitialization.symbols
@@ -26,12 +26,14 @@ foo.then((x) => {
 >foo.then : Symbol(IPromise.then, Decl(propagationOfPromiseInitialization.ts, 0, 23))
 >foo : Symbol(foo, Decl(propagationOfPromiseInitialization.ts, 4, 3))
 >then : Symbol(IPromise.then, Decl(propagationOfPromiseInitialization.ts, 0, 23))
+>(x) => {    // x is inferred to be a number    return "asdf";} : Symbol((Anonymous function), Decl(propagationOfPromiseInitialization.ts, 5, 9))
 >x : Symbol(x, Decl(propagationOfPromiseInitialization.ts, 5, 10))
 
     // x is inferred to be a number
     return "asdf";
 }).then((x) => {
 >then : Symbol(IPromise.then, Decl(propagationOfPromiseInitialization.ts, 0, 23))
+>(x) => {    // x is inferred to be string    x.length;    return 123;} : Symbol((Anonymous function), Decl(propagationOfPromiseInitialization.ts, 8, 8))
 >x : Symbol(x, Decl(propagationOfPromiseInitialization.ts, 8, 9))
 
     // x is inferred to be string
diff --git a/tests/baselines/reference/propertyAccessOnTypeParameterWithConstraints.symbols b/tests/baselines/reference/propertyAccessOnTypeParameterWithConstraints.symbols
index 99856e99ae134..02ada6e6b9ba6 100644
--- a/tests/baselines/reference/propertyAccessOnTypeParameterWithConstraints.symbols
+++ b/tests/baselines/reference/propertyAccessOnTypeParameterWithConstraints.symbols
@@ -85,9 +85,11 @@ var r3b = a()['getDate']();
 
 var b = {
 >b : Symbol(b, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 26, 3))
+>{    foo: <T extends Date>(x: T) => {        var a = x['getDate'](); // number        return a + x.getDate();    }} : Symbol(, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 26, 7))
 
     foo: <T extends Date>(x: T) => {
 >foo : Symbol(foo, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 26, 9))
+><T extends Date>(x: T) => {        var a = x['getDate'](); // number        return a + x.getDate();    } : Symbol((Anonymous function), Decl(propertyAccessOnTypeParameterWithConstraints.ts, 27, 8))
 >T : Symbol(T, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 27, 10))
 >Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
 >x : Symbol(x, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 27, 26))
diff --git a/tests/baselines/reference/propertyAccessOnTypeParameterWithConstraints2.symbols b/tests/baselines/reference/propertyAccessOnTypeParameterWithConstraints2.symbols
index 29a3b30d45040..655efd3384c4b 100644
--- a/tests/baselines/reference/propertyAccessOnTypeParameterWithConstraints2.symbols
+++ b/tests/baselines/reference/propertyAccessOnTypeParameterWithConstraints2.symbols
@@ -197,9 +197,11 @@ var r3d = a(aB, aB)['foo']();
 
 var b = {
 >b : Symbol(b, Decl(propertyAccessOnTypeParameterWithConstraints2.ts, 67, 3))
+>{    foo: <U extends A, T extends A>(x: U, y: T) => {        var a = x['foo'](); // should be string        return a + x.foo();    }} : Symbol(, Decl(propertyAccessOnTypeParameterWithConstraints2.ts, 67, 7))
 
     foo: <U extends A, T extends A>(x: U, y: T) => {
 >foo : Symbol(foo, Decl(propertyAccessOnTypeParameterWithConstraints2.ts, 67, 9))
+><U extends A, T extends A>(x: U, y: T) => {        var a = x['foo'](); // should be string        return a + x.foo();    } : Symbol((Anonymous function), Decl(propertyAccessOnTypeParameterWithConstraints2.ts, 68, 8))
 >U : Symbol(U, Decl(propertyAccessOnTypeParameterWithConstraints2.ts, 68, 10))
 >A : Symbol(A, Decl(propertyAccessOnTypeParameterWithConstraints2.ts, 0, 0))
 >T : Symbol(T, Decl(propertyAccessOnTypeParameterWithConstraints2.ts, 68, 22))
diff --git a/tests/baselines/reference/propertyAccessOnTypeParameterWithoutConstraints.symbols b/tests/baselines/reference/propertyAccessOnTypeParameterWithoutConstraints.symbols
index 425c7e42aff83..10d2190519055 100644
--- a/tests/baselines/reference/propertyAccessOnTypeParameterWithoutConstraints.symbols
+++ b/tests/baselines/reference/propertyAccessOnTypeParameterWithoutConstraints.symbols
@@ -76,9 +76,11 @@ var r3b: string = a()['toString']();
 
 var b = {
 >b : Symbol(b, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 23, 3))
+>{    foo: <T>(x: T) => {        var a = x['toString'](); // should be string        return a + x.toString();    }} : Symbol(, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 23, 7))
 
     foo: <T>(x: T) => {
 >foo : Symbol(foo, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 23, 9))
+><T>(x: T) => {        var a = x['toString'](); // should be string        return a + x.toString();    } : Symbol((Anonymous function), Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 24, 8))
 >T : Symbol(T, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 24, 10))
 >x : Symbol(x, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 24, 13))
 >T : Symbol(T, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 24, 10))
diff --git a/tests/baselines/reference/propertyNameWithoutTypeAnnotation.symbols b/tests/baselines/reference/propertyNameWithoutTypeAnnotation.symbols
index 45840561fa72f..58cfd4c8d0042 100644
--- a/tests/baselines/reference/propertyNameWithoutTypeAnnotation.symbols
+++ b/tests/baselines/reference/propertyNameWithoutTypeAnnotation.symbols
@@ -22,6 +22,7 @@ var a: {
 
 var b = {
 >b : Symbol(b, Decl(propertyNameWithoutTypeAnnotation.ts, 12, 3))
+>{    foo: null} : Symbol(, Decl(propertyNameWithoutTypeAnnotation.ts, 12, 7))
 
     foo: null
 >foo : Symbol(foo, Decl(propertyNameWithoutTypeAnnotation.ts, 12, 9))
diff --git a/tests/baselines/reference/protectedClassPropertyAccessibleWithinClass.symbols b/tests/baselines/reference/protectedClassPropertyAccessibleWithinClass.symbols
index ccca7ab7501b7..319bc7816c081 100644
--- a/tests/baselines/reference/protectedClassPropertyAccessibleWithinClass.symbols
+++ b/tests/baselines/reference/protectedClassPropertyAccessibleWithinClass.symbols
@@ -70,6 +70,7 @@ class C2 {
 
     protected get y() { () => this.x; return null; }
 >y : Symbol(y, Decl(protectedClassPropertyAccessibleWithinClass.ts, 17, 24), Decl(protectedClassPropertyAccessibleWithinClass.ts, 18, 52))
+>() => this.x : Symbol((Anonymous function), Decl(protectedClassPropertyAccessibleWithinClass.ts, 18, 23))
 >this.x : Symbol(x, Decl(protectedClassPropertyAccessibleWithinClass.ts, 16, 10))
 >this : Symbol(C2, Decl(protectedClassPropertyAccessibleWithinClass.ts, 13, 1))
 >x : Symbol(x, Decl(protectedClassPropertyAccessibleWithinClass.ts, 16, 10))
@@ -77,6 +78,7 @@ class C2 {
     protected set y(x) { () => { this.y = this.x; } }
 >y : Symbol(y, Decl(protectedClassPropertyAccessibleWithinClass.ts, 17, 24), Decl(protectedClassPropertyAccessibleWithinClass.ts, 18, 52))
 >x : Symbol(x, Decl(protectedClassPropertyAccessibleWithinClass.ts, 19, 20))
+>() => { this.y = this.x; } : Symbol((Anonymous function), Decl(protectedClassPropertyAccessibleWithinClass.ts, 19, 24))
 >this.y : Symbol(y, Decl(protectedClassPropertyAccessibleWithinClass.ts, 17, 24), Decl(protectedClassPropertyAccessibleWithinClass.ts, 18, 52))
 >this : Symbol(C2, Decl(protectedClassPropertyAccessibleWithinClass.ts, 13, 1))
 >y : Symbol(y, Decl(protectedClassPropertyAccessibleWithinClass.ts, 17, 24), Decl(protectedClassPropertyAccessibleWithinClass.ts, 18, 52))
@@ -86,6 +88,7 @@ class C2 {
 
     protected foo() { () => this.foo; }
 >foo : Symbol(foo, Decl(protectedClassPropertyAccessibleWithinClass.ts, 19, 53))
+>() => this.foo : Symbol((Anonymous function), Decl(protectedClassPropertyAccessibleWithinClass.ts, 20, 21))
 >this.foo : Symbol(foo, Decl(protectedClassPropertyAccessibleWithinClass.ts, 19, 53))
 >this : Symbol(C2, Decl(protectedClassPropertyAccessibleWithinClass.ts, 13, 1))
 >foo : Symbol(foo, Decl(protectedClassPropertyAccessibleWithinClass.ts, 19, 53))
@@ -95,6 +98,7 @@ class C2 {
 
     protected static get y() { () => this.x; return null; }
 >y : Symbol(C2.y, Decl(protectedClassPropertyAccessibleWithinClass.ts, 22, 31), Decl(protectedClassPropertyAccessibleWithinClass.ts, 23, 59))
+>() => this.x : Symbol((Anonymous function), Decl(protectedClassPropertyAccessibleWithinClass.ts, 23, 30))
 >this.x : Symbol(C2.x, Decl(protectedClassPropertyAccessibleWithinClass.ts, 20, 39))
 >this : Symbol(C2, Decl(protectedClassPropertyAccessibleWithinClass.ts, 13, 1))
 >x : Symbol(C2.x, Decl(protectedClassPropertyAccessibleWithinClass.ts, 20, 39))
@@ -104,6 +108,7 @@ class C2 {
 >x : Symbol(x, Decl(protectedClassPropertyAccessibleWithinClass.ts, 24, 27))
 
         () => { this.y = this.x; }
+>() => { this.y = this.x; } : Symbol((Anonymous function), Decl(protectedClassPropertyAccessibleWithinClass.ts, 24, 31))
 >this.y : Symbol(C2.y, Decl(protectedClassPropertyAccessibleWithinClass.ts, 22, 31), Decl(protectedClassPropertyAccessibleWithinClass.ts, 23, 59))
 >this : Symbol(C2, Decl(protectedClassPropertyAccessibleWithinClass.ts, 13, 1))
 >y : Symbol(C2.y, Decl(protectedClassPropertyAccessibleWithinClass.ts, 22, 31), Decl(protectedClassPropertyAccessibleWithinClass.ts, 23, 59))
@@ -113,12 +118,14 @@ class C2 {
      }
     protected static foo() { () => this.foo; }
 >foo : Symbol(C2.foo, Decl(protectedClassPropertyAccessibleWithinClass.ts, 26, 6))
+>() => this.foo : Symbol((Anonymous function), Decl(protectedClassPropertyAccessibleWithinClass.ts, 27, 28))
 >this.foo : Symbol(C2.foo, Decl(protectedClassPropertyAccessibleWithinClass.ts, 26, 6))
 >this : Symbol(C2, Decl(protectedClassPropertyAccessibleWithinClass.ts, 13, 1))
 >foo : Symbol(C2.foo, Decl(protectedClassPropertyAccessibleWithinClass.ts, 26, 6))
 
     protected static bar() { () => this.foo(); }
 >bar : Symbol(C2.bar, Decl(protectedClassPropertyAccessibleWithinClass.ts, 27, 46))
+>() => this.foo() : Symbol((Anonymous function), Decl(protectedClassPropertyAccessibleWithinClass.ts, 28, 28))
 >this.foo : Symbol(C2.foo, Decl(protectedClassPropertyAccessibleWithinClass.ts, 26, 6))
 >this : Symbol(C2, Decl(protectedClassPropertyAccessibleWithinClass.ts, 13, 1))
 >foo : Symbol(C2.foo, Decl(protectedClassPropertyAccessibleWithinClass.ts, 26, 6))
diff --git a/tests/baselines/reference/protoAsIndexInIndexExpression.symbols b/tests/baselines/reference/protoAsIndexInIndexExpression.symbols
index 3a5f39c65c638..5343d8c067cb9 100644
--- a/tests/baselines/reference/protoAsIndexInIndexExpression.symbols
+++ b/tests/baselines/reference/protoAsIndexInIndexExpression.symbols
@@ -6,9 +6,11 @@ var EntityPrototype = undefined;
 
 var WorkspacePrototype = {
 >WorkspacePrototype : Symbol(WorkspacePrototype, Decl(protoAsIndexInIndexExpression_1.ts, 2, 3))
+>{    serialize: function (): any {    }} : Symbol(, Decl(protoAsIndexInIndexExpression_1.ts, 2, 24))
 
     serialize: function (): any {
 >serialize : Symbol(serialize, Decl(protoAsIndexInIndexExpression_1.ts, 2, 26))
+>function (): any {    } : Symbol((Anonymous function), Decl(protoAsIndexInIndexExpression_1.ts, 3, 14))
     }
 };
 WorkspacePrototype['__proto__'] = EntityPrototype;
@@ -17,6 +19,7 @@ WorkspacePrototype['__proto__'] = EntityPrototype;
 
 var o = {
 >o : Symbol(o, Decl(protoAsIndexInIndexExpression_1.ts, 8, 3))
+>{    "__proto__": 0} : Symbol(, Decl(protoAsIndexInIndexExpression_1.ts, 8, 7))
 
     "__proto__": 0
 };
diff --git a/tests/baselines/reference/quotedPropertyName3.symbols b/tests/baselines/reference/quotedPropertyName3.symbols
index 1a84302242574..c594787ba30b0 100644
--- a/tests/baselines/reference/quotedPropertyName3.symbols
+++ b/tests/baselines/reference/quotedPropertyName3.symbols
@@ -8,6 +8,7 @@ class Test {
 
         var x = () => this["prop1"];
 >x : Symbol(x, Decl(quotedPropertyName3.ts, 3, 11))
+>() => this["prop1"] : Symbol((Anonymous function), Decl(quotedPropertyName3.ts, 3, 15))
 >this : Symbol(Test, Decl(quotedPropertyName3.ts, 0, 0))
 >"prop1" : Symbol("prop1", Decl(quotedPropertyName3.ts, 0, 12))
 
diff --git a/tests/baselines/reference/recur1.symbols b/tests/baselines/reference/recur1.symbols
index a36fe5cc2a76f..93329e2ede8ab 100644
--- a/tests/baselines/reference/recur1.symbols
+++ b/tests/baselines/reference/recur1.symbols
@@ -5,6 +5,7 @@ var salt:any = new salt.pepper();
 
 salt.pepper = function() {}
 >salt : Symbol(salt, Decl(recur1.ts, 0, 3))
+>function() {} : Symbol((Anonymous function), Decl(recur1.ts, 1, 13))
 
 var cobalt = new cobalt.pitch();   
 >cobalt : Symbol(cobalt, Decl(recur1.ts, 3, 3))
@@ -12,5 +13,6 @@ var cobalt = new cobalt.pitch();
 
 cobalt.pitch = function() {}
 >cobalt : Symbol(cobalt, Decl(recur1.ts, 3, 3))
+>function() {} : Symbol((Anonymous function), Decl(recur1.ts, 4, 14))
  
 
diff --git a/tests/baselines/reference/recursiveInitializer.symbols b/tests/baselines/reference/recursiveInitializer.symbols
index 56fcbd7b438de..2f1ab68f155b0 100644
--- a/tests/baselines/reference/recursiveInitializer.symbols
+++ b/tests/baselines/reference/recursiveInitializer.symbols
@@ -55,6 +55,7 @@ var b4 = (!b4) && b4; // expected boolean here. actually 'any'
 // (x:string) => any
 var f = (x: string) => f(x);
 >f : Symbol(f, Decl(recursiveInitializer.ts, 18, 3))
+>(x: string) => f(x) : Symbol((Anonymous function), Decl(recursiveInitializer.ts, 18, 7))
 >x : Symbol(x, Decl(recursiveInitializer.ts, 18, 9))
 >f : Symbol(f, Decl(recursiveInitializer.ts, 18, 3))
 >x : Symbol(x, Decl(recursiveInitializer.ts, 18, 9))
diff --git a/tests/baselines/reference/recursiveObjectLiteral.symbols b/tests/baselines/reference/recursiveObjectLiteral.symbols
index 8ee5c49b60d23..d48c89bcdaa0f 100644
--- a/tests/baselines/reference/recursiveObjectLiteral.symbols
+++ b/tests/baselines/reference/recursiveObjectLiteral.symbols
@@ -1,6 +1,7 @@
 === tests/cases/compiler/recursiveObjectLiteral.ts ===
 var a = { f: a };
 >a : Symbol(a, Decl(recursiveObjectLiteral.ts, 0, 3))
+>{ f: a } : Symbol(, Decl(recursiveObjectLiteral.ts, 0, 7))
 >f : Symbol(f, Decl(recursiveObjectLiteral.ts, 0, 9))
 >a : Symbol(a, Decl(recursiveObjectLiteral.ts, 0, 3))
 
diff --git a/tests/baselines/reference/reservedWords.symbols b/tests/baselines/reference/reservedWords.symbols
index 98795f3c719b2..3bb9a50811fe4 100644
--- a/tests/baselines/reference/reservedWords.symbols
+++ b/tests/baselines/reference/reservedWords.symbols
@@ -1,6 +1,7 @@
 === tests/cases/compiler/reservedWords.ts ===
 var obj = {
 >obj : Symbol(obj, Decl(reservedWords.ts, 0, 3))
+>{    if: 0,    debugger: 2,    break: 3,    function: 4} : Symbol(, Decl(reservedWords.ts, 0, 9))
 
     if: 0,
 >if : Symbol(if, Decl(reservedWords.ts, 0, 11))
@@ -19,6 +20,7 @@ var obj = {
 
 var obj2 = {
 >obj2 : Symbol(obj2, Decl(reservedWords.ts, 9, 3))
+>{    if: 0,    while: 1,    debugger: 2,    break: 3,    function: 4} : Symbol(, Decl(reservedWords.ts, 9, 10))
 
     if: 0,
 >if : Symbol(if, Decl(reservedWords.ts, 9, 12))
diff --git a/tests/baselines/reference/returnStatement1.symbols b/tests/baselines/reference/returnStatement1.symbols
index acec9f7600374..3236b1842ad27 100644
--- a/tests/baselines/reference/returnStatement1.symbols
+++ b/tests/baselines/reference/returnStatement1.symbols
@@ -3,6 +3,7 @@ function f() {
 >f : Symbol(f, Decl(returnStatement1.ts, 0, 0))
 
     return function (s) {
+>function (s) {        var x = s;    } : Symbol((Anonymous function), Decl(returnStatement1.ts, 1, 10))
 >s : Symbol(s, Decl(returnStatement1.ts, 1, 21))
 
         var x = s;
diff --git a/tests/baselines/reference/returnStatements.symbols b/tests/baselines/reference/returnStatements.symbols
index e12f3ba5d8a39..ed3d68c60931d 100644
--- a/tests/baselines/reference/returnStatements.symbols
+++ b/tests/baselines/reference/returnStatements.symbols
@@ -51,6 +51,7 @@ class D extends C {
 function fn10(): I { return { id: 12 }; } 
 >fn10 : Symbol(fn10, Decl(returnStatements.ts, 17, 1))
 >I : Symbol(I, Decl(returnStatements.ts, 8, 31))
+>{ id: 12 } : Symbol(, Decl(returnStatements.ts, 18, 27))
 >id : Symbol(id, Decl(returnStatements.ts, 18, 29))
 
 function fn11(): I { return new C(); }
diff --git a/tests/baselines/reference/returnTypeParameterWithModules.symbols b/tests/baselines/reference/returnTypeParameterWithModules.symbols
index c4b354ad9205f..be6d8edae1b90 100644
--- a/tests/baselines/reference/returnTypeParameterWithModules.symbols
+++ b/tests/baselines/reference/returnTypeParameterWithModules.symbols
@@ -63,6 +63,7 @@ module M2 {
 >C : Symbol(C, Decl(returnTypeParameterWithModules.ts, 10, 31))
 
     return function (x) { return g(f(x)); }
+>function (x) { return g(f(x)); } : Symbol((Anonymous function), Decl(returnTypeParameterWithModules.ts, 11, 10))
 >x : Symbol(x, Decl(returnTypeParameterWithModules.ts, 11, 21))
 >g : Symbol(g, Decl(returnTypeParameterWithModules.ts, 10, 38))
 >f : Symbol(f, Decl(returnTypeParameterWithModules.ts, 10, 53))
diff --git a/tests/baselines/reference/selfInCallback.symbols b/tests/baselines/reference/selfInCallback.symbols
index 805b77140126c..a8bc749921da5 100644
--- a/tests/baselines/reference/selfInCallback.symbols
+++ b/tests/baselines/reference/selfInCallback.symbols
@@ -17,6 +17,7 @@ class C {
 >this.callback : Symbol(callback, Decl(selfInCallback.ts, 1, 15))
 >this : Symbol(C, Decl(selfInCallback.ts, 0, 0))
 >callback : Symbol(callback, Decl(selfInCallback.ts, 1, 15))
+>()=>{this.p1+1} : Symbol((Anonymous function), Decl(selfInCallback.ts, 4, 16))
 >this.p1 : Symbol(p1, Decl(selfInCallback.ts, 0, 9))
 >this : Symbol(C, Decl(selfInCallback.ts, 0, 0))
 >p1 : Symbol(p1, Decl(selfInCallback.ts, 0, 9))
diff --git a/tests/baselines/reference/selfInLambdas.symbols b/tests/baselines/reference/selfInLambdas.symbols
index 032de5e776783..9a3d14359e9bd 100644
--- a/tests/baselines/reference/selfInLambdas.symbols
+++ b/tests/baselines/reference/selfInLambdas.symbols
@@ -24,21 +24,25 @@ interface Window {
 }
 var o = {
 >o : Symbol(o, Decl(selfInLambdas.ts, 10, 3))
+>{    counter: 0,    start: function() {        window.onmousemove = () => {            this.counter++            var f = () => this.counter;        }    }} : Symbol(, Decl(selfInLambdas.ts, 10, 7))
 
     counter: 0,
 >counter : Symbol(counter, Decl(selfInLambdas.ts, 10, 9))
 
     start: function() {
 >start : Symbol(start, Decl(selfInLambdas.ts, 12, 15))
+>function() {        window.onmousemove = () => {            this.counter++            var f = () => this.counter;        }    } : Symbol((Anonymous function), Decl(selfInLambdas.ts, 14, 10))
 
         window.onmousemove = () => {
 >window.onmousemove : Symbol(Window.onmousemove, Decl(selfInLambdas.ts, 6, 18))
 >window : Symbol(window, Decl(selfInLambdas.ts, 5, 11))
 >onmousemove : Symbol(Window.onmousemove, Decl(selfInLambdas.ts, 6, 18))
+>() => {            this.counter++            var f = () => this.counter;        } : Symbol((Anonymous function), Decl(selfInLambdas.ts, 16, 28))
 
             this.counter++
             var f = () => this.counter;
 >f : Symbol(f, Decl(selfInLambdas.ts, 18, 15))
+>() => this.counter : Symbol((Anonymous function), Decl(selfInLambdas.ts, 18, 19))
 
         }
 
@@ -59,6 +63,7 @@ class X {
 
 		var outer= () => {
 >outer : Symbol(outer, Decl(selfInLambdas.ts, 32, 5))
+>() => {            var x = this.value;            var inner = () => {                var y = this.value;			}			inner();		} : Symbol((Anonymous function), Decl(selfInLambdas.ts, 32, 12))
 
             var x = this.value;
 >x : Symbol(x, Decl(selfInLambdas.ts, 33, 15))
@@ -68,6 +73,7 @@ class X {
 
             var inner = () => {
 >inner : Symbol(inner, Decl(selfInLambdas.ts, 34, 15))
+>() => {                var y = this.value;			} : Symbol((Anonymous function), Decl(selfInLambdas.ts, 34, 23))
 
                 var y = this.value;
 >y : Symbol(y, Decl(selfInLambdas.ts, 35, 19))
diff --git a/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.symbols b/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.symbols
index ab79174a43a16..ecb3a082aa5a1 100644
--- a/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.symbols
+++ b/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.symbols
@@ -2,9 +2,12 @@
 [].map(() => [].map(p => ({ X: p })));
 >[].map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
 >map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>() => [].map(p => ({ X: p })) : Symbol((Anonymous function), Decl(simpleArrowFunctionParameterReferencedInObjectLiteral1.ts, 0, 7))
 >[].map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
 >map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>p => ({ X: p }) : Symbol((Anonymous function), Decl(simpleArrowFunctionParameterReferencedInObjectLiteral1.ts, 0, 20))
 >p : Symbol(p, Decl(simpleArrowFunctionParameterReferencedInObjectLiteral1.ts, 0, 20))
+>{ X: p } : Symbol(, Decl(simpleArrowFunctionParameterReferencedInObjectLiteral1.ts, 0, 26))
 >X : Symbol(X, Decl(simpleArrowFunctionParameterReferencedInObjectLiteral1.ts, 0, 27))
 >p : Symbol(p, Decl(simpleArrowFunctionParameterReferencedInObjectLiteral1.ts, 0, 20))
 
diff --git a/tests/baselines/reference/sourceMapValidationClassWithDefaultConstructorAndCapturedThisStatement.symbols b/tests/baselines/reference/sourceMapValidationClassWithDefaultConstructorAndCapturedThisStatement.symbols
index 44612abacbb8a..a2fc1f95c5fdd 100644
--- a/tests/baselines/reference/sourceMapValidationClassWithDefaultConstructorAndCapturedThisStatement.symbols
+++ b/tests/baselines/reference/sourceMapValidationClassWithDefaultConstructorAndCapturedThisStatement.symbols
@@ -7,6 +7,7 @@ class Greeter {
 
     public returnA = () => this.a;
 >returnA : Symbol(returnA, Decl(sourceMapValidationClassWithDefaultConstructorAndCapturedThisStatement.ts, 1, 18))
+>() => this.a : Symbol((Anonymous function), Decl(sourceMapValidationClassWithDefaultConstructorAndCapturedThisStatement.ts, 2, 20))
 >this.a : Symbol(a, Decl(sourceMapValidationClassWithDefaultConstructorAndCapturedThisStatement.ts, 0, 15))
 >this : Symbol(Greeter, Decl(sourceMapValidationClassWithDefaultConstructorAndCapturedThisStatement.ts, 0, 0))
 >a : Symbol(a, Decl(sourceMapValidationClassWithDefaultConstructorAndCapturedThisStatement.ts, 0, 15))
diff --git a/tests/baselines/reference/sourceMapValidationFunctionExpressions.symbols b/tests/baselines/reference/sourceMapValidationFunctionExpressions.symbols
index 64e2bdad7e476..c89f1f2e2a5f7 100644
--- a/tests/baselines/reference/sourceMapValidationFunctionExpressions.symbols
+++ b/tests/baselines/reference/sourceMapValidationFunctionExpressions.symbols
@@ -4,6 +4,7 @@ var greetings = 0;
 
 var greet = (greeting: string): number => {
 >greet : Symbol(greet, Decl(sourceMapValidationFunctionExpressions.ts, 1, 3))
+>(greeting: string): number => {    greetings++;    return greetings;} : Symbol((Anonymous function), Decl(sourceMapValidationFunctionExpressions.ts, 1, 11))
 >greeting : Symbol(greeting, Decl(sourceMapValidationFunctionExpressions.ts, 1, 13))
 
     greetings++;
@@ -17,5 +18,6 @@ greet("Hello");
 
 var incrGreetings = () => greetings++;
 >incrGreetings : Symbol(incrGreetings, Decl(sourceMapValidationFunctionExpressions.ts, 6, 3))
+>() => greetings++ : Symbol((Anonymous function), Decl(sourceMapValidationFunctionExpressions.ts, 6, 19))
 >greetings : Symbol(greetings, Decl(sourceMapValidationFunctionExpressions.ts, 0, 3))
 
diff --git a/tests/baselines/reference/sourceMapValidationFunctionPropertyAssignment.symbols b/tests/baselines/reference/sourceMapValidationFunctionPropertyAssignment.symbols
index 2718a5e8848fb..600477d5b3989 100644
--- a/tests/baselines/reference/sourceMapValidationFunctionPropertyAssignment.symbols
+++ b/tests/baselines/reference/sourceMapValidationFunctionPropertyAssignment.symbols
@@ -1,5 +1,6 @@
 === tests/cases/compiler/sourceMapValidationFunctionPropertyAssignment.ts ===
 var x = { n() { } };
 >x : Symbol(x, Decl(sourceMapValidationFunctionPropertyAssignment.ts, 0, 3))
+>{ n() { } } : Symbol(, Decl(sourceMapValidationFunctionPropertyAssignment.ts, 0, 7))
 >n : Symbol(n, Decl(sourceMapValidationFunctionPropertyAssignment.ts, 0, 9))
 
diff --git a/tests/baselines/reference/sourceMapWithMultipleFilesWithCopyright.symbols b/tests/baselines/reference/sourceMapWithMultipleFilesWithCopyright.symbols
index 8ec6f81767279..d8e0bf34934e2 100644
--- a/tests/baselines/reference/sourceMapWithMultipleFilesWithCopyright.symbols
+++ b/tests/baselines/reference/sourceMapWithMultipleFilesWithCopyright.symbols
@@ -15,6 +15,7 @@ Copyright
 
 var x = {
 >x : Symbol(x, Decl(a.ts, 4, 3))
+>{    a: 10,    b: 20} : Symbol(, Decl(a.ts, 4, 7))
 
     a: 10,
 >a : Symbol(a, Decl(a.ts, 4, 9))
diff --git a/tests/baselines/reference/specializationsShouldNotAffectEachOther.symbols b/tests/baselines/reference/specializationsShouldNotAffectEachOther.symbols
index 9f03f8fca018f..7286bfaeda126 100644
--- a/tests/baselines/reference/specializationsShouldNotAffectEachOther.symbols
+++ b/tests/baselines/reference/specializationsShouldNotAffectEachOther.symbols
@@ -17,6 +17,7 @@ function foo() {
 
     var seriesExtent = (series) => null;
 >seriesExtent : Symbol(seriesExtent, Decl(specializationsShouldNotAffectEachOther.ts, 10, 7))
+>(series) => null : Symbol((Anonymous function), Decl(specializationsShouldNotAffectEachOther.ts, 10, 22))
 >series : Symbol(series, Decl(specializationsShouldNotAffectEachOther.ts, 10, 24))
 
     var series2: number[];
@@ -39,6 +40,7 @@ var keyExtent2: any[] = series.data.map(function (d: string) { return d; });
 >series : Symbol(series, Decl(specializationsShouldNotAffectEachOther.ts, 5, 3))
 >data : Symbol(Series.data, Decl(specializationsShouldNotAffectEachOther.ts, 1, 19))
 >map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>function (d: string) { return d; } : Symbol((Anonymous function), Decl(specializationsShouldNotAffectEachOther.ts, 19, 40))
 >d : Symbol(d, Decl(specializationsShouldNotAffectEachOther.ts, 19, 50))
 >d : Symbol(d, Decl(specializationsShouldNotAffectEachOther.ts, 19, 50))
 
diff --git a/tests/baselines/reference/specializedInheritedConstructors1.symbols b/tests/baselines/reference/specializedInheritedConstructors1.symbols
index 97285e073cc4d..80f8ae4575d24 100644
--- a/tests/baselines/reference/specializedInheritedConstructors1.symbols
+++ b/tests/baselines/reference/specializedInheritedConstructors1.symbols
@@ -34,12 +34,14 @@ var m: ViewOptions<Model> = { model: new Model() };
 >m : Symbol(m, Decl(specializedInheritedConstructors1.ts, 12, 3))
 >ViewOptions : Symbol(ViewOptions, Decl(specializedInheritedConstructors1.ts, 0, 0))
 >Model : Symbol(Model, Decl(specializedInheritedConstructors1.ts, 7, 1))
+>{ model: new Model() } : Symbol(, Decl(specializedInheritedConstructors1.ts, 12, 27))
 >model : Symbol(model, Decl(specializedInheritedConstructors1.ts, 12, 29))
 >Model : Symbol(Model, Decl(specializedInheritedConstructors1.ts, 7, 1))
 
 var aView = new View({ model: new Model() }); 
 >aView : Symbol(aView, Decl(specializedInheritedConstructors1.ts, 13, 3))
 >View : Symbol(View, Decl(specializedInheritedConstructors1.ts, 2, 1))
+>{ model: new Model() } : Symbol(, Decl(specializedInheritedConstructors1.ts, 13, 21))
 >model : Symbol(model, Decl(specializedInheritedConstructors1.ts, 13, 22))
 >Model : Symbol(Model, Decl(specializedInheritedConstructors1.ts, 7, 1))
 
diff --git a/tests/baselines/reference/strictModeUseContextualKeyword.symbols b/tests/baselines/reference/strictModeUseContextualKeyword.symbols
index a0a3182b9c62d..925f79fc4b31a 100644
--- a/tests/baselines/reference/strictModeUseContextualKeyword.symbols
+++ b/tests/baselines/reference/strictModeUseContextualKeyword.symbols
@@ -24,6 +24,7 @@ function H() {
 
     let {as} = { as: 1 };
 >as : Symbol(as, Decl(strictModeUseContextualKeyword.ts, 10, 9))
+>{ as: 1 } : Symbol(, Decl(strictModeUseContextualKeyword.ts, 10, 14))
 >as : Symbol(as, Decl(strictModeUseContextualKeyword.ts, 10, 16))
 }
 
diff --git a/tests/baselines/reference/stringIndexingResults.symbols b/tests/baselines/reference/stringIndexingResults.symbols
index 4890b44bce6fa..bcfca21e056fc 100644
--- a/tests/baselines/reference/stringIndexingResults.symbols
+++ b/tests/baselines/reference/stringIndexingResults.symbols
@@ -79,6 +79,7 @@ var r9 = a[1];
 var b: { [x: string]: string } = { y: '' }
 >b : Symbol(b, Decl(stringIndexingResults.ts, 29, 3))
 >x : Symbol(x, Decl(stringIndexingResults.ts, 29, 10))
+>{ y: '' } : Symbol(, Decl(stringIndexingResults.ts, 29, 32))
 >y : Symbol(y, Decl(stringIndexingResults.ts, 29, 34))
 
 var r10 = b['y'];
diff --git a/tests/baselines/reference/stringLiteralObjectLiteralDeclaration1.symbols b/tests/baselines/reference/stringLiteralObjectLiteralDeclaration1.symbols
index b4bdeb71c79a9..0b8827392405e 100644
--- a/tests/baselines/reference/stringLiteralObjectLiteralDeclaration1.symbols
+++ b/tests/baselines/reference/stringLiteralObjectLiteralDeclaration1.symbols
@@ -4,5 +4,6 @@ module m1 {
 
   export var n = { 'foo bar': 4 };
 >n : Symbol(n, Decl(stringLiteralObjectLiteralDeclaration1.ts, 1, 12))
+>{ 'foo bar': 4 } : Symbol(, Decl(stringLiteralObjectLiteralDeclaration1.ts, 1, 16))
 }
 
diff --git a/tests/baselines/reference/stringLiteralPropertyNameWithLineContinuation1.symbols b/tests/baselines/reference/stringLiteralPropertyNameWithLineContinuation1.symbols
index 3f7804a18a72b..13aa82b07361d 100644
--- a/tests/baselines/reference/stringLiteralPropertyNameWithLineContinuation1.symbols
+++ b/tests/baselines/reference/stringLiteralPropertyNameWithLineContinuation1.symbols
@@ -1,6 +1,7 @@
 === tests/cases/compiler/stringLiteralPropertyNameWithLineContinuation1.ts ===
 var x = {'text\
 >x : Symbol(x, Decl(stringLiteralPropertyNameWithLineContinuation1.ts, 0, 3))
+>{'text\':'hello'} : Symbol(, Decl(stringLiteralPropertyNameWithLineContinuation1.ts, 0, 7))
 
 ':'hello'}
 x.text = "bar"
diff --git a/tests/baselines/reference/stringNamedPropertyAccess.symbols b/tests/baselines/reference/stringNamedPropertyAccess.symbols
index 583e5da06edd7..abec459427b7a 100644
--- a/tests/baselines/reference/stringNamedPropertyAccess.symbols
+++ b/tests/baselines/reference/stringNamedPropertyAccess.symbols
@@ -45,6 +45,7 @@ var r3 = a["a b"];
 
 var b = {
 >b : Symbol(b, Decl(stringNamedPropertyAccess.ts, 19, 3))
+>{    "a b": 1} : Symbol(, Decl(stringNamedPropertyAccess.ts, 19, 7))
 
     "a b": 1
 }
diff --git a/tests/baselines/reference/stringPropCodeGen.symbols b/tests/baselines/reference/stringPropCodeGen.symbols
index b0d9cb91fc237..8f650d9487253 100644
--- a/tests/baselines/reference/stringPropCodeGen.symbols
+++ b/tests/baselines/reference/stringPropCodeGen.symbols
@@ -1,8 +1,11 @@
 === tests/cases/compiler/stringPropCodeGen.ts ===
 var a = {
 >a : Symbol(a, Decl(stringPropCodeGen.ts, 0, 3))
+>{  "foo" : function() { },  "bar" : 5} : Symbol(, Decl(stringPropCodeGen.ts, 0, 7))
 
   "foo" : function() { },
+>function() { } : Symbol((Anonymous function), Decl(stringPropCodeGen.ts, 2, 9))
+
   "bar" : 5
 
 };
diff --git a/tests/baselines/reference/structural1.symbols b/tests/baselines/reference/structural1.symbols
index 78330978cd4d4..0cbdc8bcf526e 100644
--- a/tests/baselines/reference/structural1.symbols
+++ b/tests/baselines/reference/structural1.symbols
@@ -20,6 +20,7 @@ module M {
 
     f({salt:2,pepper:0});
 >f : Symbol(f, Decl(structural1.ts, 4, 5))
+>{salt:2,pepper:0} : Symbol(, Decl(structural1.ts, 9, 6))
 >salt : Symbol(salt, Decl(structural1.ts, 9, 7))
 >pepper : Symbol(pepper, Decl(structural1.ts, 9, 14))
 }
diff --git a/tests/baselines/reference/subtypingWithCallSignatures.symbols b/tests/baselines/reference/subtypingWithCallSignatures.symbols
index 1f7dda99be744..5d40856453524 100644
--- a/tests/baselines/reference/subtypingWithCallSignatures.symbols
+++ b/tests/baselines/reference/subtypingWithCallSignatures.symbols
@@ -15,11 +15,13 @@ module CallSignature {
     var r = foo1((x: number) => 1); // ok because base returns void
 >r : Symbol(r, Decl(subtypingWithCallSignatures.ts, 3, 7))
 >foo1 : Symbol(foo1, Decl(subtypingWithCallSignatures.ts, 0, 22), Decl(subtypingWithCallSignatures.ts, 1, 62))
+>(x: number) => 1 : Symbol((Anonymous function), Decl(subtypingWithCallSignatures.ts, 3, 17))
 >x : Symbol(x, Decl(subtypingWithCallSignatures.ts, 3, 18))
 
     var r2 = foo1(<T>(x: T) => ''); // ok because base returns void
 >r2 : Symbol(r2, Decl(subtypingWithCallSignatures.ts, 4, 7))
 >foo1 : Symbol(foo1, Decl(subtypingWithCallSignatures.ts, 0, 22), Decl(subtypingWithCallSignatures.ts, 1, 62))
+><T>(x: T) => '' : Symbol((Anonymous function), Decl(subtypingWithCallSignatures.ts, 4, 18))
 >T : Symbol(T, Decl(subtypingWithCallSignatures.ts, 4, 19))
 >x : Symbol(x, Decl(subtypingWithCallSignatures.ts, 4, 22))
 >T : Symbol(T, Decl(subtypingWithCallSignatures.ts, 4, 19))
@@ -38,12 +40,14 @@ module CallSignature {
     var r3 = foo2((x: number, y: number) => 1); // ok because base returns void
 >r3 : Symbol(r3, Decl(subtypingWithCallSignatures.ts, 8, 7))
 >foo2 : Symbol(foo2, Decl(subtypingWithCallSignatures.ts, 4, 35), Decl(subtypingWithCallSignatures.ts, 6, 73))
+>(x: number, y: number) => 1 : Symbol((Anonymous function), Decl(subtypingWithCallSignatures.ts, 8, 18))
 >x : Symbol(x, Decl(subtypingWithCallSignatures.ts, 8, 19))
 >y : Symbol(y, Decl(subtypingWithCallSignatures.ts, 8, 29))
 
     var r4 = foo2(<T>(x: T) => ''); // ok because base returns void
 >r4 : Symbol(r4, Decl(subtypingWithCallSignatures.ts, 9, 7))
 >foo2 : Symbol(foo2, Decl(subtypingWithCallSignatures.ts, 4, 35), Decl(subtypingWithCallSignatures.ts, 6, 73))
+><T>(x: T) => '' : Symbol((Anonymous function), Decl(subtypingWithCallSignatures.ts, 9, 18))
 >T : Symbol(T, Decl(subtypingWithCallSignatures.ts, 9, 19))
 >x : Symbol(x, Decl(subtypingWithCallSignatures.ts, 9, 22))
 >T : Symbol(T, Decl(subtypingWithCallSignatures.ts, 9, 19))
diff --git a/tests/baselines/reference/subtypingWithCallSignatures2.symbols b/tests/baselines/reference/subtypingWithCallSignatures2.symbols
index 5aa1021d26070..d5771c5d2337a 100644
--- a/tests/baselines/reference/subtypingWithCallSignatures2.symbols
+++ b/tests/baselines/reference/subtypingWithCallSignatures2.symbols
@@ -310,6 +310,7 @@ declare function foo18(a: any): any;
 
 var r1arg1 = <T>(x: T) => [x];
 >r1arg1 : Symbol(r1arg1, Decl(subtypingWithCallSignatures2.ts, 79, 3))
+><T>(x: T) => [x] : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 79, 12))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 79, 14))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 79, 17))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 79, 14))
@@ -317,6 +318,7 @@ var r1arg1 = <T>(x: T) => [x];
 
 var r1arg2 = (x: number) => [1];
 >r1arg2 : Symbol(r1arg2, Decl(subtypingWithCallSignatures2.ts, 80, 3))
+>(x: number) => [1] : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 80, 12))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 80, 14))
 
 var r1 = foo1(r1arg1); // any, return types are not subtype of first overload
@@ -336,12 +338,14 @@ var r1b = [r1arg1, r1arg2]; // generic signature, subtype in both directions
 
 var r2arg1 = <T>(x: T) => [''];
 >r2arg1 : Symbol(r2arg1, Decl(subtypingWithCallSignatures2.ts, 85, 3))
+><T>(x: T) => [''] : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 85, 12))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 85, 14))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 85, 17))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 85, 14))
 
 var r2arg2 = (x: number) => [''];
 >r2arg2 : Symbol(r2arg2, Decl(subtypingWithCallSignatures2.ts, 86, 3))
+>(x: number) => [''] : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 86, 12))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 86, 14))
 
 var r2 = foo2(r2arg1); 
@@ -361,6 +365,7 @@ var r2b = [r2arg2, r2arg1];
 
 var r3arg1 = <T>(x: T) => x;
 >r3arg1 : Symbol(r3arg1, Decl(subtypingWithCallSignatures2.ts, 91, 3))
+><T>(x: T) => x : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 91, 12))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 91, 14))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 91, 17))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 91, 14))
@@ -368,6 +373,7 @@ var r3arg1 = <T>(x: T) => x;
 
 var r3arg2 = (x: number) => { };
 >r3arg2 : Symbol(r3arg2, Decl(subtypingWithCallSignatures2.ts, 92, 3))
+>(x: number) => { } : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 92, 12))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 92, 14))
 
 var r3 = foo3(r3arg1); 
@@ -387,6 +393,7 @@ var r3b = [r3arg2, r3arg1];
 
 var r4arg1 = <T, U>(x: T, y: U) => x;
 >r4arg1 : Symbol(r4arg1, Decl(subtypingWithCallSignatures2.ts, 97, 3))
+><T, U>(x: T, y: U) => x : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 97, 12))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 97, 14))
 >U : Symbol(U, Decl(subtypingWithCallSignatures2.ts, 97, 16))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 97, 20))
@@ -397,6 +404,7 @@ var r4arg1 = <T, U>(x: T, y: U) => x;
 
 var r4arg2 = (x: string, y: number) => '';
 >r4arg2 : Symbol(r4arg2, Decl(subtypingWithCallSignatures2.ts, 98, 3))
+>(x: string, y: number) => '' : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 98, 12))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 98, 14))
 >y : Symbol(y, Decl(subtypingWithCallSignatures2.ts, 98, 24))
 
@@ -417,6 +425,7 @@ var r4b = [r4arg2, r4arg1];
 
 var r5arg1 = <T, U>(x: (arg: T) => U) => <T>null;
 >r5arg1 : Symbol(r5arg1, Decl(subtypingWithCallSignatures2.ts, 103, 3))
+><T, U>(x: (arg: T) => U) => <T>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 103, 12))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 103, 14))
 >U : Symbol(U, Decl(subtypingWithCallSignatures2.ts, 103, 16))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 103, 20))
@@ -427,6 +436,7 @@ var r5arg1 = <T, U>(x: (arg: T) => U) => <T>null;
 
 var r5arg2 = (x: (arg: string) => number) => '';
 >r5arg2 : Symbol(r5arg2, Decl(subtypingWithCallSignatures2.ts, 104, 3))
+>(x: (arg: string) => number) => '' : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 104, 12))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 104, 14))
 >arg : Symbol(arg, Decl(subtypingWithCallSignatures2.ts, 104, 18))
 
@@ -447,6 +457,7 @@ var r5b = [r5arg2, r5arg1];
 
 var r6arg1 = <T extends Base, U extends Derived>(x: (arg: T) => U) => <T>null;
 >r6arg1 : Symbol(r6arg1, Decl(subtypingWithCallSignatures2.ts, 109, 3))
+><T extends Base, U extends Derived>(x: (arg: T) => U) => <T>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 109, 12))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 109, 14))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
 >U : Symbol(U, Decl(subtypingWithCallSignatures2.ts, 109, 29))
@@ -459,6 +470,7 @@ var r6arg1 = <T extends Base, U extends Derived>(x: (arg: T) => U) => <T>null;
 
 var r6arg2 = (x: (arg: Base) => Derived) => <Base>null;
 >r6arg2 : Symbol(r6arg2, Decl(subtypingWithCallSignatures2.ts, 110, 3))
+>(x: (arg: Base) => Derived) => <Base>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 110, 12))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 110, 14))
 >arg : Symbol(arg, Decl(subtypingWithCallSignatures2.ts, 110, 18))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
@@ -482,6 +494,7 @@ var r6b = [r6arg2, r6arg1];
 
 var r7arg1 = <T extends Base, U extends Derived>(x: (arg: T) => U) => (r: T) => <U>null;
 >r7arg1 : Symbol(r7arg1, Decl(subtypingWithCallSignatures2.ts, 115, 3))
+><T extends Base, U extends Derived>(x: (arg: T) => U) => (r: T) => <U>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 115, 12))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 115, 14))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
 >U : Symbol(U, Decl(subtypingWithCallSignatures2.ts, 115, 29))
@@ -490,16 +503,19 @@ var r7arg1 = <T extends Base, U extends Derived>(x: (arg: T) => U) => (r: T) =>
 >arg : Symbol(arg, Decl(subtypingWithCallSignatures2.ts, 115, 53))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 115, 14))
 >U : Symbol(U, Decl(subtypingWithCallSignatures2.ts, 115, 29))
+>(r: T) => <U>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 115, 69))
 >r : Symbol(r, Decl(subtypingWithCallSignatures2.ts, 115, 71))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 115, 14))
 >U : Symbol(U, Decl(subtypingWithCallSignatures2.ts, 115, 29))
 
 var r7arg2 = (x: (arg: Base) => Derived) => (r: Base) => <Derived>null;
 >r7arg2 : Symbol(r7arg2, Decl(subtypingWithCallSignatures2.ts, 116, 3))
+>(x: (arg: Base) => Derived) => (r: Base) => <Derived>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 116, 12))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 116, 14))
 >arg : Symbol(arg, Decl(subtypingWithCallSignatures2.ts, 116, 18))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures2.ts, 2, 27))
+>(r: Base) => <Derived>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 116, 43))
 >r : Symbol(r, Decl(subtypingWithCallSignatures2.ts, 116, 45))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures2.ts, 2, 27))
@@ -521,6 +537,7 @@ var r7b = [r7arg2, r7arg1];
 
 var r8arg1 = <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: T) => U) => (r: T) => <U>null;
 >r8arg1 : Symbol(r8arg1, Decl(subtypingWithCallSignatures2.ts, 121, 3))
+><T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: T) => U) => (r: T) => <U>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 121, 12))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 121, 14))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
 >U : Symbol(U, Decl(subtypingWithCallSignatures2.ts, 121, 29))
@@ -533,12 +550,14 @@ var r8arg1 = <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: T)
 >arg2 : Symbol(arg2, Decl(subtypingWithCallSignatures2.ts, 121, 71))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 121, 14))
 >U : Symbol(U, Decl(subtypingWithCallSignatures2.ts, 121, 29))
+>(r: T) => <U>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 121, 88))
 >r : Symbol(r, Decl(subtypingWithCallSignatures2.ts, 121, 90))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 121, 14))
 >U : Symbol(U, Decl(subtypingWithCallSignatures2.ts, 121, 29))
 
 var r8arg2 = (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => <Derived>null;
 >r8arg2 : Symbol(r8arg2, Decl(subtypingWithCallSignatures2.ts, 122, 3))
+>(x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => <Derived>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 122, 12))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 122, 14))
 >arg : Symbol(arg, Decl(subtypingWithCallSignatures2.ts, 122, 18))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
@@ -547,6 +566,7 @@ var r8arg2 = (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base
 >arg2 : Symbol(arg2, Decl(subtypingWithCallSignatures2.ts, 122, 45))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures2.ts, 2, 27))
+>(r: Base) => <Derived>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 122, 71))
 >r : Symbol(r, Decl(subtypingWithCallSignatures2.ts, 122, 73))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures2.ts, 2, 27))
@@ -568,6 +588,7 @@ var r8b = [r8arg2, r8arg1];
 
 var r9arg1 = <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number }) => U) => (r: T) => <U>null;
 >r9arg1 : Symbol(r9arg1, Decl(subtypingWithCallSignatures2.ts, 127, 3))
+><T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number }) => U) => (r: T) => <U>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 127, 12))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 127, 14))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
 >U : Symbol(U, Decl(subtypingWithCallSignatures2.ts, 127, 29))
@@ -581,12 +602,14 @@ var r9arg1 = <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { f
 >foo : Symbol(foo, Decl(subtypingWithCallSignatures2.ts, 127, 78))
 >bing : Symbol(bing, Decl(subtypingWithCallSignatures2.ts, 127, 91))
 >U : Symbol(U, Decl(subtypingWithCallSignatures2.ts, 127, 29))
+>(r: T) => <U>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 127, 116))
 >r : Symbol(r, Decl(subtypingWithCallSignatures2.ts, 127, 118))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 127, 14))
 >U : Symbol(U, Decl(subtypingWithCallSignatures2.ts, 127, 29))
 
 var r9arg2 = (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => <Derived>null;
 >r9arg2 : Symbol(r9arg2, Decl(subtypingWithCallSignatures2.ts, 128, 3))
+>(x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => <Derived>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 128, 12))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 128, 14))
 >arg : Symbol(arg, Decl(subtypingWithCallSignatures2.ts, 128, 18))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
@@ -595,6 +618,7 @@ var r9arg2 = (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base
 >arg2 : Symbol(arg2, Decl(subtypingWithCallSignatures2.ts, 128, 45))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures2.ts, 2, 27))
+>(r: Base) => <Derived>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 128, 71))
 >r : Symbol(r, Decl(subtypingWithCallSignatures2.ts, 128, 73))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures2.ts, 2, 27))
@@ -616,6 +640,7 @@ var r9b = [r9arg2, r9arg1];
 
 var r10arg1 = <T extends Derived>(...x: T[]) => x[0];
 >r10arg1 : Symbol(r10arg1, Decl(subtypingWithCallSignatures2.ts, 133, 3))
+><T extends Derived>(...x: T[]) => x[0] : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 133, 13))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 133, 15))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures2.ts, 2, 27))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 133, 34))
@@ -624,6 +649,7 @@ var r10arg1 = <T extends Derived>(...x: T[]) => x[0];
 
 var r10arg2 = (...x: Derived[]) => <Derived>null;
 >r10arg2 : Symbol(r10arg2, Decl(subtypingWithCallSignatures2.ts, 134, 3))
+>(...x: Derived[]) => <Derived>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 134, 13))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 134, 15))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures2.ts, 2, 27))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures2.ts, 2, 27))
@@ -645,6 +671,7 @@ var r10b = [r10arg2, r10arg1];
 
 var r11arg1 = <T extends Base>(x: T, y: T) => x;
 >r11arg1 : Symbol(r11arg1, Decl(subtypingWithCallSignatures2.ts, 139, 3))
+><T extends Base>(x: T, y: T) => x : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 139, 13))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 139, 15))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 139, 31))
@@ -655,6 +682,7 @@ var r11arg1 = <T extends Base>(x: T, y: T) => x;
 
 var r11arg2 = (x: { foo: string }, y: { foo: string; bar: string }) => <Base>null;
 >r11arg2 : Symbol(r11arg2, Decl(subtypingWithCallSignatures2.ts, 140, 3))
+>(x: { foo: string }, y: { foo: string; bar: string }) => <Base>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 140, 13))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 140, 15))
 >foo : Symbol(foo, Decl(subtypingWithCallSignatures2.ts, 140, 19))
 >y : Symbol(y, Decl(subtypingWithCallSignatures2.ts, 140, 34))
@@ -679,6 +707,7 @@ var r11b = [r11arg2, r11arg1];
 
 var r12arg1 = <T extends Array<Base>>(x: Array<Base>, y: T) => <Array<Derived>>null;
 >r12arg1 : Symbol(r12arg1, Decl(subtypingWithCallSignatures2.ts, 145, 3))
+><T extends Array<Base>>(x: Array<Base>, y: T) => <Array<Derived>>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 145, 13))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 145, 15))
 >Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
@@ -692,6 +721,7 @@ var r12arg1 = <T extends Array<Base>>(x: Array<Base>, y: T) => <Array<Derived>>n
 
 var r12arg2 = (x: Array<Base>, y: Array<Derived2>) => <Array<Derived>>null;
 >r12arg2 : Symbol(r12arg2, Decl(subtypingWithCallSignatures2.ts, 146, 3))
+>(x: Array<Base>, y: Array<Derived2>) => <Array<Derived>>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 146, 13))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 146, 15))
 >Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
@@ -718,6 +748,7 @@ var r12b = [r12arg2, r12arg1];
 
 var r13arg1 = <T extends Array<Derived>>(x: Array<Base>, y: T) => y;
 >r13arg1 : Symbol(r13arg1, Decl(subtypingWithCallSignatures2.ts, 151, 3))
+><T extends Array<Derived>>(x: Array<Base>, y: T) => y : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 151, 13))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 151, 15))
 >Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures2.ts, 2, 27))
@@ -730,6 +761,7 @@ var r13arg1 = <T extends Array<Derived>>(x: Array<Base>, y: T) => y;
 
 var r13arg2 = (x: Array<Base>, y: Array<Derived>) => <Array<Derived>>null;
 >r13arg2 : Symbol(r13arg2, Decl(subtypingWithCallSignatures2.ts, 152, 3))
+>(x: Array<Base>, y: Array<Derived>) => <Array<Derived>>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 152, 13))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 152, 15))
 >Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
@@ -756,6 +788,7 @@ var r13b = [r13arg2, r13arg1];
 
 var r14arg1 = <T>(x: { a: T; b: T }) => x.a;
 >r14arg1 : Symbol(r14arg1, Decl(subtypingWithCallSignatures2.ts, 157, 3))
+><T>(x: { a: T; b: T }) => x.a : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 157, 13))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 157, 15))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 157, 18))
 >a : Symbol(a, Decl(subtypingWithCallSignatures2.ts, 157, 22))
@@ -768,6 +801,7 @@ var r14arg1 = <T>(x: { a: T; b: T }) => x.a;
 
 var r14arg2 = (x: { a: string; b: number }) => <Object>null;
 >r14arg2 : Symbol(r14arg2, Decl(subtypingWithCallSignatures2.ts, 158, 3))
+>(x: { a: string; b: number }) => <Object>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 158, 13))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 158, 15))
 >a : Symbol(a, Decl(subtypingWithCallSignatures2.ts, 158, 19))
 >b : Symbol(b, Decl(subtypingWithCallSignatures2.ts, 158, 30))
@@ -790,6 +824,7 @@ var r14b = [r14arg2, r14arg1];
 
 var r15arg1 = <T>(x: T) => <T[]>null
 >r15arg1 : Symbol(r15arg1, Decl(subtypingWithCallSignatures2.ts, 163, 3))
+><T>(x: T) => <T[]>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 163, 13))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 163, 15))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 163, 18))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 163, 15))
@@ -802,6 +837,7 @@ var r15 = foo15(r15arg1); // any
 
 var r16arg1 = <T extends Base>(x: T) => [1];
 >r16arg1 : Symbol(r16arg1, Decl(subtypingWithCallSignatures2.ts, 165, 3))
+><T extends Base>(x: T) => [1] : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 165, 13))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 165, 15))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 165, 31))
@@ -814,6 +850,7 @@ var r16 = foo16(r16arg1);
 
 var r17arg1 = <T>(x: (a: T) => T) => <T[]>null;
 >r17arg1 : Symbol(r17arg1, Decl(subtypingWithCallSignatures2.ts, 167, 3))
+><T>(x: (a: T) => T) => <T[]>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 167, 13))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 167, 15))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 167, 18))
 >a : Symbol(a, Decl(subtypingWithCallSignatures2.ts, 167, 22))
@@ -828,6 +865,7 @@ var r17 = foo17(r17arg1); // any
 
 var r18arg1 = <T>(x: (a: T) => T) => <T[]>null;
 >r18arg1 : Symbol(r18arg1, Decl(subtypingWithCallSignatures2.ts, 169, 3))
+><T>(x: (a: T) => T) => <T[]>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 169, 13))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 169, 15))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 169, 18))
 >a : Symbol(a, Decl(subtypingWithCallSignatures2.ts, 169, 22))
diff --git a/tests/baselines/reference/subtypingWithCallSignatures3.symbols b/tests/baselines/reference/subtypingWithCallSignatures3.symbols
index 666977c62d92f..72464dc7655bd 100644
--- a/tests/baselines/reference/subtypingWithCallSignatures3.symbols
+++ b/tests/baselines/reference/subtypingWithCallSignatures3.symbols
@@ -208,6 +208,7 @@ module Errors {
     var r1 = foo2(<T, U>(x: T) => <U[]>null); // any
 >r1 : Symbol(r1, Decl(subtypingWithCallSignatures3.ts, 55, 7))
 >foo2 : Symbol(foo2, Decl(subtypingWithCallSignatures3.ts, 7, 53), Decl(subtypingWithCallSignatures3.ts, 9, 66))
+><T, U>(x: T) => <U[]>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 55, 18))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 55, 19))
 >U : Symbol(U, Decl(subtypingWithCallSignatures3.ts, 55, 21))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 55, 25))
@@ -216,7 +217,9 @@ module Errors {
 
     var r1a = [(x: number) => [''], <T, U>(x: T) => <U[]>null];
 >r1a : Symbol(r1a, Decl(subtypingWithCallSignatures3.ts, 56, 7))
+>(x: number) => [''] : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 56, 15))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 56, 16))
+><T, U>(x: T) => <U[]>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 56, 35))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 56, 37))
 >U : Symbol(U, Decl(subtypingWithCallSignatures3.ts, 56, 39))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 56, 43))
@@ -225,15 +228,18 @@ module Errors {
 
     var r1b = [<T, U>(x: T) => <U[]>null, (x: number) => ['']];
 >r1b : Symbol(r1b, Decl(subtypingWithCallSignatures3.ts, 57, 7))
+><T, U>(x: T) => <U[]>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 57, 15))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 57, 16))
 >U : Symbol(U, Decl(subtypingWithCallSignatures3.ts, 57, 18))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 57, 22))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 57, 16))
 >U : Symbol(U, Decl(subtypingWithCallSignatures3.ts, 57, 18))
+>(x: number) => [''] : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 57, 41))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 57, 43))
 
     var r2arg = <T extends Base, U extends Derived, V extends Derived2>(x: (arg: T) => U) => (r: T) => <V>null;
 >r2arg : Symbol(r2arg, Decl(subtypingWithCallSignatures3.ts, 59, 7))
+><T extends Base, U extends Derived, V extends Derived2>(x: (arg: T) => U) => (r: T) => <V>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 59, 15))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 59, 17))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures3.ts, 3, 15))
 >U : Symbol(U, Decl(subtypingWithCallSignatures3.ts, 59, 32))
@@ -244,16 +250,19 @@ module Errors {
 >arg : Symbol(arg, Decl(subtypingWithCallSignatures3.ts, 59, 76))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 59, 17))
 >U : Symbol(U, Decl(subtypingWithCallSignatures3.ts, 59, 32))
+>(r: T) => <V>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 59, 92))
 >r : Symbol(r, Decl(subtypingWithCallSignatures3.ts, 59, 94))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 59, 17))
 >V : Symbol(V, Decl(subtypingWithCallSignatures3.ts, 59, 51))
 
     var r2arg2 = (x: (arg: Base) => Derived) => (r: Base) => <Derived2>null;
 >r2arg2 : Symbol(r2arg2, Decl(subtypingWithCallSignatures3.ts, 60, 7))
+>(x: (arg: Base) => Derived) => (r: Base) => <Derived2>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 60, 16))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 60, 18))
 >arg : Symbol(arg, Decl(subtypingWithCallSignatures3.ts, 60, 22))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures3.ts, 3, 15))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures3.ts, 4, 31))
+>(r: Base) => <Derived2>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 60, 47))
 >r : Symbol(r, Decl(subtypingWithCallSignatures3.ts, 60, 49))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures3.ts, 3, 15))
 >Derived2 : Symbol(Derived2, Decl(subtypingWithCallSignatures3.ts, 5, 47))
@@ -275,6 +284,7 @@ module Errors {
 
     var r3arg = <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => <U>null;
 >r3arg : Symbol(r3arg, Decl(subtypingWithCallSignatures3.ts, 65, 7))
+><T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => <U>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 65, 15))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 65, 17))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures3.ts, 3, 15))
 >U : Symbol(U, Decl(subtypingWithCallSignatures3.ts, 65, 32))
@@ -287,12 +297,14 @@ module Errors {
 >arg2 : Symbol(arg2, Decl(subtypingWithCallSignatures3.ts, 65, 74))
 >foo : Symbol(foo, Decl(subtypingWithCallSignatures3.ts, 65, 81))
 >U : Symbol(U, Decl(subtypingWithCallSignatures3.ts, 65, 32))
+>(r: T) => <U>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 65, 106))
 >r : Symbol(r, Decl(subtypingWithCallSignatures3.ts, 65, 108))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 65, 17))
 >U : Symbol(U, Decl(subtypingWithCallSignatures3.ts, 65, 32))
 
     var r3arg2 = (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => <Derived>null;
 >r3arg2 : Symbol(r3arg2, Decl(subtypingWithCallSignatures3.ts, 66, 7))
+>(x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => <Derived>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 66, 16))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 66, 18))
 >arg : Symbol(arg, Decl(subtypingWithCallSignatures3.ts, 66, 22))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures3.ts, 3, 15))
@@ -301,6 +313,7 @@ module Errors {
 >arg2 : Symbol(arg2, Decl(subtypingWithCallSignatures3.ts, 66, 49))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures3.ts, 3, 15))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures3.ts, 4, 31))
+>(r: Base) => <Derived>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 66, 75))
 >r : Symbol(r, Decl(subtypingWithCallSignatures3.ts, 66, 77))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures3.ts, 3, 15))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures3.ts, 4, 31))
@@ -322,6 +335,7 @@ module Errors {
 
     var r4arg = <T extends Derived>(...x: T[]) => <T>null;
 >r4arg : Symbol(r4arg, Decl(subtypingWithCallSignatures3.ts, 71, 7))
+><T extends Derived>(...x: T[]) => <T>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 71, 15))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 71, 17))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures3.ts, 4, 31))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 71, 36))
@@ -330,6 +344,7 @@ module Errors {
 
     var r4arg2 = (...x: Base[]) => <Base>null;
 >r4arg2 : Symbol(r4arg2, Decl(subtypingWithCallSignatures3.ts, 72, 7))
+>(...x: Base[]) => <Base>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 72, 16))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 72, 18))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures3.ts, 3, 15))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures3.ts, 3, 15))
@@ -351,6 +366,7 @@ module Errors {
 
     var r5arg = <T extends Derived>(x: T, y: T) => <T>null;
 >r5arg : Symbol(r5arg, Decl(subtypingWithCallSignatures3.ts, 77, 7))
+><T extends Derived>(x: T, y: T) => <T>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 77, 15))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 77, 17))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures3.ts, 4, 31))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 77, 36))
@@ -361,6 +377,7 @@ module Errors {
 
     var r5arg2 = (x: { foo: string }, y: { foo: string; bar: string }) => <Base>null;
 >r5arg2 : Symbol(r5arg2, Decl(subtypingWithCallSignatures3.ts, 78, 7))
+>(x: { foo: string }, y: { foo: string; bar: string }) => <Base>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 78, 16))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 78, 18))
 >foo : Symbol(foo, Decl(subtypingWithCallSignatures3.ts, 78, 22))
 >y : Symbol(y, Decl(subtypingWithCallSignatures3.ts, 78, 37))
@@ -385,6 +402,7 @@ module Errors {
 
     var r6arg = (x: Array<Base>, y: Array<Derived2>) => <Array<Derived>>null;
 >r6arg : Symbol(r6arg, Decl(subtypingWithCallSignatures3.ts, 83, 7))
+>(x: Array<Base>, y: Array<Derived2>) => <Array<Derived>>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 83, 15))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 83, 17))
 >Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures3.ts, 3, 15))
@@ -396,6 +414,7 @@ module Errors {
 
     var r6arg2 = <T extends Array<Derived2>>(x: Array<Base>, y: Array<Base>) => <T>null;
 >r6arg2 : Symbol(r6arg2, Decl(subtypingWithCallSignatures3.ts, 84, 7))
+><T extends Array<Derived2>>(x: Array<Base>, y: Array<Base>) => <T>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 84, 16))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 84, 18))
 >Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
 >Derived2 : Symbol(Derived2, Decl(subtypingWithCallSignatures3.ts, 5, 47))
@@ -424,6 +443,7 @@ module Errors {
 
     var r7arg = <T>(x: { a: T; b: T }) => <T>null;
 >r7arg : Symbol(r7arg, Decl(subtypingWithCallSignatures3.ts, 89, 7))
+><T>(x: { a: T; b: T }) => <T>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 89, 15))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 89, 17))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 89, 20))
 >a : Symbol(a, Decl(subtypingWithCallSignatures3.ts, 89, 24))
@@ -434,6 +454,7 @@ module Errors {
 
     var r7arg2 = (x: { a: string; b: number }) => 1;
 >r7arg2 : Symbol(r7arg2, Decl(subtypingWithCallSignatures3.ts, 90, 7))
+>(x: { a: string; b: number }) => 1 : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 90, 16))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 90, 18))
 >a : Symbol(a, Decl(subtypingWithCallSignatures3.ts, 90, 22))
 >b : Symbol(b, Decl(subtypingWithCallSignatures3.ts, 90, 33))
@@ -455,6 +476,7 @@ module Errors {
 
     var r7arg3 = <T extends Base>(x: { a: T; b: T }) => 1;
 >r7arg3 : Symbol(r7arg3, Decl(subtypingWithCallSignatures3.ts, 95, 7))
+><T extends Base>(x: { a: T; b: T }) => 1 : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 95, 16))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 95, 18))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures3.ts, 3, 15))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 95, 34))
@@ -480,6 +502,7 @@ module Errors {
 
     var r8arg = <T>(x: (a: T) => T) => <T[]>null;
 >r8arg : Symbol(r8arg, Decl(subtypingWithCallSignatures3.ts, 100, 7))
+><T>(x: (a: T) => T) => <T[]>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 100, 15))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 100, 17))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 100, 20))
 >a : Symbol(a, Decl(subtypingWithCallSignatures3.ts, 100, 24))
@@ -494,6 +517,7 @@ module Errors {
 
     var r9arg = <T>(x: (a: T) => T) => <any[]>null;
 >r9arg : Symbol(r9arg, Decl(subtypingWithCallSignatures3.ts, 103, 7))
+><T>(x: (a: T) => T) => <any[]>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 103, 15))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 103, 17))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 103, 20))
 >a : Symbol(a, Decl(subtypingWithCallSignatures3.ts, 103, 24))
@@ -524,6 +548,7 @@ module WithGenericSignaturesInBaseType {
 
     var r2arg2 = <T>(x: T) => [''];
 >r2arg2 : Symbol(r2arg2, Decl(subtypingWithCallSignatures3.ts, 110, 7))
+><T>(x: T) => [''] : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 110, 16))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 110, 18))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 110, 21))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 110, 18))
@@ -547,6 +572,7 @@ module WithGenericSignaturesInBaseType {
 
     var r3arg2 = <T>(x: T) => <T[]>null;
 >r3arg2 : Symbol(r3arg2, Decl(subtypingWithCallSignatures3.ts, 115, 7))
+><T>(x: T) => <T[]>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 115, 16))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 115, 18))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 115, 21))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 115, 18))
diff --git a/tests/baselines/reference/subtypingWithCallSignatures4.symbols b/tests/baselines/reference/subtypingWithCallSignatures4.symbols
index 382abb58a0d46..4a38a993c698c 100644
--- a/tests/baselines/reference/subtypingWithCallSignatures4.symbols
+++ b/tests/baselines/reference/subtypingWithCallSignatures4.symbols
@@ -221,6 +221,7 @@ declare function foo18(a: any): any;
 
 var r1arg = <T>(x: T) => <T[]>null;
 >r1arg : Symbol(r1arg, Decl(subtypingWithCallSignatures4.ts, 52, 3))
+><T>(x: T) => <T[]>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 52, 11))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 52, 13))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 52, 16))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 52, 13))
@@ -228,6 +229,7 @@ var r1arg = <T>(x: T) => <T[]>null;
 
 var r1arg2 = <T>(x: T) => <T[]>null;
 >r1arg2 : Symbol(r1arg2, Decl(subtypingWithCallSignatures4.ts, 53, 3))
+><T>(x: T) => <T[]>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 53, 12))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 53, 14))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 53, 17))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 53, 14))
@@ -250,12 +252,14 @@ var r1b = [r1arg2, r1arg];
 
 var r2arg = <T>(x: T) => [''];
 >r2arg : Symbol(r2arg, Decl(subtypingWithCallSignatures4.ts, 58, 3))
+><T>(x: T) => [''] : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 58, 11))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 58, 13))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 58, 16))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 58, 13))
 
 var r2arg2 = <T>(x: T) => [''];
 >r2arg2 : Symbol(r2arg2, Decl(subtypingWithCallSignatures4.ts, 59, 3))
+><T>(x: T) => [''] : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 59, 12))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 59, 14))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 59, 17))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 59, 14))
@@ -277,6 +281,7 @@ var r2b = [r2arg2, r2arg];
 
 var r3arg = <T>(x: T) => <T>null;
 >r3arg : Symbol(r3arg, Decl(subtypingWithCallSignatures4.ts, 64, 3))
+><T>(x: T) => <T>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 64, 11))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 64, 13))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 64, 16))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 64, 13))
@@ -284,6 +289,7 @@ var r3arg = <T>(x: T) => <T>null;
 
 var r3arg2 = <T>(x: T) => { };
 >r3arg2 : Symbol(r3arg2, Decl(subtypingWithCallSignatures4.ts, 65, 3))
+><T>(x: T) => { } : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 65, 12))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 65, 14))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 65, 17))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 65, 14))
@@ -305,6 +311,7 @@ var r3b = [r3arg2, r3arg];
 
 var r4arg = <T, U>(x: T, y: U) => '';
 >r4arg : Symbol(r4arg, Decl(subtypingWithCallSignatures4.ts, 70, 3))
+><T, U>(x: T, y: U) => '' : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 70, 11))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 70, 13))
 >U : Symbol(U, Decl(subtypingWithCallSignatures4.ts, 70, 15))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 70, 19))
@@ -314,6 +321,7 @@ var r4arg = <T, U>(x: T, y: U) => '';
 
 var r4arg2 = <T, U>(x: T, y: U) => '';
 >r4arg2 : Symbol(r4arg2, Decl(subtypingWithCallSignatures4.ts, 71, 3))
+><T, U>(x: T, y: U) => '' : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 71, 12))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 71, 14))
 >U : Symbol(U, Decl(subtypingWithCallSignatures4.ts, 71, 16))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 71, 20))
@@ -338,6 +346,7 @@ var r4b = [r4arg2, r4arg];
 
 var r5arg = <T, U>(x: (arg: T) => U) => <T>null;
 >r5arg : Symbol(r5arg, Decl(subtypingWithCallSignatures4.ts, 76, 3))
+><T, U>(x: (arg: T) => U) => <T>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 76, 11))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 76, 13))
 >U : Symbol(U, Decl(subtypingWithCallSignatures4.ts, 76, 15))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 76, 19))
@@ -348,6 +357,7 @@ var r5arg = <T, U>(x: (arg: T) => U) => <T>null;
 
 var r5arg2 = <T, U>(x: (arg: T) => U) => <T>null;
 >r5arg2 : Symbol(r5arg2, Decl(subtypingWithCallSignatures4.ts, 77, 3))
+><T, U>(x: (arg: T) => U) => <T>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 77, 12))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 77, 14))
 >U : Symbol(U, Decl(subtypingWithCallSignatures4.ts, 77, 16))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 77, 20))
@@ -373,6 +383,7 @@ var r5b = [r5arg2, r5arg];
 
 var r6arg = <T extends Base, U extends Derived>(x: (arg: T) => U) => <T>null;
 >r6arg : Symbol(r6arg, Decl(subtypingWithCallSignatures4.ts, 82, 3))
+><T extends Base, U extends Derived>(x: (arg: T) => U) => <T>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 82, 11))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 82, 13))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures4.ts, 0, 0))
 >U : Symbol(U, Decl(subtypingWithCallSignatures4.ts, 82, 28))
@@ -385,6 +396,7 @@ var r6arg = <T extends Base, U extends Derived>(x: (arg: T) => U) => <T>null;
 
 var r6arg2 = <T extends Base>(x: (arg: T) => Derived) => <T>null;
 >r6arg2 : Symbol(r6arg2, Decl(subtypingWithCallSignatures4.ts, 83, 3))
+><T extends Base>(x: (arg: T) => Derived) => <T>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 83, 12))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 83, 14))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures4.ts, 0, 0))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 83, 30))
@@ -410,6 +422,7 @@ var r6b = [r6arg2, r6arg];
 
 var r11arg = <T, U>(x: { foo: T }, y: { foo: U; bar: U }) => <Base>null;
 >r11arg : Symbol(r11arg, Decl(subtypingWithCallSignatures4.ts, 88, 3))
+><T, U>(x: { foo: T }, y: { foo: U; bar: U }) => <Base>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 88, 12))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 88, 14))
 >U : Symbol(U, Decl(subtypingWithCallSignatures4.ts, 88, 16))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 88, 20))
@@ -424,6 +437,7 @@ var r11arg = <T, U>(x: { foo: T }, y: { foo: U; bar: U }) => <Base>null;
 
 var r11arg2 = <T>(x: { foo: T }, y: { foo: T; bar: T }) => <Base>null;
 >r11arg2 : Symbol(r11arg2, Decl(subtypingWithCallSignatures4.ts, 89, 3))
+><T>(x: { foo: T }, y: { foo: T; bar: T }) => <Base>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 89, 13))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 89, 15))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 89, 18))
 >foo : Symbol(foo, Decl(subtypingWithCallSignatures4.ts, 89, 22))
@@ -452,6 +466,7 @@ var r11b = [r11arg2, r11arg];
 
 var r15arg = <U, V>(x: { a: U; b: V; }) => <U[]>null;
 >r15arg : Symbol(r15arg, Decl(subtypingWithCallSignatures4.ts, 94, 3))
+><U, V>(x: { a: U; b: V; }) => <U[]>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 94, 12))
 >U : Symbol(U, Decl(subtypingWithCallSignatures4.ts, 94, 14))
 >V : Symbol(V, Decl(subtypingWithCallSignatures4.ts, 94, 16))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 94, 20))
@@ -463,6 +478,7 @@ var r15arg = <U, V>(x: { a: U; b: V; }) => <U[]>null;
 
 var r15arg2 = <T>(x: { a: T; b: T }) => <T[]>null;
 >r15arg2 : Symbol(r15arg2, Decl(subtypingWithCallSignatures4.ts, 95, 3))
+><T>(x: { a: T; b: T }) => <T[]>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 95, 13))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 95, 15))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 95, 18))
 >a : Symbol(a, Decl(subtypingWithCallSignatures4.ts, 95, 22))
@@ -488,6 +504,7 @@ var r15b = [r15arg2, r15arg];
 
 var r16arg = <T extends Base>(x: { a: T; b: T }) => <T[]>null;
 >r16arg : Symbol(r16arg, Decl(subtypingWithCallSignatures4.ts, 100, 3))
+><T extends Base>(x: { a: T; b: T }) => <T[]>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 100, 12))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 100, 14))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures4.ts, 0, 0))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 100, 30))
@@ -499,6 +516,7 @@ var r16arg = <T extends Base>(x: { a: T; b: T }) => <T[]>null;
 
 var r16arg2 = <T extends Base>(x: { a: T; b: T }) => <T[]>null;
 >r16arg2 : Symbol(r16arg2, Decl(subtypingWithCallSignatures4.ts, 101, 3))
+><T extends Base>(x: { a: T; b: T }) => <T[]>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 101, 13))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 101, 15))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures4.ts, 0, 0))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 101, 31))
@@ -525,6 +543,7 @@ var r16b = [r16arg2, r16arg];
 
 var r17arg = <T>(x: (a: T) => T) => <T[]>null;
 >r17arg : Symbol(r17arg, Decl(subtypingWithCallSignatures4.ts, 106, 3))
+><T>(x: (a: T) => T) => <T[]>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 106, 12))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 106, 14))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 106, 17))
 >a : Symbol(a, Decl(subtypingWithCallSignatures4.ts, 106, 21))
@@ -539,6 +558,7 @@ var r17 = foo17(r17arg);
 
 var r18arg = (x: <T>(a: T) => T) => <any[]>null;
 >r18arg : Symbol(r18arg, Decl(subtypingWithCallSignatures4.ts, 109, 3))
+>(x: <T>(a: T) => T) => <any[]>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 109, 12))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 109, 14))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 109, 18))
 >a : Symbol(a, Decl(subtypingWithCallSignatures4.ts, 109, 21))
diff --git a/tests/baselines/reference/subtypingWithObjectMembersOptionality.symbols b/tests/baselines/reference/subtypingWithObjectMembersOptionality.symbols
index 7fce581b74b57..9d566b08864d3 100644
--- a/tests/baselines/reference/subtypingWithObjectMembersOptionality.symbols
+++ b/tests/baselines/reference/subtypingWithObjectMembersOptionality.symbols
@@ -78,6 +78,7 @@ var a: { Foo?: Base; };
 
 var b = { Foo: <Derived>null };
 >b : Symbol(b, Decl(subtypingWithObjectMembersOptionality.ts, 40, 3))
+>{ Foo: <Derived>null } : Symbol(, Decl(subtypingWithObjectMembersOptionality.ts, 40, 7))
 >Foo : Symbol(Foo, Decl(subtypingWithObjectMembersOptionality.ts, 40, 9))
 >Derived : Symbol(Derived, Decl(subtypingWithObjectMembersOptionality.ts, 2, 31))
 
@@ -144,6 +145,7 @@ module TwoLevels {
 
     var b = { Foo: <Derived2>null };
 >b : Symbol(b, Decl(subtypingWithObjectMembersOptionality.ts, 70, 7))
+>{ Foo: <Derived2>null } : Symbol(, Decl(subtypingWithObjectMembersOptionality.ts, 70, 11))
 >Foo : Symbol(Foo, Decl(subtypingWithObjectMembersOptionality.ts, 70, 13))
 >Derived2 : Symbol(Derived2, Decl(subtypingWithObjectMembersOptionality.ts, 3, 47))
 
diff --git a/tests/baselines/reference/subtypingWithOptionalProperties.symbols b/tests/baselines/reference/subtypingWithOptionalProperties.symbols
index 44ebbe99fd7da..65124a294ce65 100644
--- a/tests/baselines/reference/subtypingWithOptionalProperties.symbols
+++ b/tests/baselines/reference/subtypingWithOptionalProperties.symbols
@@ -20,6 +20,7 @@ function f<T>(a: T) {
 var r = f({ s: new Object() }); // ok
 >r : Symbol(r, Decl(subtypingWithOptionalProperties.ts, 8, 3))
 >f : Symbol(f, Decl(subtypingWithOptionalProperties.ts, 0, 0))
+>{ s: new Object() } : Symbol(, Decl(subtypingWithOptionalProperties.ts, 8, 10))
 >s : Symbol(s, Decl(subtypingWithOptionalProperties.ts, 8, 11))
 >Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
 
diff --git a/tests/baselines/reference/superAccessInFatArrow1.symbols b/tests/baselines/reference/superAccessInFatArrow1.symbols
index 9b0a0607e0a19..0485002b52bc0 100644
--- a/tests/baselines/reference/superAccessInFatArrow1.symbols
+++ b/tests/baselines/reference/superAccessInFatArrow1.symbols
@@ -24,6 +24,7 @@ module test {
 >this.bar : Symbol(bar, Decl(superAccessInFatArrow1.ts, 5, 30))
 >this : Symbol(B, Decl(superAccessInFatArrow1.ts, 4, 5))
 >bar : Symbol(bar, Decl(superAccessInFatArrow1.ts, 5, 30))
+>() => {                super.foo();            } : Symbol((Anonymous function), Decl(superAccessInFatArrow1.ts, 9, 21))
 
                 super.foo();
 >super.foo : Symbol(A.foo, Decl(superAccessInFatArrow1.ts, 1, 20))
diff --git a/tests/baselines/reference/superCallParameterContextualTyping1.symbols b/tests/baselines/reference/superCallParameterContextualTyping1.symbols
index 80876e2ee9d84..8b9cad9122281 100644
--- a/tests/baselines/reference/superCallParameterContextualTyping1.symbols
+++ b/tests/baselines/reference/superCallParameterContextualTyping1.symbols
@@ -21,6 +21,7 @@ class B extends A<number, string> {
     // Ensure 'value' is of type 'number (and not '{}') by using its 'toExponential()' method.
     constructor() { super(value => String(value.toExponential())); }
 >super : Symbol(A, Decl(superCallParameterContextualTyping1.ts, 0, 0))
+>value => String(value.toExponential()) : Symbol((Anonymous function), Decl(superCallParameterContextualTyping1.ts, 9, 26))
 >value : Symbol(value, Decl(superCallParameterContextualTyping1.ts, 9, 26))
 >String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
 >value.toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45))
diff --git a/tests/baselines/reference/superCallParameterContextualTyping3.symbols b/tests/baselines/reference/superCallParameterContextualTyping3.symbols
index 04bc148ac0f27..9c42055d89ee9 100644
--- a/tests/baselines/reference/superCallParameterContextualTyping3.symbols
+++ b/tests/baselines/reference/superCallParameterContextualTyping3.symbols
@@ -36,6 +36,7 @@ class C extends CBase<string> {
         // 'p' should have type 'string'.
         super({
 >super : Symbol(CBase, Decl(superCallParameterContextualTyping3.ts, 2, 1))
+>{            method(p) {                p.length;            }        } : Symbol(, Decl(superCallParameterContextualTyping3.ts, 16, 14))
 
             method(p) {
 >method : Symbol(method, Decl(superCallParameterContextualTyping3.ts, 16, 15))
@@ -54,6 +55,7 @@ class C extends CBase<string> {
 >super.foo : Symbol(CBase.foo, Decl(superCallParameterContextualTyping3.ts, 6, 5))
 >super : Symbol(CBase, Decl(superCallParameterContextualTyping3.ts, 2, 1))
 >foo : Symbol(CBase.foo, Decl(superCallParameterContextualTyping3.ts, 6, 5))
+>{            method(p) {                p.length;            }        } : Symbol(, Decl(superCallParameterContextualTyping3.ts, 24, 18))
 
             method(p) {
 >method : Symbol(method, Decl(superCallParameterContextualTyping3.ts, 24, 19))
diff --git a/tests/baselines/reference/switchBreakStatements.symbols b/tests/baselines/reference/switchBreakStatements.symbols
index 226262418818a..9a3475cd341bf 100644
--- a/tests/baselines/reference/switchBreakStatements.symbols
+++ b/tests/baselines/reference/switchBreakStatements.symbols
@@ -49,6 +49,7 @@ switch ('') {
                             case 'a':
                                 var fn = function () { }
 >fn : Symbol(fn, Decl(switchBreakStatements.ts, 48, 35))
+>function () { } : Symbol((Anonymous function), Decl(switchBreakStatements.ts, 48, 40))
 
                                 break EIGHT;
                         }
diff --git a/tests/baselines/reference/switchStatements.symbols b/tests/baselines/reference/switchStatements.symbols
index fc8f076a12ccc..100e03f2a6634 100644
--- a/tests/baselines/reference/switchStatements.symbols
+++ b/tests/baselines/reference/switchStatements.symbols
@@ -32,7 +32,10 @@ switch (x) {
     case /[a-z]/:
     case[]:
     case {}:
+>{} : Symbol(, Decl(switchStatements.ts, 17, 8))
+
     case { id: 12 }:
+>{ id: 12 } : Symbol(, Decl(switchStatements.ts, 18, 8))
 >id : Symbol(id, Decl(switchStatements.ts, 18, 10))
 
     case['a']:
@@ -48,10 +51,12 @@ switch (x) {
 >fn : Symbol(M.fn, Decl(switchStatements.ts, 0, 10))
 
     case <T>(x: number) => '':
+><T>(x: number) => '' : Symbol((Anonymous function), Decl(switchStatements.ts, 23, 8))
 >T : Symbol(T, Decl(switchStatements.ts, 23, 10))
 >x : Symbol(x, Decl(switchStatements.ts, 23, 13))
 
     case (<T>(x: number) => '')(2):
+><T>(x: number) => '' : Symbol((Anonymous function), Decl(switchStatements.ts, 24, 10))
 >T : Symbol(T, Decl(switchStatements.ts, 24, 11))
 >x : Symbol(x, Decl(switchStatements.ts, 24, 14))
 
@@ -75,6 +80,7 @@ switch (new C()) {
 >D : Symbol(D, Decl(switchStatements.ts, 29, 23))
 
     case { id: 12, name: '' }:
+>{ id: 12, name: '' } : Symbol(, Decl(switchStatements.ts, 34, 8))
 >id : Symbol(id, Decl(switchStatements.ts, 34, 10))
 >name : Symbol(name, Decl(switchStatements.ts, 34, 18))
 
@@ -98,15 +104,20 @@ switch (new Object()) { }
 switch (/[a-z]/) { }
 switch ([]) { }
 switch ({}) { }
+>{} : Symbol(, Decl(switchStatements.ts, 47, 8))
+
 switch ({ id: 12 }) { }
+>{ id: 12 } : Symbol(, Decl(switchStatements.ts, 48, 8))
 >id : Symbol(id, Decl(switchStatements.ts, 48, 9))
 
 switch (['a']) { }
 switch (<T>(x: number) => '') { }
+><T>(x: number) => '' : Symbol((Anonymous function), Decl(switchStatements.ts, 50, 8))
 >T : Symbol(T, Decl(switchStatements.ts, 50, 9))
 >x : Symbol(x, Decl(switchStatements.ts, 50, 12))
 
 switch ((<T>(x: T) => '')(1)) { }
+><T>(x: T) => '' : Symbol((Anonymous function), Decl(switchStatements.ts, 51, 9))
 >T : Symbol(T, Decl(switchStatements.ts, 51, 10))
 >x : Symbol(x, Decl(switchStatements.ts, 51, 13))
 >T : Symbol(T, Decl(switchStatements.ts, 51, 10))
diff --git a/tests/baselines/reference/symbolDeclarationEmit10.symbols b/tests/baselines/reference/symbolDeclarationEmit10.symbols
index 5dba2268d2641..39b7ba76f45d4 100644
--- a/tests/baselines/reference/symbolDeclarationEmit10.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit10.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/Symbols/symbolDeclarationEmit10.ts ===
 var obj = {
 >obj : Symbol(obj, Decl(symbolDeclarationEmit10.ts, 0, 3))
+>{    get [Symbol.isConcatSpreadable]() { return '' },    set [Symbol.isConcatSpreadable](x) { }} : Symbol(, Decl(symbolDeclarationEmit10.ts, 0, 9))
 
     get [Symbol.isConcatSpreadable]() { return '' },
 >Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1243, 24))
diff --git a/tests/baselines/reference/symbolDeclarationEmit8.symbols b/tests/baselines/reference/symbolDeclarationEmit8.symbols
index 7879d28b02f52..0bd55049b0d5e 100644
--- a/tests/baselines/reference/symbolDeclarationEmit8.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit8.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/Symbols/symbolDeclarationEmit8.ts ===
 var obj = {
 >obj : Symbol(obj, Decl(symbolDeclarationEmit8.ts, 0, 3))
+>{    [Symbol.isConcatSpreadable]: 0} : Symbol(, Decl(symbolDeclarationEmit8.ts, 0, 9))
 
     [Symbol.isConcatSpreadable]: 0
 >Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1243, 24))
diff --git a/tests/baselines/reference/symbolDeclarationEmit9.symbols b/tests/baselines/reference/symbolDeclarationEmit9.symbols
index 17901fb713aac..7a4ea8fd55cb0 100644
--- a/tests/baselines/reference/symbolDeclarationEmit9.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit9.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/Symbols/symbolDeclarationEmit9.ts ===
 var obj = {
 >obj : Symbol(obj, Decl(symbolDeclarationEmit9.ts, 0, 3))
+>{    [Symbol.isConcatSpreadable]() { }} : Symbol(, Decl(symbolDeclarationEmit9.ts, 0, 9))
 
     [Symbol.isConcatSpreadable]() { }
 >Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1243, 24))
diff --git a/tests/baselines/reference/symbolProperty1.symbols b/tests/baselines/reference/symbolProperty1.symbols
index 9c911623b74aa..486dfd7f57f74 100644
--- a/tests/baselines/reference/symbolProperty1.symbols
+++ b/tests/baselines/reference/symbolProperty1.symbols
@@ -4,6 +4,7 @@ var s: symbol;
 
 var x = {
 >x : Symbol(x, Decl(symbolProperty1.ts, 1, 3))
+>{    [s]: 0,    [s]() { },    get [s]() {        return 0;    }} : Symbol(, Decl(symbolProperty1.ts, 1, 7))
 
     [s]: 0,
 >s : Symbol(s, Decl(symbolProperty1.ts, 0, 3))
diff --git a/tests/baselines/reference/symbolProperty18.symbols b/tests/baselines/reference/symbolProperty18.symbols
index 89df72d65430d..d069a88368f34 100644
--- a/tests/baselines/reference/symbolProperty18.symbols
+++ b/tests/baselines/reference/symbolProperty18.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/Symbols/symbolProperty18.ts ===
 var i = {
 >i : Symbol(i, Decl(symbolProperty18.ts, 0, 3))
+>{    [Symbol.iterator]: 0,    [Symbol.toStringTag]() { return "" },    set [Symbol.toPrimitive](p: boolean) { }} : Symbol(, Decl(symbolProperty18.ts, 0, 7))
 
     [Symbol.iterator]: 0,
 >Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31))
diff --git a/tests/baselines/reference/symbolProperty19.symbols b/tests/baselines/reference/symbolProperty19.symbols
index 3ee9ed595c2ad..0a4f105cb828d 100644
--- a/tests/baselines/reference/symbolProperty19.symbols
+++ b/tests/baselines/reference/symbolProperty19.symbols
@@ -1,8 +1,10 @@
 === tests/cases/conformance/es6/Symbols/symbolProperty19.ts ===
 var i = {
 >i : Symbol(i, Decl(symbolProperty19.ts, 0, 3))
+>{    [Symbol.iterator]: { p: null },    [Symbol.toStringTag]() { return { p: undefined }; }} : Symbol(, Decl(symbolProperty19.ts, 0, 7))
 
     [Symbol.iterator]: { p: null },
+<<<<<<< HEAD
 >Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31))
 >Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11))
 >iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31))
@@ -12,6 +14,19 @@ var i = {
 >Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24))
 >Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11))
 >toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24))
+=======
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>{ p: null } : Symbol(, Decl(symbolProperty19.ts, 1, 22))
+>p : Symbol(p, Decl(symbolProperty19.ts, 1, 24))
+
+    [Symbol.toStringTag]() { return { p: undefined }; }
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24))
+>{ p: undefined } : Symbol(, Decl(symbolProperty19.ts, 2, 35))
+>>>>>>> Accept symbol baselines
 >p : Symbol(p, Decl(symbolProperty19.ts, 2, 37))
 >undefined : Symbol(undefined)
 }
diff --git a/tests/baselines/reference/symbolProperty2.symbols b/tests/baselines/reference/symbolProperty2.symbols
index b52c4087d7143..82b20127f363a 100644
--- a/tests/baselines/reference/symbolProperty2.symbols
+++ b/tests/baselines/reference/symbolProperty2.symbols
@@ -5,6 +5,7 @@ var s = Symbol();
 
 var x = {
 >x : Symbol(x, Decl(symbolProperty2.ts, 1, 3))
+>{    [s]: 0,    [s]() { },    get [s]() {        return 0;    }} : Symbol(, Decl(symbolProperty2.ts, 1, 7))
 
     [s]: 0,
 >s : Symbol(s, Decl(symbolProperty2.ts, 0, 3))
diff --git a/tests/baselines/reference/symbolProperty20.symbols b/tests/baselines/reference/symbolProperty20.symbols
index ad4f0c7952351..8750b0e0e099d 100644
--- a/tests/baselines/reference/symbolProperty20.symbols
+++ b/tests/baselines/reference/symbolProperty20.symbols
@@ -18,11 +18,19 @@ interface I {
 var i: I = {
 >i : Symbol(i, Decl(symbolProperty20.ts, 5, 3))
 >I : Symbol(I, Decl(symbolProperty20.ts, 0, 0))
+>{    [Symbol.iterator]: s => s,    [Symbol.toStringTag](n) { return n; }} : Symbol(, Decl(symbolProperty20.ts, 5, 10))
 
     [Symbol.iterator]: s => s,
+<<<<<<< HEAD
 >Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31))
 >Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11))
 >iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31))
+=======
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>s => s : Symbol((Anonymous function), Decl(symbolProperty20.ts, 6, 22))
+>>>>>>> Accept symbol baselines
 >s : Symbol(s, Decl(symbolProperty20.ts, 6, 22))
 >s : Symbol(s, Decl(symbolProperty20.ts, 6, 22))
 
diff --git a/tests/baselines/reference/symbolProperty21.symbols b/tests/baselines/reference/symbolProperty21.symbols
index 09997f687d53f..c83aad9b078f4 100644
--- a/tests/baselines/reference/symbolProperty21.symbols
+++ b/tests/baselines/reference/symbolProperty21.symbols
@@ -32,6 +32,7 @@ declare function foo<T, U>(p: I<T, U>): { t: T; u: U };
 
 foo({
 >foo : Symbol(foo, Decl(symbolProperty21.ts, 3, 1))
+>{    [Symbol.isConcatSpreadable]: "",    [Symbol.toPrimitive]: 0,    [Symbol.unscopables]: true} : Symbol(, Decl(symbolProperty21.ts, 7, 4))
 
     [Symbol.isConcatSpreadable]: "",
 >Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1243, 24))
diff --git a/tests/baselines/reference/symbolProperty22.symbols b/tests/baselines/reference/symbolProperty22.symbols
index b62037e32a507..42feb27aa19b9 100644
--- a/tests/baselines/reference/symbolProperty22.symbols
+++ b/tests/baselines/reference/symbolProperty22.symbols
@@ -27,9 +27,17 @@ declare function foo<T, U>(p1: T, p2: I<T, U>): U;
 
 foo("", { [Symbol.unscopables]: s => s.length });
 >foo : Symbol(foo, Decl(symbolProperty22.ts, 2, 1))
+<<<<<<< HEAD
 >Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1297, 24))
 >Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11))
 >unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1297, 24))
+=======
+>{ [Symbol.unscopables]: s => s.length } : Symbol(, Decl(symbolProperty22.ts, 6, 7))
+>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1284, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
+>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1284, 24))
+>s => s.length : Symbol((Anonymous function), Decl(symbolProperty22.ts, 6, 31))
+>>>>>>> Accept symbol baselines
 >s : Symbol(s, Decl(symbolProperty22.ts, 6, 31))
 >s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >s : Symbol(s, Decl(symbolProperty22.ts, 6, 31))
diff --git a/tests/baselines/reference/symbolProperty27.symbols b/tests/baselines/reference/symbolProperty27.symbols
index 69fe473e17c3f..f0ede58e84d77 100644
--- a/tests/baselines/reference/symbolProperty27.symbols
+++ b/tests/baselines/reference/symbolProperty27.symbols
@@ -8,6 +8,7 @@ class C1 {
 >toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24))
 
         return {};
+>{} : Symbol(, Decl(symbolProperty27.ts, 2, 14))
     }
 }
 
diff --git a/tests/baselines/reference/symbolProperty28.symbols b/tests/baselines/reference/symbolProperty28.symbols
index cf6ab1f5edba1..c52a3fa9b68c3 100644
--- a/tests/baselines/reference/symbolProperty28.symbols
+++ b/tests/baselines/reference/symbolProperty28.symbols
@@ -8,6 +8,7 @@ class C1 {
 >toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24))
 
         return { x: "" };
+>{ x: "" } : Symbol(, Decl(symbolProperty28.ts, 2, 14))
 >x : Symbol(x, Decl(symbolProperty28.ts, 2, 16))
     }
 }
diff --git a/tests/baselines/reference/symbolProperty4.symbols b/tests/baselines/reference/symbolProperty4.symbols
index 4e17e561bce0e..ab0fa9d282fd2 100644
--- a/tests/baselines/reference/symbolProperty4.symbols
+++ b/tests/baselines/reference/symbolProperty4.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/Symbols/symbolProperty4.ts ===
 var x = {
 >x : Symbol(x, Decl(symbolProperty4.ts, 0, 3))
+>{    [Symbol()]: 0,    [Symbol()]() { },    get [Symbol()]() {        return 0;    }} : Symbol(, Decl(symbolProperty4.ts, 0, 7))
 
     [Symbol()]: 0,
 >Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11))
diff --git a/tests/baselines/reference/symbolProperty5.symbols b/tests/baselines/reference/symbolProperty5.symbols
index 7b57003e607a0..6cca8227cf0cb 100644
--- a/tests/baselines/reference/symbolProperty5.symbols
+++ b/tests/baselines/reference/symbolProperty5.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/Symbols/symbolProperty5.ts ===
 var x = {
 >x : Symbol(x, Decl(symbolProperty5.ts, 0, 3))
+>{    [Symbol.iterator]: 0,    [Symbol.toPrimitive]() { },    get [Symbol.toStringTag]() {        return 0;    }} : Symbol(, Decl(symbolProperty5.ts, 0, 7))
 
     [Symbol.iterator]: 0,
 >Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31))
diff --git a/tests/baselines/reference/symbolProperty55.symbols b/tests/baselines/reference/symbolProperty55.symbols
index 05eeace3b869e..3b791f7866c4a 100644
--- a/tests/baselines/reference/symbolProperty55.symbols
+++ b/tests/baselines/reference/symbolProperty55.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/Symbols/symbolProperty55.ts ===
 var obj = {
 >obj : Symbol(obj, Decl(symbolProperty55.ts, 0, 3))
+>{    [Symbol.iterator]: 0} : Symbol(, Decl(symbolProperty55.ts, 0, 9))
 
     [Symbol.iterator]: 0
 >Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31))
diff --git a/tests/baselines/reference/symbolProperty56.symbols b/tests/baselines/reference/symbolProperty56.symbols
index a4e335cc7d7c3..df865f79077d1 100644
--- a/tests/baselines/reference/symbolProperty56.symbols
+++ b/tests/baselines/reference/symbolProperty56.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/Symbols/symbolProperty56.ts ===
 var obj = {
 >obj : Symbol(obj, Decl(symbolProperty56.ts, 0, 3))
+>{    [Symbol.iterator]: 0} : Symbol(, Decl(symbolProperty56.ts, 0, 9))
 
     [Symbol.iterator]: 0
 >Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31))
diff --git a/tests/baselines/reference/symbolProperty57.symbols b/tests/baselines/reference/symbolProperty57.symbols
index 249545872b1d0..82a0c9fc90ae6 100644
--- a/tests/baselines/reference/symbolProperty57.symbols
+++ b/tests/baselines/reference/symbolProperty57.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/Symbols/symbolProperty57.ts ===
 var obj = {
 >obj : Symbol(obj, Decl(symbolProperty57.ts, 0, 3))
+>{    [Symbol.iterator]: 0} : Symbol(, Decl(symbolProperty57.ts, 0, 9))
 
     [Symbol.iterator]: 0
 >Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31))
diff --git a/tests/baselines/reference/symbolType11.symbols b/tests/baselines/reference/symbolType11.symbols
index d40e0e7272474..0a5806e6431ab 100644
--- a/tests/baselines/reference/symbolType11.symbols
+++ b/tests/baselines/reference/symbolType11.symbols
@@ -23,5 +23,6 @@ s || 1;
 >s : Symbol(s, Decl(symbolType11.ts, 0, 3))
 
 ({}) || s;
+>{} : Symbol(, Decl(symbolType11.ts, 6, 1))
 >s : Symbol(s, Decl(symbolType11.ts, 0, 3))
 
diff --git a/tests/baselines/reference/systemModule13.symbols b/tests/baselines/reference/systemModule13.symbols
index d9e64335c2bdd..97b811ef18f64 100644
--- a/tests/baselines/reference/systemModule13.symbols
+++ b/tests/baselines/reference/systemModule13.symbols
@@ -8,8 +8,10 @@ export let [x,y,z] = [1, 2, 3];
 export const {a: z0, b: {c: z1}} = {a: true, b: {c: "123"}};
 >z0 : Symbol(z0, Decl(systemModule13.ts, 2, 14))
 >z1 : Symbol(z1, Decl(systemModule13.ts, 2, 25))
+>{a: true, b: {c: "123"}} : Symbol(, Decl(systemModule13.ts, 2, 34))
 >a : Symbol(a, Decl(systemModule13.ts, 2, 36))
 >b : Symbol(b, Decl(systemModule13.ts, 2, 44))
+>{c: "123"} : Symbol(, Decl(systemModule13.ts, 2, 47))
 >c : Symbol(c, Decl(systemModule13.ts, 2, 49))
 
 for ([x] of [[1]]) {}
diff --git a/tests/baselines/reference/systemModule8.symbols b/tests/baselines/reference/systemModule8.symbols
index 3365ce7e37d8d..320e47ed38e15 100644
--- a/tests/baselines/reference/systemModule8.symbols
+++ b/tests/baselines/reference/systemModule8.symbols
@@ -80,8 +80,10 @@ export let [y] = [1];
 export const {a: z0, b: {c: z1}} = {a: true, b: {c: "123"}};
 >z0 : Symbol(z0, Decl(systemModule8.ts, 28, 14))
 >z1 : Symbol(z1, Decl(systemModule8.ts, 28, 25))
+>{a: true, b: {c: "123"}} : Symbol(, Decl(systemModule8.ts, 28, 34))
 >a : Symbol(a, Decl(systemModule8.ts, 28, 36))
 >b : Symbol(b, Decl(systemModule8.ts, 28, 44))
+>{c: "123"} : Symbol(, Decl(systemModule8.ts, 28, 47))
 >c : Symbol(c, Decl(systemModule8.ts, 28, 49))
 
 for ([x] of [[1]]) {}
diff --git a/tests/baselines/reference/taggedTemplateContextualTyping1.symbols b/tests/baselines/reference/taggedTemplateContextualTyping1.symbols
index f042978fa8c9b..6677a920d0923 100644
--- a/tests/baselines/reference/taggedTemplateContextualTyping1.symbols
+++ b/tests/baselines/reference/taggedTemplateContextualTyping1.symbols
@@ -49,6 +49,7 @@ function tempTag1<T>(...rest: any[]): T {
 // so this test will error.
 tempTag1 `${ x => { x<number>(undefined); return x; }                   }${ 10 }`;
 >tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 1, 48), Decl(taggedTemplateContextualTyping1.ts, 3, 79), Decl(taggedTemplateContextualTyping1.ts, 4, 92))
+>x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(taggedTemplateContextualTyping1.ts, 13, 12))
 >x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 13, 12))
 >x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 13, 12))
 >undefined : Symbol(undefined)
@@ -56,10 +57,12 @@ tempTag1 `${ x => { x<number>(undefined); return x; }                   }${ 10 }
 
 tempTag1 `${ x => { x<number>(undefined); return x; }                   }${ y => { y<number>(undefined); return y; }                  }${ 10 }`;
 >tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 1, 48), Decl(taggedTemplateContextualTyping1.ts, 3, 79), Decl(taggedTemplateContextualTyping1.ts, 4, 92))
+>x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(taggedTemplateContextualTyping1.ts, 14, 12))
 >x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 14, 12))
 >x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 14, 12))
 >undefined : Symbol(undefined)
 >x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 14, 12))
+>y => { y<number>(undefined); return y; } : Symbol((Anonymous function), Decl(taggedTemplateContextualTyping1.ts, 14, 75))
 >y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 14, 75))
 >y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 14, 75))
 >undefined : Symbol(undefined)
@@ -67,10 +70,12 @@ tempTag1 `${ x => { x<number>(undefined); return x; }                   }${ y =>
 
 tempTag1 `${ x => { x<number>(undefined); return x; }                   }${ (y: <T>(p: T) => T) => { y<number>(undefined); return y } }${ undefined }`;
 >tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 1, 48), Decl(taggedTemplateContextualTyping1.ts, 3, 79), Decl(taggedTemplateContextualTyping1.ts, 4, 92))
+>x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(taggedTemplateContextualTyping1.ts, 15, 12))
 >x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 15, 12))
 >x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 15, 12))
 >undefined : Symbol(undefined)
 >x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 15, 12))
+>(y: <T>(p: T) => T) => { y<number>(undefined); return y } : Symbol((Anonymous function), Decl(taggedTemplateContextualTyping1.ts, 15, 75))
 >y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 15, 77))
 >T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 15, 81))
 >p : Symbol(p, Decl(taggedTemplateContextualTyping1.ts, 15, 84))
@@ -83,6 +88,7 @@ tempTag1 `${ x => { x<number>(undefined); return x; }                   }${ (y:
 
 tempTag1 `${ (x: <T>(p: T) => T) => { x<number>(undefined); return x; } }${ y => { y<number>(undefined); return y; }                  }${ undefined }`;
 >tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 1, 48), Decl(taggedTemplateContextualTyping1.ts, 3, 79), Decl(taggedTemplateContextualTyping1.ts, 4, 92))
+>(x: <T>(p: T) => T) => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(taggedTemplateContextualTyping1.ts, 16, 12))
 >x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 16, 14))
 >T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 16, 18))
 >p : Symbol(p, Decl(taggedTemplateContextualTyping1.ts, 16, 21))
@@ -91,6 +97,7 @@ tempTag1 `${ (x: <T>(p: T) => T) => { x<number>(undefined); return x; } }${ y =>
 >x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 16, 14))
 >undefined : Symbol(undefined)
 >x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 16, 14))
+>y => { y<number>(undefined); return y; } : Symbol((Anonymous function), Decl(taggedTemplateContextualTyping1.ts, 16, 75))
 >y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 16, 75))
 >y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 16, 75))
 >undefined : Symbol(undefined)
diff --git a/tests/baselines/reference/taggedTemplateContextualTyping2.symbols b/tests/baselines/reference/taggedTemplateContextualTyping2.symbols
index 6918c5606a8d9..8e1c2db714c98 100644
--- a/tests/baselines/reference/taggedTemplateContextualTyping2.symbols
+++ b/tests/baselines/reference/taggedTemplateContextualTyping2.symbols
@@ -51,6 +51,7 @@ function tempTag2(...rest: any[]): any {
 // so this test will error.
 tempTag2 `${ x => { x<number>(undefined); return x; }         }${ 0 }`;
 >tempTag2 : Symbol(tempTag2, Decl(taggedTemplateContextualTyping2.ts, 2, 52), Decl(taggedTemplateContextualTyping2.ts, 4, 87), Decl(taggedTemplateContextualTyping2.ts, 5, 101))
+>x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(taggedTemplateContextualTyping2.ts, 14, 12))
 >x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 14, 12))
 >x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 14, 12))
 >undefined : Symbol(undefined)
@@ -58,16 +59,19 @@ tempTag2 `${ x => { x<number>(undefined); return x; }         }${ 0 }`;
 
 tempTag2 `${ x => { x<number, string>(undefined); return x; } }${ y => { y<string, number>(null); return y; } }${ "hello" }`;
 >tempTag2 : Symbol(tempTag2, Decl(taggedTemplateContextualTyping2.ts, 2, 52), Decl(taggedTemplateContextualTyping2.ts, 4, 87), Decl(taggedTemplateContextualTyping2.ts, 5, 101))
+>x => { x<number, string>(undefined); return x; } : Symbol((Anonymous function), Decl(taggedTemplateContextualTyping2.ts, 15, 12))
 >x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 15, 12))
 >x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 15, 12))
 >undefined : Symbol(undefined)
 >x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 15, 12))
+>y => { y<string, number>(null); return y; } : Symbol((Anonymous function), Decl(taggedTemplateContextualTyping2.ts, 15, 65))
 >y : Symbol(y, Decl(taggedTemplateContextualTyping2.ts, 15, 65))
 >y : Symbol(y, Decl(taggedTemplateContextualTyping2.ts, 15, 65))
 >y : Symbol(y, Decl(taggedTemplateContextualTyping2.ts, 15, 65))
 
 tempTag2 `${ x => { x<number, string>(undefined); return x; } }${ undefined }${ "hello" }`;
 >tempTag2 : Symbol(tempTag2, Decl(taggedTemplateContextualTyping2.ts, 2, 52), Decl(taggedTemplateContextualTyping2.ts, 4, 87), Decl(taggedTemplateContextualTyping2.ts, 5, 101))
+>x => { x<number, string>(undefined); return x; } : Symbol((Anonymous function), Decl(taggedTemplateContextualTyping2.ts, 16, 12))
 >x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 16, 12))
 >x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 16, 12))
 >undefined : Symbol(undefined)
diff --git a/tests/baselines/reference/targetTypeArgs.symbols b/tests/baselines/reference/targetTypeArgs.symbols
index 6c1b2cd9cfe68..9518ad8e56958 100644
--- a/tests/baselines/reference/targetTypeArgs.symbols
+++ b/tests/baselines/reference/targetTypeArgs.symbols
@@ -10,12 +10,14 @@ function foo(callback: (x: string) => void) {
 
 foo(function(x) { x });
 >foo : Symbol(foo, Decl(targetTypeArgs.ts, 0, 0))
+>function(x) { x } : Symbol((Anonymous function), Decl(targetTypeArgs.ts, 4, 4))
 >x : Symbol(x, Decl(targetTypeArgs.ts, 4, 13))
 >x : Symbol(x, Decl(targetTypeArgs.ts, 4, 13))
 
 [1].forEach(function(v,i,a) { v });
 >[1].forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
 >forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
+>function(v,i,a) { v } : Symbol((Anonymous function), Decl(targetTypeArgs.ts, 6, 12))
 >v : Symbol(v, Decl(targetTypeArgs.ts, 6, 21))
 >i : Symbol(i, Decl(targetTypeArgs.ts, 6, 23))
 >a : Symbol(a, Decl(targetTypeArgs.ts, 6, 25))
@@ -24,6 +26,7 @@ foo(function(x) { x });
 ["hello"].every(function(v,i,a) {return true;});
 >["hello"].every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
 >every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
+>function(v,i,a) {return true;} : Symbol((Anonymous function), Decl(targetTypeArgs.ts, 7, 16))
 >v : Symbol(v, Decl(targetTypeArgs.ts, 7, 25))
 >i : Symbol(i, Decl(targetTypeArgs.ts, 7, 27))
 >a : Symbol(a, Decl(targetTypeArgs.ts, 7, 29))
@@ -31,6 +34,7 @@ foo(function(x) { x });
 [1].every(function(v,i,a) {return true;});
 >[1].every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
 >every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
+>function(v,i,a) {return true;} : Symbol((Anonymous function), Decl(targetTypeArgs.ts, 8, 10))
 >v : Symbol(v, Decl(targetTypeArgs.ts, 8, 19))
 >i : Symbol(i, Decl(targetTypeArgs.ts, 8, 21))
 >a : Symbol(a, Decl(targetTypeArgs.ts, 8, 23))
@@ -38,6 +42,7 @@ foo(function(x) { x });
 [1].every(function(v,i,a) {return true;});
 >[1].every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
 >every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
+>function(v,i,a) {return true;} : Symbol((Anonymous function), Decl(targetTypeArgs.ts, 9, 10))
 >v : Symbol(v, Decl(targetTypeArgs.ts, 9, 19))
 >i : Symbol(i, Decl(targetTypeArgs.ts, 9, 21))
 >a : Symbol(a, Decl(targetTypeArgs.ts, 9, 23))
@@ -45,6 +50,7 @@ foo(function(x) { x });
 ["s"].every(function(v,i,a) {return true;});
 >["s"].every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
 >every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
+>function(v,i,a) {return true;} : Symbol((Anonymous function), Decl(targetTypeArgs.ts, 10, 12))
 >v : Symbol(v, Decl(targetTypeArgs.ts, 10, 21))
 >i : Symbol(i, Decl(targetTypeArgs.ts, 10, 23))
 >a : Symbol(a, Decl(targetTypeArgs.ts, 10, 25))
@@ -52,6 +58,7 @@ foo(function(x) { x });
 ["s"].forEach(function(v,i,a) { v });
 >["s"].forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
 >forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
+>function(v,i,a) { v } : Symbol((Anonymous function), Decl(targetTypeArgs.ts, 11, 14))
 >v : Symbol(v, Decl(targetTypeArgs.ts, 11, 23))
 >i : Symbol(i, Decl(targetTypeArgs.ts, 11, 25))
 >a : Symbol(a, Decl(targetTypeArgs.ts, 11, 27))
diff --git a/tests/baselines/reference/targetTypeCalls.symbols b/tests/baselines/reference/targetTypeCalls.symbols
index 7a5ade57e8cb7..7196565d49600 100644
--- a/tests/baselines/reference/targetTypeCalls.symbols
+++ b/tests/baselines/reference/targetTypeCalls.symbols
@@ -2,22 +2,32 @@
 var fra1: (v:any)=>string = function() { return function (v:string) {return v;}; }() // should work
 >fra1 : Symbol(fra1, Decl(targetTypeCalls.ts, 0, 3))
 >v : Symbol(v, Decl(targetTypeCalls.ts, 0, 11))
+>function() { return function (v:string) {return v;}; } : Symbol((Anonymous function), Decl(targetTypeCalls.ts, 0, 27))
+>function (v:string) {return v;} : Symbol((Anonymous function), Decl(targetTypeCalls.ts, 0, 47))
 >v : Symbol(v, Decl(targetTypeCalls.ts, 0, 58))
 >v : Symbol(v, Decl(targetTypeCalls.ts, 0, 58))
 
 var fra2: (v:any)=>number = function() { return function () { return 0; } }() // should work
 >fra2 : Symbol(fra2, Decl(targetTypeCalls.ts, 1, 3))
 >v : Symbol(v, Decl(targetTypeCalls.ts, 1, 11))
+>function() { return function () { return 0; } } : Symbol((Anonymous function), Decl(targetTypeCalls.ts, 1, 27))
+>function () { return 0; } : Symbol((Anonymous function), Decl(targetTypeCalls.ts, 1, 47))
 
 var fra3: (v:any)=>string = function() { return function() { return function(v) {return v;};}(); }() // should work
 >fra3 : Symbol(fra3, Decl(targetTypeCalls.ts, 3, 3))
 >v : Symbol(v, Decl(targetTypeCalls.ts, 3, 11))
+>function() { return function() { return function(v) {return v;};}(); } : Symbol((Anonymous function), Decl(targetTypeCalls.ts, 3, 27))
+>function() { return function(v) {return v;};} : Symbol((Anonymous function), Decl(targetTypeCalls.ts, 3, 47))
+>function(v) {return v;} : Symbol((Anonymous function), Decl(targetTypeCalls.ts, 3, 67))
 >v : Symbol(v, Decl(targetTypeCalls.ts, 3, 77))
 >v : Symbol(v, Decl(targetTypeCalls.ts, 3, 77))
 
 var fra4: (v:any)=>void = function() { return function() { return function(v) {return v;};}(); }() // should work
 >fra4 : Symbol(fra4, Decl(targetTypeCalls.ts, 4, 3))
 >v : Symbol(v, Decl(targetTypeCalls.ts, 4, 11))
+>function() { return function() { return function(v) {return v;};}(); } : Symbol((Anonymous function), Decl(targetTypeCalls.ts, 4, 25))
+>function() { return function(v) {return v;};} : Symbol((Anonymous function), Decl(targetTypeCalls.ts, 4, 45))
+>function(v) {return v;} : Symbol((Anonymous function), Decl(targetTypeCalls.ts, 4, 65))
 >v : Symbol(v, Decl(targetTypeCalls.ts, 4, 75))
 >v : Symbol(v, Decl(targetTypeCalls.ts, 4, 75))
 
diff --git a/tests/baselines/reference/targetTypeObjectLiteral.symbols b/tests/baselines/reference/targetTypeObjectLiteral.symbols
index f387b60ddf602..0c1a18a12d22b 100644
--- a/tests/baselines/reference/targetTypeObjectLiteral.symbols
+++ b/tests/baselines/reference/targetTypeObjectLiteral.symbols
@@ -4,12 +4,14 @@ var z: { x: number; y: (w:string)=>number;} = {
 >x : Symbol(x, Decl(targetTypeObjectLiteral.ts, 0, 8))
 >y : Symbol(y, Decl(targetTypeObjectLiteral.ts, 0, 19))
 >w : Symbol(w, Decl(targetTypeObjectLiteral.ts, 0, 24))
+>{    x: 12,    y: function(w) {        return 0;    }} : Symbol(, Decl(targetTypeObjectLiteral.ts, 0, 45))
 
     x: 12,
 >x : Symbol(x, Decl(targetTypeObjectLiteral.ts, 0, 47))
 
     y: function(w) {
 >y : Symbol(y, Decl(targetTypeObjectLiteral.ts, 2, 10))
+>function(w) {        return 0;    } : Symbol((Anonymous function), Decl(targetTypeObjectLiteral.ts, 4, 6))
 >w : Symbol(w, Decl(targetTypeObjectLiteral.ts, 4, 16))
 
         return 0;
diff --git a/tests/baselines/reference/targetTypeObjectLiteralToAny.symbols b/tests/baselines/reference/targetTypeObjectLiteralToAny.symbols
index dbac3b573661a..8f84203743c2a 100644
--- a/tests/baselines/reference/targetTypeObjectLiteralToAny.symbols
+++ b/tests/baselines/reference/targetTypeObjectLiteralToAny.symbols
@@ -12,10 +12,12 @@ function suggest(){
 >TypeScriptKeywords.forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
 >TypeScriptKeywords : Symbol(TypeScriptKeywords, Decl(targetTypeObjectLiteralToAny.ts, 1, 4))
 >forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
+>function(keyword) {								result.push({text:keyword, type:"keyword"}); // this should not cause a crash - push should be typed to any	} : Symbol((Anonymous function), Decl(targetTypeObjectLiteralToAny.ts, 4, 28))
 >keyword : Symbol(keyword, Decl(targetTypeObjectLiteralToAny.ts, 4, 37))
 
 		result.push({text:keyword, type:"keyword"}); // this should not cause a crash - push should be typed to any
 >result : Symbol(result, Decl(targetTypeObjectLiteralToAny.ts, 2, 4))
+>{text:keyword, type:"keyword"} : Symbol(, Decl(targetTypeObjectLiteralToAny.ts, 5, 14))
 >text : Symbol(text, Decl(targetTypeObjectLiteralToAny.ts, 5, 15))
 >keyword : Symbol(keyword, Decl(targetTypeObjectLiteralToAny.ts, 4, 37))
 >type : Symbol(type, Decl(targetTypeObjectLiteralToAny.ts, 5, 28))
diff --git a/tests/baselines/reference/targetTypingOnFunctions.symbols b/tests/baselines/reference/targetTypingOnFunctions.symbols
index ccf669ffa671f..95cfe424e0cc9 100644
--- a/tests/baselines/reference/targetTypingOnFunctions.symbols
+++ b/tests/baselines/reference/targetTypingOnFunctions.symbols
@@ -2,6 +2,7 @@
 var fu: (s: string) => string = function (s) { return s.toLowerCase() };
 >fu : Symbol(fu, Decl(targetTypingOnFunctions.ts, 0, 3))
 >s : Symbol(s, Decl(targetTypingOnFunctions.ts, 0, 9))
+>function (s) { return s.toLowerCase() } : Symbol((Anonymous function), Decl(targetTypingOnFunctions.ts, 0, 31))
 >s : Symbol(s, Decl(targetTypingOnFunctions.ts, 0, 42))
 >s.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51))
 >s : Symbol(s, Decl(targetTypingOnFunctions.ts, 0, 42))
@@ -10,6 +11,7 @@ var fu: (s: string) => string = function (s) { return s.toLowerCase() };
 var zu = fu = function (s) { return s.toLowerCase() };
 >zu : Symbol(zu, Decl(targetTypingOnFunctions.ts, 2, 3))
 >fu : Symbol(fu, Decl(targetTypingOnFunctions.ts, 0, 3))
+>function (s) { return s.toLowerCase() } : Symbol((Anonymous function), Decl(targetTypingOnFunctions.ts, 2, 13))
 >s : Symbol(s, Decl(targetTypingOnFunctions.ts, 2, 24))
 >s.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51))
 >s : Symbol(s, Decl(targetTypingOnFunctions.ts, 2, 24))
diff --git a/tests/baselines/reference/templateStringInArrowFunction.symbols b/tests/baselines/reference/templateStringInArrowFunction.symbols
index 7d1c1a20cba5d..ea48714238101 100644
--- a/tests/baselines/reference/templateStringInArrowFunction.symbols
+++ b/tests/baselines/reference/templateStringInArrowFunction.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/templates/templateStringInArrowFunction.ts ===
 var x = x => `abc${ x }def`;
 >x : Symbol(x, Decl(templateStringInArrowFunction.ts, 0, 3))
+>x => `abc${ x }def` : Symbol((Anonymous function), Decl(templateStringInArrowFunction.ts, 0, 7))
 >x : Symbol(x, Decl(templateStringInArrowFunction.ts, 0, 7))
 >x : Symbol(x, Decl(templateStringInArrowFunction.ts, 0, 7))
 
diff --git a/tests/baselines/reference/templateStringInArrowFunctionES6.symbols b/tests/baselines/reference/templateStringInArrowFunctionES6.symbols
index c78790d4cd633..b375317c08ef6 100644
--- a/tests/baselines/reference/templateStringInArrowFunctionES6.symbols
+++ b/tests/baselines/reference/templateStringInArrowFunctionES6.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/templates/templateStringInArrowFunctionES6.ts ===
 var x = x => `abc${ x }def`;
 >x : Symbol(x, Decl(templateStringInArrowFunctionES6.ts, 0, 3))
+>x => `abc${ x }def` : Symbol((Anonymous function), Decl(templateStringInArrowFunctionES6.ts, 0, 7))
 >x : Symbol(x, Decl(templateStringInArrowFunctionES6.ts, 0, 7))
 >x : Symbol(x, Decl(templateStringInArrowFunctionES6.ts, 0, 7))
 
diff --git a/tests/baselines/reference/templateStringInFunctionExpression.symbols b/tests/baselines/reference/templateStringInFunctionExpression.symbols
index 26674e5e6aa8d..9a93e123b4f12 100644
--- a/tests/baselines/reference/templateStringInFunctionExpression.symbols
+++ b/tests/baselines/reference/templateStringInFunctionExpression.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/templates/templateStringInFunctionExpression.ts ===
 var x = function y() {
 >x : Symbol(x, Decl(templateStringInFunctionExpression.ts, 0, 3))
+>function y() {    `abc${ 0 }def`    return `abc${ 0 }def`;} : Symbol(y, Decl(templateStringInFunctionExpression.ts, 0, 7))
 >y : Symbol(y, Decl(templateStringInFunctionExpression.ts, 0, 7))
 
     `abc${ 0 }def`
diff --git a/tests/baselines/reference/templateStringInFunctionExpressionES6.symbols b/tests/baselines/reference/templateStringInFunctionExpressionES6.symbols
index 1f500b0e74d62..a9fd9e996aa4f 100644
--- a/tests/baselines/reference/templateStringInFunctionExpressionES6.symbols
+++ b/tests/baselines/reference/templateStringInFunctionExpressionES6.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/templates/templateStringInFunctionExpressionES6.ts ===
 var x = function y() {
 >x : Symbol(x, Decl(templateStringInFunctionExpressionES6.ts, 0, 3))
+>function y() {    `abc${ 0 }def`    return `abc${ 0 }def`;} : Symbol(y, Decl(templateStringInFunctionExpressionES6.ts, 0, 7))
 >y : Symbol(y, Decl(templateStringInFunctionExpressionES6.ts, 0, 7))
 
     `abc${ 0 }def`
diff --git a/tests/baselines/reference/templateStringInInOperator.symbols b/tests/baselines/reference/templateStringInInOperator.symbols
index 89eb5a380cfac..96844878122ce 100644
--- a/tests/baselines/reference/templateStringInInOperator.symbols
+++ b/tests/baselines/reference/templateStringInInOperator.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/templates/templateStringInInOperator.ts ===
 var x = `${ "hi" }` in { hi: 10, hello: 20};
 >x : Symbol(x, Decl(templateStringInInOperator.ts, 0, 3))
+>{ hi: 10, hello: 20} : Symbol(, Decl(templateStringInInOperator.ts, 0, 22))
 >hi : Symbol(hi, Decl(templateStringInInOperator.ts, 0, 24))
 >hello : Symbol(hello, Decl(templateStringInInOperator.ts, 0, 32))
 
diff --git a/tests/baselines/reference/templateStringInInOperatorES6.symbols b/tests/baselines/reference/templateStringInInOperatorES6.symbols
index 710ed18af3cdc..1f71f3fb15623 100644
--- a/tests/baselines/reference/templateStringInInOperatorES6.symbols
+++ b/tests/baselines/reference/templateStringInInOperatorES6.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/templates/templateStringInInOperatorES6.ts ===
 var x = `${ "hi" }` in { hi: 10, hello: 20};
 >x : Symbol(x, Decl(templateStringInInOperatorES6.ts, 0, 3))
+>{ hi: 10, hello: 20} : Symbol(, Decl(templateStringInInOperatorES6.ts, 0, 22))
 >hi : Symbol(hi, Decl(templateStringInInOperatorES6.ts, 0, 24))
 >hello : Symbol(hello, Decl(templateStringInInOperatorES6.ts, 0, 32))
 
diff --git a/tests/baselines/reference/templateStringInPropertyAssignment.symbols b/tests/baselines/reference/templateStringInPropertyAssignment.symbols
index a4c5df2270113..23fa8da69c748 100644
--- a/tests/baselines/reference/templateStringInPropertyAssignment.symbols
+++ b/tests/baselines/reference/templateStringInPropertyAssignment.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/templates/templateStringInPropertyAssignment.ts ===
 var x = {
 >x : Symbol(x, Decl(templateStringInPropertyAssignment.ts, 0, 3))
+>{    a: `abc${ 123 }def${ 456 }ghi`} : Symbol(, Decl(templateStringInPropertyAssignment.ts, 0, 7))
 
     a: `abc${ 123 }def${ 456 }ghi`
 >a : Symbol(a, Decl(templateStringInPropertyAssignment.ts, 0, 9))
diff --git a/tests/baselines/reference/templateStringInPropertyAssignmentES6.symbols b/tests/baselines/reference/templateStringInPropertyAssignmentES6.symbols
index ac888a52235e4..bc297bdf1f2f4 100644
--- a/tests/baselines/reference/templateStringInPropertyAssignmentES6.symbols
+++ b/tests/baselines/reference/templateStringInPropertyAssignmentES6.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/templates/templateStringInPropertyAssignmentES6.ts ===
 var x = {
 >x : Symbol(x, Decl(templateStringInPropertyAssignmentES6.ts, 0, 3))
+>{    a: `abc${ 123 }def${ 456 }ghi`} : Symbol(, Decl(templateStringInPropertyAssignmentES6.ts, 0, 7))
 
     a: `abc${ 123 }def${ 456 }ghi`
 >a : Symbol(a, Decl(templateStringInPropertyAssignmentES6.ts, 0, 9))
diff --git a/tests/baselines/reference/templateStringWithEmbeddedArrowFunction.symbols b/tests/baselines/reference/templateStringWithEmbeddedArrowFunction.symbols
index 9a8e6a2545543..dcc817f0ea32f 100644
--- a/tests/baselines/reference/templateStringWithEmbeddedArrowFunction.symbols
+++ b/tests/baselines/reference/templateStringWithEmbeddedArrowFunction.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/templates/templateStringWithEmbeddedArrowFunction.ts ===
 var x = `abc${ x => x }def`;
 >x : Symbol(x, Decl(templateStringWithEmbeddedArrowFunction.ts, 0, 3))
+>x => x : Symbol((Anonymous function), Decl(templateStringWithEmbeddedArrowFunction.ts, 0, 14))
 >x : Symbol(x, Decl(templateStringWithEmbeddedArrowFunction.ts, 0, 14))
 >x : Symbol(x, Decl(templateStringWithEmbeddedArrowFunction.ts, 0, 14))
 
diff --git a/tests/baselines/reference/templateStringWithEmbeddedArrowFunctionES6.symbols b/tests/baselines/reference/templateStringWithEmbeddedArrowFunctionES6.symbols
index 343e78d0dc0b8..3222c85961fff 100644
--- a/tests/baselines/reference/templateStringWithEmbeddedArrowFunctionES6.symbols
+++ b/tests/baselines/reference/templateStringWithEmbeddedArrowFunctionES6.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/templates/templateStringWithEmbeddedArrowFunctionES6.ts ===
 var x = `abc${ x => x }def`;
 >x : Symbol(x, Decl(templateStringWithEmbeddedArrowFunctionES6.ts, 0, 3))
+>x => x : Symbol((Anonymous function), Decl(templateStringWithEmbeddedArrowFunctionES6.ts, 0, 14))
 >x : Symbol(x, Decl(templateStringWithEmbeddedArrowFunctionES6.ts, 0, 14))
 >x : Symbol(x, Decl(templateStringWithEmbeddedArrowFunctionES6.ts, 0, 14))
 
diff --git a/tests/baselines/reference/templateStringWithEmbeddedFunctionExpression.symbols b/tests/baselines/reference/templateStringWithEmbeddedFunctionExpression.symbols
index eb790b782b0f3..d6a0f1e3f4ac9 100644
--- a/tests/baselines/reference/templateStringWithEmbeddedFunctionExpression.symbols
+++ b/tests/baselines/reference/templateStringWithEmbeddedFunctionExpression.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/templates/templateStringWithEmbeddedFunctionExpression.ts ===
 var x = `abc${ function y() { return y; } }def`;
 >x : Symbol(x, Decl(templateStringWithEmbeddedFunctionExpression.ts, 0, 3))
+>function y() { return y; } : Symbol(y, Decl(templateStringWithEmbeddedFunctionExpression.ts, 0, 14))
 >y : Symbol(y, Decl(templateStringWithEmbeddedFunctionExpression.ts, 0, 14))
 >y : Symbol(y, Decl(templateStringWithEmbeddedFunctionExpression.ts, 0, 14))
 
diff --git a/tests/baselines/reference/templateStringWithEmbeddedFunctionExpressionES6.symbols b/tests/baselines/reference/templateStringWithEmbeddedFunctionExpressionES6.symbols
index 87fb7d4b53713..513e1eb1daa7f 100644
--- a/tests/baselines/reference/templateStringWithEmbeddedFunctionExpressionES6.symbols
+++ b/tests/baselines/reference/templateStringWithEmbeddedFunctionExpressionES6.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/templates/templateStringWithEmbeddedFunctionExpressionES6.ts ===
 var x = `abc${ function y() { return y; } }def`;
 >x : Symbol(x, Decl(templateStringWithEmbeddedFunctionExpressionES6.ts, 0, 3))
+>function y() { return y; } : Symbol(y, Decl(templateStringWithEmbeddedFunctionExpressionES6.ts, 0, 14))
 >y : Symbol(y, Decl(templateStringWithEmbeddedFunctionExpressionES6.ts, 0, 14))
 >y : Symbol(y, Decl(templateStringWithEmbeddedFunctionExpressionES6.ts, 0, 14))
 
diff --git a/tests/baselines/reference/templateStringWithEmbeddedInOperator.symbols b/tests/baselines/reference/templateStringWithEmbeddedInOperator.symbols
index c1c6ce2daa557..5018064ae446a 100644
--- a/tests/baselines/reference/templateStringWithEmbeddedInOperator.symbols
+++ b/tests/baselines/reference/templateStringWithEmbeddedInOperator.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/templates/templateStringWithEmbeddedInOperator.ts ===
 var x = `abc${ "hi" in { hi: 10, hello: 20} }def`;
 >x : Symbol(x, Decl(templateStringWithEmbeddedInOperator.ts, 0, 3))
+>{ hi: 10, hello: 20} : Symbol(, Decl(templateStringWithEmbeddedInOperator.ts, 0, 22))
 >hi : Symbol(hi, Decl(templateStringWithEmbeddedInOperator.ts, 0, 24))
 >hello : Symbol(hello, Decl(templateStringWithEmbeddedInOperator.ts, 0, 32))
 
diff --git a/tests/baselines/reference/templateStringWithEmbeddedInOperatorES6.symbols b/tests/baselines/reference/templateStringWithEmbeddedInOperatorES6.symbols
index 7651708853798..4acdd4742d126 100644
--- a/tests/baselines/reference/templateStringWithEmbeddedInOperatorES6.symbols
+++ b/tests/baselines/reference/templateStringWithEmbeddedInOperatorES6.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/templates/templateStringWithEmbeddedInOperatorES6.ts ===
 var x = `abc${ "hi" in { hi: 10, hello: 20} }def`;
 >x : Symbol(x, Decl(templateStringWithEmbeddedInOperatorES6.ts, 0, 3))
+>{ hi: 10, hello: 20} : Symbol(, Decl(templateStringWithEmbeddedInOperatorES6.ts, 0, 22))
 >hi : Symbol(hi, Decl(templateStringWithEmbeddedInOperatorES6.ts, 0, 24))
 >hello : Symbol(hello, Decl(templateStringWithEmbeddedInOperatorES6.ts, 0, 32))
 
diff --git a/tests/baselines/reference/templateStringWithEmbeddedObjectLiteral.symbols b/tests/baselines/reference/templateStringWithEmbeddedObjectLiteral.symbols
index 0e287d84772d0..20cda3ab5e40b 100644
--- a/tests/baselines/reference/templateStringWithEmbeddedObjectLiteral.symbols
+++ b/tests/baselines/reference/templateStringWithEmbeddedObjectLiteral.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/templates/templateStringWithEmbeddedObjectLiteral.ts ===
 var x = `abc${ { x: 10, y: 20 } }def`;
 >x : Symbol(x, Decl(templateStringWithEmbeddedObjectLiteral.ts, 0, 3))
+>{ x: 10, y: 20 } : Symbol(, Decl(templateStringWithEmbeddedObjectLiteral.ts, 0, 14))
 >x : Symbol(x, Decl(templateStringWithEmbeddedObjectLiteral.ts, 0, 16))
 >y : Symbol(y, Decl(templateStringWithEmbeddedObjectLiteral.ts, 0, 23))
 
diff --git a/tests/baselines/reference/templateStringWithEmbeddedObjectLiteralES6.symbols b/tests/baselines/reference/templateStringWithEmbeddedObjectLiteralES6.symbols
index b7c1f271c5ab2..25b7ed110d854 100644
--- a/tests/baselines/reference/templateStringWithEmbeddedObjectLiteralES6.symbols
+++ b/tests/baselines/reference/templateStringWithEmbeddedObjectLiteralES6.symbols
@@ -1,6 +1,7 @@
 === tests/cases/conformance/es6/templates/templateStringWithEmbeddedObjectLiteralES6.ts ===
 var x = `abc${ { x: 10, y: 20 } }def`;
 >x : Symbol(x, Decl(templateStringWithEmbeddedObjectLiteralES6.ts, 0, 3))
+>{ x: 10, y: 20 } : Symbol(, Decl(templateStringWithEmbeddedObjectLiteralES6.ts, 0, 14))
 >x : Symbol(x, Decl(templateStringWithEmbeddedObjectLiteralES6.ts, 0, 16))
 >y : Symbol(y, Decl(templateStringWithEmbeddedObjectLiteralES6.ts, 0, 23))
 
diff --git a/tests/baselines/reference/ternaryExpressionSourceMap.symbols b/tests/baselines/reference/ternaryExpressionSourceMap.symbols
index 5893e5cb2c5cf..19e23f37f7f2c 100644
--- a/tests/baselines/reference/ternaryExpressionSourceMap.symbols
+++ b/tests/baselines/reference/ternaryExpressionSourceMap.symbols
@@ -6,4 +6,6 @@ var x = 1;
 var foo = x ? () => 0 : () => 0;
 >foo : Symbol(foo, Decl(ternaryExpressionSourceMap.ts, 2, 3))
 >x : Symbol(x, Decl(ternaryExpressionSourceMap.ts, 1, 3))
+>() => 0 : Symbol((Anonymous function), Decl(ternaryExpressionSourceMap.ts, 2, 13))
+>() => 0 : Symbol((Anonymous function), Decl(ternaryExpressionSourceMap.ts, 2, 23))
 
diff --git a/tests/baselines/reference/thisBinding2.symbols b/tests/baselines/reference/thisBinding2.symbols
index 60c11c2e959a0..ee671f09413ee 100644
--- a/tests/baselines/reference/thisBinding2.symbols
+++ b/tests/baselines/reference/thisBinding2.symbols
@@ -10,6 +10,7 @@ class C {
 >this.x : Symbol(x, Decl(thisBinding2.ts, 0, 9))
 >this : Symbol(C, Decl(thisBinding2.ts, 0, 0))
 >x : Symbol(x, Decl(thisBinding2.ts, 0, 9))
+>() => {   var x = 1;   return this.x;  } : Symbol((Anonymous function), Decl(thisBinding2.ts, 3, 18))
 
    var x = 1;
 >x : Symbol(x, Decl(thisBinding2.ts, 4, 6))
@@ -24,6 +25,7 @@ class C {
 >this.x : Symbol(x, Decl(thisBinding2.ts, 0, 9))
 >this : Symbol(C, Decl(thisBinding2.ts, 0, 0))
 >x : Symbol(x, Decl(thisBinding2.ts, 0, 9))
+>function() {   var x = 1;   return this.x;  } : Symbol((Anonymous function), Decl(thisBinding2.ts, 7, 10))
 
    var x = 1;
 >x : Symbol(x, Decl(thisBinding2.ts, 8, 6))
@@ -40,15 +42,18 @@ declare function setTimeout(expression: any, msec?: number, language?: any): num
 
 var messenger = {
 >messenger : Symbol(messenger, Decl(thisBinding2.ts, 14, 3))
+>{    message: "Hello World",    start: function () {        return setTimeout(() => { var x = this.message; }, 3000);    }} : Symbol(, Decl(thisBinding2.ts, 14, 15))
 
     message: "Hello World",
 >message : Symbol(message, Decl(thisBinding2.ts, 14, 17))
 
     start: function () {
 >start : Symbol(start, Decl(thisBinding2.ts, 15, 27))
+>function () {        return setTimeout(() => { var x = this.message; }, 3000);    } : Symbol((Anonymous function), Decl(thisBinding2.ts, 16, 10))
 
         return setTimeout(() => { var x = this.message; }, 3000);
 >setTimeout : Symbol(setTimeout, Decl(thisBinding2.ts, 12, 1))
+>() => { var x = this.message; } : Symbol((Anonymous function), Decl(thisBinding2.ts, 17, 26))
 >x : Symbol(x, Decl(thisBinding2.ts, 17, 37))
     }
 };
diff --git a/tests/baselines/reference/thisCapture1.symbols b/tests/baselines/reference/thisCapture1.symbols
index fade5bbeca339..48055b8ef299b 100644
--- a/tests/baselines/reference/thisCapture1.symbols
+++ b/tests/baselines/reference/thisCapture1.symbols
@@ -14,6 +14,7 @@ class X {
 
         return ret.always(() => {
 >ret : Symbol(ret, Decl(thisCapture1.ts, 3, 11))
+>() => {            this.y = 0;        } : Symbol((Anonymous function), Decl(thisCapture1.ts, 4, 26))
 
             this.y = 0;
 >this.y : Symbol(y, Decl(thisCapture1.ts, 0, 9))
diff --git a/tests/baselines/reference/thisExpressionInIndexExpression.symbols b/tests/baselines/reference/thisExpressionInIndexExpression.symbols
index b7df97a696b5f..d73bc7d146e0a 100644
--- a/tests/baselines/reference/thisExpressionInIndexExpression.symbols
+++ b/tests/baselines/reference/thisExpressionInIndexExpression.symbols
@@ -3,6 +3,7 @@ function f() {
 >f : Symbol(f, Decl(thisExpressionInIndexExpression.ts, 0, 0))
 
     return r => r[this];
+>r => r[this] : Symbol((Anonymous function), Decl(thisExpressionInIndexExpression.ts, 1, 10))
 >r : Symbol(r, Decl(thisExpressionInIndexExpression.ts, 1, 10))
 >r : Symbol(r, Decl(thisExpressionInIndexExpression.ts, 1, 10))
 }
diff --git a/tests/baselines/reference/thisExpressionOfGenericObject.symbols b/tests/baselines/reference/thisExpressionOfGenericObject.symbols
index f923b675e5d64..c39eddbc3737a 100644
--- a/tests/baselines/reference/thisExpressionOfGenericObject.symbols
+++ b/tests/baselines/reference/thisExpressionOfGenericObject.symbols
@@ -9,6 +9,7 @@ class MyClass1<T> {
 
     constructor() {
         () => this;
+>() => this : Symbol((Anonymous function), Decl(thisExpressionOfGenericObject.ts, 2, 19))
 >this : Symbol(MyClass1, Decl(thisExpressionOfGenericObject.ts, 0, 0))
     }
 }
diff --git a/tests/baselines/reference/thisInInnerFunctions.symbols b/tests/baselines/reference/thisInInnerFunctions.symbols
index 70c9106f9f853..cc109894a63d9 100644
--- a/tests/baselines/reference/thisInInnerFunctions.symbols
+++ b/tests/baselines/reference/thisInInnerFunctions.symbols
@@ -14,6 +14,7 @@ class Foo {
             this.y = "hi"; // 'this' should be not type to 'Foo' either
             var f = () => this.y;  // 'this' should be not type to 'Foo' either
 >f : Symbol(f, Decl(thisInInnerFunctions.ts, 5, 15))
+>() => this.y : Symbol((Anonymous function), Decl(thisInInnerFunctions.ts, 5, 19))
         }
     }
 }
@@ -23,8 +24,11 @@ function test() {
 
     var x = () => {
 >x : Symbol(x, Decl(thisInInnerFunctions.ts, 11, 7))
+>() => {        (() => this)();        this;    } : Symbol((Anonymous function), Decl(thisInInnerFunctions.ts, 11, 11))
 
         (() => this)();
+>() => this : Symbol((Anonymous function), Decl(thisInInnerFunctions.ts, 12, 9))
+
         this;
     };
 }
diff --git a/tests/baselines/reference/thisInLambda.symbols b/tests/baselines/reference/thisInLambda.symbols
index e760c1b1c0212..818bc32a308c6 100644
--- a/tests/baselines/reference/thisInLambda.symbols
+++ b/tests/baselines/reference/thisInLambda.symbols
@@ -15,6 +15,7 @@ class Foo {
 
         var f = () => this.x; // 'this' should be type 'Foo' as well
 >f : Symbol(f, Decl(thisInLambda.ts, 4, 11))
+>() => this.x : Symbol((Anonymous function), Decl(thisInLambda.ts, 4, 15))
 >this.x : Symbol(x, Decl(thisInLambda.ts, 0, 11))
 >this : Symbol(Foo, Decl(thisInLambda.ts, 0, 0))
 >x : Symbol(x, Decl(thisInLambda.ts, 0, 11))
@@ -31,9 +32,11 @@ class myCls {
     constructor () {
         myFn(() => {
 >myFn : Symbol(myFn, Decl(thisInLambda.ts, 6, 1))
+>() => {            myFn(() => {                var x = this;            });        } : Symbol((Anonymous function), Decl(thisInLambda.ts, 11, 13))
 
             myFn(() => {
 >myFn : Symbol(myFn, Decl(thisInLambda.ts, 6, 1))
+>() => {                var x = this;            } : Symbol((Anonymous function), Decl(thisInLambda.ts, 12, 17))
 
                 var x = this;
 >x : Symbol(x, Decl(thisInLambda.ts, 13, 19))
diff --git a/tests/baselines/reference/thisInObjectLiterals.symbols b/tests/baselines/reference/thisInObjectLiterals.symbols
index cb351ccd45756..610d5d2970c5e 100644
--- a/tests/baselines/reference/thisInObjectLiterals.symbols
+++ b/tests/baselines/reference/thisInObjectLiterals.symbols
@@ -11,6 +11,7 @@ class MyClass {
         //type of 'this' in an object literal is the containing scope's this
         var t = { x: this, y: this.t };
 >t : Symbol(t, Decl(thisInObjectLiterals.ts, 5, 11), Decl(thisInObjectLiterals.ts, 6, 11))
+>{ x: this, y: this.t } : Symbol(, Decl(thisInObjectLiterals.ts, 5, 15))
 >x : Symbol(x, Decl(thisInObjectLiterals.ts, 5, 17))
 >this : Symbol(MyClass, Decl(thisInObjectLiterals.ts, 0, 0))
 >y : Symbol(y, Decl(thisInObjectLiterals.ts, 5, 26))
@@ -29,6 +30,7 @@ class MyClass {
 //type of 'this' in an object literal property of a function type is Any
 var obj = {
 >obj : Symbol(obj, Decl(thisInObjectLiterals.ts, 11, 3), Decl(thisInObjectLiterals.ts, 16, 3))
+>{    f() {        return this.spaaace;    }} : Symbol(, Decl(thisInObjectLiterals.ts, 11, 9))
 
     f() {
 >f : Symbol(f, Decl(thisInObjectLiterals.ts, 11, 11))
diff --git a/tests/baselines/reference/thisInPropertyBoundDeclarations.symbols b/tests/baselines/reference/thisInPropertyBoundDeclarations.symbols
index 6a5f1417cd086..6878015ab7c63 100644
--- a/tests/baselines/reference/thisInPropertyBoundDeclarations.symbols
+++ b/tests/baselines/reference/thisInPropertyBoundDeclarations.symbols
@@ -10,6 +10,7 @@ class Bug {
 >Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
 
      (that: Bug, name: string) => {
+>(that: Bug, name: string) => {         that.foo(name);     } : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 3, 39))
 >that : Symbol(that, Decl(thisInPropertyBoundDeclarations.ts, 4, 6))
 >Bug : Symbol(Bug, Decl(thisInPropertyBoundDeclarations.ts, 0, 0))
 >name : Symbol(name, Decl(thisInPropertyBoundDeclarations.ts, 4, 16))
@@ -40,12 +41,14 @@ class A {
 
     prop1 = function() {
 >prop1 : Symbol(prop1, Decl(thisInPropertyBoundDeclarations.ts, 15, 9))
+>function() {        this;    } : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 16, 11))
 
         this;
     };
 
     prop2 = function() {
 >prop2 : Symbol(prop2, Decl(thisInPropertyBoundDeclarations.ts, 18, 6))
+>function() {        function inner() {            this;        }        () => this;    } : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 20, 11))
 
         function inner() {
 >inner : Symbol(inner, Decl(thisInPropertyBoundDeclarations.ts, 20, 24))
@@ -53,10 +56,13 @@ class A {
             this;
         }
         () => this;
+>() => this : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 23, 9))
+
     };
 
     prop3 = () => {
 >prop3 : Symbol(prop3, Decl(thisInPropertyBoundDeclarations.ts, 25, 6))
+>() => {        function inner() {            this;        }    } : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 27, 11))
 
         function inner() {
 >inner : Symbol(inner, Decl(thisInPropertyBoundDeclarations.ts, 27, 19))
@@ -67,18 +73,24 @@ class A {
 
     prop4 = {
 >prop4 : Symbol(prop4, Decl(thisInPropertyBoundDeclarations.ts, 31, 6))
+>{        a: function() { return this; },    } : Symbol(, Decl(thisInPropertyBoundDeclarations.ts, 33, 11))
 
         a: function() { return this; },
 >a : Symbol(a, Decl(thisInPropertyBoundDeclarations.ts, 33, 13))
+>function() { return this; } : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 34, 10))
 
     };
 
     prop5 = () => {
 >prop5 : Symbol(prop5, Decl(thisInPropertyBoundDeclarations.ts, 35, 6))
+>() => {        return {            a: function() { return this; },        };    } : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 37, 11))
 
         return {
+>{            a: function() { return this; },        } : Symbol(, Decl(thisInPropertyBoundDeclarations.ts, 38, 14))
+
             a: function() { return this; },
 >a : Symbol(a, Decl(thisInPropertyBoundDeclarations.ts, 38, 16))
+>function() { return this; } : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 39, 14))
 
         };
     };
@@ -93,36 +105,52 @@ class B {
 
     prop2 = () => this;
 >prop2 : Symbol(prop2, Decl(thisInPropertyBoundDeclarations.ts, 45, 17))
+>() => this : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 47, 11))
 >this : Symbol(B, Decl(thisInPropertyBoundDeclarations.ts, 42, 1))
 
     prop3 = () => () => () => () => this;
 >prop3 : Symbol(prop3, Decl(thisInPropertyBoundDeclarations.ts, 47, 23))
+>() => () => () => () => this : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 49, 11))
+>() => () => () => this : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 49, 17))
+>() => () => this : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 49, 23))
+>() => this : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 49, 29))
 >this : Symbol(B, Decl(thisInPropertyBoundDeclarations.ts, 42, 1))
 
     prop4 = '  ' +
 >prop4 : Symbol(prop4, Decl(thisInPropertyBoundDeclarations.ts, 49, 41))
 
     function() {
+>function() {    } : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 51, 18))
+
     } +
     ' ' +
     (() => () => () => this);
+>() => () => () => this : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 55, 5))
+>() => () => this : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 55, 10))
+>() => this : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 55, 16))
 >this : Symbol(B, Decl(thisInPropertyBoundDeclarations.ts, 42, 1))
 
     prop5 = {
 >prop5 : Symbol(prop5, Decl(thisInPropertyBoundDeclarations.ts, 55, 29))
+>{        a: () => { return this; }    } : Symbol(, Decl(thisInPropertyBoundDeclarations.ts, 57, 11))
 
         a: () => { return this; }
 >a : Symbol(a, Decl(thisInPropertyBoundDeclarations.ts, 57, 13))
+>() => { return this; } : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 58, 10))
 >this : Symbol(B, Decl(thisInPropertyBoundDeclarations.ts, 42, 1))
 
     };
 
     prop6 = () => {
 >prop6 : Symbol(prop6, Decl(thisInPropertyBoundDeclarations.ts, 59, 6))
+>() => {        return {            a: () => { return this; }        };    } : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 61, 11))
 
         return {
+>{            a: () => { return this; }        } : Symbol(, Decl(thisInPropertyBoundDeclarations.ts, 62, 14))
+
             a: () => { return this; }
 >a : Symbol(a, Decl(thisInPropertyBoundDeclarations.ts, 62, 16))
+>() => { return this; } : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 63, 14))
 >this : Symbol(B, Decl(thisInPropertyBoundDeclarations.ts, 42, 1))
 
         };
diff --git a/tests/baselines/reference/thisReferencedInFunctionInsideArrowFunction1.symbols b/tests/baselines/reference/thisReferencedInFunctionInsideArrowFunction1.symbols
index 7197239714024..a73ede4a221e5 100644
--- a/tests/baselines/reference/thisReferencedInFunctionInsideArrowFunction1.symbols
+++ b/tests/baselines/reference/thisReferencedInFunctionInsideArrowFunction1.symbols
@@ -1,6 +1,7 @@
 === tests/cases/compiler/thisReferencedInFunctionInsideArrowFunction1.ts ===
 var foo = (dummy) => { };
 >foo : Symbol(foo, Decl(thisReferencedInFunctionInsideArrowFunction1.ts, 0, 3))
+>(dummy) => { } : Symbol((Anonymous function), Decl(thisReferencedInFunctionInsideArrowFunction1.ts, 0, 9))
 >dummy : Symbol(dummy, Decl(thisReferencedInFunctionInsideArrowFunction1.ts, 0, 11))
 
 function test()
@@ -8,7 +9,10 @@ function test()
 {
     foo(() =>
 >foo : Symbol(foo, Decl(thisReferencedInFunctionInsideArrowFunction1.ts, 0, 3))
+>() =>        function () { return this; } : Symbol((Anonymous function), Decl(thisReferencedInFunctionInsideArrowFunction1.ts, 3, 8))
 
         function () { return this; }
+>function () { return this; } : Symbol((Anonymous function), Decl(thisReferencedInFunctionInsideArrowFunction1.ts, 3, 13))
+
     );
 }
diff --git a/tests/baselines/reference/throwInEnclosingStatements.symbols b/tests/baselines/reference/throwInEnclosingStatements.symbols
index 007894047dee4..841bdde7b25a2 100644
--- a/tests/baselines/reference/throwInEnclosingStatements.symbols
+++ b/tests/baselines/reference/throwInEnclosingStatements.symbols
@@ -8,6 +8,7 @@ function fn(x) {
 }
 
 <T>(x: T) => { throw x; }
+><T>(x: T) => { throw x; } : Symbol((Anonymous function), Decl(throwInEnclosingStatements.ts, 2, 1))
 >T : Symbol(T, Decl(throwInEnclosingStatements.ts, 4, 1))
 >x : Symbol(x, Decl(throwInEnclosingStatements.ts, 4, 4))
 >T : Symbol(T, Decl(throwInEnclosingStatements.ts, 4, 1))
@@ -44,6 +45,7 @@ for (var i = 0; ;) { throw i; }
 
 for (var idx in {}) { throw idx; }
 >idx : Symbol(idx, Decl(throwInEnclosingStatements.ts, 21, 8))
+>{} : Symbol(, Decl(throwInEnclosingStatements.ts, 21, 15))
 >idx : Symbol(idx, Decl(throwInEnclosingStatements.ts, 21, 8))
 
 do { throw null; }while(true)
@@ -80,6 +82,7 @@ class C<T> {
 
 var aa = {
 >aa : Symbol(aa, Decl(throwInEnclosingStatements.ts, 39, 3))
+>{    id:12,    biz() {        throw this;    }} : Symbol(, Decl(throwInEnclosingStatements.ts, 39, 8))
 
     id:12,
 >id : Symbol(id, Decl(throwInEnclosingStatements.ts, 39, 10))
diff --git a/tests/baselines/reference/throwStatements.symbols b/tests/baselines/reference/throwStatements.symbols
index cb65755a145aa..9dd6b9d5d4a8a 100644
--- a/tests/baselines/reference/throwStatements.symbols
+++ b/tests/baselines/reference/throwStatements.symbols
@@ -120,6 +120,7 @@ throw aGenericClass;
 
 var anObjectLiteral = { id: 12 };
 >anObjectLiteral : Symbol(anObjectLiteral, Decl(throwStatements.ts, 46, 3))
+>{ id: 12 } : Symbol(, Decl(throwStatements.ts, 46, 21))
 >id : Symbol(id, Decl(throwStatements.ts, 46, 23))
 
 throw anObjectLiteral;
@@ -137,6 +138,7 @@ throw aFunction('');
 
 var aLambda = (x) => 2;
 >aLambda : Symbol(aLambda, Decl(throwStatements.ts, 52, 3))
+>(x) => 2 : Symbol((Anonymous function), Decl(throwStatements.ts, 52, 13))
 >x : Symbol(x, Decl(throwStatements.ts, 52, 15))
 
 throw aLambda;
@@ -189,12 +191,16 @@ throw undefined;
 
 throw 'a string';
 throw function () { return 'a string' };
+>function () { return 'a string' } : Symbol((Anonymous function), Decl(throwStatements.ts, 74, 5))
+
 throw <T>(x:T) => 42;
+><T>(x:T) => 42 : Symbol((Anonymous function), Decl(throwStatements.ts, 75, 5))
 >T : Symbol(T, Decl(throwStatements.ts, 75, 7))
 >x : Symbol(x, Decl(throwStatements.ts, 75, 10))
 >T : Symbol(T, Decl(throwStatements.ts, 75, 7))
 
 throw { x: 12, y: 13 };
+>{ x: 12, y: 13 } : Symbol(, Decl(throwStatements.ts, 76, 5))
 >x : Symbol(x, Decl(throwStatements.ts, 76, 7))
 >y : Symbol(y, Decl(throwStatements.ts, 76, 14))
 
diff --git a/tests/baselines/reference/tooFewArgumentsInGenericFunctionTypedArgument.symbols b/tests/baselines/reference/tooFewArgumentsInGenericFunctionTypedArgument.symbols
index 79d5bc3e7a7e9..2a0aa5b74e586 100644
--- a/tests/baselines/reference/tooFewArgumentsInGenericFunctionTypedArgument.symbols
+++ b/tests/baselines/reference/tooFewArgumentsInGenericFunctionTypedArgument.symbols
@@ -72,6 +72,7 @@ var r1a = _.map(c2, (x) => { return x.toFixed() });
 >_ : Symbol(_, Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 10, 3))
 >map : Symbol(Combinators.map, Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 5, 23), Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 6, 77))
 >c2 : Symbol(c2, Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 9, 3))
+>(x) => { return x.toFixed() } : Symbol((Anonymous function), Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 11, 19))
 >x : Symbol(x, Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 11, 21))
 >x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
 >x : Symbol(x, Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 11, 21))
@@ -79,6 +80,7 @@ var r1a = _.map(c2, (x) => { return x.toFixed() });
 
 var rf1 = (x: number) => { return x.toFixed() };
 >rf1 : Symbol(rf1, Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 12, 3))
+>(x: number) => { return x.toFixed() } : Symbol((Anonymous function), Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 12, 9))
 >x : Symbol(x, Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 12, 11))
 >x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
 >x : Symbol(x, Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 12, 11))
diff --git a/tests/baselines/reference/topLevelLambda2.symbols b/tests/baselines/reference/topLevelLambda2.symbols
index 712d0a1611afc..93ade112e85bf 100644
--- a/tests/baselines/reference/topLevelLambda2.symbols
+++ b/tests/baselines/reference/topLevelLambda2.symbols
@@ -5,4 +5,5 @@ function foo(x:any) {}
 
 foo(()=>this.window);
 >foo : Symbol(foo, Decl(topLevelLambda2.ts, 0, 0))
+>()=>this.window : Symbol((Anonymous function), Decl(topLevelLambda2.ts, 2, 4))
 
diff --git a/tests/baselines/reference/topLevelLambda3.symbols b/tests/baselines/reference/topLevelLambda3.symbols
index 6ec9476ff743a..940e35e2918dd 100644
--- a/tests/baselines/reference/topLevelLambda3.symbols
+++ b/tests/baselines/reference/topLevelLambda3.symbols
@@ -1,4 +1,5 @@
 === tests/cases/compiler/topLevelLambda3.ts ===
 var f = () => {this.window;}
 >f : Symbol(f, Decl(topLevelLambda3.ts, 0, 3))
+>() => {this.window;} : Symbol((Anonymous function), Decl(topLevelLambda3.ts, 0, 7))
 
diff --git a/tests/baselines/reference/topLevelLambda4.symbols b/tests/baselines/reference/topLevelLambda4.symbols
index a4f403a762ffd..86ec6f6139d7d 100644
--- a/tests/baselines/reference/topLevelLambda4.symbols
+++ b/tests/baselines/reference/topLevelLambda4.symbols
@@ -1,4 +1,5 @@
 === tests/cases/compiler/topLevelLambda4.ts ===
 export var x = () => this.window;
 >x : Symbol(x, Decl(topLevelLambda4.ts, 0, 10))
+>() => this.window : Symbol((Anonymous function), Decl(topLevelLambda4.ts, 0, 14))
 
diff --git a/tests/baselines/reference/trailingCommasES3.symbols b/tests/baselines/reference/trailingCommasES3.symbols
index f176c9765c957..5d1112e052e8f 100644
--- a/tests/baselines/reference/trailingCommasES3.symbols
+++ b/tests/baselines/reference/trailingCommasES3.symbols
@@ -2,20 +2,24 @@
 
 var o1 = { a: 1, b: 2 };
 >o1 : Symbol(o1, Decl(trailingCommasES3.ts, 1, 3))
+>{ a: 1, b: 2 } : Symbol(, Decl(trailingCommasES3.ts, 1, 8))
 >a : Symbol(a, Decl(trailingCommasES3.ts, 1, 10))
 >b : Symbol(b, Decl(trailingCommasES3.ts, 1, 16))
 
 var o2 = { a: 1, b: 2, };
 >o2 : Symbol(o2, Decl(trailingCommasES3.ts, 2, 3))
+>{ a: 1, b: 2, } : Symbol(, Decl(trailingCommasES3.ts, 2, 8))
 >a : Symbol(a, Decl(trailingCommasES3.ts, 2, 10))
 >b : Symbol(b, Decl(trailingCommasES3.ts, 2, 16))
 
 var o3 = { a: 1, };
 >o3 : Symbol(o3, Decl(trailingCommasES3.ts, 3, 3))
+>{ a: 1, } : Symbol(, Decl(trailingCommasES3.ts, 3, 8))
 >a : Symbol(a, Decl(trailingCommasES3.ts, 3, 10))
 
 var o4 = {};
 >o4 : Symbol(o4, Decl(trailingCommasES3.ts, 4, 3))
+>{} : Symbol(, Decl(trailingCommasES3.ts, 4, 8))
 
 var a1 = [1, 2];
 >a1 : Symbol(a1, Decl(trailingCommasES3.ts, 6, 3))
diff --git a/tests/baselines/reference/trailingCommasES5.symbols b/tests/baselines/reference/trailingCommasES5.symbols
index 1cf7a32154769..75a2544ee5dd4 100644
--- a/tests/baselines/reference/trailingCommasES5.symbols
+++ b/tests/baselines/reference/trailingCommasES5.symbols
@@ -2,20 +2,24 @@
 
 var o1 = { a: 1, b: 2 };
 >o1 : Symbol(o1, Decl(trailingCommasES5.ts, 1, 3))
+>{ a: 1, b: 2 } : Symbol(, Decl(trailingCommasES5.ts, 1, 8))
 >a : Symbol(a, Decl(trailingCommasES5.ts, 1, 10))
 >b : Symbol(b, Decl(trailingCommasES5.ts, 1, 16))
 
 var o2 = { a: 1, b: 2, };
 >o2 : Symbol(o2, Decl(trailingCommasES5.ts, 2, 3))
+>{ a: 1, b: 2, } : Symbol(, Decl(trailingCommasES5.ts, 2, 8))
 >a : Symbol(a, Decl(trailingCommasES5.ts, 2, 10))
 >b : Symbol(b, Decl(trailingCommasES5.ts, 2, 16))
 
 var o3 = { a: 1, };
 >o3 : Symbol(o3, Decl(trailingCommasES5.ts, 3, 3))
+>{ a: 1, } : Symbol(, Decl(trailingCommasES5.ts, 3, 8))
 >a : Symbol(a, Decl(trailingCommasES5.ts, 3, 10))
 
 var o4 = {};
 >o4 : Symbol(o4, Decl(trailingCommasES5.ts, 4, 3))
+>{} : Symbol(, Decl(trailingCommasES5.ts, 4, 8))
 
 var a1 = [1, 2];
 >a1 : Symbol(a1, Decl(trailingCommasES5.ts, 6, 3))
diff --git a/tests/baselines/reference/tsxEmit1.symbols b/tests/baselines/reference/tsxEmit1.symbols
index 284f6cd9ce748..7eccc1172bbad 100644
--- a/tests/baselines/reference/tsxEmit1.symbols
+++ b/tests/baselines/reference/tsxEmit1.symbols
@@ -91,6 +91,7 @@ class SomeClass {
 		var rewrites1 = <div>{() => this}</div>;
 >rewrites1 : Symbol(rewrites1, Decl(tsxEmit1.tsx, 24, 5))
 >div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit1.tsx, 1, 22))
+>() => this : Symbol((Anonymous function), Decl(tsxEmit1.tsx, 24, 24))
 >this : Symbol(SomeClass, Decl(tsxEmit1.tsx, 20, 43))
 
 		var rewrites2 = <div>{[p, ...p, p]}</div>;
@@ -103,12 +104,14 @@ class SomeClass {
 		var rewrites3 = <div>{{p}}</div>;
 >rewrites3 : Symbol(rewrites3, Decl(tsxEmit1.tsx, 26, 5))
 >div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit1.tsx, 1, 22))
+>{p} : Symbol(, Decl(tsxEmit1.tsx, 26, 24))
 >p : Symbol(p, Decl(tsxEmit1.tsx, 26, 25))
 
 		var rewrites4 = <div a={() => this}></div>;
 >rewrites4 : Symbol(rewrites4, Decl(tsxEmit1.tsx, 28, 5))
 >div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit1.tsx, 1, 22))
 >a : Symbol(unknown)
+>() => this : Symbol((Anonymous function), Decl(tsxEmit1.tsx, 28, 26))
 >this : Symbol(SomeClass, Decl(tsxEmit1.tsx, 20, 43))
 
 		var rewrites5 = <div a={[p, ...p, p]}></div>;
@@ -123,6 +126,7 @@ class SomeClass {
 >rewrites6 : Symbol(rewrites6, Decl(tsxEmit1.tsx, 30, 5))
 >div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit1.tsx, 1, 22))
 >a : Symbol(unknown)
+>{p} : Symbol(, Decl(tsxEmit1.tsx, 30, 26))
 >p : Symbol(p, Decl(tsxEmit1.tsx, 30, 27))
 	}
 }
diff --git a/tests/baselines/reference/tsxGenericArrowFunctionParsing.symbols b/tests/baselines/reference/tsxGenericArrowFunctionParsing.symbols
index 8bd68b2e8e7e5..297a584d52803 100644
--- a/tests/baselines/reference/tsxGenericArrowFunctionParsing.symbols
+++ b/tests/baselines/reference/tsxGenericArrowFunctionParsing.symbols
@@ -25,6 +25,7 @@ x1.isElement;
 // This is a generic function
 var x2 = <T extends {}>() => {};
 >x2 : Symbol(x2, Decl(tsxGenericArrowFunctionParsing.tsx, 11, 3))
+><T extends {}>() => {} : Symbol((Anonymous function), Decl(tsxGenericArrowFunctionParsing.tsx, 11, 8))
 >T : Symbol(T, Decl(tsxGenericArrowFunctionParsing.tsx, 11, 10))
 
 x2();
@@ -33,6 +34,7 @@ x2();
 // This is a generic function
 var x3 = <T, T1>() => {};
 >x3 : Symbol(x3, Decl(tsxGenericArrowFunctionParsing.tsx, 15, 3))
+><T, T1>() => {} : Symbol((Anonymous function), Decl(tsxGenericArrowFunctionParsing.tsx, 15, 8))
 >T : Symbol(T, Decl(tsxGenericArrowFunctionParsing.tsx, 15, 10))
 >T1 : Symbol(T1, Decl(tsxGenericArrowFunctionParsing.tsx, 15, 12))
 
diff --git a/tests/baselines/reference/tsxInArrowFunction.symbols b/tests/baselines/reference/tsxInArrowFunction.symbols
index 814f2577bf095..4342434300cde 100644
--- a/tests/baselines/reference/tsxInArrowFunction.symbols
+++ b/tests/baselines/reference/tsxInArrowFunction.symbols
@@ -22,12 +22,14 @@ declare namespace JSX {
 // didn't work
 <div>{() => <div text="wat" />}</div>;
 >div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33))
+>() => <div text="wat" /> : Symbol((Anonymous function), Decl(tsxInArrowFunction.tsx, 12, 6))
 >div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33))
 >text : Symbol(text, Decl(tsxInArrowFunction.tsx, 4, 14))
 
 // didn't work
 <div>{x => <div text="wat" />}</div>;
 >div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33))
+>x => <div text="wat" /> : Symbol((Anonymous function), Decl(tsxInArrowFunction.tsx, 15, 6))
 >x : Symbol(x, Decl(tsxInArrowFunction.tsx, 15, 6))
 >div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33))
 >text : Symbol(text, Decl(tsxInArrowFunction.tsx, 4, 14))
@@ -35,12 +37,14 @@ declare namespace JSX {
 // worked
 <div>{() => (<div text="wat" />)}</div>;
 >div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33))
+>() => (<div text="wat" />) : Symbol((Anonymous function), Decl(tsxInArrowFunction.tsx, 18, 6))
 >div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33))
 >text : Symbol(text, Decl(tsxInArrowFunction.tsx, 4, 14))
 
 // worked (!)
 <div>{() => <div text="wat"></div>}</div>;
 >div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33))
+>() => <div text="wat"></div> : Symbol((Anonymous function), Decl(tsxInArrowFunction.tsx, 21, 6))
 >div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33))
 >text : Symbol(text, Decl(tsxInArrowFunction.tsx, 4, 14))
 
diff --git a/tests/baselines/reference/tsxReactEmit1.symbols b/tests/baselines/reference/tsxReactEmit1.symbols
index c9e819c82d3e3..1787c391a3964 100644
--- a/tests/baselines/reference/tsxReactEmit1.symbols
+++ b/tests/baselines/reference/tsxReactEmit1.symbols
@@ -95,7 +95,12 @@ class SomeClass {
 		var rewrites1 = <div>{() => this}</div>;
 >rewrites1 : Symbol(rewrites1, Decl(tsxReactEmit1.tsx, 25, 5))
 >div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit1.tsx, 1, 22))
+<<<<<<< HEAD
 >this : Symbol(SomeClass, Decl(tsxReactEmit1.tsx, 21, 45))
+=======
+>() => this : Symbol((Anonymous function), Decl(tsxReactEmit1.tsx, 24, 24))
+>this : Symbol(SomeClass, Decl(tsxReactEmit1.tsx, 20, 45))
+>>>>>>> Accept symbol baselines
 
 		var rewrites2 = <div>{[p, ...p, p]}</div>;
 >rewrites2 : Symbol(rewrites2, Decl(tsxReactEmit1.tsx, 26, 5))
@@ -107,13 +112,23 @@ class SomeClass {
 		var rewrites3 = <div>{{p}}</div>;
 >rewrites3 : Symbol(rewrites3, Decl(tsxReactEmit1.tsx, 27, 5))
 >div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit1.tsx, 1, 22))
+<<<<<<< HEAD
 >p : Symbol(p, Decl(tsxReactEmit1.tsx, 27, 25))
+=======
+>{p} : Symbol(, Decl(tsxReactEmit1.tsx, 26, 24))
+>p : Symbol(p, Decl(tsxReactEmit1.tsx, 26, 25))
+>>>>>>> Accept symbol baselines
 
 		var rewrites4 = <div a={() => this}></div>;
 >rewrites4 : Symbol(rewrites4, Decl(tsxReactEmit1.tsx, 29, 5))
 >div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit1.tsx, 1, 22))
 >a : Symbol(unknown)
+<<<<<<< HEAD
 >this : Symbol(SomeClass, Decl(tsxReactEmit1.tsx, 21, 45))
+=======
+>() => this : Symbol((Anonymous function), Decl(tsxReactEmit1.tsx, 28, 26))
+>this : Symbol(SomeClass, Decl(tsxReactEmit1.tsx, 20, 45))
+>>>>>>> Accept symbol baselines
 
 		var rewrites5 = <div a={[p, ...p, p]}></div>;
 >rewrites5 : Symbol(rewrites5, Decl(tsxReactEmit1.tsx, 30, 5))
@@ -127,7 +142,12 @@ class SomeClass {
 >rewrites6 : Symbol(rewrites6, Decl(tsxReactEmit1.tsx, 31, 5))
 >div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit1.tsx, 1, 22))
 >a : Symbol(unknown)
+<<<<<<< HEAD
 >p : Symbol(p, Decl(tsxReactEmit1.tsx, 31, 27))
+=======
+>{p} : Symbol(, Decl(tsxReactEmit1.tsx, 30, 26))
+>p : Symbol(p, Decl(tsxReactEmit1.tsx, 30, 27))
+>>>>>>> Accept symbol baselines
 	}
 }
 
diff --git a/tests/baselines/reference/tsxTypeErrors.symbols b/tests/baselines/reference/tsxTypeErrors.symbols
index bfe0c5686403e..5d21e28b8cc18 100644
--- a/tests/baselines/reference/tsxTypeErrors.symbols
+++ b/tests/baselines/reference/tsxTypeErrors.symbols
@@ -13,6 +13,7 @@ var a2 = <img srce="foo.jpg" />
 // A built-in element with a badly-typed attribute value (error)
 var thing = { oops: 100 };
 >thing : Symbol(thing, Decl(tsxTypeErrors.tsx, 8, 3))
+>{ oops: 100 } : Symbol(, Decl(tsxTypeErrors.tsx, 8, 11))
 >oops : Symbol(oops, Decl(tsxTypeErrors.tsx, 8, 13))
 
 var a3 = <div id={thing} />
@@ -59,6 +60,7 @@ var b2 = <MyClass pt={{x: 4, y: 'oops'}} />;
 >b2 : Symbol(b2, Decl(tsxTypeErrors.tsx, 31, 3))
 >MyClass : Symbol(MyClass, Decl(tsxTypeErrors.tsx, 12, 31))
 >pt : Symbol(unknown)
+>{x: 4, y: 'oops'} : Symbol(, Decl(tsxTypeErrors.tsx, 31, 22))
 >x : Symbol(x, Decl(tsxTypeErrors.tsx, 31, 23))
 >y : Symbol(y, Decl(tsxTypeErrors.tsx, 31, 28))
 
diff --git a/tests/baselines/reference/typeAnnotationBestCommonTypeInArrayLiteral.symbols b/tests/baselines/reference/typeAnnotationBestCommonTypeInArrayLiteral.symbols
index f172c91f26525..e20ca063af2e8 100644
--- a/tests/baselines/reference/typeAnnotationBestCommonTypeInArrayLiteral.symbols
+++ b/tests/baselines/reference/typeAnnotationBestCommonTypeInArrayLiteral.symbols
@@ -24,11 +24,15 @@ var menuData: IMenuItem[] = [
 >menuData : Symbol(menuData, Decl(typeAnnotationBestCommonTypeInArrayLiteral.ts, 8, 3))
 >IMenuItem : Symbol(IMenuItem, Decl(typeAnnotationBestCommonTypeInArrayLiteral.ts, 0, 0))
     {
+>{        "id": "ourLogo",        "type": "image",        "link": "",        "icon": "modules/menu/logo.svg"    } : Symbol(, Decl(typeAnnotationBestCommonTypeInArrayLiteral.ts, 8, 29))
+
         "id": "ourLogo",
         "type": "image",
         "link": "",
         "icon": "modules/menu/logo.svg"
     }, {
+>{        "id": "productName",        "type": "default",        "link": "",        "text": "Product Name"    } : Symbol(, Decl(typeAnnotationBestCommonTypeInArrayLiteral.ts, 14, 6))
+
         "id": "productName",
         "type": "default",
         "link": "",
diff --git a/tests/baselines/reference/typeArgInference.symbols b/tests/baselines/reference/typeArgInference.symbols
index 37318e35906a6..1e91429751fcb 100644
--- a/tests/baselines/reference/typeArgInference.symbols
+++ b/tests/baselines/reference/typeArgInference.symbols
@@ -37,6 +37,7 @@ interface I {
 }
 var o = { a: 3, b: "test" };
 >o : Symbol(o, Decl(typeArgInference.ts, 4, 3))
+>{ a: 3, b: "test" } : Symbol(, Decl(typeArgInference.ts, 4, 7))
 >a : Symbol(a, Decl(typeArgInference.ts, 4, 9))
 >b : Symbol(b, Decl(typeArgInference.ts, 4, 15))
 
diff --git a/tests/baselines/reference/typeArgInferenceWithNull.symbols b/tests/baselines/reference/typeArgInferenceWithNull.symbols
index 565508eb7821d..ced4c2e379353 100644
--- a/tests/baselines/reference/typeArgInferenceWithNull.symbols
+++ b/tests/baselines/reference/typeArgInferenceWithNull.symbols
@@ -19,6 +19,7 @@ function fn5<T extends { x: string }>(n: T) { }
 
 fn5({ x: null });
 >fn5 : Symbol(fn5, Decl(typeArgInferenceWithNull.ts, 3, 10))
+>{ x: null } : Symbol(, Decl(typeArgInferenceWithNull.ts, 6, 4))
 >x : Symbol(x, Decl(typeArgInferenceWithNull.ts, 6, 5))
 
 function fn6<T extends { x: string }>(n: T, fun: (x: T) => void, n2: T) { }
@@ -35,7 +36,10 @@ function fn6<T extends { x: string }>(n: T, fun: (x: T) => void, n2: T) { }
 
 fn6({ x: null }, y => { }, { x: "" }); // y has type { x: any }, but ideally would have type { x: string }
 >fn6 : Symbol(fn6, Decl(typeArgInferenceWithNull.ts, 6, 17))
+>{ x: null } : Symbol(, Decl(typeArgInferenceWithNull.ts, 9, 4))
 >x : Symbol(x, Decl(typeArgInferenceWithNull.ts, 9, 5))
+>y => { } : Symbol((Anonymous function), Decl(typeArgInferenceWithNull.ts, 9, 16))
 >y : Symbol(y, Decl(typeArgInferenceWithNull.ts, 9, 16))
+>{ x: "" } : Symbol(, Decl(typeArgInferenceWithNull.ts, 9, 26))
 >x : Symbol(x, Decl(typeArgInferenceWithNull.ts, 9, 28))
 
diff --git a/tests/baselines/reference/typeArgumentsInFunctionExpressions.symbols b/tests/baselines/reference/typeArgumentsInFunctionExpressions.symbols
index 1f8cc74e30ed7..172a6f64b2f32 100644
--- a/tests/baselines/reference/typeArgumentsInFunctionExpressions.symbols
+++ b/tests/baselines/reference/typeArgumentsInFunctionExpressions.symbols
@@ -1,6 +1,7 @@
 === tests/cases/compiler/typeArgumentsInFunctionExpressions.ts ===
 var obj = function f<T>(a: T) { // should not error
 >obj : Symbol(obj, Decl(typeArgumentsInFunctionExpressions.ts, 0, 3))
+>function f<T>(a: T) { // should not error    var x: T;    return a;} : Symbol(f, Decl(typeArgumentsInFunctionExpressions.ts, 0, 9))
 >f : Symbol(f, Decl(typeArgumentsInFunctionExpressions.ts, 0, 9))
 >T : Symbol(T, Decl(typeArgumentsInFunctionExpressions.ts, 0, 21))
 >a : Symbol(a, Decl(typeArgumentsInFunctionExpressions.ts, 0, 24))
@@ -17,6 +18,7 @@ var obj = function f<T>(a: T) { // should not error
  
 var obj2 = function f<T>(a: T): T { // should not error
 >obj2 : Symbol(obj2, Decl(typeArgumentsInFunctionExpressions.ts, 5, 3))
+>function f<T>(a: T): T { // should not error    var x: T;    return a;} : Symbol(f, Decl(typeArgumentsInFunctionExpressions.ts, 5, 10))
 >f : Symbol(f, Decl(typeArgumentsInFunctionExpressions.ts, 5, 10))
 >T : Symbol(T, Decl(typeArgumentsInFunctionExpressions.ts, 5, 22))
 >a : Symbol(a, Decl(typeArgumentsInFunctionExpressions.ts, 5, 25))
diff --git a/tests/baselines/reference/typeGuardFunction.symbols b/tests/baselines/reference/typeGuardFunction.symbols
index 13ad30de5c548..7a8343ca77536 100644
--- a/tests/baselines/reference/typeGuardFunction.symbols
+++ b/tests/baselines/reference/typeGuardFunction.symbols
@@ -152,6 +152,7 @@ class D {
 // Arrow function
 let f1 = (p1: A): p1 is C => false;
 >f1 : Symbol(f1, Decl(typeGuardFunction.ts, 62, 3))
+>(p1: A): p1 is C => false : Symbol((Anonymous function), Decl(typeGuardFunction.ts, 62, 8))
 >p1 : Symbol(p1, Decl(typeGuardFunction.ts, 62, 10))
 >A : Symbol(A, Decl(typeGuardFunction.ts, 0, 0))
 >p1 : Symbol(p1, Decl(typeGuardFunction.ts, 62, 10))
@@ -169,6 +170,7 @@ declare function f2(p1: (p1: A) => p1 is C);
 // Function expressions
 f2(function(p1: A): p1 is C {
 >f2 : Symbol(f2, Decl(typeGuardFunction.ts, 62, 35))
+>function(p1: A): p1 is C {    return true;} : Symbol((Anonymous function), Decl(typeGuardFunction.ts, 68, 3))
 >p1 : Symbol(p1, Decl(typeGuardFunction.ts, 68, 12))
 >A : Symbol(A, Decl(typeGuardFunction.ts, 0, 0))
 >p1 : Symbol(p1, Decl(typeGuardFunction.ts, 68, 12))
diff --git a/tests/baselines/reference/typeGuardsDefeat.symbols b/tests/baselines/reference/typeGuardsDefeat.symbols
index e5b2b4b2047d7..18245fd46bf97 100644
--- a/tests/baselines/reference/typeGuardsDefeat.symbols
+++ b/tests/baselines/reference/typeGuardsDefeat.symbols
@@ -42,6 +42,7 @@ function foo2(x: number | string) {
     else {
         var f = function () {
 >f : Symbol(f, Decl(typeGuardsDefeat.ts, 19, 11))
+>function () {            return x * x;        } : Symbol((Anonymous function), Decl(typeGuardsDefeat.ts, 19, 15))
 
             return x * x;
 >x : Symbol(x, Decl(typeGuardsDefeat.ts, 14, 14))
@@ -70,6 +71,7 @@ function foo3(x: number | string) {
     else {
         var f = () => x * x;
 >f : Symbol(f, Decl(typeGuardsDefeat.ts, 31, 11))
+>() => x * x : Symbol((Anonymous function), Decl(typeGuardsDefeat.ts, 31, 15))
 >x : Symbol(x, Decl(typeGuardsDefeat.ts, 26, 14))
 >x : Symbol(x, Decl(typeGuardsDefeat.ts, 26, 14))
     }
diff --git a/tests/baselines/reference/typeGuardsInFunction.symbols b/tests/baselines/reference/typeGuardsInFunction.symbols
index 32a37f62a070f..8efb2113e14e0 100644
--- a/tests/baselines/reference/typeGuardsInFunction.symbols
+++ b/tests/baselines/reference/typeGuardsInFunction.symbols
@@ -108,6 +108,7 @@ function f2(param: string | number) {
     // variables in function expressions
     var r = function (param1: string | number) {
 >r : Symbol(r, Decl(typeGuardsInFunction.ts, 42, 7))
+>function (param1: string | number) {        // global vars in function declaration        num = typeof var1 === "string" && var1.length; // string        // variables from outer function declaration        num = typeof var2 === "string" && var2.length; // string        // parameters in outer declaration        num = typeof param === "string" && param.length; // string        // local        var var3: string | number;        num = typeof var3 === "string" && var3.length; // string        num = typeof param1 === "string" && param1.length; // string    } : Symbol((Anonymous function), Decl(typeGuardsInFunction.ts, 42, 11))
 >param1 : Symbol(param1, Decl(typeGuardsInFunction.ts, 42, 22))
 
         // global vars in function declaration
@@ -167,6 +168,7 @@ function f3(param: string | number) {
     // variables in function expressions
     var r = ((param1: string | number) => {
 >r : Symbol(r, Decl(typeGuardsInFunction.ts, 63, 7))
+>(param1: string | number) => {        // global vars in function declaration        num = typeof var1 === "string" && var1.length; // string        // variables from outer function declaration        num = typeof var2 === "string" && var2.length; // string        // parameters in outer declaration        num = typeof param === "string" && param.length; // string        // local        var var3: string | number;        num = typeof var3 === "string" && var3.length; // string        num = typeof param1 === "string" && param1.length; // string    } : Symbol((Anonymous function), Decl(typeGuardsInFunction.ts, 63, 13))
 >param1 : Symbol(param1, Decl(typeGuardsInFunction.ts, 63, 14))
 
         // global vars in function declaration
diff --git a/tests/baselines/reference/typeGuardsInFunctionAndModuleBlock.symbols b/tests/baselines/reference/typeGuardsInFunctionAndModuleBlock.symbols
index d1140e3af6016..af76639a467ce 100644
--- a/tests/baselines/reference/typeGuardsInFunctionAndModuleBlock.symbols
+++ b/tests/baselines/reference/typeGuardsInFunctionAndModuleBlock.symbols
@@ -12,6 +12,7 @@ function foo(x: number | string | boolean) {
 >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 2, 13))
 
         : function f() {
+>function f() {            var b = x; // number | boolean            return typeof x === "boolean"                ? x.toString() // boolean                : x.toString(); // number        } : Symbol(f, Decl(typeGuardsInFunctionAndModuleBlock.ts, 5, 9))
 >f : Symbol(f, Decl(typeGuardsInFunctionAndModuleBlock.ts, 5, 9))
 
             var b = x; // number | boolean
@@ -44,6 +45,7 @@ function foo2(x: number | string | boolean) {
 >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 12, 14))
 
         : function f(a: number | boolean) {
+>function f(a: number | boolean) {            var b = x; // new scope - number | boolean            return typeof x === "boolean"                ? x.toString() // boolean                : x.toString(); // number        } : Symbol(f, Decl(typeGuardsInFunctionAndModuleBlock.ts, 15, 9))
 >f : Symbol(f, Decl(typeGuardsInFunctionAndModuleBlock.ts, 15, 9))
 >a : Symbol(a, Decl(typeGuardsInFunctionAndModuleBlock.ts, 15, 21))
 
@@ -78,6 +80,8 @@ function foo3(x: number | string | boolean) {
 >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 22, 14))
 
         : (() => {
+>() => {            var b = x; // new scope - number | boolean            return typeof x === "boolean"                ? x.toString() // boolean                : x.toString(); // number        } : Symbol((Anonymous function), Decl(typeGuardsInFunctionAndModuleBlock.ts, 25, 11))
+
             var b = x; // new scope - number | boolean
 >b : Symbol(b, Decl(typeGuardsInFunctionAndModuleBlock.ts, 26, 15))
 >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 22, 14))
@@ -108,6 +112,7 @@ function foo4(x: number | string | boolean) {
 >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 32, 14))
 
         : ((a: number | boolean) => {
+>(a: number | boolean) => {            var b = x; // new scope - number | boolean            return typeof x === "boolean"                ? x.toString() // boolean                : x.toString(); // number        } : Symbol((Anonymous function), Decl(typeGuardsInFunctionAndModuleBlock.ts, 35, 11))
 >a : Symbol(a, Decl(typeGuardsInFunctionAndModuleBlock.ts, 35, 12))
 
             var b = x; // new scope - number | boolean
diff --git a/tests/baselines/reference/typeGuardsObjectMethods.symbols b/tests/baselines/reference/typeGuardsObjectMethods.symbols
index 3f585c1e4c621..e5a2c3bd47e4e 100644
--- a/tests/baselines/reference/typeGuardsObjectMethods.symbols
+++ b/tests/baselines/reference/typeGuardsObjectMethods.symbols
@@ -15,6 +15,7 @@ var var1: string | number;
 
 var obj1 = {
 >obj1 : Symbol(obj1, Decl(typeGuardsObjectMethods.ts, 8, 3))
+>{    // Inside method    method(param: string | number) {        // global vars in function declaration        num = typeof var1 === "string" && var1.length; // string        // variables in function declaration        var var2: string | number;        num = typeof var2 === "string" && var2.length; // string        // parameters in function declaration        num = typeof param === "string" && param.length; // string        return strOrNum;    },    get prop() {        // global vars in function declaration        num = typeof var1 === "string" && var1.length; // string        // variables in function declaration        var var2: string | number;        num = typeof var2 === "string" && var2.length; // string        return strOrNum;    },    set prop(param: string | number) {        // global vars in function declaration        num = typeof var1 === "string" && var1.length; // string        // variables in function declaration        var var2: string | number;        num = typeof var2 === "string" && var2.length; // string        // parameters in function declaration        num = typeof param === "string" && param.length; // string    }} : Symbol(, Decl(typeGuardsObjectMethods.ts, 8, 10))
 
     // Inside method
     method(param: string | number) {
diff --git a/tests/baselines/reference/typeInferenceFixEarly.symbols b/tests/baselines/reference/typeInferenceFixEarly.symbols
index 6e91d741a81a7..0739a3dab5177 100644
--- a/tests/baselines/reference/typeInferenceFixEarly.symbols
+++ b/tests/baselines/reference/typeInferenceFixEarly.symbols
@@ -10,5 +10,6 @@ declare function f<T>(p: (t: T) => T): T;
 
 f(n => 3);
 >f : Symbol(f, Decl(typeInferenceFixEarly.ts, 0, 0))
+>n => 3 : Symbol((Anonymous function), Decl(typeInferenceFixEarly.ts, 2, 2))
 >n : Symbol(n, Decl(typeInferenceFixEarly.ts, 2, 2))
 
diff --git a/tests/baselines/reference/typeInferenceReturnTypeCallback.symbols b/tests/baselines/reference/typeInferenceReturnTypeCallback.symbols
index a7322f7e69ba8..e3df0c48df9ca 100644
--- a/tests/baselines/reference/typeInferenceReturnTypeCallback.symbols
+++ b/tests/baselines/reference/typeInferenceReturnTypeCallback.symbols
@@ -56,6 +56,7 @@ class Cons<T> implements IList<T>{
 >foldRight : Symbol(foldRight, Decl(typeInferenceReturnTypeCallback.ts, 15, 5))
 >Nil : Symbol(Nil, Decl(typeInferenceReturnTypeCallback.ts, 2, 1))
 >U : Symbol(U, Decl(typeInferenceReturnTypeCallback.ts, 11, 8))
+>(t, acc) => {            return new Cons<U>();        } : Symbol((Anonymous function), Decl(typeInferenceReturnTypeCallback.ts, 12, 43))
 >t : Symbol(t, Decl(typeInferenceReturnTypeCallback.ts, 12, 45))
 >acc : Symbol(acc, Decl(typeInferenceReturnTypeCallback.ts, 12, 47))
 
diff --git a/tests/baselines/reference/typeInferenceWithTypeAnnotation.symbols b/tests/baselines/reference/typeInferenceWithTypeAnnotation.symbols
index 47d7ef080ed8a..003d4b776a82b 100644
--- a/tests/baselines/reference/typeInferenceWithTypeAnnotation.symbols
+++ b/tests/baselines/reference/typeInferenceWithTypeAnnotation.symbols
@@ -10,6 +10,7 @@ declare function f<T>(p: (t: T) => T): T;
 
 f((n: number) => n); 
 >f : Symbol(f, Decl(typeInferenceWithTypeAnnotation.ts, 0, 0))
+>(n: number) => n : Symbol((Anonymous function), Decl(typeInferenceWithTypeAnnotation.ts, 2, 2))
 >n : Symbol(n, Decl(typeInferenceWithTypeAnnotation.ts, 2, 3))
 >n : Symbol(n, Decl(typeInferenceWithTypeAnnotation.ts, 2, 3))
 
diff --git a/tests/baselines/reference/typeLiteralCallback.symbols b/tests/baselines/reference/typeLiteralCallback.symbols
index 14bdd2406120e..5256baf641d0f 100644
--- a/tests/baselines/reference/typeLiteralCallback.symbols
+++ b/tests/baselines/reference/typeLiteralCallback.symbols
@@ -36,6 +36,7 @@ test.fail(arg => foo.reject(arg));
 >test.fail : Symbol(bar.fail, Decl(typeLiteralCallback.ts, 5, 18))
 >test : Symbol(test, Decl(typeLiteralCallback.ts, 9, 3))
 >fail : Symbol(bar.fail, Decl(typeLiteralCallback.ts, 5, 18))
+>arg => foo.reject(arg) : Symbol((Anonymous function), Decl(typeLiteralCallback.ts, 11, 10))
 >arg : Symbol(arg, Decl(typeLiteralCallback.ts, 11, 10))
 >foo.reject : Symbol(Foo.reject, Decl(typeLiteralCallback.ts, 0, 18))
 >foo : Symbol(foo, Decl(typeLiteralCallback.ts, 3, 3))
@@ -46,6 +47,7 @@ test.fail2(arg => foo.reject(arg));  // Should be OK.  Was: Error: Supplied para
 >test.fail2 : Symbol(bar.fail2, Decl(typeLiteralCallback.ts, 6, 41))
 >test : Symbol(test, Decl(typeLiteralCallback.ts, 9, 3))
 >fail2 : Symbol(bar.fail2, Decl(typeLiteralCallback.ts, 6, 41))
+>arg => foo.reject(arg) : Symbol((Anonymous function), Decl(typeLiteralCallback.ts, 12, 11))
 >arg : Symbol(arg, Decl(typeLiteralCallback.ts, 12, 11))
 >foo.reject : Symbol(Foo.reject, Decl(typeLiteralCallback.ts, 0, 18))
 >foo : Symbol(foo, Decl(typeLiteralCallback.ts, 3, 3))
diff --git a/tests/baselines/reference/typeOfThisInFunctionExpression.symbols b/tests/baselines/reference/typeOfThisInFunctionExpression.symbols
index 59a7b11bc9f1f..382f909fa7e77 100644
--- a/tests/baselines/reference/typeOfThisInFunctionExpression.symbols
+++ b/tests/baselines/reference/typeOfThisInFunctionExpression.symbols
@@ -13,6 +13,7 @@ function fn() {
 
 var t = function () {
 >t : Symbol(t, Decl(typeOfThisInFunctionExpression.ts, 7, 3))
+>function () {    var p = this;    var p: any;} : Symbol((Anonymous function), Decl(typeOfThisInFunctionExpression.ts, 7, 7))
 
     var p = this;
 >p : Symbol(p, Decl(typeOfThisInFunctionExpression.ts, 8, 7), Decl(typeOfThisInFunctionExpression.ts, 9, 7))
@@ -23,6 +24,7 @@ var t = function () {
 
 var t2 = function f() {
 >t2 : Symbol(t2, Decl(typeOfThisInFunctionExpression.ts, 12, 3))
+>function f() {    var x = this;    var x: any;} : Symbol(f, Decl(typeOfThisInFunctionExpression.ts, 12, 8))
 >f : Symbol(f, Decl(typeOfThisInFunctionExpression.ts, 12, 8))
 
     var x = this;
@@ -37,6 +39,7 @@ class C {
 
     x = function () {
 >x : Symbol(x, Decl(typeOfThisInFunctionExpression.ts, 17, 9))
+>function () {        var q: any;        var q = this;    } : Symbol((Anonymous function), Decl(typeOfThisInFunctionExpression.ts, 18, 7))
 
         var q: any;
 >q : Symbol(q, Decl(typeOfThisInFunctionExpression.ts, 19, 11), Decl(typeOfThisInFunctionExpression.ts, 20, 11))
@@ -46,6 +49,7 @@ class C {
     }
     y = function ff() {
 >y : Symbol(y, Decl(typeOfThisInFunctionExpression.ts, 21, 5))
+>function ff() {        var q: any;        var q = this;    } : Symbol(ff, Decl(typeOfThisInFunctionExpression.ts, 22, 7))
 >ff : Symbol(ff, Decl(typeOfThisInFunctionExpression.ts, 22, 7))
 
         var q: any;
@@ -71,6 +75,7 @@ module M {
 
     var t = function () {
 >t : Symbol(t, Decl(typeOfThisInFunctionExpression.ts, 34, 7))
+>function () {        var p = this;        var p: any;    } : Symbol((Anonymous function), Decl(typeOfThisInFunctionExpression.ts, 34, 11))
 
         var p = this;
 >p : Symbol(p, Decl(typeOfThisInFunctionExpression.ts, 35, 11), Decl(typeOfThisInFunctionExpression.ts, 36, 11))
@@ -81,6 +86,7 @@ module M {
 
     var t2 = function f() {
 >t2 : Symbol(t2, Decl(typeOfThisInFunctionExpression.ts, 39, 7))
+>function f() {        var x = this;        var x: any;    } : Symbol(f, Decl(typeOfThisInFunctionExpression.ts, 39, 12))
 >f : Symbol(f, Decl(typeOfThisInFunctionExpression.ts, 39, 12))
 
         var x = this;
diff --git a/tests/baselines/reference/typeParameterAsTypeParameterConstraintTransitively.symbols b/tests/baselines/reference/typeParameterAsTypeParameterConstraintTransitively.symbols
index 90276a96b3db8..182ae85e8682c 100644
--- a/tests/baselines/reference/typeParameterAsTypeParameterConstraintTransitively.symbols
+++ b/tests/baselines/reference/typeParameterAsTypeParameterConstraintTransitively.symbols
@@ -49,9 +49,12 @@ foo(1, 2, 3);
 
 foo({ x: 1 }, { x: 1, y: '' }, { x: 2, y: '', z: true });
 >foo : Symbol(foo, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 8, 9))
+>{ x: 1 } : Symbol(, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 14, 4))
 >x : Symbol(x, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 14, 5))
+>{ x: 1, y: '' } : Symbol(, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 14, 13))
 >x : Symbol(x, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 14, 15))
 >y : Symbol(y, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 14, 21))
+>{ x: 2, y: '', z: true } : Symbol(, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 14, 30))
 >x : Symbol(x, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 14, 32))
 >y : Symbol(y, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 14, 38))
 >z : Symbol(z, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 14, 45))
@@ -66,15 +69,19 @@ foo(a, b, { foo: 1, bar: '', hm: true });
 >foo : Symbol(foo, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 8, 9))
 >a : Symbol(a, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 6, 3))
 >b : Symbol(b, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 7, 3))
+>{ foo: 1, bar: '', hm: true } : Symbol(, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 16, 9))
 >foo : Symbol(foo, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 16, 11))
 >bar : Symbol(bar, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 16, 19))
 >hm : Symbol(hm, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 16, 28))
 
 foo((x: number, y) => { }, (x) => { }, () => { });
 >foo : Symbol(foo, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 8, 9))
+>(x: number, y) => { } : Symbol((Anonymous function), Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 17, 4))
 >x : Symbol(x, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 17, 5))
 >y : Symbol(y, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 17, 15))
+>(x) => { } : Symbol((Anonymous function), Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 17, 26))
 >x : Symbol(x, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 17, 28))
+>() => { } : Symbol((Anonymous function), Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 17, 38))
 
 function foo2<T extends A, U, V>(x: T, y: U, z: V): V { return z; }
 >foo2 : Symbol(foo2, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 17, 50))
@@ -108,6 +115,7 @@ foo(b, b, { foo: 1, bar: '', hm: '' });
 >foo : Symbol(foo, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 8, 9))
 >b : Symbol(b, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 7, 3))
 >b : Symbol(b, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 7, 3))
+>{ foo: 1, bar: '', hm: '' } : Symbol(, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 23, 9))
 >foo : Symbol(foo, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 23, 11))
 >bar : Symbol(bar, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 23, 19))
 >hm : Symbol(hm, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 23, 28))
diff --git a/tests/baselines/reference/typeParameterAsTypeParameterConstraintTransitively2.symbols b/tests/baselines/reference/typeParameterAsTypeParameterConstraintTransitively2.symbols
index 5635d0e61ed54..7aa094c18d19d 100644
--- a/tests/baselines/reference/typeParameterAsTypeParameterConstraintTransitively2.symbols
+++ b/tests/baselines/reference/typeParameterAsTypeParameterConstraintTransitively2.symbols
@@ -49,9 +49,12 @@ foo(1, 2, '');
 
 foo({ x: 1 }, { x: 1, y: '' }, { x: 2, y: 2, z: true });
 >foo : Symbol(foo, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 8, 9))
+>{ x: 1 } : Symbol(, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 14, 4))
 >x : Symbol(x, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 14, 5))
+>{ x: 1, y: '' } : Symbol(, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 14, 13))
 >x : Symbol(x, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 14, 15))
 >y : Symbol(y, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 14, 21))
+>{ x: 2, y: 2, z: true } : Symbol(, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 14, 30))
 >x : Symbol(x, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 14, 32))
 >y : Symbol(y, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 14, 38))
 >z : Symbol(z, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 14, 44))
@@ -65,6 +68,7 @@ foo(a, b, a);
 foo(a, { foo: 1, bar: '', hm: true }, b);
 >foo : Symbol(foo, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 8, 9))
 >a : Symbol(a, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 6, 3))
+>{ foo: 1, bar: '', hm: true } : Symbol(, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 16, 6))
 >foo : Symbol(foo, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 16, 8))
 >bar : Symbol(bar, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 16, 16))
 >hm : Symbol(hm, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 16, 25))
@@ -72,10 +76,13 @@ foo(a, { foo: 1, bar: '', hm: true }, b);
 
 foo((x: number, y: string) => { }, (x, y: boolean) => { }, () => { });
 >foo : Symbol(foo, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 8, 9))
+>(x: number, y: string) => { } : Symbol((Anonymous function), Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 17, 4))
 >x : Symbol(x, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 17, 5))
 >y : Symbol(y, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 17, 15))
+>(x, y: boolean) => { } : Symbol((Anonymous function), Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 17, 34))
 >x : Symbol(x, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 17, 36))
 >y : Symbol(y, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 17, 38))
+>() => { } : Symbol((Anonymous function), Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 17, 58))
 
 function foo2<T extends A, U extends A, V extends A>(x: T, y: U, z: V): V { return z; }
 >foo2 : Symbol(foo2, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 17, 70))
diff --git a/tests/baselines/reference/typeParameterCompatibilityAccrossDeclarations.symbols b/tests/baselines/reference/typeParameterCompatibilityAccrossDeclarations.symbols
index eb1aeeaca2725..02d0aef6eb398 100644
--- a/tests/baselines/reference/typeParameterCompatibilityAccrossDeclarations.symbols
+++ b/tests/baselines/reference/typeParameterCompatibilityAccrossDeclarations.symbols
@@ -1,9 +1,11 @@
 === tests/cases/compiler/typeParameterCompatibilityAccrossDeclarations.ts ===
 var a = {
 >a : Symbol(a, Decl(typeParameterCompatibilityAccrossDeclarations.ts, 0, 3))
+>{   x: function <T>(y: T): T { return null; }} : Symbol(, Decl(typeParameterCompatibilityAccrossDeclarations.ts, 0, 7))
 
    x: function <T>(y: T): T { return null; }
 >x : Symbol(x, Decl(typeParameterCompatibilityAccrossDeclarations.ts, 0, 9))
+>function <T>(y: T): T { return null; } : Symbol((Anonymous function), Decl(typeParameterCompatibilityAccrossDeclarations.ts, 1, 5))
 >T : Symbol(T, Decl(typeParameterCompatibilityAccrossDeclarations.ts, 1, 16))
 >y : Symbol(y, Decl(typeParameterCompatibilityAccrossDeclarations.ts, 1, 19))
 >T : Symbol(T, Decl(typeParameterCompatibilityAccrossDeclarations.ts, 1, 16))
@@ -11,9 +13,11 @@ var a = {
 }
 var a2 = {
 >a2 : Symbol(a2, Decl(typeParameterCompatibilityAccrossDeclarations.ts, 3, 3))
+>{   x: function (y: any): any { return null; }} : Symbol(, Decl(typeParameterCompatibilityAccrossDeclarations.ts, 3, 8))
 
    x: function (y: any): any { return null; }
 >x : Symbol(x, Decl(typeParameterCompatibilityAccrossDeclarations.ts, 3, 10))
+>function (y: any): any { return null; } : Symbol((Anonymous function), Decl(typeParameterCompatibilityAccrossDeclarations.ts, 4, 5))
 >y : Symbol(y, Decl(typeParameterCompatibilityAccrossDeclarations.ts, 4, 16))
 }
 export interface I {
diff --git a/tests/baselines/reference/typeParameterFixingWithConstraints.symbols b/tests/baselines/reference/typeParameterFixingWithConstraints.symbols
index 94e1b8172cb55..b5a13e97dd8dc 100644
--- a/tests/baselines/reference/typeParameterFixingWithConstraints.symbols
+++ b/tests/baselines/reference/typeParameterFixingWithConstraints.symbols
@@ -34,7 +34,10 @@ foo.foo({ bar: null }, bar => null, bar => null);
 >foo.foo : Symbol(IFoo.foo, Decl(typeParameterFixingWithConstraints.ts, 4, 16))
 >foo : Symbol(foo, Decl(typeParameterFixingWithConstraints.ts, 8, 3))
 >foo : Symbol(IFoo.foo, Decl(typeParameterFixingWithConstraints.ts, 4, 16))
+>{ bar: null } : Symbol(, Decl(typeParameterFixingWithConstraints.ts, 9, 8))
 >bar : Symbol(bar, Decl(typeParameterFixingWithConstraints.ts, 9, 9))
+>bar => null : Symbol((Anonymous function), Decl(typeParameterFixingWithConstraints.ts, 9, 22))
 >bar : Symbol(bar, Decl(typeParameterFixingWithConstraints.ts, 9, 22))
+>bar => null : Symbol((Anonymous function), Decl(typeParameterFixingWithConstraints.ts, 9, 35))
 >bar : Symbol(bar, Decl(typeParameterFixingWithConstraints.ts, 9, 35))
 
diff --git a/tests/baselines/reference/typeParameterFixingWithContextSensitiveArguments.symbols b/tests/baselines/reference/typeParameterFixingWithContextSensitiveArguments.symbols
index fcf8fcb8dc474..6a68761eeda62 100644
--- a/tests/baselines/reference/typeParameterFixingWithContextSensitiveArguments.symbols
+++ b/tests/baselines/reference/typeParameterFixingWithContextSensitiveArguments.symbols
@@ -37,6 +37,7 @@ var d = f(b, x => x.a, a); // type [A, A]
 >d : Symbol(d, Decl(typeParameterFixingWithContextSensitiveArguments.ts, 6, 3))
 >f : Symbol(f, Decl(typeParameterFixingWithContextSensitiveArguments.ts, 0, 0))
 >b : Symbol(b, Decl(typeParameterFixingWithContextSensitiveArguments.ts, 4, 9))
+>x => x.a : Symbol((Anonymous function), Decl(typeParameterFixingWithContextSensitiveArguments.ts, 6, 12))
 >x : Symbol(x, Decl(typeParameterFixingWithContextSensitiveArguments.ts, 6, 12))
 >x.a : Symbol(A.a, Decl(typeParameterFixingWithContextSensitiveArguments.ts, 1, 13))
 >x : Symbol(x, Decl(typeParameterFixingWithContextSensitiveArguments.ts, 6, 12))
@@ -47,6 +48,7 @@ var d2 = f(b, x => x.a, null); // type [B, A]
 >d2 : Symbol(d2, Decl(typeParameterFixingWithContextSensitiveArguments.ts, 7, 3))
 >f : Symbol(f, Decl(typeParameterFixingWithContextSensitiveArguments.ts, 0, 0))
 >b : Symbol(b, Decl(typeParameterFixingWithContextSensitiveArguments.ts, 4, 9))
+>x => x.a : Symbol((Anonymous function), Decl(typeParameterFixingWithContextSensitiveArguments.ts, 7, 13))
 >x : Symbol(x, Decl(typeParameterFixingWithContextSensitiveArguments.ts, 7, 13))
 >x.a : Symbol(A.a, Decl(typeParameterFixingWithContextSensitiveArguments.ts, 1, 13))
 >x : Symbol(x, Decl(typeParameterFixingWithContextSensitiveArguments.ts, 7, 13))
@@ -56,6 +58,7 @@ var d3 = f(b, x => x.b, null); // type [B, any]
 >d3 : Symbol(d3, Decl(typeParameterFixingWithContextSensitiveArguments.ts, 8, 3))
 >f : Symbol(f, Decl(typeParameterFixingWithContextSensitiveArguments.ts, 0, 0))
 >b : Symbol(b, Decl(typeParameterFixingWithContextSensitiveArguments.ts, 4, 9))
+>x => x.b : Symbol((Anonymous function), Decl(typeParameterFixingWithContextSensitiveArguments.ts, 8, 13))
 >x : Symbol(x, Decl(typeParameterFixingWithContextSensitiveArguments.ts, 8, 13))
 >x.b : Symbol(B.b, Decl(typeParameterFixingWithContextSensitiveArguments.ts, 2, 23))
 >x : Symbol(x, Decl(typeParameterFixingWithContextSensitiveArguments.ts, 8, 13))
diff --git a/tests/baselines/reference/typeParameterFixingWithContextSensitiveArguments4.symbols b/tests/baselines/reference/typeParameterFixingWithContextSensitiveArguments4.symbols
index d8f7abea60644..4222dc780e150 100644
--- a/tests/baselines/reference/typeParameterFixingWithContextSensitiveArguments4.symbols
+++ b/tests/baselines/reference/typeParameterFixingWithContextSensitiveArguments4.symbols
@@ -42,8 +42,10 @@ var d = f(a, b, x => x, x => <any>x); // Type [A, B]
 >f : Symbol(f, Decl(typeParameterFixingWithContextSensitiveArguments4.ts, 0, 0))
 >a : Symbol(a, Decl(typeParameterFixingWithContextSensitiveArguments4.ts, 4, 3))
 >b : Symbol(b, Decl(typeParameterFixingWithContextSensitiveArguments4.ts, 4, 9))
+>x => x : Symbol((Anonymous function), Decl(typeParameterFixingWithContextSensitiveArguments4.ts, 6, 15))
 >x : Symbol(x, Decl(typeParameterFixingWithContextSensitiveArguments4.ts, 6, 15))
 >x : Symbol(x, Decl(typeParameterFixingWithContextSensitiveArguments4.ts, 6, 15))
+>x => <any>x : Symbol((Anonymous function), Decl(typeParameterFixingWithContextSensitiveArguments4.ts, 6, 23))
 >x : Symbol(x, Decl(typeParameterFixingWithContextSensitiveArguments4.ts, 6, 23))
 >x : Symbol(x, Decl(typeParameterFixingWithContextSensitiveArguments4.ts, 6, 23))
 
diff --git a/tests/baselines/reference/typeParameterFixingWithContextSensitiveArguments5.symbols b/tests/baselines/reference/typeParameterFixingWithContextSensitiveArguments5.symbols
index 5ba8aee8dba54..80b0c122e7ac0 100644
--- a/tests/baselines/reference/typeParameterFixingWithContextSensitiveArguments5.symbols
+++ b/tests/baselines/reference/typeParameterFixingWithContextSensitiveArguments5.symbols
@@ -42,10 +42,12 @@ var d = f(a, b, u2 => u2.b, t2 => t2);
 >f : Symbol(f, Decl(typeParameterFixingWithContextSensitiveArguments5.ts, 0, 0))
 >a : Symbol(a, Decl(typeParameterFixingWithContextSensitiveArguments5.ts, 4, 3))
 >b : Symbol(b, Decl(typeParameterFixingWithContextSensitiveArguments5.ts, 4, 9))
+>u2 => u2.b : Symbol((Anonymous function), Decl(typeParameterFixingWithContextSensitiveArguments5.ts, 6, 15))
 >u2 : Symbol(u2, Decl(typeParameterFixingWithContextSensitiveArguments5.ts, 6, 15))
 >u2.b : Symbol(B.b, Decl(typeParameterFixingWithContextSensitiveArguments5.ts, 2, 23))
 >u2 : Symbol(u2, Decl(typeParameterFixingWithContextSensitiveArguments5.ts, 6, 15))
 >b : Symbol(B.b, Decl(typeParameterFixingWithContextSensitiveArguments5.ts, 2, 23))
+>t2 => t2 : Symbol((Anonymous function), Decl(typeParameterFixingWithContextSensitiveArguments5.ts, 6, 27))
 >t2 : Symbol(t2, Decl(typeParameterFixingWithContextSensitiveArguments5.ts, 6, 27))
 >t2 : Symbol(t2, Decl(typeParameterFixingWithContextSensitiveArguments5.ts, 6, 27))
 
diff --git a/tests/baselines/reference/typeParametersAvailableInNestedScope.symbols b/tests/baselines/reference/typeParametersAvailableInNestedScope.symbols
index 905ccba8f3f11..72190471cc5d4 100644
--- a/tests/baselines/reference/typeParametersAvailableInNestedScope.symbols
+++ b/tests/baselines/reference/typeParametersAvailableInNestedScope.symbols
@@ -9,6 +9,7 @@ class C<T> {
 
     x = <U>(a: U) => {
 >x : Symbol(x, Decl(typeParametersAvailableInNestedScope.ts, 1, 12))
+><U>(a: U) => {        var y: T;        return y;    } : Symbol((Anonymous function), Decl(typeParametersAvailableInNestedScope.ts, 3, 7))
 >U : Symbol(U, Decl(typeParametersAvailableInNestedScope.ts, 3, 9))
 >a : Symbol(a, Decl(typeParametersAvailableInNestedScope.ts, 3, 12))
 >U : Symbol(U, Decl(typeParametersAvailableInNestedScope.ts, 3, 9))
diff --git a/tests/baselines/reference/typeVal.symbols b/tests/baselines/reference/typeVal.symbols
index 353b187a48ed9..aa291ca31da8b 100644
--- a/tests/baselines/reference/typeVal.symbols
+++ b/tests/baselines/reference/typeVal.symbols
@@ -9,6 +9,7 @@ interface I {
 var I:I = { I: 3};
 >I : Symbol(I, Decl(typeVal.ts, 0, 0), Decl(typeVal.ts, 4, 3))
 >I : Symbol(I, Decl(typeVal.ts, 0, 0), Decl(typeVal.ts, 4, 3))
+>{ I: 3} : Symbol(, Decl(typeVal.ts, 4, 9))
 >I : Symbol(I, Decl(typeVal.ts, 4, 11))
 
 I.I=4;
diff --git a/tests/baselines/reference/typeofInterface.symbols b/tests/baselines/reference/typeofInterface.symbols
index 9aa305e0a30ff..a93145738f404 100644
--- a/tests/baselines/reference/typeofInterface.symbols
+++ b/tests/baselines/reference/typeofInterface.symbols
@@ -23,5 +23,6 @@ var j: typeof k.foo = { a: "hello" };
 >k.foo : Symbol(I.foo, Decl(typeofInterface.ts, 3, 14))
 >k : Symbol(k, Decl(typeofInterface.ts, 7, 3))
 >foo : Symbol(I.foo, Decl(typeofInterface.ts, 3, 14))
+>{ a: "hello" } : Symbol(, Decl(typeofInterface.ts, 8, 21))
 >a : Symbol(a, Decl(typeofInterface.ts, 8, 23))
 
diff --git a/tests/baselines/reference/typeofOperatorWithBooleanType.symbols b/tests/baselines/reference/typeofOperatorWithBooleanType.symbols
index 39276e6162562..a68b0a67e2b5c 100644
--- a/tests/baselines/reference/typeofOperatorWithBooleanType.symbols
+++ b/tests/baselines/reference/typeofOperatorWithBooleanType.symbols
@@ -37,6 +37,7 @@ var ResultIsString2 = typeof true;
 
 var ResultIsString3 = typeof { x: true, y: false };
 >ResultIsString3 : Symbol(ResultIsString3, Decl(typeofOperatorWithBooleanType.ts, 20, 3))
+>{ x: true, y: false } : Symbol(, Decl(typeofOperatorWithBooleanType.ts, 20, 28))
 >x : Symbol(x, Decl(typeofOperatorWithBooleanType.ts, 20, 30))
 >y : Symbol(y, Decl(typeofOperatorWithBooleanType.ts, 20, 39))
 
@@ -105,6 +106,7 @@ r: typeof foo;
 
 var y = { a: true, b: false};
 >y : Symbol(y, Decl(typeofOperatorWithBooleanType.ts, 45, 3))
+>{ a: true, b: false} : Symbol(, Decl(typeofOperatorWithBooleanType.ts, 45, 7))
 >a : Symbol(a, Decl(typeofOperatorWithBooleanType.ts, 45, 9))
 >b : Symbol(b, Decl(typeofOperatorWithBooleanType.ts, 45, 18))
 
diff --git a/tests/baselines/reference/typeofOperatorWithNumberType.symbols b/tests/baselines/reference/typeofOperatorWithNumberType.symbols
index df49b7dccb6f0..c77b7cc1a1e07 100644
--- a/tests/baselines/reference/typeofOperatorWithNumberType.symbols
+++ b/tests/baselines/reference/typeofOperatorWithNumberType.symbols
@@ -44,13 +44,16 @@ var ResultIsString3 = typeof 1;
 
 var ResultIsString4 = typeof { x: 1, y: 2};
 >ResultIsString4 : Symbol(ResultIsString4, Decl(typeofOperatorWithNumberType.ts, 22, 3))
+>{ x: 1, y: 2} : Symbol(, Decl(typeofOperatorWithNumberType.ts, 22, 28))
 >x : Symbol(x, Decl(typeofOperatorWithNumberType.ts, 22, 30))
 >y : Symbol(y, Decl(typeofOperatorWithNumberType.ts, 22, 36))
 
 var ResultIsString5 = typeof { x: 1, y: (n: number) => { return n; } };
 >ResultIsString5 : Symbol(ResultIsString5, Decl(typeofOperatorWithNumberType.ts, 23, 3))
+>{ x: 1, y: (n: number) => { return n; } } : Symbol(, Decl(typeofOperatorWithNumberType.ts, 23, 28))
 >x : Symbol(x, Decl(typeofOperatorWithNumberType.ts, 23, 30))
 >y : Symbol(y, Decl(typeofOperatorWithNumberType.ts, 23, 36))
+>(n: number) => { return n; } : Symbol((Anonymous function), Decl(typeofOperatorWithNumberType.ts, 23, 39))
 >n : Symbol(n, Decl(typeofOperatorWithNumberType.ts, 23, 41))
 >n : Symbol(n, Decl(typeofOperatorWithNumberType.ts, 23, 41))
 
@@ -143,6 +146,7 @@ r: typeof foo;
 
 var y = { a: 1, b: 2 };
 >y : Symbol(y, Decl(typeofOperatorWithNumberType.ts, 52, 3))
+>{ a: 1, b: 2 } : Symbol(, Decl(typeofOperatorWithNumberType.ts, 52, 7))
 >a : Symbol(a, Decl(typeofOperatorWithNumberType.ts, 52, 9))
 >b : Symbol(b, Decl(typeofOperatorWithNumberType.ts, 52, 15))
 
diff --git a/tests/baselines/reference/typeofOperatorWithStringType.symbols b/tests/baselines/reference/typeofOperatorWithStringType.symbols
index 6da22469f839f..c6ba3220005fd 100644
--- a/tests/baselines/reference/typeofOperatorWithStringType.symbols
+++ b/tests/baselines/reference/typeofOperatorWithStringType.symbols
@@ -44,13 +44,16 @@ var ResultIsString3 = typeof "";
 
 var ResultIsString4 = typeof { x: "", y: "" };
 >ResultIsString4 : Symbol(ResultIsString4, Decl(typeofOperatorWithStringType.ts, 22, 3))
+>{ x: "", y: "" } : Symbol(, Decl(typeofOperatorWithStringType.ts, 22, 28))
 >x : Symbol(x, Decl(typeofOperatorWithStringType.ts, 22, 30))
 >y : Symbol(y, Decl(typeofOperatorWithStringType.ts, 22, 37))
 
 var ResultIsString5 = typeof { x: "", y: (s: string) => { return s; } };
 >ResultIsString5 : Symbol(ResultIsString5, Decl(typeofOperatorWithStringType.ts, 23, 3))
+>{ x: "", y: (s: string) => { return s; } } : Symbol(, Decl(typeofOperatorWithStringType.ts, 23, 28))
 >x : Symbol(x, Decl(typeofOperatorWithStringType.ts, 23, 30))
 >y : Symbol(y, Decl(typeofOperatorWithStringType.ts, 23, 37))
+>(s: string) => { return s; } : Symbol((Anonymous function), Decl(typeofOperatorWithStringType.ts, 23, 40))
 >s : Symbol(s, Decl(typeofOperatorWithStringType.ts, 23, 42))
 >s : Symbol(s, Decl(typeofOperatorWithStringType.ts, 23, 42))
 
@@ -142,6 +145,7 @@ r: typeof foo;
 
 var y = { a: "", b: "" };
 >y : Symbol(y, Decl(typeofOperatorWithStringType.ts, 52, 3))
+>{ a: "", b: "" } : Symbol(, Decl(typeofOperatorWithStringType.ts, 52, 7))
 >a : Symbol(a, Decl(typeofOperatorWithStringType.ts, 52, 9))
 >b : Symbol(b, Decl(typeofOperatorWithStringType.ts, 52, 16))
 
diff --git a/tests/baselines/reference/typesWithOptionalProperty.symbols b/tests/baselines/reference/typesWithOptionalProperty.symbols
index 9c5461010990a..de7a6458c8c5b 100644
--- a/tests/baselines/reference/typesWithOptionalProperty.symbols
+++ b/tests/baselines/reference/typesWithOptionalProperty.symbols
@@ -30,18 +30,22 @@ var a: {
 
 var b = { foo: '' };
 >b : Symbol(b, Decl(typesWithOptionalProperty.ts, 14, 3))
+>{ foo: '' } : Symbol(, Decl(typesWithOptionalProperty.ts, 14, 7))
 >foo : Symbol(foo, Decl(typesWithOptionalProperty.ts, 14, 9))
 
 var c = { foo: '', bar: 3 };
 >c : Symbol(c, Decl(typesWithOptionalProperty.ts, 15, 3))
+>{ foo: '', bar: 3 } : Symbol(, Decl(typesWithOptionalProperty.ts, 15, 7))
 >foo : Symbol(foo, Decl(typesWithOptionalProperty.ts, 15, 9))
 >bar : Symbol(bar, Decl(typesWithOptionalProperty.ts, 15, 18))
 
 var d = { foo: '', bar: 3, baz: () => '' };
 >d : Symbol(d, Decl(typesWithOptionalProperty.ts, 16, 3))
+>{ foo: '', bar: 3, baz: () => '' } : Symbol(, Decl(typesWithOptionalProperty.ts, 16, 7))
 >foo : Symbol(foo, Decl(typesWithOptionalProperty.ts, 16, 9))
 >bar : Symbol(bar, Decl(typesWithOptionalProperty.ts, 16, 18))
 >baz : Symbol(baz, Decl(typesWithOptionalProperty.ts, 16, 26))
+>() => '' : Symbol((Anonymous function), Decl(typesWithOptionalProperty.ts, 16, 31))
 
 var i: I;
 >i : Symbol(i, Decl(typesWithOptionalProperty.ts, 18, 3))
diff --git a/tests/baselines/reference/uncaughtCompilerError1.symbols b/tests/baselines/reference/uncaughtCompilerError1.symbols
index ab265163a86de..7adc9d3122217 100644
--- a/tests/baselines/reference/uncaughtCompilerError1.symbols
+++ b/tests/baselines/reference/uncaughtCompilerError1.symbols
@@ -21,6 +21,7 @@ function f() {
 >tokens : Symbol(tokens, Decl(uncaughtCompilerError1.ts, 0, 37))
 
             return { appendText: '\"\"', advanceCount: 1 };
+>{ appendText: '\"\"', advanceCount: 1 } : Symbol(, Decl(uncaughtCompilerError1.ts, 5, 18))
 >appendText : Symbol(appendText, Decl(uncaughtCompilerError1.ts, 5, 20))
 >advanceCount : Symbol(advanceCount, Decl(uncaughtCompilerError1.ts, 5, 40))
         }
@@ -31,6 +32,7 @@ function f() {
 >index : Symbol(index, Decl(uncaughtCompilerError1.ts, 0, 11))
 
             return { appendText: '\"\"', advanceCount: 1 };
+>{ appendText: '\"\"', advanceCount: 1 } : Symbol(, Decl(uncaughtCompilerError1.ts, 8, 18))
 >appendText : Symbol(appendText, Decl(uncaughtCompilerError1.ts, 8, 20))
 >advanceCount : Symbol(advanceCount, Decl(uncaughtCompilerError1.ts, 8, 40))
         }
diff --git a/tests/baselines/reference/undefinedArgumentInference.symbols b/tests/baselines/reference/undefinedArgumentInference.symbols
index da362bd66cca5..59e099ed98021 100644
--- a/tests/baselines/reference/undefinedArgumentInference.symbols
+++ b/tests/baselines/reference/undefinedArgumentInference.symbols
@@ -17,6 +17,7 @@ function foo1<T>(f1: { x: T; y: T }): T {
 var z1 = foo1({ x: undefined, y: undefined }); 
 >z1 : Symbol(z1, Decl(undefinedArgumentInference.ts, 6, 3))
 >foo1 : Symbol(foo1, Decl(undefinedArgumentInference.ts, 0, 0))
+>{ x: undefined, y: undefined } : Symbol(, Decl(undefinedArgumentInference.ts, 6, 14))
 >x : Symbol(x, Decl(undefinedArgumentInference.ts, 6, 15))
 >undefined : Symbol(undefined)
 >y : Symbol(y, Decl(undefinedArgumentInference.ts, 6, 29))
diff --git a/tests/baselines/reference/underscoreTest1.symbols b/tests/baselines/reference/underscoreTest1.symbols
index 128ce83051a64..c20bd6057358b 100644
--- a/tests/baselines/reference/underscoreTest1.symbols
+++ b/tests/baselines/reference/underscoreTest1.symbols
@@ -12,6 +12,7 @@ _.each([1, 2, 3], (num) => alert(num.toString()));
 >_.each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 394, 43), Decl(underscoreTest1_underscore.ts, 396, 77))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 394, 43), Decl(underscoreTest1_underscore.ts, 396, 77))
+>(num) => alert(num.toString()) : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 5, 17))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 5, 19))
 >alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
 >num.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
@@ -22,9 +23,11 @@ _.each({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => alert(valu
 >_.each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 394, 43), Decl(underscoreTest1_underscore.ts, 396, 77))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 394, 43), Decl(underscoreTest1_underscore.ts, 396, 77))
+>{ one: 1, two: 2, three: 3 } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 6, 7))
 >one : Symbol(one, Decl(underscoreTest1_underscoreTests.ts, 6, 8))
 >two : Symbol(two, Decl(underscoreTest1_underscoreTests.ts, 6, 16))
 >three : Symbol(three, Decl(underscoreTest1_underscoreTests.ts, 6, 24))
+>(value: number, key?: string) => alert(value.toString()) : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 6, 36))
 >value : Symbol(value, Decl(underscoreTest1_underscoreTests.ts, 6, 38))
 >key : Symbol(key, Decl(underscoreTest1_underscoreTests.ts, 6, 52))
 >alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
@@ -36,6 +39,7 @@ _.map([1, 2, 3], (num) => num * 3);
 >_.map : Symbol(Underscore.Static.map, Decl(underscoreTest1_underscore.ts, 399, 90), Decl(underscoreTest1_underscore.ts, 401, 75))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >map : Symbol(Underscore.Static.map, Decl(underscoreTest1_underscore.ts, 399, 90), Decl(underscoreTest1_underscore.ts, 401, 75))
+>(num) => num * 3 : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 8, 16))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 8, 18))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 8, 18))
 
@@ -43,9 +47,11 @@ _.map({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => value * 3);
 >_.map : Symbol(Underscore.Static.map, Decl(underscoreTest1_underscore.ts, 399, 90), Decl(underscoreTest1_underscore.ts, 401, 75))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >map : Symbol(Underscore.Static.map, Decl(underscoreTest1_underscore.ts, 399, 90), Decl(underscoreTest1_underscore.ts, 401, 75))
+>{ one: 1, two: 2, three: 3 } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 9, 6))
 >one : Symbol(one, Decl(underscoreTest1_underscoreTests.ts, 9, 7))
 >two : Symbol(two, Decl(underscoreTest1_underscoreTests.ts, 9, 15))
 >three : Symbol(three, Decl(underscoreTest1_underscoreTests.ts, 9, 23))
+>(value: number, key?: string) => value * 3 : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 9, 35))
 >value : Symbol(value, Decl(underscoreTest1_underscoreTests.ts, 9, 37))
 >key : Symbol(key, Decl(underscoreTest1_underscoreTests.ts, 9, 51))
 >value : Symbol(value, Decl(underscoreTest1_underscoreTests.ts, 9, 37))
@@ -55,6 +61,7 @@ var sum = _.reduce([1, 2, 3], (memo, num) => memo + num, 0);
 >_.reduce : Symbol(Underscore.Static.reduce, Decl(underscoreTest1_underscore.ts, 404, 89), Decl(underscoreTest1_underscore.ts, 406, 90), Decl(underscoreTest1_underscore.ts, 407, 92), Decl(underscoreTest1_underscore.ts, 408, 100))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >reduce : Symbol(Underscore.Static.reduce, Decl(underscoreTest1_underscore.ts, 404, 89), Decl(underscoreTest1_underscore.ts, 406, 90), Decl(underscoreTest1_underscore.ts, 407, 92), Decl(underscoreTest1_underscore.ts, 408, 100))
+>(memo, num) => memo + num : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 11, 29))
 >memo : Symbol(memo, Decl(underscoreTest1_underscoreTests.ts, 11, 31))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 11, 36))
 >memo : Symbol(memo, Decl(underscoreTest1_underscoreTests.ts, 11, 31))
@@ -69,6 +76,7 @@ var flat = _.reduceRight(list, (a, b) => a.concat(b), []);
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >reduceRight : Symbol(Underscore.Static.reduceRight, Decl(underscoreTest1_underscore.ts, 417, 102), Decl(underscoreTest1_underscore.ts, 419, 95), Decl(underscoreTest1_underscore.ts, 420, 97), Decl(underscoreTest1_underscore.ts, 421, 105))
 >list : Symbol(list, Decl(underscoreTest1_underscoreTests.ts, 13, 3))
+>(a, b) => a.concat(b) : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 14, 30))
 >a : Symbol(a, Decl(underscoreTest1_underscoreTests.ts, 14, 32))
 >b : Symbol(b, Decl(underscoreTest1_underscoreTests.ts, 14, 34))
 >a.concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
@@ -81,6 +89,7 @@ var even = _.find([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0);
 >_.find : Symbol(Underscore.Static.find, Decl(underscoreTest1_underscore.ts, 426, 101), Decl(underscoreTest1_underscore.ts, 428, 77))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >find : Symbol(Underscore.Static.find, Decl(underscoreTest1_underscore.ts, 426, 101), Decl(underscoreTest1_underscore.ts, 428, 77))
+>(num) => num % 2 == 0 : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 16, 37))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 16, 39))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 16, 39))
 
@@ -89,17 +98,21 @@ var evens = _.filter([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0);
 >_.filter : Symbol(Underscore.Static.filter, Decl(underscoreTest1_underscore.ts, 431, 89), Decl(underscoreTest1_underscore.ts, 433, 81))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >filter : Symbol(Underscore.Static.filter, Decl(underscoreTest1_underscore.ts, 431, 89), Decl(underscoreTest1_underscore.ts, 433, 81))
+>(num) => num % 2 == 0 : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 18, 40))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 18, 42))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 18, 42))
 
 var listOfPlays = [{ title: "Cymbeline", author: "Shakespeare", year: 1611 }, { title: "The Tempest", author: "Shakespeare", year: 1611 }, { title: "Other", author: "Not Shakespeare", year: 2012 }];
 >listOfPlays : Symbol(listOfPlays, Decl(underscoreTest1_underscoreTests.ts, 20, 3))
+>{ title: "Cymbeline", author: "Shakespeare", year: 1611 } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 20, 19))
 >title : Symbol(title, Decl(underscoreTest1_underscoreTests.ts, 20, 20))
 >author : Symbol(author, Decl(underscoreTest1_underscoreTests.ts, 20, 40))
 >year : Symbol(year, Decl(underscoreTest1_underscoreTests.ts, 20, 63))
+>{ title: "The Tempest", author: "Shakespeare", year: 1611 } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 20, 77))
 >title : Symbol(title, Decl(underscoreTest1_underscoreTests.ts, 20, 79))
 >author : Symbol(author, Decl(underscoreTest1_underscoreTests.ts, 20, 101))
 >year : Symbol(year, Decl(underscoreTest1_underscoreTests.ts, 20, 124))
+>{ title: "Other", author: "Not Shakespeare", year: 2012 } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 20, 138))
 >title : Symbol(title, Decl(underscoreTest1_underscoreTests.ts, 20, 140))
 >author : Symbol(author, Decl(underscoreTest1_underscoreTests.ts, 20, 156))
 >year : Symbol(year, Decl(underscoreTest1_underscoreTests.ts, 20, 183))
@@ -109,6 +122,7 @@ _.where(listOfPlays, { author: "Shakespeare", year: 1611 });
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >where : Symbol(Underscore.Static.where, Decl(underscoreTest1_underscore.ts, 436, 91), Decl(underscoreTest1_underscore.ts, 438, 53))
 >listOfPlays : Symbol(listOfPlays, Decl(underscoreTest1_underscoreTests.ts, 20, 3))
+>{ author: "Shakespeare", year: 1611 } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 21, 20))
 >author : Symbol(author, Decl(underscoreTest1_underscoreTests.ts, 21, 22))
 >year : Symbol(year, Decl(underscoreTest1_underscoreTests.ts, 21, 45))
 
@@ -117,6 +131,7 @@ var odds = _.reject([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0);
 >_.reject : Symbol(Underscore.Static.reject, Decl(underscoreTest1_underscore.ts, 442, 65), Decl(underscoreTest1_underscore.ts, 444, 81))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >reject : Symbol(Underscore.Static.reject, Decl(underscoreTest1_underscore.ts, 442, 65), Decl(underscoreTest1_underscore.ts, 444, 81))
+>(num) => num % 2 == 0 : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 23, 39))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 23, 41))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 23, 41))
 
@@ -145,10 +160,13 @@ _.invoke([[5, 1, 7], [3, 2, 1]], 'sort');
 
 var stooges = [{ name: 'moe', age: 40 }, { name: 'larry', age: 50 }, { name: 'curly', age: 60 }];
 >stooges : Symbol(stooges, Decl(underscoreTest1_underscoreTests.ts, 33, 3))
+>{ name: 'moe', age: 40 } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 33, 15))
 >name : Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 33, 16))
 >age : Symbol(age, Decl(underscoreTest1_underscoreTests.ts, 33, 29))
+>{ name: 'larry', age: 50 } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 33, 40))
 >name : Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 33, 42))
 >age : Symbol(age, Decl(underscoreTest1_underscoreTests.ts, 33, 57))
+>{ name: 'curly', age: 60 } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 33, 68))
 >name : Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 33, 70))
 >age : Symbol(age, Decl(underscoreTest1_underscoreTests.ts, 33, 85))
 
@@ -163,6 +181,7 @@ _.max(stooges, (stooge) => stooge.age);
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >max : Symbol(Underscore.Static.max, Decl(underscoreTest1_underscore.ts, 466, 66), Decl(underscoreTest1_underscore.ts, 468, 73))
 >stooges : Symbol(stooges, Decl(underscoreTest1_underscoreTests.ts, 33, 3))
+>(stooge) => stooge.age : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 36, 14))
 >stooge : Symbol(stooge, Decl(underscoreTest1_underscoreTests.ts, 36, 16))
 >stooge.age : Symbol(age, Decl(underscoreTest1_underscoreTests.ts, 33, 29))
 >stooge : Symbol(stooge, Decl(underscoreTest1_underscoreTests.ts, 36, 16))
@@ -181,6 +200,7 @@ _.sortBy([1, 2, 3, 4, 5, 6], (num) => Math.sin(num));
 >_.sortBy : Symbol(Underscore.Static.sortBy, Decl(underscoreTest1_underscore.ts, 472, 83), Decl(underscoreTest1_underscore.ts, 474, 77), Decl(underscoreTest1_underscore.ts, 475, 87), Decl(underscoreTest1_underscore.ts, 476, 56))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >sortBy : Symbol(Underscore.Static.sortBy, Decl(underscoreTest1_underscore.ts, 472, 83), Decl(underscoreTest1_underscore.ts, 474, 77), Decl(underscoreTest1_underscore.ts, 475, 87), Decl(underscoreTest1_underscore.ts, 476, 56))
+>(num) => Math.sin(num) : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 41, 28))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 41, 30))
 >Math.sin : Symbol(Math.sin, Decl(lib.d.ts, 615, 29))
 >Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
@@ -193,6 +213,7 @@ _([1.3, 2.1, 2.4]).groupBy((e: number, i?: number, list?: number[]) => Math.floo
 >_([1.3, 2.1, 2.4]).groupBy : Symbol(Underscore.WrappedArray.groupBy, Decl(underscoreTest1_underscore.ts, 112, 42), Decl(underscoreTest1_underscore.ts, 113, 77))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >groupBy : Symbol(Underscore.WrappedArray.groupBy, Decl(underscoreTest1_underscore.ts, 112, 42), Decl(underscoreTest1_underscore.ts, 113, 77))
+>(e: number, i?: number, list?: number[]) => Math.floor(e) : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 45, 27))
 >e : Symbol(e, Decl(underscoreTest1_underscoreTests.ts, 45, 28))
 >i : Symbol(i, Decl(underscoreTest1_underscoreTests.ts, 45, 38))
 >list : Symbol(list, Decl(underscoreTest1_underscoreTests.ts, 45, 50))
@@ -205,6 +226,7 @@ _.groupBy([1.3, 2.1, 2.4], (num: number) => Math.floor(num));
 >_.groupBy : Symbol(Underscore.Static.groupBy, Decl(underscoreTest1_underscore.ts, 477, 66), Decl(underscoreTest1_underscore.ts, 479, 91), Decl(underscoreTest1_underscore.ts, 480, 101), Decl(underscoreTest1_underscore.ts, 481, 69))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >groupBy : Symbol(Underscore.Static.groupBy, Decl(underscoreTest1_underscore.ts, 477, 66), Decl(underscoreTest1_underscore.ts, 479, 91), Decl(underscoreTest1_underscore.ts, 480, 101), Decl(underscoreTest1_underscore.ts, 481, 69))
+>(num: number) => Math.floor(num) : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 46, 26))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 46, 28))
 >Math.floor : Symbol(Math.floor, Decl(lib.d.ts, 582, 27))
 >Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
@@ -220,6 +242,7 @@ _.countBy([1, 2, 3, 4, 5], (num) => num % 2 == 0 ? 'even' : 'odd');
 >_.countBy : Symbol(Underscore.Static.countBy, Decl(underscoreTest1_underscore.ts, 482, 79), Decl(underscoreTest1_underscore.ts, 484, 94), Decl(underscoreTest1_underscore.ts, 485, 104), Decl(underscoreTest1_underscore.ts, 486, 72))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >countBy : Symbol(Underscore.Static.countBy, Decl(underscoreTest1_underscore.ts, 482, 79), Decl(underscoreTest1_underscore.ts, 484, 94), Decl(underscoreTest1_underscore.ts, 485, 104), Decl(underscoreTest1_underscore.ts, 486, 72))
+>(num) => num % 2 == 0 ? 'even' : 'odd' : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 49, 26))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 49, 28))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 49, 28))
 
@@ -234,6 +257,7 @@ _.size({ one: 1, two: 2, three: 3 });
 >_.size : Symbol(Underscore.Static.size, Decl(underscoreTest1_underscore.ts, 493, 45), Decl(underscoreTest1_underscore.ts, 495, 35))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >size : Symbol(Underscore.Static.size, Decl(underscoreTest1_underscore.ts, 493, 45), Decl(underscoreTest1_underscore.ts, 495, 35))
+>{ one: 1, two: 2, three: 3 } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 55, 7))
 >one : Symbol(one, Decl(underscoreTest1_underscoreTests.ts, 55, 8))
 >two : Symbol(two, Decl(underscoreTest1_underscoreTests.ts, 55, 16))
 >three : Symbol(three, Decl(underscoreTest1_underscoreTests.ts, 55, 24))
@@ -370,6 +394,7 @@ _.range(0);
 
 var func = function (greeting) { return greeting + ': ' + this.name };
 >func : Symbol(func, Decl(underscoreTest1_underscoreTests.ts, 90, 3))
+>function (greeting) { return greeting + ': ' + this.name } : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 90, 10))
 >greeting : Symbol(greeting, Decl(underscoreTest1_underscoreTests.ts, 90, 21))
 >greeting : Symbol(greeting, Decl(underscoreTest1_underscoreTests.ts, 90, 21))
 
@@ -381,6 +406,7 @@ var func2 = _.bind(func, { name: 'moe' }, 'hi');
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >bind : Symbol(Underscore.Static.bind, Decl(underscoreTest1_underscore.ts, 547, 68), Decl(underscoreTest1_underscore.ts, 549, 58))
 >func : Symbol(func, Decl(underscoreTest1_underscoreTests.ts, 90, 3))
+>{ name: 'moe' } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 93, 24))
 >name : Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 93, 26))
 
 func2();
@@ -388,16 +414,19 @@ func2();
 
 var buttonView = {
 >buttonView : Symbol(buttonView, Decl(underscoreTest1_underscoreTests.ts, 96, 3))
+>{    label: 'underscore',    onClick: function () { alert('clicked: ' + this.label); },    onHover: function () { alert('hovering: ' + this.label); }} : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 96, 16))
 
     label: 'underscore',
 >label : Symbol(label, Decl(underscoreTest1_underscoreTests.ts, 96, 18))
 
     onClick: function () { alert('clicked: ' + this.label); },
 >onClick : Symbol(onClick, Decl(underscoreTest1_underscoreTests.ts, 97, 24))
+>function () { alert('clicked: ' + this.label); } : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 98, 12))
 >alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
 
     onHover: function () { alert('hovering: ' + this.label); }
 >onHover : Symbol(onHover, Decl(underscoreTest1_underscoreTests.ts, 98, 62))
+>function () { alert('hovering: ' + this.label); } : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 99, 12))
 >alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
 
 };
@@ -418,6 +447,7 @@ var fibonacci = _.memoize(function (n) {
 >_.memoize : Symbol(Underscore.Static.memoize, Decl(underscoreTest1_underscore.ts, 554, 58))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >memoize : Symbol(Underscore.Static.memoize, Decl(underscoreTest1_underscore.ts, 554, 58))
+>function (n) {    return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);} : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 104, 26))
 >n : Symbol(n, Decl(underscoreTest1_underscoreTests.ts, 104, 36))
 
     return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);
@@ -435,6 +465,7 @@ var log = _.bind((message?: string, ...rest: string[]) => { }, Date);
 >_.bind : Symbol(Underscore.Static.bind, Decl(underscoreTest1_underscore.ts, 547, 68), Decl(underscoreTest1_underscore.ts, 549, 58))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >bind : Symbol(Underscore.Static.bind, Decl(underscoreTest1_underscore.ts, 547, 68), Decl(underscoreTest1_underscore.ts, 549, 58))
+>(message?: string, ...rest: string[]) => { } : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 108, 17))
 >message : Symbol(message, Decl(underscoreTest1_underscoreTests.ts, 108, 18))
 >rest : Symbol(rest, Decl(underscoreTest1_underscoreTests.ts, 108, 35))
 >Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
@@ -449,10 +480,12 @@ _.defer(function () { alert('deferred'); });
 >_.defer : Symbol(Underscore.Static.defer, Decl(underscoreTest1_underscore.ts, 558, 68))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >defer : Symbol(Underscore.Static.defer, Decl(underscoreTest1_underscore.ts, 558, 68))
+>function () { alert('deferred'); } : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 111, 8))
 >alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
 
 var updatePosition = () => alert('updating position...');
 >updatePosition : Symbol(updatePosition, Decl(underscoreTest1_underscoreTests.ts, 113, 3))
+>() => alert('updating position...') : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 113, 20))
 >alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
 
 var throttled = _.throttle(updatePosition, 100);
@@ -468,6 +501,7 @@ $(null).scroll(throttled);
 
 var calculateLayout = () => alert('calculating layout...');
 >calculateLayout : Symbol(calculateLayout, Decl(underscoreTest1_underscoreTests.ts, 117, 3))
+>() => alert('calculating layout...') : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 117, 21))
 >alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
 
 var lazyLayout = _.debounce(calculateLayout, 300);
@@ -483,6 +517,7 @@ $(null).resize(lazyLayout);
 
 var createApplication = () => alert('creating application...');
 >createApplication : Symbol(createApplication, Decl(underscoreTest1_underscoreTests.ts, 121, 3))
+>() => alert('creating application...') : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 121, 23))
 >alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
 
 var initialize = _.once(createApplication);
@@ -503,6 +538,7 @@ var notes: any[];
 
 var render = () => alert("rendering...");
 >render : Symbol(render, Decl(underscoreTest1_underscoreTests.ts, 127, 3))
+>() => alert("rendering...") : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 127, 12))
 >alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
 
 var renderNotes = _.after(notes.length, render);
@@ -520,13 +556,16 @@ _.each(notes, (note) => note.asyncSave({ success: renderNotes }));
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 394, 43), Decl(underscoreTest1_underscore.ts, 396, 77))
 >notes : Symbol(notes, Decl(underscoreTest1_underscoreTests.ts, 126, 3))
+>(note) => note.asyncSave({ success: renderNotes }) : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 129, 13))
 >note : Symbol(note, Decl(underscoreTest1_underscoreTests.ts, 129, 15))
 >note : Symbol(note, Decl(underscoreTest1_underscoreTests.ts, 129, 15))
+>{ success: renderNotes } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 129, 39))
 >success : Symbol(success, Decl(underscoreTest1_underscoreTests.ts, 129, 40))
 >renderNotes : Symbol(renderNotes, Decl(underscoreTest1_underscoreTests.ts, 128, 3))
 
 var hello = function (name) { return "hello: " + name; };
 >hello : Symbol(hello, Decl(underscoreTest1_underscoreTests.ts, 131, 3))
+>function (name) { return "hello: " + name; } : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 131, 11))
 >name : Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 131, 22))
 >name : Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 131, 22))
 
@@ -536,6 +575,7 @@ hello = _.wrap(hello, (func, arg) => { return "before, " + func(arg) + ", after"
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >wrap : Symbol(Underscore.Static.wrap, Decl(underscoreTest1_underscore.ts, 568, 61))
 >hello : Symbol(hello, Decl(underscoreTest1_underscoreTests.ts, 131, 3))
+>(func, arg) => { return "before, " + func(arg) + ", after"; } : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 132, 21))
 >func : Symbol(func, Decl(underscoreTest1_underscoreTests.ts, 132, 23))
 >arg : Symbol(arg, Decl(underscoreTest1_underscoreTests.ts, 132, 28))
 >func : Symbol(func, Decl(underscoreTest1_underscoreTests.ts, 132, 23))
@@ -546,11 +586,13 @@ hello("moe");
 
 var greet = function (name) { return "hi: " + name; };
 >greet : Symbol(greet, Decl(underscoreTest1_underscoreTests.ts, 135, 3))
+>function (name) { return "hi: " + name; } : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 135, 11))
 >name : Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 135, 22))
 >name : Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 135, 22))
 
 var exclaim = function (statement) { return statement + "!"; };
 >exclaim : Symbol(exclaim, Decl(underscoreTest1_underscoreTests.ts, 136, 3))
+>function (statement) { return statement + "!"; } : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 136, 13))
 >statement : Symbol(statement, Decl(underscoreTest1_underscoreTests.ts, 136, 24))
 >statement : Symbol(statement, Decl(underscoreTest1_underscoreTests.ts, 136, 24))
 
@@ -571,6 +613,7 @@ _.keys({ one: 1, two: 2, three: 3 });
 >_.keys : Symbol(Underscore.Static.keys, Decl(underscoreTest1_underscore.ts, 572, 48))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >keys : Symbol(Underscore.Static.keys, Decl(underscoreTest1_underscore.ts, 572, 48))
+>{ one: 1, two: 2, three: 3 } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 142, 7))
 >one : Symbol(one, Decl(underscoreTest1_underscoreTests.ts, 142, 8))
 >two : Symbol(two, Decl(underscoreTest1_underscoreTests.ts, 142, 16))
 >three : Symbol(three, Decl(underscoreTest1_underscoreTests.ts, 142, 24))
@@ -579,6 +622,7 @@ _.values({ one: 1, two: 2, three: 3 });
 >_.values : Symbol(Underscore.Static.values, Decl(underscoreTest1_underscore.ts, 574, 36))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >values : Symbol(Underscore.Static.values, Decl(underscoreTest1_underscore.ts, 574, 36))
+>{ one: 1, two: 2, three: 3 } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 143, 9))
 >one : Symbol(one, Decl(underscoreTest1_underscoreTests.ts, 143, 10))
 >two : Symbol(two, Decl(underscoreTest1_underscoreTests.ts, 143, 18))
 >three : Symbol(three, Decl(underscoreTest1_underscoreTests.ts, 143, 26))
@@ -587,6 +631,7 @@ _.pairs({ one: 1, two: 2, three: 3 });
 >_.pairs : Symbol(Underscore.Static.pairs, Decl(underscoreTest1_underscore.ts, 576, 35))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >pairs : Symbol(Underscore.Static.pairs, Decl(underscoreTest1_underscore.ts, 576, 35))
+>{ one: 1, two: 2, three: 3 } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 144, 8))
 >one : Symbol(one, Decl(underscoreTest1_underscoreTests.ts, 144, 9))
 >two : Symbol(two, Decl(underscoreTest1_underscoreTests.ts, 144, 17))
 >three : Symbol(three, Decl(underscoreTest1_underscoreTests.ts, 144, 25))
@@ -595,6 +640,7 @@ _.invert({ Moe: "Moses", Larry: "Louis", Curly: "Jerome" });
 >_.invert : Symbol(Underscore.Static.invert, Decl(underscoreTest1_underscore.ts, 578, 36))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >invert : Symbol(Underscore.Static.invert, Decl(underscoreTest1_underscore.ts, 578, 36))
+>{ Moe: "Moses", Larry: "Louis", Curly: "Jerome" } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 145, 9))
 >Moe : Symbol(Moe, Decl(underscoreTest1_underscoreTests.ts, 145, 10))
 >Larry : Symbol(Larry, Decl(underscoreTest1_underscoreTests.ts, 145, 24))
 >Curly : Symbol(Curly, Decl(underscoreTest1_underscoreTests.ts, 145, 40))
@@ -609,13 +655,16 @@ _.extend({ name: 'moe' }, { age: 50 });
 >_.extend : Symbol(Underscore.Static.extend, Decl(underscoreTest1_underscore.ts, 583, 39))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >extend : Symbol(Underscore.Static.extend, Decl(underscoreTest1_underscore.ts, 583, 39))
+>{ name: 'moe' } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 147, 9))
 >name : Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 147, 10))
+>{ age: 50 } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 147, 25))
 >age : Symbol(age, Decl(underscoreTest1_underscoreTests.ts, 147, 27))
 
 _.pick({ name: 'moe', age: 50, userid: 'moe1' }, 'name', 'age');
 >_.pick : Symbol(Underscore.Static.pick, Decl(underscoreTest1_underscore.ts, 585, 56))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >pick : Symbol(Underscore.Static.pick, Decl(underscoreTest1_underscore.ts, 585, 56))
+>{ name: 'moe', age: 50, userid: 'moe1' } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 148, 7))
 >name : Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 148, 8))
 >age : Symbol(age, Decl(underscoreTest1_underscoreTests.ts, 148, 21))
 >userid : Symbol(userid, Decl(underscoreTest1_underscoreTests.ts, 148, 30))
@@ -624,12 +673,14 @@ _.omit({ name: 'moe', age: 50, userid: 'moe1' }, 'userid');
 >_.omit : Symbol(Underscore.Static.omit, Decl(underscoreTest1_underscore.ts, 587, 49))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >omit : Symbol(Underscore.Static.omit, Decl(underscoreTest1_underscore.ts, 587, 49))
+>{ name: 'moe', age: 50, userid: 'moe1' } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 149, 7))
 >name : Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 149, 8))
 >age : Symbol(age, Decl(underscoreTest1_underscoreTests.ts, 149, 21))
 >userid : Symbol(userid, Decl(underscoreTest1_underscoreTests.ts, 149, 30))
 
 var iceCream = { flavor: "chocolate" };
 >iceCream : Symbol(iceCream, Decl(underscoreTest1_underscoreTests.ts, 151, 3))
+>{ flavor: "chocolate" } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 151, 14))
 >flavor : Symbol(flavor, Decl(underscoreTest1_underscoreTests.ts, 151, 16))
 
 _.defaults(iceCream, { flavor: "vanilla", sprinkles: "lots" });
@@ -637,6 +688,7 @@ _.defaults(iceCream, { flavor: "vanilla", sprinkles: "lots" });
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >defaults : Symbol(Underscore.Static.defaults, Decl(underscoreTest1_underscore.ts, 589, 49))
 >iceCream : Symbol(iceCream, Decl(underscoreTest1_underscoreTests.ts, 151, 3))
+>{ flavor: "vanilla", sprinkles: "lots" } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 152, 20))
 >flavor : Symbol(flavor, Decl(underscoreTest1_underscoreTests.ts, 152, 22))
 >sprinkles : Symbol(sprinkles, Decl(underscoreTest1_underscoreTests.ts, 152, 41))
 
@@ -644,6 +696,7 @@ _.clone({ name: 'moe' });
 >_.clone : Symbol(Underscore.Static.clone, Decl(underscoreTest1_underscore.ts, 591, 54))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >clone : Symbol(Underscore.Static.clone, Decl(underscoreTest1_underscore.ts, 591, 54))
+>{ name: 'moe' } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 154, 8))
 >name : Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 154, 9))
 
 _.chain([1, 2, 3, 200])
@@ -657,6 +710,7 @@ _.chain([1, 2, 3, 200])
 
     .filter(function (num) { return num % 2 == 0; })
 >filter : Symbol(Underscore.ChainedArray.filter, Decl(underscoreTest1_underscore.ts, 254, 80))
+>function (num) { return num % 2 == 0; } : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 157, 12))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 157, 22))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 157, 22))
 
@@ -666,6 +720,7 @@ _.chain([1, 2, 3, 200])
 
     .map(function (num) { return num * num })
 >map : Symbol(Underscore.ChainedArray.map, Decl(underscoreTest1_underscore.ts, 240, 81))
+>function (num) { return num * num } : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 159, 9))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 159, 19))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 159, 19))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 159, 19))
@@ -677,17 +732,20 @@ _.has({ a: 1, b: 2, c: 3 }, "b");
 >_.has : Symbol(Underscore.Static.has, Decl(underscoreTest1_underscore.ts, 595, 63))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >has : Symbol(Underscore.Static.has, Decl(underscoreTest1_underscore.ts, 595, 63))
+>{ a: 1, b: 2, c: 3 } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 162, 6))
 >a : Symbol(a, Decl(underscoreTest1_underscoreTests.ts, 162, 7))
 >b : Symbol(b, Decl(underscoreTest1_underscoreTests.ts, 162, 13))
 >c : Symbol(c, Decl(underscoreTest1_underscoreTests.ts, 162, 19))
 
 var moe = { name: 'moe', luckyNumbers: [13, 27, 34] };
 >moe : Symbol(moe, Decl(underscoreTest1_underscoreTests.ts, 164, 3))
+>{ name: 'moe', luckyNumbers: [13, 27, 34] } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 164, 9))
 >name : Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 164, 11))
 >luckyNumbers : Symbol(luckyNumbers, Decl(underscoreTest1_underscoreTests.ts, 164, 24))
 
 var clone = { name: 'moe', luckyNumbers: [13, 27, 34] };
 >clone : Symbol(clone, Decl(underscoreTest1_underscoreTests.ts, 165, 3))
+>{ name: 'moe', luckyNumbers: [13, 27, 34] } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 165, 11))
 >name : Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 165, 13))
 >luckyNumbers : Symbol(luckyNumbers, Decl(underscoreTest1_underscoreTests.ts, 165, 26))
 
@@ -711,6 +769,7 @@ _.isEmpty({});
 >_.isEmpty : Symbol(Underscore.Static.isEmpty, Decl(underscoreTest1_underscore.ts, 599, 49))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >isEmpty : Symbol(Underscore.Static.isEmpty, Decl(underscoreTest1_underscore.ts, 599, 49))
+>{} : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 170, 10))
 
 _.isElement($('body')[0]);
 >_.isElement : Symbol(Underscore.Static.isElement, Decl(underscoreTest1_underscore.ts, 601, 38))
@@ -719,6 +778,7 @@ _.isElement($('body')[0]);
 >$ : Symbol($, Decl(underscoreTest1_underscoreTests.ts, 2, 11))
 
 (function () { return _.isArray(arguments); })();
+>function () { return _.isArray(arguments); } : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 174, 1))
 >_.isArray : Symbol(Underscore.Static.isArray, Decl(underscoreTest1_underscore.ts, 602, 40))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >isArray : Symbol(Underscore.Static.isArray, Decl(underscoreTest1_underscore.ts, 602, 40))
@@ -733,6 +793,7 @@ _.isObject({});
 >_.isObject : Symbol(Underscore.Static.isObject, Decl(underscoreTest1_underscore.ts, 603, 38))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >isObject : Symbol(Underscore.Static.isObject, Decl(underscoreTest1_underscore.ts, 603, 38))
+>{} : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 177, 11))
 
 _.isObject(1);
 >_.isObject : Symbol(Underscore.Static.isObject, Decl(underscoreTest1_underscore.ts, 603, 38))
@@ -831,6 +892,7 @@ var underscore = _.noConflict();
 
 var moe2 = { name: 'moe' };
 >moe2 : Symbol(moe2, Decl(underscoreTest1_underscoreTests.ts, 213, 3))
+>{ name: 'moe' } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 213, 10))
 >name : Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 213, 12))
 
 moe2 === _.identity(moe);
@@ -847,6 +909,7 @@ _.times(3, function (n) { genie.grantWishNumber(n); });
 >_.times : Symbol(Underscore.Static.times, Decl(underscoreTest1_underscore.ts, 619, 33))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >times : Symbol(Underscore.Static.times, Decl(underscoreTest1_underscore.ts, 619, 33))
+>function (n) { genie.grantWishNumber(n); } : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 218, 10))
 >n : Symbol(n, Decl(underscoreTest1_underscoreTests.ts, 218, 21))
 >genie : Symbol(genie, Decl(underscoreTest1_underscoreTests.ts, 216, 3))
 >n : Symbol(n, Decl(underscoreTest1_underscoreTests.ts, 218, 21))
@@ -860,9 +923,11 @@ _.mixin({
 >_.mixin : Symbol(Underscore.Static.mixin, Decl(underscoreTest1_underscore.ts, 624, 49))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >mixin : Symbol(Underscore.Static.mixin, Decl(underscoreTest1_underscore.ts, 624, 49))
+>{    capitalize: function (string) {        return string.charAt(0).toUpperCase() + string.substring(1).toLowerCase();    }} : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 222, 8))
 
     capitalize: function (string) {
 >capitalize : Symbol(capitalize, Decl(underscoreTest1_underscoreTests.ts, 222, 9))
+>function (string) {        return string.charAt(0).toUpperCase() + string.substring(1).toLowerCase();    } : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 223, 15))
 >string : Symbol(string, Decl(underscoreTest1_underscoreTests.ts, 223, 26))
 
         return string.charAt(0).toUpperCase() + string.substring(1).toLowerCase();
@@ -885,8 +950,10 @@ _.escape('Curly, Larry & Moe');
 
 var object = { cheese: 'crumpets', stuff: function () { return 'nonsense'; } };
 >object : Symbol(object, Decl(underscoreTest1_underscoreTests.ts, 233, 3))
+>{ cheese: 'crumpets', stuff: function () { return 'nonsense'; } } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 233, 12))
 >cheese : Symbol(cheese, Decl(underscoreTest1_underscoreTests.ts, 233, 14))
 >stuff : Symbol(stuff, Decl(underscoreTest1_underscoreTests.ts, 233, 34))
+>function () { return 'nonsense'; } : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 233, 41))
 
 _.result(object, 'cheese');
 >_.result : Symbol(Underscore.Static.result, Decl(underscoreTest1_underscore.ts, 633, 36))
@@ -908,6 +975,7 @@ var compiled = _.template("hello: <%= name %>");
 
 compiled({ name: 'moe' });
 >compiled : Symbol(compiled, Decl(underscoreTest1_underscoreTests.ts, 238, 3))
+>{ name: 'moe' } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 239, 9))
 >name : Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 239, 10))
 
 var list2 = "<% _.each(people, function(name) { %> <li><%= name %></li> <% }); %>";
@@ -918,6 +986,7 @@ _.template(list2, { people: ['moe', 'curly', 'larry'] });
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >template : Symbol(Underscore.Static.template, Decl(underscoreTest1_underscore.ts, 637, 43), Decl(underscoreTest1_underscore.ts, 639, 64))
 >list2 : Symbol(list2, Decl(underscoreTest1_underscoreTests.ts, 240, 3))
+>{ people: ['moe', 'curly', 'larry'] } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 241, 17))
 >people : Symbol(people, Decl(underscoreTest1_underscoreTests.ts, 241, 19))
 
 var template = _.template("<b><%- value %></b>");
@@ -928,6 +997,7 @@ var template = _.template("<b><%- value %></b>");
 
 template({ value: '<script>' });
 >template : Symbol(template, Decl(underscoreTest1_underscoreTests.ts, 242, 3))
+>{ value: '<script>' } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 243, 9))
 >value : Symbol(value, Decl(underscoreTest1_underscoreTests.ts, 243, 10))
 
 var compiled2 = _.template("<% print('Hello ' + epithet); %>");
@@ -938,12 +1008,14 @@ var compiled2 = _.template("<% print('Hello ' + epithet); %>");
 
 compiled2({ epithet: "stooge" });
 >compiled2 : Symbol(compiled2, Decl(underscoreTest1_underscoreTests.ts, 244, 3))
+>{ epithet: "stooge" } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 245, 10))
 >epithet : Symbol(epithet, Decl(underscoreTest1_underscoreTests.ts, 245, 11))
 
 _.templateSettings = {
 >_.templateSettings : Symbol(Underscore.Static.templateSettings, Decl(underscoreTest1_underscore.ts, 635, 51))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >templateSettings : Symbol(Underscore.Static.templateSettings, Decl(underscoreTest1_underscore.ts, 635, 51))
+>{    interpolate: /\{\{(.+?)\}\}/g} : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 246, 20))
 
     interpolate: /\{\{(.+?)\}\}/g
 >interpolate : Symbol(interpolate, Decl(underscoreTest1_underscoreTests.ts, 246, 22))
@@ -957,13 +1029,16 @@ var template2 = _.template("Hello {{ name }}!");
 
 template2({ name: "Mustache" });
 >template2 : Symbol(template2, Decl(underscoreTest1_underscoreTests.ts, 249, 3))
+>{ name: "Mustache" } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 250, 10))
 >name : Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 250, 11))
 
 _.template("Using 'with': <%= data.answer %>", { answer: 'no' }, { variable: 'data' });
 >_.template : Symbol(Underscore.Static.template, Decl(underscoreTest1_underscore.ts, 637, 43), Decl(underscoreTest1_underscore.ts, 639, 64))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >template : Symbol(Underscore.Static.template, Decl(underscoreTest1_underscore.ts, 637, 43), Decl(underscoreTest1_underscore.ts, 639, 64))
+>{ answer: 'no' } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 251, 46))
 >answer : Symbol(answer, Decl(underscoreTest1_underscoreTests.ts, 251, 48))
+>{ variable: 'data' } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 251, 64))
 >variable : Symbol(variable, Decl(underscoreTest1_underscoreTests.ts, 251, 66))
 
 === tests/cases/compiler/underscoreTest1_underscore.ts ===
diff --git a/tests/baselines/reference/untypedArgumentInLambdaExpression.symbols b/tests/baselines/reference/untypedArgumentInLambdaExpression.symbols
index bbcb223cb85c0..c55048a3e5b81 100644
--- a/tests/baselines/reference/untypedArgumentInLambdaExpression.symbols
+++ b/tests/baselines/reference/untypedArgumentInLambdaExpression.symbols
@@ -6,6 +6,7 @@ declare function f(fn: (a: string) => string);
  
 f((input): string => {
 >f : Symbol(f, Decl(untypedArgumentInLambdaExpression.ts, 0, 0))
+>(input): string => {    return "." + input;} : Symbol((Anonymous function), Decl(untypedArgumentInLambdaExpression.ts, 2, 2))
 >input : Symbol(input, Decl(untypedArgumentInLambdaExpression.ts, 2, 3))
 
     return "." + input;
diff --git a/tests/baselines/reference/unusedImportDeclaration.symbols b/tests/baselines/reference/unusedImportDeclaration.symbols
index 5506c4ad6b67c..85689196bc57c 100644
--- a/tests/baselines/reference/unusedImportDeclaration.symbols
+++ b/tests/baselines/reference/unusedImportDeclaration.symbols
@@ -5,6 +5,7 @@ import B = require("unusedImportDeclaration_testerB");
 var thingy: B = {
 >thingy : Symbol(thingy, Decl(unusedImportDeclaration_testerA.ts, 1, 3))
 >B : Symbol(B, Decl(unusedImportDeclaration_testerA.ts, 0, 0))
+>{    me: "A"} : Symbol(, Decl(unusedImportDeclaration_testerA.ts, 1, 15))
 
     me: "A"
 >me : Symbol(me, Decl(unusedImportDeclaration_testerA.ts, 1, 17))
diff --git a/tests/baselines/reference/validMultipleVariableDeclarations.symbols b/tests/baselines/reference/validMultipleVariableDeclarations.symbols
index 467c061c6fa88..88cf2cf6c3d9c 100644
--- a/tests/baselines/reference/validMultipleVariableDeclarations.symbols
+++ b/tests/baselines/reference/validMultipleVariableDeclarations.symbols
@@ -37,18 +37,21 @@ var p: Point;
 
 var p = { x: 1, y: 2 };
 >p : Symbol(p, Decl(validMultipleVariableDeclarations.ts, 17, 3), Decl(validMultipleVariableDeclarations.ts, 18, 3), Decl(validMultipleVariableDeclarations.ts, 19, 3), Decl(validMultipleVariableDeclarations.ts, 20, 3), Decl(validMultipleVariableDeclarations.ts, 21, 3), Decl(validMultipleVariableDeclarations.ts, 22, 3), Decl(validMultipleVariableDeclarations.ts, 23, 3))
+>{ x: 1, y: 2 } : Symbol(, Decl(validMultipleVariableDeclarations.ts, 18, 7))
 >x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 18, 9))
 >y : Symbol(y, Decl(validMultipleVariableDeclarations.ts, 18, 15))
 
 var p: Point = { x: 0, y: undefined };
 >p : Symbol(p, Decl(validMultipleVariableDeclarations.ts, 17, 3), Decl(validMultipleVariableDeclarations.ts, 18, 3), Decl(validMultipleVariableDeclarations.ts, 19, 3), Decl(validMultipleVariableDeclarations.ts, 20, 3), Decl(validMultipleVariableDeclarations.ts, 21, 3), Decl(validMultipleVariableDeclarations.ts, 22, 3), Decl(validMultipleVariableDeclarations.ts, 23, 3))
 >Point : Symbol(Point, Decl(validMultipleVariableDeclarations.ts, 13, 1))
+>{ x: 0, y: undefined } : Symbol(, Decl(validMultipleVariableDeclarations.ts, 19, 14))
 >x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 19, 16))
 >y : Symbol(y, Decl(validMultipleVariableDeclarations.ts, 19, 22))
 >undefined : Symbol(undefined)
 
 var p = { x: 1, y: <number>undefined };
 >p : Symbol(p, Decl(validMultipleVariableDeclarations.ts, 17, 3), Decl(validMultipleVariableDeclarations.ts, 18, 3), Decl(validMultipleVariableDeclarations.ts, 19, 3), Decl(validMultipleVariableDeclarations.ts, 20, 3), Decl(validMultipleVariableDeclarations.ts, 21, 3), Decl(validMultipleVariableDeclarations.ts, 22, 3), Decl(validMultipleVariableDeclarations.ts, 23, 3))
+>{ x: 1, y: <number>undefined } : Symbol(, Decl(validMultipleVariableDeclarations.ts, 20, 7))
 >x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 20, 9))
 >y : Symbol(y, Decl(validMultipleVariableDeclarations.ts, 20, 15))
 >undefined : Symbol(undefined)
@@ -57,6 +60,7 @@ var p: { x: number; y: number; } = { x: 1, y: 2 };
 >p : Symbol(p, Decl(validMultipleVariableDeclarations.ts, 17, 3), Decl(validMultipleVariableDeclarations.ts, 18, 3), Decl(validMultipleVariableDeclarations.ts, 19, 3), Decl(validMultipleVariableDeclarations.ts, 20, 3), Decl(validMultipleVariableDeclarations.ts, 21, 3), Decl(validMultipleVariableDeclarations.ts, 22, 3), Decl(validMultipleVariableDeclarations.ts, 23, 3))
 >x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 21, 8))
 >y : Symbol(y, Decl(validMultipleVariableDeclarations.ts, 21, 19))
+>{ x: 1, y: 2 } : Symbol(, Decl(validMultipleVariableDeclarations.ts, 21, 34))
 >x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 21, 36))
 >y : Symbol(y, Decl(validMultipleVariableDeclarations.ts, 21, 42))
 
@@ -64,6 +68,7 @@ var p = <{ x: number; y: number; }>{ x: 0, y: undefined };
 >p : Symbol(p, Decl(validMultipleVariableDeclarations.ts, 17, 3), Decl(validMultipleVariableDeclarations.ts, 18, 3), Decl(validMultipleVariableDeclarations.ts, 19, 3), Decl(validMultipleVariableDeclarations.ts, 20, 3), Decl(validMultipleVariableDeclarations.ts, 21, 3), Decl(validMultipleVariableDeclarations.ts, 22, 3), Decl(validMultipleVariableDeclarations.ts, 23, 3))
 >x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 22, 10))
 >y : Symbol(y, Decl(validMultipleVariableDeclarations.ts, 22, 21))
+>{ x: 0, y: undefined } : Symbol(, Decl(validMultipleVariableDeclarations.ts, 22, 35))
 >x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 22, 36))
 >y : Symbol(y, Decl(validMultipleVariableDeclarations.ts, 22, 42))
 >undefined : Symbol(undefined)
@@ -74,10 +79,12 @@ var p: typeof p;
 
 var fn = function (s: string) { return 42; }
 >fn : Symbol(fn, Decl(validMultipleVariableDeclarations.ts, 25, 3), Decl(validMultipleVariableDeclarations.ts, 26, 3), Decl(validMultipleVariableDeclarations.ts, 27, 3), Decl(validMultipleVariableDeclarations.ts, 28, 3), Decl(validMultipleVariableDeclarations.ts, 29, 3), Decl(validMultipleVariableDeclarations.ts, 30, 3))
+>function (s: string) { return 42; } : Symbol((Anonymous function), Decl(validMultipleVariableDeclarations.ts, 25, 8))
 >s : Symbol(s, Decl(validMultipleVariableDeclarations.ts, 25, 19))
 
 var fn = (s: string) => 3;
 >fn : Symbol(fn, Decl(validMultipleVariableDeclarations.ts, 25, 3), Decl(validMultipleVariableDeclarations.ts, 26, 3), Decl(validMultipleVariableDeclarations.ts, 27, 3), Decl(validMultipleVariableDeclarations.ts, 28, 3), Decl(validMultipleVariableDeclarations.ts, 29, 3), Decl(validMultipleVariableDeclarations.ts, 30, 3))
+>(s: string) => 3 : Symbol((Anonymous function), Decl(validMultipleVariableDeclarations.ts, 26, 8))
 >s : Symbol(s, Decl(validMultipleVariableDeclarations.ts, 26, 10))
 
 var fn: (s: string) => number;
diff --git a/tests/baselines/reference/validUseOfThisInSuper.symbols b/tests/baselines/reference/validUseOfThisInSuper.symbols
index 2e71c859a4fee..8129586088d16 100644
--- a/tests/baselines/reference/validUseOfThisInSuper.symbols
+++ b/tests/baselines/reference/validUseOfThisInSuper.symbols
@@ -14,6 +14,7 @@ class Super extends Base {
     constructor() {
         super((() => this)()); // ok since this is not the case: The constructor declares parameter properties or the containing class declares instance member variables with initializers.
 >super : Symbol(Base, Decl(validUseOfThisInSuper.ts, 0, 0))
+>() => this : Symbol((Anonymous function), Decl(validUseOfThisInSuper.ts, 6, 15))
 >this : Symbol(Super, Decl(validUseOfThisInSuper.ts, 3, 1))
     }
 }
diff --git a/tests/baselines/reference/varArgParamTypeCheck.symbols b/tests/baselines/reference/varArgParamTypeCheck.symbols
index b87afc740e36e..1fc8930ae4519 100644
--- a/tests/baselines/reference/varArgParamTypeCheck.symbols
+++ b/tests/baselines/reference/varArgParamTypeCheck.symbols
@@ -13,23 +13,28 @@ sequence(
 >sequence : Symbol(sequence, Decl(varArgParamTypeCheck.ts, 0, 0))
 
     function bar() {
+>function bar() {    } : Symbol(bar, Decl(varArgParamTypeCheck.ts, 6, 9))
 >bar : Symbol(bar, Decl(varArgParamTypeCheck.ts, 6, 9))
 
     },
     function foo() {
+>function foo() {        callback(()=>{            this();        });    } : Symbol(foo, Decl(varArgParamTypeCheck.ts, 8, 6))
 >foo : Symbol(foo, Decl(varArgParamTypeCheck.ts, 8, 6))
 
         callback(()=>{
 >callback : Symbol(callback, Decl(varArgParamTypeCheck.ts, 1, 1))
+>()=>{            this();        } : Symbol((Anonymous function), Decl(varArgParamTypeCheck.ts, 10, 17))
 
             this();
         });
     },
     function baz() {
+>function baz() {        callback(()=>{            this();        });    } : Symbol(baz, Decl(varArgParamTypeCheck.ts, 13, 6))
 >baz : Symbol(baz, Decl(varArgParamTypeCheck.ts, 13, 6))
 
         callback(()=>{
 >callback : Symbol(callback, Decl(varArgParamTypeCheck.ts, 1, 1))
+>()=>{            this();        } : Symbol((Anonymous function), Decl(varArgParamTypeCheck.ts, 15, 17))
 
             this();
         });
diff --git a/tests/baselines/reference/varInFunctionInVarInitializer.symbols b/tests/baselines/reference/varInFunctionInVarInitializer.symbols
index 3cae133dd0b5c..031001321e7aa 100644
--- a/tests/baselines/reference/varInFunctionInVarInitializer.symbols
+++ b/tests/baselines/reference/varInFunctionInVarInitializer.symbols
@@ -1,6 +1,7 @@
 === tests/cases/compiler/varInFunctionInVarInitializer.ts ===
 var a = function () {
 >a : Symbol(a, Decl(varInFunctionInVarInitializer.ts, 0, 3))
+>function () {    var c = 1;    return c;} : Symbol((Anonymous function), Decl(varInFunctionInVarInitializer.ts, 0, 7))
 
     var c = 1;
 >c : Symbol(c, Decl(varInFunctionInVarInitializer.ts, 1, 7))
diff --git a/tests/baselines/reference/vardecl.symbols b/tests/baselines/reference/vardecl.symbols
index 979790877c1e6..62160b42239e3 100644
--- a/tests/baselines/reference/vardecl.symbols
+++ b/tests/baselines/reference/vardecl.symbols
@@ -16,6 +16,7 @@ var varWithInitialValue = 30;
 
 var withComplicatedValue = { x: 30, y: 70, desc: "position" };
 >withComplicatedValue : Symbol(withComplicatedValue, Decl(vardecl.ts, 8, 3))
+>{ x: 30, y: 70, desc: "position" } : Symbol(, Decl(vardecl.ts, 8, 26))
 >x : Symbol(x, Decl(vardecl.ts, 8, 28))
 >y : Symbol(y, Decl(vardecl.ts, 8, 35))
 >desc : Symbol(desc, Decl(vardecl.ts, 8, 42))
@@ -44,6 +45,7 @@ complicatedArrayVar.push({ x: 30, y : 'hello world' });
 >complicatedArrayVar.push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
 >complicatedArrayVar : Symbol(complicatedArrayVar, Decl(vardecl.ts, 18, 3))
 >push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
+>{ x: 30, y : 'hello world' } : Symbol(, Decl(vardecl.ts, 19, 25))
 >x : Symbol(x, Decl(vardecl.ts, 19, 26))
 >y : Symbol(y, Decl(vardecl.ts, 19, 33))
 
diff --git a/tests/baselines/reference/variableDeclarator1.symbols b/tests/baselines/reference/variableDeclarator1.symbols
index 3d0a6be70c0e3..9aa861cbffc8a 100644
--- a/tests/baselines/reference/variableDeclarator1.symbols
+++ b/tests/baselines/reference/variableDeclarator1.symbols
@@ -1,6 +1,7 @@
 === tests/cases/compiler/variableDeclarator1.ts ===
 var a = function () {
 >a : Symbol(a, Decl(variableDeclarator1.ts, 0, 3))
+>function () {        var c = 1;        return c;    } : Symbol((Anonymous function), Decl(variableDeclarator1.ts, 0, 7))
 
         var c = 1;
 >c : Symbol(c, Decl(variableDeclarator1.ts, 1, 11))
diff --git a/tests/baselines/reference/voidFunctionAssignmentCompat.symbols b/tests/baselines/reference/voidFunctionAssignmentCompat.symbols
index 7664215ba952b..55e2c6fe769f1 100644
--- a/tests/baselines/reference/voidFunctionAssignmentCompat.symbols
+++ b/tests/baselines/reference/voidFunctionAssignmentCompat.symbols
@@ -1,15 +1,19 @@
 === tests/cases/compiler/voidFunctionAssignmentCompat.ts ===
 var fa = function(): any { return 3; }
 >fa : Symbol(fa, Decl(voidFunctionAssignmentCompat.ts, 0, 3))
+>function(): any { return 3; } : Symbol((Anonymous function), Decl(voidFunctionAssignmentCompat.ts, 0, 8))
 
 fa = function() { } // should not work
 >fa : Symbol(fa, Decl(voidFunctionAssignmentCompat.ts, 0, 3))
+>function() { } : Symbol((Anonymous function), Decl(voidFunctionAssignmentCompat.ts, 1, 4))
 
 var fv = function(): void {}
 >fv : Symbol(fv, Decl(voidFunctionAssignmentCompat.ts, 3, 3))
+>function(): void {} : Symbol((Anonymous function), Decl(voidFunctionAssignmentCompat.ts, 3, 8))
 
 fv = function() { return 0; } // should work
 >fv : Symbol(fv, Decl(voidFunctionAssignmentCompat.ts, 3, 3))
+>function() { return 0; } : Symbol((Anonymous function), Decl(voidFunctionAssignmentCompat.ts, 4, 4))
 
 function execAny(callback:(val:any)=>any) { return callback(0) }
 >execAny : Symbol(execAny, Decl(voidFunctionAssignmentCompat.ts, 4, 29))
@@ -19,6 +23,7 @@ function execAny(callback:(val:any)=>any) { return callback(0) }
 
 execAny(function () {}); // should work
 >execAny : Symbol(execAny, Decl(voidFunctionAssignmentCompat.ts, 4, 29))
+>function () {} : Symbol((Anonymous function), Decl(voidFunctionAssignmentCompat.ts, 7, 8))
 
 function execVoid(callback:(val:any)=>void) { callback(0); }
 >execVoid : Symbol(execVoid, Decl(voidFunctionAssignmentCompat.ts, 7, 24))
@@ -28,23 +33,32 @@ function execVoid(callback:(val:any)=>void) { callback(0); }
 
 execVoid(function () {return 0;}); // should work
 >execVoid : Symbol(execVoid, Decl(voidFunctionAssignmentCompat.ts, 7, 24))
+>function () {return 0;} : Symbol((Anonymous function), Decl(voidFunctionAssignmentCompat.ts, 10, 9))
 
 var fra: (v:any)=>any = function() { return function () {}; } // should work
 >fra : Symbol(fra, Decl(voidFunctionAssignmentCompat.ts, 12, 3))
 >v : Symbol(v, Decl(voidFunctionAssignmentCompat.ts, 12, 10))
+>function() { return function () {}; } : Symbol((Anonymous function), Decl(voidFunctionAssignmentCompat.ts, 12, 23))
+>function () {} : Symbol((Anonymous function), Decl(voidFunctionAssignmentCompat.ts, 12, 43))
 
 var frv: (v:any)=>void = function() { return function () { return 0; } } // should work
 >frv : Symbol(frv, Decl(voidFunctionAssignmentCompat.ts, 13, 3))
 >v : Symbol(v, Decl(voidFunctionAssignmentCompat.ts, 13, 10))
+>function() { return function () { return 0; } } : Symbol((Anonymous function), Decl(voidFunctionAssignmentCompat.ts, 13, 24))
+>function () { return 0; } : Symbol((Anonymous function), Decl(voidFunctionAssignmentCompat.ts, 13, 44))
 
 var fra3: (v:any)=>string = (function() { return function (v:string) {return v;}; })() // should work
 >fra3 : Symbol(fra3, Decl(voidFunctionAssignmentCompat.ts, 15, 3))
 >v : Symbol(v, Decl(voidFunctionAssignmentCompat.ts, 15, 11))
+>function() { return function (v:string) {return v;}; } : Symbol((Anonymous function), Decl(voidFunctionAssignmentCompat.ts, 15, 29))
+>function (v:string) {return v;} : Symbol((Anonymous function), Decl(voidFunctionAssignmentCompat.ts, 15, 48))
 >v : Symbol(v, Decl(voidFunctionAssignmentCompat.ts, 15, 59))
 >v : Symbol(v, Decl(voidFunctionAssignmentCompat.ts, 15, 59))
 
 var frv3: (v:any)=>number = (function() { return function () { return 0; } })() // should work
 >frv3 : Symbol(frv3, Decl(voidFunctionAssignmentCompat.ts, 16, 3))
 >v : Symbol(v, Decl(voidFunctionAssignmentCompat.ts, 16, 11))
+>function() { return function () { return 0; } } : Symbol((Anonymous function), Decl(voidFunctionAssignmentCompat.ts, 16, 29))
+>function () { return 0; } : Symbol((Anonymous function), Decl(voidFunctionAssignmentCompat.ts, 16, 48))
 
 
diff --git a/tests/baselines/reference/voidOperatorWithBooleanType.symbols b/tests/baselines/reference/voidOperatorWithBooleanType.symbols
index 1d044a6d9c66d..733c7fbe77d7e 100644
--- a/tests/baselines/reference/voidOperatorWithBooleanType.symbols
+++ b/tests/baselines/reference/voidOperatorWithBooleanType.symbols
@@ -37,6 +37,7 @@ var ResultIsAny2 = void true;
 
 var ResultIsAny3 = void { x: true, y: false };
 >ResultIsAny3 : Symbol(ResultIsAny3, Decl(voidOperatorWithBooleanType.ts, 20, 3))
+>{ x: true, y: false } : Symbol(, Decl(voidOperatorWithBooleanType.ts, 20, 23))
 >x : Symbol(x, Decl(voidOperatorWithBooleanType.ts, 20, 25))
 >y : Symbol(y, Decl(voidOperatorWithBooleanType.ts, 20, 34))
 
diff --git a/tests/baselines/reference/voidOperatorWithNumberType.symbols b/tests/baselines/reference/voidOperatorWithNumberType.symbols
index 43f10478499da..25b2bf45372fe 100644
--- a/tests/baselines/reference/voidOperatorWithNumberType.symbols
+++ b/tests/baselines/reference/voidOperatorWithNumberType.symbols
@@ -44,13 +44,16 @@ var ResultIsAny3 = void 1;
 
 var ResultIsAny4 = void { x: 1, y: 2};
 >ResultIsAny4 : Symbol(ResultIsAny4, Decl(voidOperatorWithNumberType.ts, 22, 3))
+>{ x: 1, y: 2} : Symbol(, Decl(voidOperatorWithNumberType.ts, 22, 23))
 >x : Symbol(x, Decl(voidOperatorWithNumberType.ts, 22, 25))
 >y : Symbol(y, Decl(voidOperatorWithNumberType.ts, 22, 31))
 
 var ResultIsAny5 = void { x: 1, y: (n: number) => { return n; } };
 >ResultIsAny5 : Symbol(ResultIsAny5, Decl(voidOperatorWithNumberType.ts, 23, 3))
+>{ x: 1, y: (n: number) => { return n; } } : Symbol(, Decl(voidOperatorWithNumberType.ts, 23, 23))
 >x : Symbol(x, Decl(voidOperatorWithNumberType.ts, 23, 25))
 >y : Symbol(y, Decl(voidOperatorWithNumberType.ts, 23, 31))
+>(n: number) => { return n; } : Symbol((Anonymous function), Decl(voidOperatorWithNumberType.ts, 23, 34))
 >n : Symbol(n, Decl(voidOperatorWithNumberType.ts, 23, 36))
 >n : Symbol(n, Decl(voidOperatorWithNumberType.ts, 23, 36))
 
diff --git a/tests/baselines/reference/voidOperatorWithStringType.symbols b/tests/baselines/reference/voidOperatorWithStringType.symbols
index ab834bf1243ca..fd05c444087fb 100644
--- a/tests/baselines/reference/voidOperatorWithStringType.symbols
+++ b/tests/baselines/reference/voidOperatorWithStringType.symbols
@@ -44,13 +44,16 @@ var ResultIsAny3 = void "";
 
 var ResultIsAny4 = void { x: "", y: "" };
 >ResultIsAny4 : Symbol(ResultIsAny4, Decl(voidOperatorWithStringType.ts, 22, 3))
+>{ x: "", y: "" } : Symbol(, Decl(voidOperatorWithStringType.ts, 22, 23))
 >x : Symbol(x, Decl(voidOperatorWithStringType.ts, 22, 25))
 >y : Symbol(y, Decl(voidOperatorWithStringType.ts, 22, 32))
 
 var ResultIsAny5 = void { x: "", y: (s: string) => { return s; } };
 >ResultIsAny5 : Symbol(ResultIsAny5, Decl(voidOperatorWithStringType.ts, 23, 3))
+>{ x: "", y: (s: string) => { return s; } } : Symbol(, Decl(voidOperatorWithStringType.ts, 23, 23))
 >x : Symbol(x, Decl(voidOperatorWithStringType.ts, 23, 25))
 >y : Symbol(y, Decl(voidOperatorWithStringType.ts, 23, 32))
+>(s: string) => { return s; } : Symbol((Anonymous function), Decl(voidOperatorWithStringType.ts, 23, 35))
 >s : Symbol(s, Decl(voidOperatorWithStringType.ts, 23, 37))
 >s : Symbol(s, Decl(voidOperatorWithStringType.ts, 23, 37))
 
diff --git a/tests/baselines/reference/whileBreakStatements.symbols b/tests/baselines/reference/whileBreakStatements.symbols
index 2ac7721621da5..d9bdf0c74a88d 100644
--- a/tests/baselines/reference/whileBreakStatements.symbols
+++ b/tests/baselines/reference/whileBreakStatements.symbols
@@ -39,6 +39,7 @@ EIGHT:
 while (true) {
     var fn = function () { }
 >fn : Symbol(fn, Decl(whileBreakStatements.ts, 38, 7))
+>function () { } : Symbol((Anonymous function), Decl(whileBreakStatements.ts, 38, 12))
 
     break EIGHT;
 }
diff --git a/tests/baselines/reference/whileContinueStatements.symbols b/tests/baselines/reference/whileContinueStatements.symbols
index 67508556f70cf..d0e795c5fd966 100644
--- a/tests/baselines/reference/whileContinueStatements.symbols
+++ b/tests/baselines/reference/whileContinueStatements.symbols
@@ -45,6 +45,7 @@ EIGHT:
 while (true) {
     var fn = function () { }
 >fn : Symbol(fn, Decl(whileContinueStatements.ts, 44, 7))
+>function () { } : Symbol((Anonymous function), Decl(whileContinueStatements.ts, 44, 12))
 
     continue EIGHT;
 }
diff --git a/tests/baselines/reference/widenedTypes1.symbols b/tests/baselines/reference/widenedTypes1.symbols
index 27d1ca7a68b85..bf8453beacc59 100644
--- a/tests/baselines/reference/widenedTypes1.symbols
+++ b/tests/baselines/reference/widenedTypes1.symbols
@@ -8,10 +8,12 @@ var b = undefined;
 
 var c = {x: null};
 >c : Symbol(c, Decl(widenedTypes1.ts, 3, 3))
+>{x: null} : Symbol(, Decl(widenedTypes1.ts, 3, 7))
 >x : Symbol(x, Decl(widenedTypes1.ts, 3, 9))
 
 var d = [{x: null}];
 >d : Symbol(d, Decl(widenedTypes1.ts, 4, 3))
+>{x: null} : Symbol(, Decl(widenedTypes1.ts, 4, 9))
 >x : Symbol(x, Decl(widenedTypes1.ts, 4, 10))
 
 var f = [null, null];
@@ -24,6 +26,7 @@ var g = [undefined, undefined];
 
 var h = [{x: undefined}];
 >h : Symbol(h, Decl(widenedTypes1.ts, 7, 3))
+>{x: undefined} : Symbol(, Decl(widenedTypes1.ts, 7, 9))
 >x : Symbol(x, Decl(widenedTypes1.ts, 7, 10))
 >undefined : Symbol(undefined)
 
diff --git a/tests/baselines/reference/withImportDecl.symbols b/tests/baselines/reference/withImportDecl.symbols
index ae41e927cfacb..a6b00abcc1dd4 100644
--- a/tests/baselines/reference/withImportDecl.symbols
+++ b/tests/baselines/reference/withImportDecl.symbols
@@ -17,6 +17,7 @@ var varWithInitialValue = 30;
 
 var withComplicatedValue = { x: 30, y: 70, desc: "position" };
 >withComplicatedValue : Symbol(withComplicatedValue, Decl(withImportDecl_1.ts, 9, 3))
+>{ x: 30, y: 70, desc: "position" } : Symbol(, Decl(withImportDecl_1.ts, 9, 26))
 >x : Symbol(x, Decl(withImportDecl_1.ts, 9, 28))
 >y : Symbol(y, Decl(withImportDecl_1.ts, 9, 35))
 >desc : Symbol(desc, Decl(withImportDecl_1.ts, 9, 42))
@@ -41,6 +42,8 @@ function simpleFunction() {
 >simpleFunction : Symbol(simpleFunction, Decl(withImportDecl_1.ts, 17, 36))
 
     return {
+>{        x: "Hello",        y: "word",        n: 2    } : Symbol(, Decl(withImportDecl_1.ts, 21, 10))
+
         x: "Hello",
 >x : Symbol(x, Decl(withImportDecl_1.ts, 21, 12))
 
diff --git a/tests/baselines/reference/wrappedAndRecursiveConstraints3.symbols b/tests/baselines/reference/wrappedAndRecursiveConstraints3.symbols
index 06279a5c2640d..f08912b359d99 100644
--- a/tests/baselines/reference/wrappedAndRecursiveConstraints3.symbols
+++ b/tests/baselines/reference/wrappedAndRecursiveConstraints3.symbols
@@ -35,6 +35,7 @@ class C<T extends { length: number }> {
 var c = new C({ length: 2 });
 >c : Symbol(c, Decl(wrappedAndRecursiveConstraints3.ts, 12, 3))
 >C : Symbol(C, Decl(wrappedAndRecursiveConstraints3.ts, 0, 0))
+>{ length: 2 } : Symbol(, Decl(wrappedAndRecursiveConstraints3.ts, 12, 14))
 >length : Symbol(length, Decl(wrappedAndRecursiveConstraints3.ts, 12, 15))
 
 var r = c.foo({ length: 3, charAt: (x: number) => { '' } });
@@ -42,8 +43,10 @@ var r = c.foo({ length: 3, charAt: (x: number) => { '' } });
 >c.foo : Symbol(C.foo, Decl(wrappedAndRecursiveConstraints3.ts, 3, 25))
 >c : Symbol(c, Decl(wrappedAndRecursiveConstraints3.ts, 12, 3))
 >foo : Symbol(C.foo, Decl(wrappedAndRecursiveConstraints3.ts, 3, 25))
+>{ length: 3, charAt: (x: number) => { '' } } : Symbol(, Decl(wrappedAndRecursiveConstraints3.ts, 13, 14))
 >length : Symbol(length, Decl(wrappedAndRecursiveConstraints3.ts, 13, 15))
 >charAt : Symbol(charAt, Decl(wrappedAndRecursiveConstraints3.ts, 13, 26))
+>(x: number) => { '' } : Symbol((Anonymous function), Decl(wrappedAndRecursiveConstraints3.ts, 13, 34))
 >x : Symbol(x, Decl(wrappedAndRecursiveConstraints3.ts, 13, 36))
 
 var r2 = r('');

From ceee493ad21426014ea46f4bf0ef3bf82a557bf1 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Wed, 8 Jul 2015 10:56:55 -0700
Subject: [PATCH 17/57] A few additional fixes

---
 src/compiler/checker.ts            | 26 ++++++++++++---
 src/compiler/declarationEmitter.ts | 51 ++++++++++++++++++++----------
 2 files changed, 56 insertions(+), 21 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index c18bed30ebcca..e39b81eb1fd1e 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -371,7 +371,8 @@ namespace ts {
             }
 
             let sourceFiles = host.getSourceFiles();
-            return indexOf(sourceFiles, file1) <= indexOf(sourceFiles, file2);
        }
+            return indexOf(sourceFiles, file1) <= indexOf(sourceFiles, file2);
+        }
 
         // Resolve a given name for a given meaning at a given location. An error is reported if the name was not found and
         // the nameNotFoundMessage argument is not undefined. Returns the resolved symbol, or undefined if no symbol with
@@ -783,12 +784,28 @@ namespace ts {
         }
 
 
-
+        // TODO: this needs to be rewriteen
         function getLocalTargetOfAliasDeclaration(node: Declaration): Symbol {
             switch (node.kind) {
                 case SyntaxKind.ImportEqualsDeclaration:
-                    return ((<ImportEqualsDeclaration>node).moduleReference.kind === SyntaxKind.ExternalModuleReference) ? undefined :
-                        getSymbolOfPartOfRightHandSideOfImportEquals(<EntityName>(<ImportEqualsDeclaration>node).moduleReference, <ImportEqualsDeclaration>node);
+                    //return ((<ImportEqualsDeclaration>node).moduleReference.kind === SyntaxKind.ExternalModuleReference) ? undefined :
+                    //    getSymbolOfPartOfRightHandSideOfImportEquals(, <ImportEqualsDeclaration>node);
+
+                    let entityName = <EntityName>(<ImportEqualsDeclaration>node).moduleReference
+                    if (entityName.kind === SyntaxKind.Identifier && isRightSideOfQualifiedNameOrPropertyAccess(entityName)) {
+                        entityName = <QualifiedName>entityName.parent;
+                    }
+                    // Check for case 1 and 3 in the above example
+                    if (entityName.kind === SyntaxKind.Identifier || entityName.parent.kind === SyntaxKind.QualifiedName) {
+                        return resolveEntityName(entityName, SymbolFlags.Namespace | SymbolFlags.Alias);
+                    }
+                    else {
+                        // Case 2 in above example
+                        // entityName.kind could be a QualifiedName or a Missing identifier
+                        Debug.assert(entityName.parent.kind === SyntaxKind.ImportEqualsDeclaration);
+                        return resolveEntityName(entityName, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace | SymbolFlags.Alias);
+                    }
+
                 case SyntaxKind.ExportSpecifier:
                     return (<ExportDeclaration>(<ExportSpecifier>node).parent.parent).moduleSpecifier ? undefined :
                         resolveEntityName((<ExportSpecifier>node).propertyName || (<ExportSpecifier>node).name, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace | SymbolFlags.Alias);
@@ -1521,6 +1538,7 @@ namespace ts {
                             }
                         }
                         writePunctuation(writer, SyntaxKind.DotToken);
+                        writer.trackSymbol(symbol);
                     }
                     parentSymbol = symbol;
                     appendSymbolNameOnly(symbol, writer);
diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index 35bf53c3870b8..2a16b1b46c118 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -52,6 +52,7 @@ namespace ts {
         interface NodeLinks {
             visibleChildren?: Node[];
             visited?: boolean;
+            hasExportDeclarations?: boolean;
         }
 
         let nodeLinks: NodeLinks[] = [];
@@ -1116,6 +1117,7 @@ namespace ts {
                 case SyntaxKind.VariableStatement:
                     return visitNodes((<VariableStatement>node).declarationList.declarations);
 
+                case SyntaxKind.Parameter:
                 case SyntaxKind.VariableDeclaration:
                 case SyntaxKind.PropertyDeclaration:
                 case SyntaxKind.PropertySignature:
@@ -1201,7 +1203,7 @@ namespace ts {
                 let writer = createNewTextWriterWithSymbolWriter();
                 let previousErrorNode = currentErrorNode;
                 currentErrorNode = node;
-                resolver.writeReturnTypeOfSignatureDeclaration(node, enclosingDeclaration, TypeFormatFlags.UseTypeOfFunction, writer);
+                resolver.writeReturnTypeOfSignatureDeclaration(node, getEnclosingDeclaration(node), TypeFormatFlags.UseTypeOfFunction, writer);
                 currentErrorNode = previousErrorNode;
             }
         }
@@ -1220,7 +1222,7 @@ namespace ts {
                 let writer = createNewTextWriterWithSymbolWriter();
                 let previousErrorNode = currentErrorNode;
                 currentErrorNode = node;
-                resolver.writeTypeOfDeclaration(node, enclosingDeclaration, TypeFormatFlags.UseTypeOfFunction, writer);
+                resolver.writeTypeOfDeclaration(node, getEnclosingDeclaration(node), TypeFormatFlags.UseTypeOfFunction, writer);
                 currentErrorNode = previousErrorNode;
             }
         }
@@ -1231,7 +1233,7 @@ namespace ts {
             let writer = createNewTextWriterWithSymbolWriter();
             let previousErrorNode = currentErrorNode;
             currentErrorNode = node;
-            resolver.writeTypeOfExpression(node.expression, enclosingDeclaration, TypeFormatFlags.UseTypeOfFunction, writer);
+            resolver.writeTypeOfExpression(node.expression, getEnclosingDeclaration(node), TypeFormatFlags.UseTypeOfFunction, writer);
             currentErrorNode = previousErrorNode;
 
             visitNodes(node.typeArguments);
@@ -1287,10 +1289,13 @@ namespace ts {
                     if (node.parent.kind === SyntaxKind.SourceFile && !isExternalModule(<SourceFile>node.parent)) {
                         return true;
                     }
-                    else {
-                        // TODO: handel ambient context
-                        return (node.flags & NodeFlags.Export) !== 0;
+                    else if ((node.flags & NodeFlags.Export) !== 0) {
+                        return true;
                     }
+                    else if (node.parent.kind === SyntaxKind.ModuleBlock && isInAmbientContext(node.parent)) {
+                        return !hasExportDeclatations(node.parent);
+                    }
+                    break;
 
                 case SyntaxKind.VariableDeclaration:
                     // TODO: do we need this
@@ -1342,21 +1347,33 @@ namespace ts {
             forEach(symbol.declarations, d => collectDeclaration(d, errorNode));
         }
 
+        function hasExportDeclatations(node: Node): boolean {
+            let links = getNodeLinks(node);
+            if (typeof links.hasExportDeclarations === undefined) {
+                let foundExportDeclarations = false;
+                /// TODO: swithc this to return a value if truthy
+                forEachTopLevelDeclaration(node, n => {
+                    if (n.kind === SyntaxKind.ExportAssignment || n.kind === SyntaxKind.ExportDeclaration) {
+                        foundExportDeclarations = true;
+                    }
+                });
+                links.hasExportDeclarations = foundExportDeclarations
+            }
+            return links.hasExportDeclarations;
+        }
+
+        // TODO: find a better name
         function isDeclarationAccessible(node: Node) {
             if (isDeclarationVisible(node)) {
                 return true;
             }
 
-            let hasScopeAlteringExport = false;
             let parent = getEnclosingDeclaration(node);
-            if (parent) {
-                forEachTopLevelDeclaration(parent, (n) => {
-                    if (n.kind === SyntaxKind.ExportAssignment || n.kind === SyntaxKind.ExportDeclaration) {
-                        hasScopeAlteringExport = true;
-                    }
-                });
+            if (parent && parent.kind === SyntaxKind.ModuleDeclaration) {
+                return hasExportDeclatations(parent);
             }
-            return hasScopeAlteringExport
+
+            return false;
         }
 
         // TODO: remove this and update error messages to not use names
@@ -1369,12 +1386,12 @@ namespace ts {
 
         function reportDeclarationAccessiblityMessage(referencedDeclaration: Declaration, errorNode: Node): void {
             Debug.assert(referencedDeclaration.name && referencedDeclaration.name.kind === SyntaxKind.Identifier);
-            let referencedDeclarationName = (<Identifier>referencedDeclaration.name).text;
 
             reportedDeclarationError = true;
 
-            referencedDeclarationName = "---" + referencedDeclarationName +"---";
+            let referencedDeclarationName = (<Identifier>referencedDeclaration.name).text;
             let container = errorNode;
+
             while (true) {
                 switch (container.kind) {
                     case SyntaxKind.ClassDeclaration:
@@ -1558,7 +1575,7 @@ namespace ts {
         let emitDeclarationResult = emitDeclarations(host, resolver, diagnostics, jsFilePath, sourceFile);
         // TODO(shkamat): Should we not write any declaration file if any of them can produce error,
         // or should we just not write this file like we are doing now
-        //if (!emitDeclarationResult.reportedDeclarationError) {
+       // if (!emitDeclarationResult.reportedDeclarationError) {
             let declarationOutput = emitDeclarationResult.referencePathsOutput
                 + emitDeclarationResult.synchronousDeclarationOutput;
             writeFile(host, diagnostics, removeFileExtension(jsFilePath) + ".d.ts", declarationOutput, host.getCompilerOptions().emitBOM);

From 34f0d546cdf50dbfe1f367d72b381795c5d6561a Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Wed, 8 Jul 2015 10:57:26 -0700
Subject: [PATCH 18/57] rename functions

---
 src/compiler/declarationEmitter.ts | 62 +++++++++++++++++++-----------
 1 file changed, 39 insertions(+), 23 deletions(-)

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index 2a16b1b46c118..199506ebc269a 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -765,7 +765,7 @@ namespace ts {
         // TODO: we only should have either statement or declaration
         function emitVariableDeclarationWithoutStatement(node: VariableDeclaration) {
             emitJsDocComments(node);
-            emitModuleElementDeclarationFlags(node);
+            emitModuleElementDeclarationFlags(node.parent.parent);
             var declarationList = node.parent;
             if (isLet(declarationList)) {
                 write("let ");
@@ -1184,6 +1184,7 @@ namespace ts {
             if (node.expression.kind === SyntaxKind.Identifier) {
                 collectAliasDeclaration(node);
             }
+            // TODO handle expression type
         }
 
         function visitSignatureDeclaration(node: SignatureDeclaration): void {
@@ -1252,7 +1253,7 @@ namespace ts {
         }
 
 
-        function isDeclarationVisible(node: Node): boolean {
+        function isDeclarationExported(node: Node): boolean {
             if (compilerOptions.stripInternal && isInternal(node)) {
                 // TODO: this is the correct place for this check, enable this 
                 // after updating the code to make internal on local declarations instead
@@ -1299,7 +1300,7 @@ namespace ts {
 
                 case SyntaxKind.VariableDeclaration:
                     // TODO: do we need this
-                    return isDeclarationVisible(node.parent.parent);
+                    return isDeclarationExported(node.parent.parent);
             }
 
             return false;
@@ -1349,7 +1350,7 @@ namespace ts {
 
         function hasExportDeclatations(node: Node): boolean {
             let links = getNodeLinks(node);
-            if (typeof links.hasExportDeclarations === undefined) {
+            if (typeof links.hasExportDeclarations === "undefined") {
                 let foundExportDeclarations = false;
                 /// TODO: swithc this to return a value if truthy
                 forEachTopLevelDeclaration(node, n => {
@@ -1362,15 +1363,30 @@ namespace ts {
             return links.hasExportDeclarations;
         }
 
-        // TODO: find a better name
-        function isDeclarationAccessible(node: Node) {
-            if (isDeclarationVisible(node)) {
+        /**
+         * Can the the declaration of this node be emitted without causing it 
+         * to be exported from its parent in the .d.ts where it was not in the .ts
+         *
+         * This is caused by the scoping rules withen an ambient module or namespace
+         * declaration where *all* top-level declarations are considered exported wether
+         * they have an export modifier or not.
+         *
+         */
+        function canWriteDeclaration(node: Node) : boolean{
+            // If the declaration is exported from its parent, we can
+            // safelly write a declaration for it
+            if (isDeclarationExported(node)) {
                 return true;
             }
 
+            // If the parent module has an export declaration  or export
+            // assingment, then the scoping rules change, and only declarations
+            // with export modifier are visible, so we can safely write 
+            // a declaration of a non-exported entity without exposing it
             let parent = getEnclosingDeclaration(node);
-            if (parent && parent.kind === SyntaxKind.ModuleDeclaration) {
-                return hasExportDeclatations(parent);
+            if (parent) {
+                return (parent.kind === SyntaxKind.ModuleDeclaration || parent.kind === SyntaxKind.SourceFile) &&
+                    hasExportDeclatations(parent);
             }
 
             return false;
@@ -1503,7 +1519,7 @@ namespace ts {
             }
 
             if (errorNode) {
-                if (!isDeclarationAccessible(node)) {
+                if (!canWriteDeclaration(node)) {
                     reportDeclarationAccessiblityMessage(<Declaration>node, errorNode);
                 }
             }
@@ -1514,16 +1530,20 @@ namespace ts {
                 case SyntaxKind.InterfaceDeclaration:
                 case SyntaxKind.ClassDeclaration:
                 case SyntaxKind.EnumDeclaration:
-                    forEachTopLevelDeclaration(node, child => {
-                        if (isDeclarationVisible(child)) {
-                            collectDeclaration(child);
-                        }
-                    });
+                    collectTopLevelChildDeclarations(node);
                     break;
             }
 
         }
 
+        function collectTopLevelChildDeclarations(node: Node): void {
+            forEachTopLevelDeclaration(node, child => {
+                if (isDeclarationExported(child)) {
+                    collectDeclaration(child);
+                }
+            });
+        }
+
         function ensureDeclarationVisible(node: Node): void {
             let links = getNodeLinks(node);
             if (!links.visited) {
@@ -1559,11 +1579,7 @@ namespace ts {
 
         function emitSourceFileDeclarations(sourceFile: SourceFile): void {
             // Collect all visible declarations
-            forEachTopLevelDeclaration(sourceFile, child => {
-                if (isDeclarationVisible(child)) {
-                    collectDeclaration(child);
-                }
-            });
+            collectTopLevelChildDeclarations(sourceFile);
 
             // write the declarations
             writeChildDeclarations(sourceFile);
@@ -1575,10 +1591,10 @@ namespace ts {
         let emitDeclarationResult = emitDeclarations(host, resolver, diagnostics, jsFilePath, sourceFile);
         // TODO(shkamat): Should we not write any declaration file if any of them can produce error,
         // or should we just not write this file like we are doing now
-       // if (!emitDeclarationResult.reportedDeclarationError) {
+        if (!emitDeclarationResult.reportedDeclarationError) {
             let declarationOutput = emitDeclarationResult.referencePathsOutput
                 + emitDeclarationResult.synchronousDeclarationOutput;
             writeFile(host, diagnostics, removeFileExtension(jsFilePath) + ".d.ts", declarationOutput, host.getCompilerOptions().emitBOM);
-        //}
+        }
     }
-}
+}
\ No newline at end of file

From 672fb443fbadf37b3a00d1016a3cd747b9a7e616 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Wed, 8 Jul 2015 17:25:32 -0700
Subject: [PATCH 19/57] use namespaces instead of module

---
 src/compiler/parser.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index fecff11b1b4b8..13402ec9ccebd 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -425,7 +425,7 @@ namespace ts {
     // Implement the parser as a singleton module.  We do this for perf reasons because creating
     // parser instances can actually be expensive enough to impact us on projects with many source
     // files.
-    module Parser {
+    namespace Parser {
         // Share a single scanner across all calls to parse a source file.  This helps speed things
         // up by avoiding the cost of creating/compiling scanners over and over again.
         const scanner = createScanner(ScriptTarget.Latest, /*skipTrivia*/ true);
@@ -5914,7 +5914,7 @@ namespace ts {
         }
     }
 
-    module IncrementalParser {
+    namespace IncrementalParser {
         export function updateSourceFile(sourceFile: SourceFile, newText: string, textChangeRange: TextChangeRange, aggressiveChecks: boolean): SourceFile {
             aggressiveChecks = aggressiveChecks || Debug.shouldAssert(AssertionLevel.Aggressive);
 

From 6eb1df7ba0b5ead4b0f1d7b79ad1e10a734cc473 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Wed, 8 Jul 2015 17:26:05 -0700
Subject: [PATCH 20/57] Ensure trackSymbol is only called for type symbols

---
 src/compiler/checker.ts | 27 ++++++++++++++-------------
 1 file changed, 14 insertions(+), 13 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index e39b81eb1fd1e..115d504a2ab3e 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -1515,15 +1515,19 @@ namespace ts {
              * Writes only the name of the symbol out to the writer. Uses the original source text
              * for the name of the symbol if it is available to match how the user inputted the name.
              */
-            function appendSymbolNameOnly(symbol: Symbol, writer: SymbolWriter): void {
+            function appendSymbolNameOnly(symbol: Symbol, writer: SymbolWriter, isTypeSymbol: boolean): void {
                 writer.writeSymbol(getNameOfSymbol(symbol), symbol);
+
+                if (isTypeSymbol) {
+                    writer.trackSymbol(symbol);
+                }
             }
 
             /**
              * Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope
              * Meaning needs to be specified if the enclosing declaration is given
              */
-            function buildSymbolDisplay(symbol: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags, typeFlags?: TypeFormatFlags): void {
+            function buildSymbolDisplay(symbol: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags, typeFlags?: TypeFormatFlags, isTypeSymbol?: boolean): void {
                 let parentSymbol: Symbol;
                 function appendParentTypeArgumentsAndSymbolName(symbol: Symbol): void {
                     if (parentSymbol) {
@@ -1538,10 +1542,10 @@ namespace ts {
                             }
                         }
                         writePunctuation(writer, SyntaxKind.DotToken);
-                        writer.trackSymbol(symbol);
                     }
+
                     parentSymbol = symbol;
-                    appendSymbolNameOnly(symbol, writer);
+                    appendSymbolNameOnly(symbol, writer, isTypeSymbol);
                 }
 
                 function walkSymbol(symbol: Symbol, meaning: SymbolFlags): void {
@@ -1607,9 +1611,8 @@ namespace ts {
                         writeTypeReference(<TypeReference>type, flags);
                     }
                     else if (type.flags & (TypeFlags.Class | TypeFlags.Interface | TypeFlags.Enum | TypeFlags.TypeParameter)) {
-                        writer.trackSymbol(type.symbol);
                         // The specified symbol flags need to be reinterpreted as type flags
-                        buildSymbolDisplay(type.symbol, writer, enclosingDeclaration, SymbolFlags.Type, SymbolFormatFlags.None, flags);
+                        buildSymbolDisplay(type.symbol, writer, enclosingDeclaration, SymbolFlags.Type, SymbolFormatFlags.None, flags, /*isTypeSymbol*/true);
                     }
                     else if (type.flags & TypeFlags.Tuple) {
                         writeTupleType(<TupleType>type);
@@ -1651,8 +1654,7 @@ namespace ts {
                     // Unnamed function expressions, arrow functions, and unnamed class expressions have reserved names that
                     // we don't want to display
                     if (!isReservedMemberName(symbol.name)) {
-                        writer.trackSymbol(symbol);
-                        buildSymbolDisplay(symbol, writer, enclosingDeclaration, SymbolFlags.Type);
+                        buildSymbolDisplay(symbol, writer, enclosingDeclaration, SymbolFlags.Type, undefined, undefined, /*isTypeSymbol*/true);
                     }
                     if (pos < end) {
                         writePunctuation(writer, SyntaxKind.LessThanToken);
@@ -1731,7 +1733,7 @@ namespace ts {
                             let typeAlias = getTypeAliasForTypeLiteral(type);
                             if (typeAlias) {
                                 // The specified symbol flags need to be reinterpreted as type flags
-                                buildSymbolDisplay(typeAlias, writer, enclosingDeclaration, SymbolFlags.Type, SymbolFormatFlags.None, flags);
+                                buildSymbolDisplay(typeAlias, writer, enclosingDeclaration, SymbolFlags.Type, SymbolFormatFlags.None, flags, /*isTypeSymbol*/true);
                             }
                             else {
                                 // Recursive usage, use any
@@ -1772,8 +1774,7 @@ namespace ts {
                 function writeTypeofSymbol(type: ObjectType, typeFormatFlags?: TypeFormatFlags) {
                     writeKeyword(writer, SyntaxKind.TypeOfKeyword);
                     writeSpace(writer);
-                    writer.trackSymbol(type.symbol);
-                    buildSymbolDisplay(type.symbol, writer, enclosingDeclaration, SymbolFlags.Value, SymbolFormatFlags.None, typeFormatFlags);
+                    buildSymbolDisplay(type.symbol, writer, enclosingDeclaration, SymbolFlags.Value, SymbolFormatFlags.None, typeFormatFlags, /*isTypeSymbol*/true);
                 }
 
                 function getIndexerParameterName(type: ObjectType, indexKind: IndexKind, fallbackName: string): string {
@@ -1903,7 +1904,7 @@ namespace ts {
             }
 
             function buildTypeParameterDisplay(tp: TypeParameter, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags, symbolStack?: Symbol[]) {
-                appendSymbolNameOnly(tp.symbol, writer);
+                appendSymbolNameOnly(tp.symbol, writer, false);
                 let constraint = getConstraintOfTypeParameter(tp);
                 if (constraint) {
                     writeSpace(writer);
@@ -1918,7 +1919,7 @@ namespace ts {
                 if (isRestParameter(parameterNode)) {
                     writePunctuation(writer, SyntaxKind.DotDotDotToken);
                 }
-                appendSymbolNameOnly(p, writer);
+                appendSymbolNameOnly(p, writer, false);
                 if (isOptionalParameter(parameterNode)) {
                     writePunctuation(writer, SyntaxKind.QuestionToken);
                 }

From fc7325bab79a4146abaf232867a441b7d54a51b1 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Wed, 8 Jul 2015 17:27:28 -0700
Subject: [PATCH 21/57] handel import clauses and export default expression

---
 src/compiler/declarationEmitter.ts | 81 +++++++++++++++++++-----------
 1 file changed, 52 insertions(+), 29 deletions(-)

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index 199506ebc269a..63da132d40b7c 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -438,37 +438,37 @@ namespace ts {
         }
 
         function emitImportDeclaration(node: ImportDeclaration) {
-            if (!node.importClause && !(node.flags & NodeFlags.Export)) {
-                // do not write non-exported import declarations that don't have import clauses
+            var children = sortDeclarations(getNodeLinks(node).visibleChildren);
+            if (!children) {
                 return;
             }
+
             emitJsDocComments(node);
-            if (node.flags & NodeFlags.Export) {
-                write("export ");
-            }
             write("import ");
-            if (node.importClause) {
-                let currentWriterPos = writer.getTextPos();
-                if (node.importClause.name) {
-                    writeTextOfNode(currentSourceFile, node.importClause.name);
-                }
-                if (node.importClause.namedBindings) {
-                    if (currentWriterPos !== writer.getTextPos()) {
-                        // If the default binding was emitted, write the separated
-                        write(", ");
-                    }
-                    if (node.importClause.namedBindings.kind === SyntaxKind.NamespaceImport) {
-                        write("* as ");
-                        writeTextOfNode(currentSourceFile, (<NamespaceImport>node.importClause.namedBindings).name);
-                    }
-                    else {
-                        write("{ ");
-                        emitCommaList((<NamedImports>node.importClause.namedBindings).elements, emitImportOrExportSpecifier);
-                        write(" }");
-                    }
+
+
+            let index: number;
+            if ((index = indexOf(children, node.importClause)) === 0) {
+                children.shift(); // remove it
+                writeTextOfNode(currentSourceFile, node.importClause.name);
+                if (children.length) {
+                    // If the default binding was emitted, write the separated
+                    write(", ");
                 }
-                write(" from ");
             }
+
+            if (node.importClause.namedBindings.kind === SyntaxKind.NamespaceImport &&
+                indexOf(children, node.importClause.namedBindings) >= 0) {
+                write("* as ");
+                writeTextOfNode(currentSourceFile, (<NamespaceImport>node.importClause.namedBindings).name);
+            }
+            else if (children.length) {
+                write("{ ");
+                emitCommaList(children, emitImportOrExportSpecifier);
+                write(" }");
+            }
+
+            write(" from ");
             writeTextOfNode(currentSourceFile, node.moduleSpecifier);
             write(";");
             writer.writeLine();
@@ -1184,7 +1184,15 @@ namespace ts {
             if (node.expression.kind === SyntaxKind.Identifier) {
                 collectAliasDeclaration(node);
             }
-            // TODO handle expression type
+            else if (!node.isExportEquals) { 
+                // TODO: handel expressions
+                // TODO: Cache the result
+                let writer = createNewTextWriterWithSymbolWriter();
+                let previousErrorNode = currentErrorNode;
+                currentErrorNode = node;
+                resolver.writeTypeOfExpression(node.expression, getEnclosingDeclaration(node), TypeFormatFlags.UseTypeOfFunction, writer);
+                currentErrorNode = previousErrorNode;
+            }
         }
 
         function visitSignatureDeclaration(node: SignatureDeclaration): void {
@@ -1262,6 +1270,7 @@ namespace ts {
             }
 
             switch (node.kind) {
+                case SyntaxKind.SourceFile:
                 case SyntaxKind.TypeParameter:
                 case SyntaxKind.Parameter:
                 case SyntaxKind.PropertySignature:
@@ -1277,6 +1286,9 @@ namespace ts {
                 case SyntaxKind.EnumMember:
                 case SyntaxKind.ExportAssignment:
                 case SyntaxKind.ExportDeclaration:
+                case SyntaxKind.NamespaceImport:
+                case SyntaxKind.ImportClause:
+                case SyntaxKind.ImportSpecifier:
                     return true;
 
                 case SyntaxKind.VariableStatement:
@@ -1335,6 +1347,7 @@ namespace ts {
                     case SyntaxKind.ModuleDeclaration:
                     case SyntaxKind.ClassDeclaration:
                     case SyntaxKind.InterfaceDeclaration:
+                    case SyntaxKind.ImportDeclaration:
                         return node.parent;
                     default:
                         node = node.parent;
@@ -1379,6 +1392,10 @@ namespace ts {
                 return true;
             }
 
+            if (node.kind === SyntaxKind.ImportEqualsDeclaration) {
+                return true;
+            }
+
             // If the parent module has an export declaration  or export
             // assingment, then the scoping rules change, and only declarations
             // with export modifier are visible, so we can safely write 
@@ -1511,7 +1528,7 @@ namespace ts {
                 // declaration
                 let parent = getEnclosingDeclaration(node);
                 if (parent) {
-                    ensureDeclarationVisible(parent);
+                    ensureDeclarationVisible(parent, errorNode);
                     attachVisibleChild(parent, node);
                 }
 
@@ -1544,17 +1561,23 @@ namespace ts {
             });
         }
 
-        function ensureDeclarationVisible(node: Node): void {
+        function ensureDeclarationVisible(node: Node, errorNode: Node): void {
             let links = getNodeLinks(node);
             if (!links.visited) {
                 links.visited = true;
 
                 var parent = getEnclosingDeclaration(node);
                 if (parent) {
-                    ensureDeclarationVisible(parent);
+                    ensureDeclarationVisible(parent, errorNode);
                     attachVisibleChild(parent, node);
                 }
             }
+
+            if (errorNode) {
+                if (!canWriteDeclaration(node)) {
+                    reportDeclarationAccessiblityMessage(<Declaration>node, errorNode);
+                }
+            }
         }
 
         function attachVisibleChild(node: Node, child: Node): void {

From c8a8ff52802f29797781ff3963da3748781b17ee Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Wed, 8 Jul 2015 21:15:43 -0700
Subject: [PATCH 22/57] Handel variableDeclarations and variableStatements

---
 src/compiler/declarationEmitter.ts | 65 +++++++++++++++++-------------
 1 file changed, 37 insertions(+), 28 deletions(-)

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index 63da132d40b7c..dae045cf4e9a8 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -757,29 +757,31 @@ namespace ts {
             else {
                 write("var ");
             }
-            emitCommaList(node.declarationList.declarations, emitVariableDeclaration);
+            let children = sortDeclarations(getNodeLinks(node).visibleChildren);
+            Debug.assert(children && children.length > 0);
+            emitCommaList(children, emitVariableDeclaration);
             write(";");
             writeLine();
         }
 
-        // TODO: we only should have either statement or declaration
-        function emitVariableDeclarationWithoutStatement(node: VariableDeclaration) {
-            emitJsDocComments(node);
-            emitModuleElementDeclarationFlags(node.parent.parent);
-            var declarationList = node.parent;
-            if (isLet(declarationList)) {
-                write("let ");
-            }
-            else if (isConst(declarationList)) {
-                write("const ");
-            }
-            else {
-                write("var ");
-            }
-            emitVariableDeclaration(node);
-            write(";");
-            writeLine();
-        }
+        //// TODO: we only should have either statement or declaration
+        //function emitVariableDeclarationWithoutStatement(node: VariableDeclaration) {
+        //    emitJsDocComments(node);
+        //    emitModuleElementDeclarationFlags(node.parent.parent);
+        //    var declarationList = node.parent;
+        //    if (isLet(declarationList)) {
+        //        write("let ");
+        //    }
+        //    else if (isConst(declarationList)) {
+        //        write("const ");
+        //    }
+        //    else {
+        //        write("var ");
+        //    }
+        //    emitVariableDeclaration(node);
+        //    write(";");
+        //    writeLine();
+        //}
 
         function emitAccessorDeclaration(node: AccessorDeclaration) {
             if (hasDynamicName(node)) {
@@ -1016,7 +1018,9 @@ namespace ts {
                 case SyntaxKind.VariableStatement:
                     return emitVariableStatement(<VariableStatement>node);
                 case SyntaxKind.VariableDeclaration:
-                    return emitVariableDeclarationWithoutStatement(<VariableDeclaration>node);
+                    Debug.fail("should not be here");
+                    //  return emitVariableDeclarationWithoutStatement(<VariableDeclaration>node);
+                    return;
 
                 case SyntaxKind.InterfaceDeclaration:
                     return emitInterfaceDeclaration(<InterfaceDeclaration>node);
@@ -1114,8 +1118,8 @@ namespace ts {
                     return visitNodes((<TypeAliasDeclaration>node).typeParameters) ||
                         visitNode((<TypeAliasDeclaration>node).type);
 
-                case SyntaxKind.VariableStatement:
-                    return visitNodes((<VariableStatement>node).declarationList.declarations);
+                //case SyntaxKind.VariableStatement:
+                //    return visitNodes((<VariableStatement>node).declarationList.declarations);
 
                 case SyntaxKind.Parameter:
                 case SyntaxKind.VariableDeclaration:
@@ -1289,6 +1293,7 @@ namespace ts {
                 case SyntaxKind.NamespaceImport:
                 case SyntaxKind.ImportClause:
                 case SyntaxKind.ImportSpecifier:
+                case SyntaxKind.VariableDeclaration:
                     return true;
 
                 case SyntaxKind.VariableStatement:
@@ -1309,10 +1314,6 @@ namespace ts {
                         return !hasExportDeclatations(node.parent);
                     }
                     break;
-
-                case SyntaxKind.VariableDeclaration:
-                    // TODO: do we need this
-                    return isDeclarationExported(node.parent.parent);
             }
 
             return false;
@@ -1328,6 +1329,9 @@ namespace ts {
                 case SyntaxKind.ClassDeclaration:
                     forEach((<InterfaceDeclaration|EnumDeclaration|ClassDeclaration>node).members, action);
                     break;
+                case SyntaxKind.VariableStatement: 
+                    forEach((<VariableStatement>node).declarationList.declarations, action);
+                    break;
                 case SyntaxKind.ModuleDeclaration:
                     if ((<ModuleDeclaration>node).body.kind === SyntaxKind.ModuleBlock) {
                         forEach((<ModuleBlock>(<ModuleDeclaration>node).body).statements, action);
@@ -1348,6 +1352,7 @@ namespace ts {
                     case SyntaxKind.ClassDeclaration:
                     case SyntaxKind.InterfaceDeclaration:
                     case SyntaxKind.ImportDeclaration:
+                    case SyntaxKind.VariableStatement:
                         return node.parent;
                     default:
                         node = node.parent;
@@ -1385,7 +1390,11 @@ namespace ts {
          * they have an export modifier or not.
          *
          */
-        function canWriteDeclaration(node: Node) : boolean{
+        function canWriteDeclaration(node: Node): boolean{
+            if (node.kind === SyntaxKind.VariableDeclaration) {
+                node = node.parent.parent;
+            }
+
             // If the declaration is exported from its parent, we can
             // safelly write a declaration for it
             if (isDeclarationExported(node)) {
@@ -1547,10 +1556,10 @@ namespace ts {
                 case SyntaxKind.InterfaceDeclaration:
                 case SyntaxKind.ClassDeclaration:
                 case SyntaxKind.EnumDeclaration:
+                case SyntaxKind.VariableStatement:
                     collectTopLevelChildDeclarations(node);
                     break;
             }
-
         }
 
         function collectTopLevelChildDeclarations(node: Node): void {

From 0f460579b41c17402168f0602bf7a08868e8af12 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Thu, 9 Jul 2015 11:57:13 -0700
Subject: [PATCH 23/57] handel binding patterns

---
 src/compiler/declarationEmitter.ts | 155 +++++++++++++++--------------
 1 file changed, 82 insertions(+), 73 deletions(-)

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index dae045cf4e9a8..d9beb260b7967 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -745,51 +745,52 @@ namespace ts {
             }
         }
 
+        function hasChildDeclaration(node: VariableStatement): boolean{
+            return forEach(<VariableDeclaration[]>getNodeLinks(node).visibleChildren, child => {
+                if (isBindingPattern(child.name)) {
+                    return forEach((<BindingPattern>child.name).elements, e => {
+                        return e.kind !== SyntaxKind.OmittedExpression;
+                    });
+                }
+                return true;
+            });
+        }
+
         function emitVariableStatement(node: VariableStatement) {
-            emitJsDocComments(node);
-            emitModuleElementDeclarationFlags(node);
-            if (isLet(node.declarationList)) {
-                write("let ");
+            let children = sortDeclarations(getNodeLinks(node).visibleChildren);
+            if (hasChildDeclaration(node)) {
+                emitJsDocComments(node);
+                emitModuleElementDeclarationFlags(node);
+                if (isLet(node.declarationList)) {
+                    write("let ");
+                }
+                else if (isConst(node.declarationList)) {
+                    write("const ");
+                }
+                else {
+                    write("var ");
+                }
+                emitCommaList(children, emitVariableDeclaration);
+                write(";");
+                writeLine();
             }
-            else if (isConst(node.declarationList)) {
-                write("const ");
+        }
+
+        function getTypeAnnotationFromAccessor(getAccessor: AccessorDeclaration, setAccessor: AccessorDeclaration): TypeNode {
+            if (getAccessor) {
+                return getAccessor.type // Getter - return type
             }
-            else {
-                write("var ");
+            if (setAccessor && setAccessor.parameters.length > 0) {
+                return setAccessor.parameters[0].type;
             }
-            let children = sortDeclarations(getNodeLinks(node).visibleChildren);
-            Debug.assert(children && children.length > 0);
-            emitCommaList(children, emitVariableDeclaration);
-            write(";");
-            writeLine();
         }
 
-        //// TODO: we only should have either statement or declaration
-        //function emitVariableDeclarationWithoutStatement(node: VariableDeclaration) {
-        //    emitJsDocComments(node);
-        //    emitModuleElementDeclarationFlags(node.parent.parent);
-        //    var declarationList = node.parent;
-        //    if (isLet(declarationList)) {
-        //        write("let ");
-        //    }
-        //    else if (isConst(declarationList)) {
-        //        write("const ");
-        //    }
-        //    else {
-        //        write("var ");
-        //    }
-        //    emitVariableDeclaration(node);
-        //    write(";");
-        //    writeLine();
-        //}
-
         function emitAccessorDeclaration(node: AccessorDeclaration) {
             if (hasDynamicName(node)) {
                 return;
             }
 
             let accessors = getAllAccessorDeclarations((<ClassDeclaration>node.parent).members, node);
-            let accessorWithTypeAnnotation: AccessorDeclaration;
 
             if (node === accessors.firstAccessor) {
                 emitJsDocComments(accessors.getAccessor);
@@ -797,31 +798,12 @@ namespace ts {
                 emitClassMemberDeclarationFlags(node);
                 writeTextOfNode(currentSourceFile, node.name);
                 if (!(node.flags & NodeFlags.Private)) {
-                    accessorWithTypeAnnotation = node;
-                    let type = getTypeAnnotationFromAccessor(node);
-                    if (!type) {
-                        // couldn't get type for the first accessor, try the another one
-                        let anotherAccessor = node.kind === SyntaxKind.GetAccessor ? accessors.setAccessor : accessors.getAccessor;
-                        type = getTypeAnnotationFromAccessor(anotherAccessor);
-                        if (type) {
-                            accessorWithTypeAnnotation = anotherAccessor;
-                        }
-                    }
+                    let type = getTypeAnnotationFromAccessor(accessors.getAccessor, accessors.setAccessor);
                     emitTypeOfDeclaration(node, type);
                 }
                 write(";");
                 writeLine();
             }
-
-            function getTypeAnnotationFromAccessor(accessor: AccessorDeclaration): TypeNode {
-                if (accessor) {
-                    return accessor.kind === SyntaxKind.GetAccessor
-                        ? accessor.type // Getter - return type
-                        : accessor.parameters.length > 0
-                            ? accessor.parameters[0].type // Setter parameter type
-                            : undefined;
-                }
-            }
         }
 
         function emitFunctionDeclaration(node: FunctionLikeDeclaration) {
@@ -1014,14 +996,8 @@ namespace ts {
             switch (node.kind) {
                 case SyntaxKind.FunctionDeclaration:
                     return emitFunctionDeclaration(<FunctionLikeDeclaration>node);
-
                 case SyntaxKind.VariableStatement:
                     return emitVariableStatement(<VariableStatement>node);
-                case SyntaxKind.VariableDeclaration:
-                    Debug.fail("should not be here");
-                    //  return emitVariableDeclarationWithoutStatement(<VariableDeclaration>node);
-                    return;
-
                 case SyntaxKind.InterfaceDeclaration:
                     return emitInterfaceDeclaration(<InterfaceDeclaration>node);
                 case SyntaxKind.ClassDeclaration:
@@ -1036,7 +1012,6 @@ namespace ts {
                     return emitImportEqualsDeclaration(<ImportEqualsDeclaration>node);
                 case SyntaxKind.ImportDeclaration:
                     return emitImportDeclaration(<ImportDeclaration>node);
-
                 case SyntaxKind.ExportDeclaration:
                     return emitExportDeclaration(<ExportDeclaration>node);
                 case SyntaxKind.Constructor:
@@ -1059,6 +1034,8 @@ namespace ts {
                     return emitExportAssignment(<ExportAssignment>node);
                 case SyntaxKind.SourceFile:
                     return emitSourceFile(<SourceFile>node);
+               // default:
+                   // Debug.fail(`unknown SyntaxKind: ${node.kind} (${ (<any>ts).SyntaxKind ? (<any>ts).SyntaxKind[node.kind] : ""})`);
             }
         }
 
@@ -1102,9 +1079,9 @@ namespace ts {
                 case SyntaxKind.IndexSignature:
                     return visitSignatureDeclaration(<FunctionLikeDeclaration>node);
 
-                //case SyntaxKind.GetAccessor:
-                //case SyntaxKind.SetAccessor:
-                //    return emitAccessorDeclaration(<AccessorDeclaration>node);
+                case SyntaxKind.GetAccessor:
+                case SyntaxKind.SetAccessor:
+                    return visitAccessorDeclaration(<AccessorDeclaration>node);
 
                 case SyntaxKind.TypeParameter:
                     return visitNode((<TypeParameterDeclaration>node).constraint);
@@ -1118,15 +1095,17 @@ namespace ts {
                     return visitNodes((<TypeAliasDeclaration>node).typeParameters) ||
                         visitNode((<TypeAliasDeclaration>node).type);
 
-                //case SyntaxKind.VariableStatement:
-                //    return visitNodes((<VariableStatement>node).declarationList.declarations);
-
                 case SyntaxKind.Parameter:
                 case SyntaxKind.VariableDeclaration:
                 case SyntaxKind.PropertyDeclaration:
                 case SyntaxKind.PropertySignature:
+                case SyntaxKind.BindingElement:
                     return visitPropertyDeclaration(<PropertyDeclaration>node);
 
+                case SyntaxKind.ObjectBindingPattern:
+                case SyntaxKind.ArrayBindingPattern:
+                    return visitNodes((<BindingPattern>node).elements);
+
                 // TypeNodes
                 case SyntaxKind.AnyKeyword:
                 case SyntaxKind.StringKeyword:
@@ -1221,11 +1200,39 @@ namespace ts {
             }
         }
 
+        function visitAccessorDeclaration(node: AccessorDeclaration) {
+            if (hasDynamicName(node) || node.flags & NodeFlags.Private) {
+                return;
+            }
+
+            let accessors = getAllAccessorDeclarations((<ClassDeclaration>node.parent).members, node);
+
+            if (accessors.firstAccessor === node) {
+                let type = getTypeAnnotationFromAccessor(accessors.getAccessor, accessors.setAccessor);
+                if (type) {
+                    visitNode(type);
+                }
+                else {
+                    // TODO: handel infered type
+                    // TODO: Cache the result
+                    let writer = createNewTextWriterWithSymbolWriter();
+                    let previousErrorNode = currentErrorNode;
+                    currentErrorNode = node;
+                    resolver.writeTypeOfDeclaration(node, getEnclosingDeclaration(node), TypeFormatFlags.UseTypeOfFunction, writer);
+                    currentErrorNode = previousErrorNode;
+                }
+            }
+        }
+
         function visitPropertyDeclaration(node: PropertyDeclaration): void {
             if (hasDynamicName(node) || node.flags & NodeFlags.Private) {
                 return;
             }
 
+            if (isBindingPattern(node.name)) {
+                return visitNode(node.name);
+            }
+
             if (node.type) {
                 visitNode(node.type);
             }
@@ -1391,7 +1398,7 @@ namespace ts {
          *
          */
         function canWriteDeclaration(node: Node): boolean{
-            if (node.kind === SyntaxKind.VariableDeclaration) {
+            if (node.kind === SyntaxKind.VariableDeclaration || node.kind === SyntaxKind.BindingElement) {
                 node = node.parent.parent;
             }
 
@@ -1418,12 +1425,8 @@ namespace ts {
             return false;
         }
 
-        // TODO: remove this and update error messages to not use names
-        function getNameText(node: ParameterDeclaration|PropertyDeclaration|VariableDeclaration):string {
-            if (node.name.kind === SyntaxKind.Identifier) {
-                return (<Identifier>node.name).text;
-            }
-            return "__bindingpattern";
+        function getNameText(node: ParameterDeclaration|PropertyDeclaration|VariableDeclaration): string {
+            return (<Identifier>node.name).text;
         }
 
         function reportDeclarationAccessiblityMessage(referencedDeclaration: Declaration, errorNode: Node): void {
@@ -1446,6 +1449,7 @@ namespace ts {
                             Diagnostics.Extends_clause_of_exported_interface_0_has_or_is_using_private_name_1,
                             (<InterfaceDeclaration>container).name.text, referencedDeclarationName));
                         return;
+                    case SyntaxKind.BindingElement:
                     case SyntaxKind.VariableDeclaration:
                         diagnostics.push(createDiagnosticForNode(errorNode,
                             Diagnostics.Exported_variable_0_has_or_is_using_private_name_1,
@@ -1471,6 +1475,11 @@ namespace ts {
                             Diagnostics.Return_type_of_public_property_getter_from_exported_class_has_or_is_using_private_name_0,
                             referencedDeclarationName));
                         return;
+                    case SyntaxKind.SetAccessor:
+                        diagnostics.push(createDiagnosticForNode(errorNode,
+                            Diagnostics.Parameter_0_of_public_property_setter_from_exported_class_has_or_is_using_private_name_1,
+                            getNameText(<ParameterDeclaration>container), referencedDeclarationName));
+                        return;
                     case SyntaxKind.ConstructSignature:
                         diagnostics.push(createDiagnosticForNode(errorNode,
                             Diagnostics.Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_0,

From cb964c1e7eee808125c4b590f485ce29d36abbb8 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Thu, 9 Jul 2015 22:26:40 -0700
Subject: [PATCH 24/57] Accept baseline for export default case

---
 .../reference/declarationEmitDefaultExport7.errors.txt   | 9 ---------
 .../baselines/reference/declarationEmitDefaultExport7.js | 7 +++++++
 .../reference/declarationEmitDefaultExport7.types        | 8 ++++++++
 3 files changed, 15 insertions(+), 9 deletions(-)
 delete mode 100644 tests/baselines/reference/declarationEmitDefaultExport7.errors.txt
 create mode 100644 tests/baselines/reference/declarationEmitDefaultExport7.types

diff --git a/tests/baselines/reference/declarationEmitDefaultExport7.errors.txt b/tests/baselines/reference/declarationEmitDefaultExport7.errors.txt
deleted file mode 100644
index f19766cbb0093..0000000000000
--- a/tests/baselines/reference/declarationEmitDefaultExport7.errors.txt
+++ /dev/null
@@ -1,9 +0,0 @@
-tests/cases/compiler/declarationEmitDefaultExport7.ts(2,1): error TS4082: Default export of the module has or is using private name 'A'.
-
-
-==== tests/cases/compiler/declarationEmitDefaultExport7.ts (1 errors) ====
-    class A {}
-    export default new A();
-    ~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4082: Default export of the module has or is using private name 'A'.
-    
\ No newline at end of file
diff --git a/tests/baselines/reference/declarationEmitDefaultExport7.js b/tests/baselines/reference/declarationEmitDefaultExport7.js
index 99751113dd66d..7ff280a880629 100644
--- a/tests/baselines/reference/declarationEmitDefaultExport7.js
+++ b/tests/baselines/reference/declarationEmitDefaultExport7.js
@@ -7,3 +7,10 @@ export default new A();
 class A {
 }
 export default new A();
+
+
+//// [declarationEmitDefaultExport7.d.ts]
+declare class A {
+}
+declare var _default: A;
+export default _default;
diff --git a/tests/baselines/reference/declarationEmitDefaultExport7.types b/tests/baselines/reference/declarationEmitDefaultExport7.types
new file mode 100644
index 0000000000000..f3f6698d1396f
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitDefaultExport7.types
@@ -0,0 +1,8 @@
+=== tests/cases/compiler/declarationEmitDefaultExport7.ts ===
+class A {}
+>A : A
+
+export default new A();
+>new A() : A
+>A : typeof A
+

From 50cf293f92d0471f7afc4dec628adca036f2fbc4 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Thu, 9 Jul 2015 23:48:51 -0700
Subject: [PATCH 25/57] accept baselines

---
 .../reference/es6ImportWithoutFromClauseWithExport.js        | 1 -
 .../reference/exportImportNonInstantiatedModule2.symbols     | 1 +
 .../privacyCheckTypeOfInvisibleModuleError.errors.txt        | 5 ++++-
 3 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/tests/baselines/reference/es6ImportWithoutFromClauseWithExport.js b/tests/baselines/reference/es6ImportWithoutFromClauseWithExport.js
index 208f71bcbfe9f..e96b755f76dcd 100644
--- a/tests/baselines/reference/es6ImportWithoutFromClauseWithExport.js
+++ b/tests/baselines/reference/es6ImportWithoutFromClauseWithExport.js
@@ -16,4 +16,3 @@ require("server");
 //// [server.d.ts]
 export declare var a: number;
 //// [client.d.ts]
-export import "server";
diff --git a/tests/baselines/reference/exportImportNonInstantiatedModule2.symbols b/tests/baselines/reference/exportImportNonInstantiatedModule2.symbols
index 02ccf97b1613d..ab1696680c988 100644
--- a/tests/baselines/reference/exportImportNonInstantiatedModule2.symbols
+++ b/tests/baselines/reference/exportImportNonInstantiatedModule2.symbols
@@ -8,6 +8,7 @@ export function w(): e.w { // Should be OK
 >w : Symbol(e.w, Decl(exporter.ts, 0, 0))
 
     return {name: 'value' };
+>{name: 'value' } : Symbol(, Decl(consumer.ts, 3, 10))
 >name : Symbol(name, Decl(consumer.ts, 3, 12))
 }
 === tests/cases/compiler/w1.ts ===
diff --git a/tests/baselines/reference/privacyCheckTypeOfInvisibleModuleError.errors.txt b/tests/baselines/reference/privacyCheckTypeOfInvisibleModuleError.errors.txt
index e8accf360dc96..360555b01875f 100644
--- a/tests/baselines/reference/privacyCheckTypeOfInvisibleModuleError.errors.txt
+++ b/tests/baselines/reference/privacyCheckTypeOfInvisibleModuleError.errors.txt
@@ -1,10 +1,13 @@
+tests/cases/compiler/privacyCheckTypeOfInvisibleModuleError.ts(3,30): error TS4025: Exported variable 'm' has or is using private name 'Inner'.
 tests/cases/compiler/privacyCheckTypeOfInvisibleModuleError.ts(6,26): error TS4025: Exported variable 'f' has or is using private name 'Inner'.
 
 
-==== tests/cases/compiler/privacyCheckTypeOfInvisibleModuleError.ts (1 errors) ====
+==== tests/cases/compiler/privacyCheckTypeOfInvisibleModuleError.ts (2 errors) ====
     module Outer {
         module Inner {
             export var m: typeof Inner;
+                                 ~~~~~
+!!! error TS4025: Exported variable 'm' has or is using private name 'Inner'.
         }
     
         export var f: typeof Inner;

From 0e28beea1c9b3af522d75f09c8a513985af6889f Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Thu, 9 Jul 2015 23:49:37 -0700
Subject: [PATCH 26/57] Fix error reporting issues

---
 src/compiler/declarationEmitter.ts | 46 ++++++++++++++++--------------
 1 file changed, 25 insertions(+), 21 deletions(-)

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index d9beb260b7967..a29819e30d562 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -457,15 +457,17 @@ namespace ts {
                 }
             }
 
-            if (node.importClause.namedBindings.kind === SyntaxKind.NamespaceImport &&
+            if (node.importClause.namedBindings) {
+              if (node.importClause.namedBindings.kind === SyntaxKind.NamespaceImport &&
                 indexOf(children, node.importClause.namedBindings) >= 0) {
                 write("* as ");
                 writeTextOfNode(currentSourceFile, (<NamespaceImport>node.importClause.namedBindings).name);
-            }
-            else if (children.length) {
+              }
+              else if (children.length) {
                 write("{ ");
                 emitCommaList(children, emitImportOrExportSpecifier);
                 write(" }");
+              }
             }
 
             write(" from ");
@@ -1143,7 +1145,7 @@ namespace ts {
                     return visitNode((<QualifiedName>node).left) ||
                         visitNode((<QualifiedName>node).right);
                 case SyntaxKind.Identifier:
-                    return visitTypeName(<Identifier|QualifiedName>node);
+                    return visitTypeName(<Identifier>node);
             }
         }
 
@@ -1153,26 +1155,26 @@ namespace ts {
 
         function visitExportDeclaration(node: ExportDeclaration): void {
             if (!node.moduleSpecifier) {
-                forEach(node.exportClause.elements, collectAliasDeclaration);
+                forEach(node.exportClause.elements, e => collectAliasDeclaration(e, node));
             }
         }
 
         function visitImportEqualsDeclaration(node: ImportEqualsDeclaration): void {
             if (node.moduleReference.kind !== SyntaxKind.ExternalModuleReference) {
-                collectAliasDeclaration(node);
+                collectAliasDeclaration(node, node.moduleReference);
             }
         }
 
         function visitExportAssignment(node: ExportAssignment): void {
             if (node.expression.kind === SyntaxKind.Identifier) {
-                collectAliasDeclaration(node);
+                collectAliasDeclaration(node, node.expression);
             }
             else if (!node.isExportEquals) { 
                 // TODO: handel expressions
                 // TODO: Cache the result
                 let writer = createNewTextWriterWithSymbolWriter();
                 let previousErrorNode = currentErrorNode;
-                currentErrorNode = node;
+                currentErrorNode = node.expression;
                 resolver.writeTypeOfExpression(node.expression, getEnclosingDeclaration(node), TypeFormatFlags.UseTypeOfFunction, writer);
                 currentErrorNode = previousErrorNode;
             }
@@ -1194,7 +1196,7 @@ namespace ts {
                 // TODO: Cache the result
                 let writer = createNewTextWriterWithSymbolWriter();
                 let previousErrorNode = currentErrorNode;
-                currentErrorNode = node;
+                currentErrorNode = node.name || node;
                 resolver.writeReturnTypeOfSignatureDeclaration(node, getEnclosingDeclaration(node), TypeFormatFlags.UseTypeOfFunction, writer);
                 currentErrorNode = previousErrorNode;
             }
@@ -1217,7 +1219,7 @@ namespace ts {
                     // TODO: Cache the result
                     let writer = createNewTextWriterWithSymbolWriter();
                     let previousErrorNode = currentErrorNode;
-                    currentErrorNode = node;
+                    currentErrorNode = node.name;
                     resolver.writeTypeOfDeclaration(node, getEnclosingDeclaration(node), TypeFormatFlags.UseTypeOfFunction, writer);
                     currentErrorNode = previousErrorNode;
                 }
@@ -1241,7 +1243,7 @@ namespace ts {
                 // TODO: Cache the result
                 let writer = createNewTextWriterWithSymbolWriter();
                 let previousErrorNode = currentErrorNode;
-                currentErrorNode = node;
+                currentErrorNode = node.name;
                 resolver.writeTypeOfDeclaration(node, getEnclosingDeclaration(node), TypeFormatFlags.UseTypeOfFunction, writer);
                 currentErrorNode = previousErrorNode;
             }
@@ -1259,16 +1261,18 @@ namespace ts {
             visitNodes(node.typeArguments);
         }
 
-        function visitTypeName(node: Identifier|QualifiedName): void {
+        function visitTypeName(node: Identifier): void {
             let symbol = resolver.getSymbolAtLocation(node);
-            Debug.assert(!!symbol);
-            collectDeclarations(symbol, node);
+            if (symbol) {
+                collectDeclarations(symbol, node);
+            }
         }
 
-        function collectAliasDeclaration(node: ImportOrExportSpecifier|ImportEqualsDeclaration|ExportAssignment) {
+        function collectAliasDeclaration(node: ImportOrExportSpecifier|ImportEqualsDeclaration|ExportAssignment, errorNode: Node) {
             let target = resolver.getLocalTargetOfAliasDeclaration(node);
-            Debug.assert(!!target);
-            collectDeclarations(target, node);
+            if (target) {
+                collectDeclarations(target, errorNode);
+            }
         }
 
 
@@ -1408,7 +1412,7 @@ namespace ts {
                 return true;
             }
 
-            if (node.kind === SyntaxKind.ImportEqualsDeclaration) {
+            if (node.kind === SyntaxKind.ImportEqualsDeclaration || node.kind === SyntaxKind.ImportDeclaration) {
                 return true;
             }
 
@@ -1516,17 +1520,17 @@ namespace ts {
                             (<TypeAliasDeclaration>container).name.text, referencedDeclarationName));
                         return;
                     case SyntaxKind.ExportAssignment:
-                        diagnostics.push(createDiagnosticForNode((<ExportAssignment>errorNode).expression,
+                        diagnostics.push(createDiagnosticForNode(errorNode,
                             Diagnostics.Default_export_of_the_module_has_or_is_using_private_name_0,
                             referencedDeclarationName));
                         return;
                     case SyntaxKind.TypeParameter:
-                        diagnostics.push(createDiagnosticForNode((<TypeParameterDeclaration>errorNode).constraint,
+                        diagnostics.push(createDiagnosticForNode(errorNode,
                             Diagnostics.Type_parameter_0_of_exported_class_has_or_is_using_private_name_1,
                             (<TypeParameterDeclaration>container).name.text, referencedDeclarationName));
                         return;
                     case SyntaxKind.ImportEqualsDeclaration:
-                        diagnostics.push(createDiagnosticForNode((<ImportEqualsDeclaration>errorNode).moduleReference,
+                        diagnostics.push(createDiagnosticForNode(errorNode,
                             Diagnostics.Import_declaration_0_is_using_private_name_1,
                             (<ImportEqualsDeclaration>container).name.text, referencedDeclarationName));
                         return;

From a27e6f2b73062e2eda6d586efff058b594455ea2 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Fri, 10 Jul 2015 12:30:01 -0700
Subject: [PATCH 27/57] handel expressions in heritage clauses

---
 src/compiler/checker.ts                       |  9 ++++
 src/compiler/declarationEmitter.ts            | 36 +++++++++----
 src/compiler/types.ts                         |  1 +
 .../reference/expressionInExtendsClause.js    | 50 +++++++++++++++++++
 .../expressionInExtendsClause.symbols         | 31 ++++++++++++
 .../reference/expressionInExtendsClause.types | 33 ++++++++++++
 ...tendsClauseWithVisibilityErrors.errors.txt | 34 +++++++++++++
 ...sionInExtendsClauseWithVisibilityErrors.js | 45 +++++++++++++++++
 .../compiler/expressionInExtendsClause.ts     | 16 ++++++
 ...sionInExtendsClauseWithVisibilityErrors.ts | 20 ++++++++
 10 files changed, 265 insertions(+), 10 deletions(-)
 create mode 100644 tests/baselines/reference/expressionInExtendsClause.js
 create mode 100644 tests/baselines/reference/expressionInExtendsClause.symbols
 create mode 100644 tests/baselines/reference/expressionInExtendsClause.types
 create mode 100644 tests/baselines/reference/expressionInExtendsClauseWithVisibilityErrors.errors.txt
 create mode 100644 tests/baselines/reference/expressionInExtendsClauseWithVisibilityErrors.js
 create mode 100644 tests/cases/compiler/expressionInExtendsClause.ts
 create mode 100644 tests/cases/compiler/expressionInExtendsClauseWithVisibilityErrors.ts

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 115d504a2ab3e..a6f77f2db45a4 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -14108,6 +14108,14 @@ namespace ts {
             getSymbolDisplayBuilder().buildTypeDisplay(type, writer, enclosingDeclaration, flags);
         }
 
+        function writeBaseConstructorTypeOfClass(node: ClassLikeDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter) {
+            let classSymbol = getSymbolOfNode(node);
+            let classType = <InterfaceType>getDeclaredTypeOfSymbol(classSymbol);
+            resolveBaseTypesOfClass(classType);
+            let type = classType.resolvedBaseTypes[0];
+            getSymbolDisplayBuilder().buildTypeDisplay(type, writer, enclosingDeclaration, flags);
+        }
+
         function hasGlobalName(name: string): boolean {
             return hasProperty(globals, name);
         }
@@ -14179,6 +14187,7 @@ namespace ts {
                 writeTypeOfDeclaration,
                 writeReturnTypeOfSignatureDeclaration,
                 writeTypeOfExpression,
+                writeBaseConstructorTypeOfClass,
                 isSymbolAccessible,
                 isEntityNameVisible,
                 getConstantValue,
diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index a29819e30d562..a025759730034 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -610,6 +610,9 @@ namespace ts {
                 if (isSupportedExpressionWithTypeArguments(node)) {
                     emitType(node);
                 }
+                else {
+                    resolver.writeBaseConstructorTypeOfClass(<ClassLikeDeclaration>enclosingDeclaration, enclosingDeclaration, TypeFormatFlags.UseTypeOfFunction, writer);
+                }
             }
         }
 
@@ -1093,6 +1096,9 @@ namespace ts {
                     return visitNodes((<InterfaceDeclaration|ClassDeclaration>node).typeParameters) ||
                         visitNodes((<InterfaceDeclaration|ClassDeclaration>node).heritageClauses);
 
+                case SyntaxKind.HeritageClause:
+                    return visitHeritageClause(<HeritageClause>node);
+
                 case SyntaxKind.TypeAliasDeclaration:
                     return visitNodes((<TypeAliasDeclaration>node).typeParameters) ||
                         visitNode((<TypeAliasDeclaration>node).type);
@@ -1134,8 +1140,6 @@ namespace ts {
                     return visitSignatureDeclaration(<FunctionOrConstructorTypeNode>node);
                 case SyntaxKind.TypeLiteral:
                     return visitNodes((<TypeLiteralNode>node).members);
-                case SyntaxKind.ExpressionWithTypeArguments:
-                    return visitExpressionWithTypeArguments(<ExpressionWithTypeArguments>node);
                 case SyntaxKind.TypeQuery:
                     return visitNode((<TypeQueryNode>node).exprName);
                 case SyntaxKind.TypeReference:
@@ -1249,15 +1253,27 @@ namespace ts {
             }
         }
 
-        function visitExpressionWithTypeArguments(node: ExpressionWithTypeArguments): void {
-            // TODO: handel infered type
-            // TODO: Cache the result
-            let writer = createNewTextWriterWithSymbolWriter();
-            let previousErrorNode = currentErrorNode;
-            currentErrorNode = node;
-            resolver.writeTypeOfExpression(node.expression, getEnclosingDeclaration(node), TypeFormatFlags.UseTypeOfFunction, writer);
-            currentErrorNode = previousErrorNode;
+        function visitHeritageClause(node: HeritageClause) {
+            let firstEntry = node.types && node.types[0];
+            if (node.token === SyntaxKind.ExtendsKeyword &&
+                firstEntry && !isSupportedExpressionWithTypeArguments(firstEntry)) {
+                // An expression in an extends clause
+                // TODO: Cache the result
+                let writer = createNewTextWriterWithSymbolWriter();
+                let previousErrorNode = currentErrorNode;
+                currentErrorNode = firstEntry;
+                resolver.writeBaseConstructorTypeOfClass((<ClassLikeDeclaration>node.parent), getEnclosingDeclaration(node), TypeFormatFlags.UseTypeOfFunction, writer);
+                currentErrorNode = previousErrorNode;
+            }
+            else {
+                // regular type references
+                forEach(node.types, visitExpressionWithTypeArguments);
+            }
+        }
 
+        function visitExpressionWithTypeArguments(node: ExpressionWithTypeArguments): void {
+            Debug.assert(node.expression.kind === SyntaxKind.Identifier || node.expression.kind === SyntaxKind.PropertyAccessExpression);
+            visitNode(node.expression);
             visitNodes(node.typeArguments);
         }
 
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 728e6369892ea..138726ccc5d62 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -1567,6 +1567,7 @@ namespace ts {
         writeTypeOfDeclaration(declaration: AccessorDeclaration | VariableLikeDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
         writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
         writeTypeOfExpression(expr: Expression, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
+        writeBaseConstructorTypeOfClass(expr: ClassLikeDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
         isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessiblityResult;
         isEntityNameVisible(entityName: EntityName | Expression, enclosingDeclaration: Node): SymbolVisibilityResult;
         // Returns the constant value this property access resolves to, or 'undefined' for a non-constant
diff --git a/tests/baselines/reference/expressionInExtendsClause.js b/tests/baselines/reference/expressionInExtendsClause.js
new file mode 100644
index 0000000000000..50465bb91e9fa
--- /dev/null
+++ b/tests/baselines/reference/expressionInExtendsClause.js
@@ -0,0 +1,50 @@
+//// [expressionInExtendsClause.ts]
+
+export class C<T, U> {
+    x: T;
+    y: U;
+}
+
+// Not exported, but not important in declaration generation
+function getClass(a) {
+    return C;
+}
+
+export class MyClass extends getClass(2) <string, number> {
+}
+
+
+
+//// [expressionInExtendsClause.js]
+var __extends = (this && this.__extends) || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+};
+var C = (function () {
+    function C() {
+    }
+    return C;
+})();
+exports.C = C;
+// Not exported, but not important in declaration generation
+function getClass(a) {
+    return C;
+}
+var MyClass = (function (_super) {
+    __extends(MyClass, _super);
+    function MyClass() {
+        _super.apply(this, arguments);
+    }
+    return MyClass;
+})(getClass(2));
+exports.MyClass = MyClass;
+
+
+//// [expressionInExtendsClause.d.ts]
+export declare class C<T, U> {
+    x: T;
+    y: U;
+}
+export declare class MyClass extends C<string, number> {
+}
diff --git a/tests/baselines/reference/expressionInExtendsClause.symbols b/tests/baselines/reference/expressionInExtendsClause.symbols
new file mode 100644
index 0000000000000..be0b9f97f32fa
--- /dev/null
+++ b/tests/baselines/reference/expressionInExtendsClause.symbols
@@ -0,0 +1,31 @@
+=== tests/cases/compiler/expressionInExtendsClause.ts ===
+
+export class C<T, U> {
+>C : Symbol(C, Decl(expressionInExtendsClause.ts, 0, 0))
+>T : Symbol(T, Decl(expressionInExtendsClause.ts, 1, 15))
+>U : Symbol(U, Decl(expressionInExtendsClause.ts, 1, 17))
+
+    x: T;
+>x : Symbol(x, Decl(expressionInExtendsClause.ts, 1, 22))
+>T : Symbol(T, Decl(expressionInExtendsClause.ts, 1, 15))
+
+    y: U;
+>y : Symbol(y, Decl(expressionInExtendsClause.ts, 2, 9))
+>U : Symbol(U, Decl(expressionInExtendsClause.ts, 1, 17))
+}
+
+// Not exported, but not important in declaration generation
+function getClass(a) {
+>getClass : Symbol(getClass, Decl(expressionInExtendsClause.ts, 4, 1))
+>a : Symbol(a, Decl(expressionInExtendsClause.ts, 7, 18))
+
+    return C;
+>C : Symbol(C, Decl(expressionInExtendsClause.ts, 0, 0))
+}
+
+export class MyClass extends getClass(2) <string, number> {
+>MyClass : Symbol(MyClass, Decl(expressionInExtendsClause.ts, 9, 1))
+>getClass : Symbol(getClass, Decl(expressionInExtendsClause.ts, 4, 1))
+}
+
+
diff --git a/tests/baselines/reference/expressionInExtendsClause.types b/tests/baselines/reference/expressionInExtendsClause.types
new file mode 100644
index 0000000000000..83f237e6aae69
--- /dev/null
+++ b/tests/baselines/reference/expressionInExtendsClause.types
@@ -0,0 +1,33 @@
+=== tests/cases/compiler/expressionInExtendsClause.ts ===
+
+export class C<T, U> {
+>C : C<T, U>
+>T : T
+>U : U
+
+    x: T;
+>x : T
+>T : T
+
+    y: U;
+>y : U
+>U : U
+}
+
+// Not exported, but not important in declaration generation
+function getClass(a) {
+>getClass : (a: any) => typeof C
+>a : any
+
+    return C;
+>C : typeof C
+}
+
+export class MyClass extends getClass(2) <string, number> {
+>MyClass : MyClass
+>getClass(2) : C<string, number>
+>getClass : (a: any) => typeof C
+>2 : number
+}
+
+
diff --git a/tests/baselines/reference/expressionInExtendsClauseWithVisibilityErrors.errors.txt b/tests/baselines/reference/expressionInExtendsClauseWithVisibilityErrors.errors.txt
new file mode 100644
index 0000000000000..f570421846b06
--- /dev/null
+++ b/tests/baselines/reference/expressionInExtendsClauseWithVisibilityErrors.errors.txt
@@ -0,0 +1,34 @@
+tests/cases/compiler/expressionInExtendsClauseWithVisibilityErrors.ts(6,8): error TS4033: Property 'x' of exported interface has or is using private name 'C'.
+tests/cases/compiler/expressionInExtendsClauseWithVisibilityErrors.ts(7,8): error TS4033: Property 'y' of exported interface has or is using private name 'C'.
+tests/cases/compiler/expressionInExtendsClauseWithVisibilityErrors.ts(16,30): error TS4020: Extends clause of exported class 'MyClass' has or is using private name 'C'.
+tests/cases/compiler/expressionInExtendsClauseWithVisibilityErrors.ts(16,30): error TS4020: Extends clause of exported class 'MyClass' has or is using private name 'I'.
+
+
+==== tests/cases/compiler/expressionInExtendsClauseWithVisibilityErrors.ts (4 errors) ====
+    
+    interface I {
+    }
+    
+    class C<T, U> {
+        x: T;
+           ~
+!!! error TS4033: Property 'x' of exported interface has or is using private name 'C'.
+        y: U;
+           ~
+!!! error TS4033: Property 'y' of exported interface has or is using private name 'C'.
+    }
+    
+    function getClass(a) {
+        return C;
+    }
+    
+    // Error C is not exported
+    // Error I is not exported
+    export class MyClass extends getClass(2) <string, I> {
+                                 ~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4020: Extends clause of exported class 'MyClass' has or is using private name 'C'.
+                                 ~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4020: Extends clause of exported class 'MyClass' has or is using private name 'I'.
+    }
+    
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/expressionInExtendsClauseWithVisibilityErrors.js b/tests/baselines/reference/expressionInExtendsClauseWithVisibilityErrors.js
new file mode 100644
index 0000000000000..3c6989c795db2
--- /dev/null
+++ b/tests/baselines/reference/expressionInExtendsClauseWithVisibilityErrors.js
@@ -0,0 +1,45 @@
+//// [expressionInExtendsClauseWithVisibilityErrors.ts]
+
+interface I {
+}
+
+class C<T, U> {
+    x: T;
+    y: U;
+}
+
+function getClass(a) {
+    return C;
+}
+
+// Error C is not exported
+// Error I is not exported
+export class MyClass extends getClass(2) <string, I> {
+}
+
+
+
+//// [expressionInExtendsClauseWithVisibilityErrors.js]
+var __extends = (this && this.__extends) || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+};
+var C = (function () {
+    function C() {
+    }
+    return C;
+})();
+function getClass(a) {
+    return C;
+}
+// Error C is not exported
+// Error I is not exported
+var MyClass = (function (_super) {
+    __extends(MyClass, _super);
+    function MyClass() {
+        _super.apply(this, arguments);
+    }
+    return MyClass;
+})(getClass(2));
+exports.MyClass = MyClass;
diff --git a/tests/cases/compiler/expressionInExtendsClause.ts b/tests/cases/compiler/expressionInExtendsClause.ts
new file mode 100644
index 0000000000000..fffa28fb9de41
--- /dev/null
+++ b/tests/cases/compiler/expressionInExtendsClause.ts
@@ -0,0 +1,16 @@
+// @module: commonjs
+// @declaration: true
+
+export class C<T, U> {
+    x: T;
+    y: U;
+}
+
+// Not exported, but not important in declaration generation
+function getClass(a) {
+    return C;
+}
+
+export class MyClass extends getClass(2) <string, number> {
+}
+
diff --git a/tests/cases/compiler/expressionInExtendsClauseWithVisibilityErrors.ts b/tests/cases/compiler/expressionInExtendsClauseWithVisibilityErrors.ts
new file mode 100644
index 0000000000000..c5218c241fcc6
--- /dev/null
+++ b/tests/cases/compiler/expressionInExtendsClauseWithVisibilityErrors.ts
@@ -0,0 +1,20 @@
+// @module: commonjs
+// @declaration: true
+
+interface I {
+}
+
+class C<T, U> {
+    x: T;
+    y: U;
+}
+
+function getClass(a) {
+    return C;
+}
+
+// Error C is not exported
+// Error I is not exported
+export class MyClass extends getClass(2) <string, I> {
+}
+

From 6384dcfaea939555a9c8ad0e7b4222ef3b1eb3b3 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Fri, 10 Jul 2015 14:45:38 -0700
Subject: [PATCH 28/57] Handel type paramter declarations correctelly

---
 src/compiler/declarationEmitter.ts                   | 12 +++++++-----
 ...ionInExtendsClauseWithVisibilityErrors.errors.txt |  8 +-------
 2 files changed, 8 insertions(+), 12 deletions(-)

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index a025759730034..906ffd0b66349 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -1039,8 +1039,8 @@ namespace ts {
                     return emitExportAssignment(<ExportAssignment>node);
                 case SyntaxKind.SourceFile:
                     return emitSourceFile(<SourceFile>node);
-               // default:
-                   // Debug.fail(`unknown SyntaxKind: ${node.kind} (${ (<any>ts).SyntaxKind ? (<any>ts).SyntaxKind[node.kind] : ""})`);
+                default:
+                    Debug.fail(`unknown SyntaxKind: ${node.kind} (${ (<any>ts).SyntaxKind ? (<any>ts).SyntaxKind[node.kind] : ""})`);
             }
         }
 
@@ -1302,8 +1302,6 @@ namespace ts {
 
             switch (node.kind) {
                 case SyntaxKind.SourceFile:
-                case SyntaxKind.TypeParameter:
-                case SyntaxKind.Parameter:
                 case SyntaxKind.PropertySignature:
                 case SyntaxKind.PropertyDeclaration:
                 case SyntaxKind.MethodSignature:
@@ -1555,7 +1553,11 @@ namespace ts {
             }
         }
 
-        function collectDeclaration(node: Node, errorNode?:Node): void {
+        function collectDeclaration(node: Node, errorNode?: Node): void {
+            if (node.kind === SyntaxKind.TypeParameter || node.kind === SyntaxKind.Parameter) {
+                return;
+            }
+
             let links = getNodeLinks(node);
             if (!links.visited) {
                 links.visited = true;
diff --git a/tests/baselines/reference/expressionInExtendsClauseWithVisibilityErrors.errors.txt b/tests/baselines/reference/expressionInExtendsClauseWithVisibilityErrors.errors.txt
index f570421846b06..ddee65e4cc994 100644
--- a/tests/baselines/reference/expressionInExtendsClauseWithVisibilityErrors.errors.txt
+++ b/tests/baselines/reference/expressionInExtendsClauseWithVisibilityErrors.errors.txt
@@ -1,21 +1,15 @@
-tests/cases/compiler/expressionInExtendsClauseWithVisibilityErrors.ts(6,8): error TS4033: Property 'x' of exported interface has or is using private name 'C'.
-tests/cases/compiler/expressionInExtendsClauseWithVisibilityErrors.ts(7,8): error TS4033: Property 'y' of exported interface has or is using private name 'C'.
 tests/cases/compiler/expressionInExtendsClauseWithVisibilityErrors.ts(16,30): error TS4020: Extends clause of exported class 'MyClass' has or is using private name 'C'.
 tests/cases/compiler/expressionInExtendsClauseWithVisibilityErrors.ts(16,30): error TS4020: Extends clause of exported class 'MyClass' has or is using private name 'I'.
 
 
-==== tests/cases/compiler/expressionInExtendsClauseWithVisibilityErrors.ts (4 errors) ====
+==== tests/cases/compiler/expressionInExtendsClauseWithVisibilityErrors.ts (2 errors) ====
     
     interface I {
     }
     
     class C<T, U> {
         x: T;
-           ~
-!!! error TS4033: Property 'x' of exported interface has or is using private name 'C'.
         y: U;
-           ~
-!!! error TS4033: Property 'y' of exported interface has or is using private name 'C'.
     }
     
     function getClass(a) {

From ffde83c653aae2398ef29463653e4287c90ff978 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Fri, 10 Jul 2015 15:34:41 -0700
Subject: [PATCH 29/57] reorder declarations

---
 src/compiler/declarationEmitter.ts | 198 ++++++++++++++---------------
 1 file changed, 99 insertions(+), 99 deletions(-)

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index 906ffd0b66349..12f6843dacdf1 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -1151,72 +1151,93 @@ namespace ts {
                 case SyntaxKind.Identifier:
                     return visitTypeName(<Identifier>node);
             }
-        }
 
-        function visitNodes(nodes: NodeArray<any>): void {
-            forEach(nodes, visitNode);
-        }
+            return;
 
-        function visitExportDeclaration(node: ExportDeclaration): void {
-            if (!node.moduleSpecifier) {
-                forEach(node.exportClause.elements, e => collectAliasDeclaration(e, node));
+            function visitExportDeclaration(node: ExportDeclaration): void {
+                if (!node.moduleSpecifier) {
+                    forEach(node.exportClause.elements, e => collectAliasDeclaration(e, node));
+                }
             }
-        }
 
-        function visitImportEqualsDeclaration(node: ImportEqualsDeclaration): void {
-            if (node.moduleReference.kind !== SyntaxKind.ExternalModuleReference) {
-                collectAliasDeclaration(node, node.moduleReference);
+            function visitImportEqualsDeclaration(node: ImportEqualsDeclaration): void {
+                if (node.moduleReference.kind !== SyntaxKind.ExternalModuleReference) {
+                    collectAliasDeclaration(node, node.moduleReference);
+                }
             }
-        }
 
-        function visitExportAssignment(node: ExportAssignment): void {
-            if (node.expression.kind === SyntaxKind.Identifier) {
-                collectAliasDeclaration(node, node.expression);
-            }
-            else if (!node.isExportEquals) { 
-                // TODO: handel expressions
-                // TODO: Cache the result
-                let writer = createNewTextWriterWithSymbolWriter();
-                let previousErrorNode = currentErrorNode;
-                currentErrorNode = node.expression;
-                resolver.writeTypeOfExpression(node.expression, getEnclosingDeclaration(node), TypeFormatFlags.UseTypeOfFunction, writer);
-                currentErrorNode = previousErrorNode;
+            function visitExportAssignment(node: ExportAssignment): void {
+                if (node.expression.kind === SyntaxKind.Identifier) {
+                    collectAliasDeclaration(node, node.expression);
+                }
+                else if (!node.isExportEquals) { 
+                    // TODO: handel expressions
+                    // TODO: Cache the result
+                    let writer = createNewTextWriterWithSymbolWriter();
+                    let previousErrorNode = currentErrorNode;
+                    currentErrorNode = node.expression;
+                    resolver.writeTypeOfExpression(node.expression, getEnclosingDeclaration(node), TypeFormatFlags.UseTypeOfFunction, writer);
+                    currentErrorNode = previousErrorNode;
+                }
             }
-        }
 
-        function visitSignatureDeclaration(node: SignatureDeclaration): void {
-            if (hasDynamicName(node) || node.flags & NodeFlags.Private) {
-                return;
-            }
+            function visitSignatureDeclaration(node: SignatureDeclaration): void {
+                if (hasDynamicName(node) || node.flags & NodeFlags.Private) {
+                    return;
+                }
 
-            visitNodes(node.typeParameters);
-            visitNodes(node.parameters);
+                visitNodes(node.typeParameters);
+                visitNodes(node.parameters);
 
-            if (node.type) {
-                visitNode(node.type);
-            }
-            else if (node.kind !== SyntaxKind.Constructor) {
-                // TODO: handel infered type
-                // TODO: Cache the result
-                let writer = createNewTextWriterWithSymbolWriter();
-                let previousErrorNode = currentErrorNode;
-                currentErrorNode = node.name || node;
-                resolver.writeReturnTypeOfSignatureDeclaration(node, getEnclosingDeclaration(node), TypeFormatFlags.UseTypeOfFunction, writer);
-                currentErrorNode = previousErrorNode;
+                if (node.type) {
+                    visitNode(node.type);
+                }
+                else if (node.kind !== SyntaxKind.Constructor) {
+                    // TODO: handel infered type
+                    // TODO: Cache the result
+                    let writer = createNewTextWriterWithSymbolWriter();
+                    let previousErrorNode = currentErrorNode;
+                    currentErrorNode = node.name || node;
+                    resolver.writeReturnTypeOfSignatureDeclaration(node, getEnclosingDeclaration(node), TypeFormatFlags.UseTypeOfFunction, writer);
+                    currentErrorNode = previousErrorNode;
+                }
             }
-        }
 
-        function visitAccessorDeclaration(node: AccessorDeclaration) {
-            if (hasDynamicName(node) || node.flags & NodeFlags.Private) {
-                return;
+            function visitAccessorDeclaration(node: AccessorDeclaration) {
+                if (hasDynamicName(node) || node.flags & NodeFlags.Private) {
+                    return;
+                }
+
+                let accessors = getAllAccessorDeclarations((<ClassDeclaration>node.parent).members, node);
+
+                if (accessors.firstAccessor === node) {
+                    let type = getTypeAnnotationFromAccessor(accessors.getAccessor, accessors.setAccessor);
+                    if (type) {
+                        visitNode(type);
+                    }
+                    else {
+                        // TODO: handel infered type
+                        // TODO: Cache the result
+                        let writer = createNewTextWriterWithSymbolWriter();
+                        let previousErrorNode = currentErrorNode;
+                        currentErrorNode = node.name;
+                        resolver.writeTypeOfDeclaration(node, getEnclosingDeclaration(node), TypeFormatFlags.UseTypeOfFunction, writer);
+                        currentErrorNode = previousErrorNode;
+                    }
+                }
             }
 
-            let accessors = getAllAccessorDeclarations((<ClassDeclaration>node.parent).members, node);
+            function visitPropertyDeclaration(node: PropertyDeclaration): void {
+                if (hasDynamicName(node) || node.flags & NodeFlags.Private) {
+                    return;
+                }
 
-            if (accessors.firstAccessor === node) {
-                let type = getTypeAnnotationFromAccessor(accessors.getAccessor, accessors.setAccessor);
-                if (type) {
-                    visitNode(type);
+                if (isBindingPattern(node.name)) {
+                    return visitNode(node.name);
+                }
+
+                if (node.type) {
+                    visitNode(node.type);
                 }
                 else {
                     // TODO: handel infered type
@@ -1228,59 +1249,40 @@ namespace ts {
                     currentErrorNode = previousErrorNode;
                 }
             }
-        }
 
-        function visitPropertyDeclaration(node: PropertyDeclaration): void {
-            if (hasDynamicName(node) || node.flags & NodeFlags.Private) {
-                return;
+            function visitHeritageClause(node: HeritageClause) {
+                let firstEntry = node.types && node.types[0];
+                if (node.token === SyntaxKind.ExtendsKeyword &&
+                    firstEntry && !isSupportedExpressionWithTypeArguments(firstEntry)) {
+                    // An expression in an extends clause
+                    // TODO: Cache the result
+                    let writer = createNewTextWriterWithSymbolWriter();
+                    let previousErrorNode = currentErrorNode;
+                    currentErrorNode = firstEntry;
+                    resolver.writeBaseConstructorTypeOfClass((<ClassLikeDeclaration>node.parent), getEnclosingDeclaration(node), TypeFormatFlags.UseTypeOfFunction, writer);
+                    currentErrorNode = previousErrorNode;
+                }
+                else {
+                    // regular type references
+                    forEach(node.types, visitExpressionWithTypeArguments);
+                }
             }
 
-            if (isBindingPattern(node.name)) {
-                return visitNode(node.name);
+            function visitExpressionWithTypeArguments(node: ExpressionWithTypeArguments): void {
+                Debug.assert(node.expression.kind === SyntaxKind.Identifier || node.expression.kind === SyntaxKind.PropertyAccessExpression);
+                visitNode(node.expression);
+                visitNodes(node.typeArguments);
             }
 
-            if (node.type) {
-                visitNode(node.type);
-            }
-            else {
-                // TODO: handel infered type
-                // TODO: Cache the result
-                let writer = createNewTextWriterWithSymbolWriter();
-                let previousErrorNode = currentErrorNode;
-                currentErrorNode = node.name;
-                resolver.writeTypeOfDeclaration(node, getEnclosingDeclaration(node), TypeFormatFlags.UseTypeOfFunction, writer);
-                currentErrorNode = previousErrorNode;
-            }
-        }
-
-        function visitHeritageClause(node: HeritageClause) {
-            let firstEntry = node.types && node.types[0];
-            if (node.token === SyntaxKind.ExtendsKeyword &&
-                firstEntry && !isSupportedExpressionWithTypeArguments(firstEntry)) {
-                // An expression in an extends clause
-                // TODO: Cache the result
-                let writer = createNewTextWriterWithSymbolWriter();
-                let previousErrorNode = currentErrorNode;
-                currentErrorNode = firstEntry;
-                resolver.writeBaseConstructorTypeOfClass((<ClassLikeDeclaration>node.parent), getEnclosingDeclaration(node), TypeFormatFlags.UseTypeOfFunction, writer);
-                currentErrorNode = previousErrorNode;
-            }
-            else {
-                // regular type references
-                forEach(node.types, visitExpressionWithTypeArguments);
+            function visitTypeName(node: Identifier): void {
+                let symbol = resolver.getSymbolAtLocation(node);
+                if (symbol) {
+                    collectDeclarations(symbol, node);
+                }
             }
-        }
 
-        function visitExpressionWithTypeArguments(node: ExpressionWithTypeArguments): void {
-            Debug.assert(node.expression.kind === SyntaxKind.Identifier || node.expression.kind === SyntaxKind.PropertyAccessExpression);
-            visitNode(node.expression);
-            visitNodes(node.typeArguments);
-        }
-
-        function visitTypeName(node: Identifier): void {
-            let symbol = resolver.getSymbolAtLocation(node);
-            if (symbol) {
-                collectDeclarations(symbol, node);
+            function visitNodes(nodes: NodeArray<any>): void {
+                forEach(nodes, visitNode);
             }
         }
 
@@ -1291,7 +1293,6 @@ namespace ts {
             }
         }
 
-
         function isDeclarationExported(node: Node): boolean {
             if (compilerOptions.stripInternal && isInternal(node)) {
                 // TODO: this is the correct place for this check, enable this 
@@ -1386,7 +1387,6 @@ namespace ts {
             return undefined;
         }
 
-
         function collectDeclarations(symbol: Symbol, errorNode: Node): void {
             forEach(symbol.declarations, d => collectDeclaration(d, errorNode));
         }

From 99d4e461c4b176e388e8ca7977007f69e06eb17a Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Fri, 10 Jul 2015 16:25:41 -0700
Subject: [PATCH 30/57] clean up collection logic

---
 src/compiler/declarationEmitter.ts | 48 +++++++++++++-----------------
 1 file changed, 21 insertions(+), 27 deletions(-)

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index 12f6843dacdf1..9a7b79e768fbf 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -52,6 +52,7 @@ namespace ts {
         interface NodeLinks {
             visibleChildren?: Node[];
             visited?: boolean;
+            collected?: boolean;
             hasExportDeclarations?: boolean;
         }
 
@@ -1558,39 +1559,27 @@ namespace ts {
                 return;
             }
 
-            let links = getNodeLinks(node);
-            if (!links.visited) {
-                links.visited = true;
+            // Make sure it is connected to its parent
+            ensureDeclarationVisible(node, errorNode);
 
-                // Make the declaration visble by attaching it to its
-                // parent's visible declarations.
-                // also make sure the parent is reachable from a top-level
-                // declaration
-                let parent = getEnclosingDeclaration(node);
-                if (parent) {
-                    ensureDeclarationVisible(parent, errorNode);
-                    attachVisibleChild(parent, node);
-                }
+            let links = getNodeLinks(node);
+            if (!links.collected) {
+                links.collected = true;
 
+                // Collect any dependencies
                 visitNode(node);
-            }
 
-            if (errorNode) {
-                if (!canWriteDeclaration(node)) {
-                    reportDeclarationAccessiblityMessage(<Declaration>node, errorNode);
+                // Collect children as well
+                switch (node.kind) {
+                    case SyntaxKind.ModuleDeclaration:
+                    case SyntaxKind.InterfaceDeclaration:
+                    case SyntaxKind.ClassDeclaration:
+                    case SyntaxKind.EnumDeclaration:
+                    case SyntaxKind.VariableStatement:
+                        collectTopLevelChildDeclarations(node);
+                        break;
                 }
             }
-
-            // Collect children as well
-            switch (node.kind) {
-                case SyntaxKind.ModuleDeclaration:
-                case SyntaxKind.InterfaceDeclaration:
-                case SyntaxKind.ClassDeclaration:
-                case SyntaxKind.EnumDeclaration:
-                case SyntaxKind.VariableStatement:
-                    collectTopLevelChildDeclarations(node);
-                    break;
-            }
         }
 
         function collectTopLevelChildDeclarations(node: Node): void {
@@ -1606,6 +1595,10 @@ namespace ts {
             if (!links.visited) {
                 links.visited = true;
 
+                // Make the declaration visble by attaching it to its
+                // parent's visible declarations.
+                // also make sure the parent is reachable from a top-level
+                // declaration
                 var parent = getEnclosingDeclaration(node);
                 if (parent) {
                     ensureDeclarationVisible(parent, errorNode);
@@ -1613,6 +1606,7 @@ namespace ts {
                 }
             }
 
+            // Always report the error, even if the node was visited before
             if (errorNode) {
                 if (!canWriteDeclaration(node)) {
                     reportDeclarationAccessiblityMessage(<Declaration>node, errorNode);

From 767e27f572748a6fd6215546240c071b1f425dba Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Tue, 14 Jul 2015 10:43:32 -0700
Subject: [PATCH 31/57] Handel missing PropertyAccessExpression

---
 src/compiler/declarationEmitter.ts | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index 9a7b79e768fbf..de73bf610a45b 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -1149,6 +1149,9 @@ namespace ts {
                 case SyntaxKind.QualifiedName:
                     return visitNode((<QualifiedName>node).left) ||
                         visitNode((<QualifiedName>node).right);
+                case SyntaxKind.PropertyAccessExpression:
+                    return visitNode((<PropertyAccessExpression>node).expression) ||
+                        visitNode((<PropertyAccessExpression>node).name);
                 case SyntaxKind.Identifier:
                     return visitTypeName(<Identifier>node);
             }

From edaed88df99b82f03546a5cff954e906de57449c Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Tue, 14 Jul 2015 11:26:52 -0700
Subject: [PATCH 32/57] Filter declarations from other files

---
 src/compiler/declarationEmitter.ts | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index de73bf610a45b..db26b4b50663f 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -1562,9 +1562,15 @@ namespace ts {
                 return;
             }
 
-            // Make sure it is connected to its parent
+            // Make sure this declaration can be emitted, that is it is accessible
+            // and is connected to its parent, or else report a accessibility error
             ensureDeclarationVisible(node, errorNode);
 
+            // If this declaration is from a diffrent file, we will get to it later. 
+            if (getSourceFileOfNode(node) !== currentSourceFile) {
+                return;
+            }
+
             let links = getNodeLinks(node);
             if (!links.collected) {
                 links.collected = true;

From 2f3c689203f48d1842c6c9d061cbe6c69c2c2d91 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Tue, 14 Jul 2015 12:34:19 -0700
Subject: [PATCH 33/57] use forEachChild in visitNode

---
 src/compiler/declarationEmitter.ts | 79 +++++++++---------------------
 1 file changed, 23 insertions(+), 56 deletions(-)

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index db26b4b50663f..33550e229de98 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -1076,6 +1076,24 @@ namespace ts {
                     return visitExportAssignment(<ExportAssignment>node);
 
                 // declarations
+                case SyntaxKind.InterfaceDeclaration:
+                case SyntaxKind.ClassDeclaration:
+                    return visitNodes((<InterfaceDeclaration|ClassDeclaration>node).typeParameters) ||
+                        forEach((<InterfaceDeclaration|ClassDeclaration>node).heritageClauses, visitHeritageClause);
+
+                case SyntaxKind.ModuleDeclaration:
+                case SyntaxKind.EnumDeclaration:
+                case SyntaxKind.EnumMember:
+                    // Nothing to visit here
+                    return;
+
+                case SyntaxKind.TypeAliasDeclaration:
+                    return visitNodes((<TypeAliasDeclaration>node).typeParameters) ||
+                        visitNode((<TypeAliasDeclaration>node).type);
+
+                case SyntaxKind.TypeParameter:
+                    return visitNode((<TypeParameterDeclaration>node).constraint);
+
                 case SyntaxKind.FunctionDeclaration:
                 case SyntaxKind.Constructor:
                 case SyntaxKind.MethodDeclaration:
@@ -1083,27 +1101,14 @@ namespace ts {
                 case SyntaxKind.ConstructSignature:
                 case SyntaxKind.CallSignature:
                 case SyntaxKind.IndexSignature:
+                case SyntaxKind.FunctionType:
+                case SyntaxKind.ConstructorType:
                     return visitSignatureDeclaration(<FunctionLikeDeclaration>node);
 
                 case SyntaxKind.GetAccessor:
                 case SyntaxKind.SetAccessor:
                     return visitAccessorDeclaration(<AccessorDeclaration>node);
 
-                case SyntaxKind.TypeParameter:
-                    return visitNode((<TypeParameterDeclaration>node).constraint);
-
-                case SyntaxKind.InterfaceDeclaration:
-                case SyntaxKind.ClassDeclaration:
-                    return visitNodes((<InterfaceDeclaration|ClassDeclaration>node).typeParameters) ||
-                        visitNodes((<InterfaceDeclaration|ClassDeclaration>node).heritageClauses);
-
-                case SyntaxKind.HeritageClause:
-                    return visitHeritageClause(<HeritageClause>node);
-
-                case SyntaxKind.TypeAliasDeclaration:
-                    return visitNodes((<TypeAliasDeclaration>node).typeParameters) ||
-                        visitNode((<TypeAliasDeclaration>node).type);
-
                 case SyntaxKind.Parameter:
                 case SyntaxKind.VariableDeclaration:
                 case SyntaxKind.PropertyDeclaration:
@@ -1111,49 +1116,11 @@ namespace ts {
                 case SyntaxKind.BindingElement:
                     return visitPropertyDeclaration(<PropertyDeclaration>node);
 
-                case SyntaxKind.ObjectBindingPattern:
-                case SyntaxKind.ArrayBindingPattern:
-                    return visitNodes((<BindingPattern>node).elements);
-
-                // TypeNodes
-                case SyntaxKind.AnyKeyword:
-                case SyntaxKind.StringKeyword:
-                case SyntaxKind.NumberKeyword:
-                case SyntaxKind.BooleanKeyword:
-                case SyntaxKind.SymbolKeyword:
-                case SyntaxKind.VoidKeyword:
-                case SyntaxKind.StringLiteral:
-                    // Nothing to visit
-                    return;
-
-                case SyntaxKind.TypePredicate:
-                    return visitNode((<TypePredicateNode>node).type);
-                case SyntaxKind.ArrayType:
-                    return visitNode((<ArrayTypeNode>node).elementType);
-                case SyntaxKind.TupleType:
-                    return visitNodes((<TupleTypeNode>node).elementTypes);
-                case SyntaxKind.UnionType:
-                    return visitNodes((<UnionTypeNode>node).types);
-                case SyntaxKind.ParenthesizedType:
-                    return visitNode((<ParenthesizedTypeNode>node).type);
-                case SyntaxKind.FunctionType:
-                case SyntaxKind.ConstructorType:
-                    return visitSignatureDeclaration(<FunctionOrConstructorTypeNode>node);
-                case SyntaxKind.TypeLiteral:
-                    return visitNodes((<TypeLiteralNode>node).members);
-                case SyntaxKind.TypeQuery:
-                    return visitNode((<TypeQueryNode>node).exprName);
-                case SyntaxKind.TypeReference:
-                    return visitNode((<TypeReferenceNode>node).typeName) ||
-                        visitNodes((<TypeReferenceNode>node).typeArguments);
-                case SyntaxKind.QualifiedName:
-                    return visitNode((<QualifiedName>node).left) ||
-                        visitNode((<QualifiedName>node).right);
-                case SyntaxKind.PropertyAccessExpression:
-                    return visitNode((<PropertyAccessExpression>node).expression) ||
-                        visitNode((<PropertyAccessExpression>node).name);
                 case SyntaxKind.Identifier:
                     return visitTypeName(<Identifier>node);
+
+                default:
+                    return forEachChild(node, visitNode);
             }
 
             return;

From d1ce92eb200954b3978191ffd8fe76d2f92f42d9 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Tue, 14 Jul 2015 12:36:01 -0700
Subject: [PATCH 34/57] Do not collect import declarations

---
 src/compiler/declarationEmitter.ts | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index 33550e229de98..2d426bed8615b 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -1067,15 +1067,17 @@ namespace ts {
             if (!node) return;
 
             switch (node.kind) {
-                // import/export aliases
                 case SyntaxKind.ExportDeclaration:
                     return visitExportDeclaration(<ExportDeclaration>node);
                 case SyntaxKind.ImportEqualsDeclaration:
                     return visitImportEqualsDeclaration(<ImportEqualsDeclaration>node);
                 case SyntaxKind.ExportAssignment:
                     return visitExportAssignment(<ExportAssignment>node);
+                case SyntaxKind.ImportDeclaration:
+                case SyntaxKind.ImportClause:
+                    // Nothing to visit, import declarations are only pulled in if referenced
+                    return;
 
-                // declarations
                 case SyntaxKind.InterfaceDeclaration:
                 case SyntaxKind.ClassDeclaration:
                     return visitNodes((<InterfaceDeclaration|ClassDeclaration>node).typeParameters) ||

From 6193c5a3fdf4ff9565c3fea67764c07e8fb4674c Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Tue, 14 Jul 2015 12:55:44 -0700
Subject: [PATCH 35/57] Revert "Accept symbol baselines"

This reverts commit a823d7dbe798d62da7fc1a7c80ab4aa451e383fb.
---
 src/compiler/checker.ts                       |    2 +-
 tests/baselines/reference/2dArrays.symbols    |    1 -
 ...nctionWithTheSameNameAndCommonRoot.symbols |    1 -
 .../reference/ArrowFunction4.symbols          |    1 -
 ...dNonExportedFunctionThatShareAName.symbols |    2 -
 ...bleAndNonExportedVarThatShareAName.symbols |    2 -
 tests/baselines/reference/ES5For-of10.symbols |    1 -
 tests/baselines/reference/ES5For-of9.symbols  |    1 -
 ...sHeritageListMemberTypeAnnotations.symbols |    2 -
 ...sibleTypeInTypeParameterConstraint.symbols |    2 -
 ...InParameterAndReturnTypeAnnotation.symbols |    1 -
 ...ibleTypesInParameterTypeAnnotation.symbols |    1 -
 ...essibleTypesInReturnTypeAnnotation.symbols |    1 -
 ...sHeritageListMemberTypeAnnotations.symbols |    2 -
 ...sibleTypeInTypeParameterConstraint.symbols |    2 -
 ...ccessibleTypesOnItsExportedMembers.symbols |    1 -
 ...ssibleTypesInMemberTypeAnnotations.symbols |    2 -
 ...WithAccessibleTypeInTypeAnnotation.symbols |    1 -
 ...thInaccessibleTypeInTypeAnnotation.symbols |    2 -
 ...WithSameNameAndDifferentCommonRoot.symbols |    2 -
 ...AndNonExportedClassesOfTheSameName.symbols |    1 -
 ...dNonExportedLocalVarsOfTheSameName.symbols |    3 -
 ...hTheSameNameAndDifferentCommonRoot.symbols |    2 -
 ...esWithTheSameNameAndSameCommonRoot.symbols |    3 -
 .../reference/accessorWithES5.symbols         |    2 -
 ...dditionOperatorWithAnyAndEveryType.symbols |    2 -
 ...tionOperatorWithStringAndEveryType.symbols |    1 -
 .../aliasUsageInFunctionExpression.symbols    |    2 -
 .../aliasUsageInGenericFunction.symbols       |    2 -
 .../aliasUsageInObjectLiteral.symbols         |    4 -
 .../aliasUsageInOrExpression.symbols          |    2 -
 .../reference/aliasUsedAsNameValue.symbols    |    1 -
 .../amdImportNotAsPrimaryExpression.symbols   |    1 -
 tests/baselines/reference/anonterface.symbols |    1 -
 .../anonymousClassExpression1.symbols         |    1 -
 .../anyInferenceAnonymousFunctions.symbols    |    8 -
 ...gumentsUsedInObjectLiteralProperty.symbols |    2 -
 .../reference/arrayBestCommonTypes.symbols    |   30 -
 ...ayBindingPatternOmittedExpressions.symbols |    1 -
 .../reference/arrayConcatMap.symbols          |    3 -
 .../arrayLiteralTypeInference.symbols         |    4 -
 ...LiteralWithMultipleBestCommonTypes.symbols |    8 -
 .../baselines/reference/arrayLiterals.symbols |    4 -
 .../reference/arrayLiterals2ES5.symbols       |    1 -
 .../reference/arrayLiterals2ES6.symbols       |    1 -
 .../reference/arrayOfFunctionTypes3.symbols   |    2 -
 tests/baselines/reference/arrayconcat.symbols |    1 -
 .../arrowFunctionExpressions.symbols          |   36 -
 ...rrowFunctionInExpressionStatement1.symbols |    3 +-
 ...rrowFunctionInExpressionStatement2.symbols |    1 -
 ...rrowFunctionWithObjectLiteralBody1.symbols |    2 -
 ...rrowFunctionWithObjectLiteralBody2.symbols |    2 -
 ...rrowFunctionWithObjectLiteralBody3.symbols |    2 -
 ...rrowFunctionWithObjectLiteralBody4.symbols |    2 -
 ...rrowFunctionWithObjectLiteralBody5.symbols |    8 -
 ...rrowFunctionWithObjectLiteralBody6.symbols |    8 -
 .../reference/asiInES6Classes.symbols         |    1 -
 .../asiPreventsParsingAsNamespace04.symbols   |    1 -
 tests/baselines/reference/assign1.symbols     |    1 -
 .../reference/assignEveryTypeToAny.symbols    |    2 -
 .../reference/assignToPrototype1.symbols      |    1 -
 .../assignmentCompatForEnums.symbols          |    1 -
 .../assignmentCompatWithObjectMembers.symbols |    4 -
 ...assignmentCompatWithObjectMembers2.symbols |    2 -
 ...assignmentCompatWithObjectMembers3.symbols |    2 -
 ...ompatWithObjectMembersNumericNames.symbols |    2 -
 .../assignmentCompatability1.symbols          |    2 -
 .../assignmentCompatability2.symbols          |    1 -
 .../assignmentCompatability3.symbols          |    2 -
 .../assignmentCompatability4.symbols          |    1 -
 .../assignmentCompatability5.symbols          |    2 -
 .../assignmentCompatability6.symbols          |    2 -
 .../assignmentCompatability7.symbols          |    2 -
 .../assignmentCompatability8.symbols          |    1 -
 .../assignmentCompatability9.symbols          |    1 -
 ...tedTypeBracketAccessIndexSignature.symbols |    2 -
 ...ntedTypeBracketNamedPropertyAccess.symbols |    2 -
 .../reference/badOverloadError.symbols        |    1 -
 .../reference/badThisBinding.symbols          |    2 -
 ...CommonTypeOfConditionalExpressions.symbols |    7 -
 ...bestCommonTypeWithContextualTyping.symbols |    1 -
 .../reference/binaryIntegerLiteral.symbols    |    2 -
 .../reference/binaryIntegerLiteralES6.symbols |    2 -
 .../bitwiseNotOperatorWithBooleanType.symbols |    1 -
 .../bitwiseNotOperatorWithNumberType.symbols  |    3 -
 .../bitwiseNotOperatorWithStringType.symbols  |    3 -
 ...nericFunctionWithZeroTypeArguments.symbols |    1 -
 ...thoutReturnTypeAnnotationInference.symbols |    1 -
 ...llSignaturesWithOptionalParameters.symbols |    5 -
 .../reference/callbacksDontShareTypes.symbols |    3 -
 .../reference/captureThisInSuperCall.symbols  |    2 -
 .../castExpressionParentheses.symbols         |    3 -
 tests/baselines/reference/castTest.symbols    |    3 -
 ...dSpecializationToObjectTypeLiteral.symbols |    2 -
 .../reference/classExpression.symbols         |    4 -
 .../reference/classExpression1.symbols        |    1 -
 .../reference/classExpression2.symbols        |    1 -
 .../reference/classExpression3.symbols        |    3 -
 .../reference/classExpression4.symbols        |    1 -
 .../reference/classExpressionES61.symbols     |    1 -
 .../reference/classExpressionES62.symbols     |    1 -
 .../reference/classExpressionES63.symbols     |    3 -
 .../reference/classExpressionTest1.symbols    |    1 -
 .../reference/classExpressionTest2.symbols    |    2 -
 ...hResolutionOfNamespaceOfSameName01.symbols |    1 -
 ...assExpressionWithStaticProperties1.symbols |    1 -
 ...assExpressionWithStaticProperties2.symbols |    1 -
 ...ExpressionWithStaticPropertiesES61.symbols |    1 -
 ...ExpressionWithStaticPropertiesES62.symbols |    1 -
 ...MemberInitializerWithLamdaScoping5.symbols |    1 -
 .../reference/classWithEmptyBody.symbols      |    4 -
 .../classWithProtectedProperty.symbols        |    2 -
 .../reference/classWithPublicProperty.symbols |    2 -
 ...llisionRestParameterArrowFunctions.symbols |    4 -
 ...peratorWithSecondOperandObjectType.symbols |    4 -
 .../reference/commentInMethodCall.symbols     |    1 -
 .../commentOnSimpleArrowFunctionBody1.symbols |    1 -
 .../commentsBeforeFunctionExpression1.symbols |    2 -
 .../reference/commentsFunction.symbols        |    7 -
 .../reference/commentsInterface.symbols       |    2 -
 .../commentsOnObjectLiteral3.symbols          |    2 -
 .../commentsOnObjectLiteral4.symbols          |    1 -
 .../commentsPropertySignature1.symbols        |    1 -
 .../reference/commentsVarDecl.symbols         |    1 -
 ...mmonJSImportNotAsPrimaryExpression.symbols |    1 -
 .../complexClassRelationships.symbols         |    1 -
 ...AdditionAssignmentLHSCanBeAssigned.symbols |    2 -
 .../computedPropertyNames10_ES5.symbols       |    1 -
 .../computedPropertyNames10_ES6.symbols       |    1 -
 .../computedPropertyNames11_ES5.symbols       |    1 -
 .../computedPropertyNames11_ES6.symbols       |    1 -
 .../computedPropertyNames18_ES5.symbols       |    1 -
 .../computedPropertyNames18_ES6.symbols       |    1 -
 .../computedPropertyNames1_ES5.symbols        |    1 -
 .../computedPropertyNames1_ES6.symbols        |    1 -
 .../computedPropertyNames20_ES5.symbols       |    1 -
 .../computedPropertyNames20_ES6.symbols       |    1 -
 .../computedPropertyNames22_ES5.symbols       |    1 -
 .../computedPropertyNames22_ES6.symbols       |    1 -
 .../computedPropertyNames25_ES5.symbols       |    1 -
 .../computedPropertyNames25_ES6.symbols       |    1 -
 .../computedPropertyNames28_ES5.symbols       |    1 -
 .../computedPropertyNames28_ES6.symbols       |    1 -
 .../computedPropertyNames29_ES5.symbols       |    3 -
 .../computedPropertyNames29_ES6.symbols       |    3 -
 .../computedPropertyNames31_ES5.symbols       |    3 -
 .../computedPropertyNames31_ES6.symbols       |    3 -
 .../computedPropertyNames33_ES5.symbols       |    1 -
 .../computedPropertyNames33_ES6.symbols       |    1 -
 .../computedPropertyNames46_ES5.symbols       |    1 -
 .../computedPropertyNames46_ES6.symbols       |    1 -
 .../computedPropertyNames47_ES5.symbols       |    1 -
 .../computedPropertyNames47_ES6.symbols       |    1 -
 .../computedPropertyNames48_ES5.symbols       |    3 -
 .../computedPropertyNames48_ES6.symbols       |    3 -
 .../computedPropertyNames4_ES5.symbols        |    1 -
 .../computedPropertyNames4_ES6.symbols        |    1 -
 .../computedPropertyNames7_ES5.symbols        |    1 -
 .../computedPropertyNames7_ES6.symbols        |    1 -
 ...edPropertyNamesContextualType1_ES5.symbols |    2 -
 ...edPropertyNamesContextualType1_ES6.symbols |    2 -
 ...edPropertyNamesContextualType2_ES5.symbols |    2 -
 ...edPropertyNamesContextualType2_ES6.symbols |    2 -
 ...edPropertyNamesContextualType3_ES5.symbols |    2 -
 ...edPropertyNamesContextualType3_ES6.symbols |    2 -
 ...edPropertyNamesContextualType4_ES5.symbols |    1 -
 ...edPropertyNamesContextualType4_ES6.symbols |    1 -
 ...edPropertyNamesContextualType5_ES5.symbols |    1 -
 ...edPropertyNamesContextualType5_ES6.symbols |    1 -
 ...edPropertyNamesContextualType6_ES5.symbols |    3 -
 ...edPropertyNamesContextualType6_ES6.symbols |    3 -
 ...edPropertyNamesContextualType7_ES5.symbols |    3 -
 ...edPropertyNamesContextualType7_ES6.symbols |    3 -
 ...dPropertyNamesDeclarationEmit5_ES5.symbols |    1 -
 ...dPropertyNamesDeclarationEmit5_ES6.symbols |    1 -
 ...omputedPropertyNamesSourceMap2_ES5.symbols |    1 -
 ...omputedPropertyNamesSourceMap2_ES6.symbols |    1 -
 .../reference/conditionalExpressions2.symbols |    3 -
 ...ionalOperatorConditionIsObjectType.symbols |   12 -
 ...onditionalOperatorWithIdenticalBCT.symbols |   20 -
 ...verloadsCausedByOverloadResolution.symbols |    2 -
 .../constEnumPropertyAccess1.symbols          |    2 -
 ...straintSatisfactionWithEmptyObject.symbols |    8 -
 .../contextualSignatureInstantiation1.symbols |    2 -
 .../contextualSignatureInstantiation2.symbols |    3 -
 .../reference/contextualTypeAny.symbols       |    1 -
 .../contextualTypeAppliedToVarArgs.symbols    |    2 -
 .../contextualTypeArrayReturnType.symbols     |    4 -
 ...ualTypeWithUnionTypeCallSignatures.symbols |    5 -
 ...alTypeWithUnionTypeIndexSignatures.symbols |   18 -
 ...contextualTypeWithUnionTypeMembers.symbols |   37 -
 .../reference/contextualTyping1.symbols       |    1 -
 .../reference/contextualTyping10.symbols      |    2 -
 .../reference/contextualTyping12.symbols      |    2 -
 .../reference/contextualTyping13.symbols      |    1 -
 .../reference/contextualTyping14.symbols      |    1 -
 .../reference/contextualTyping15.symbols      |    1 -
 .../reference/contextualTyping16.symbols      |    2 -
 .../reference/contextualTyping17.symbols      |    2 -
 .../reference/contextualTyping18.symbols      |    2 -
 .../reference/contextualTyping19.symbols      |    3 -
 .../reference/contextualTyping2.symbols       |    1 -
 .../reference/contextualTyping20.symbols      |    3 -
 .../reference/contextualTyping22.symbols      |    2 -
 .../reference/contextualTyping23.symbols      |    1 -
 .../reference/contextualTyping25.symbols      |    1 -
 .../reference/contextualTyping26.symbols      |    1 -
 .../reference/contextualTyping27.symbols      |    1 -
 .../reference/contextualTyping3.symbols       |    1 -
 .../reference/contextualTyping32.symbols      |    2 -
 .../reference/contextualTyping34.symbols      |    1 -
 .../reference/contextualTyping35.symbols      |    1 -
 .../reference/contextualTyping36.symbols      |    2 -
 .../reference/contextualTyping37.symbols      |    2 -
 .../reference/contextualTyping38.symbols      |    1 -
 .../reference/contextualTyping4.symbols       |    1 -
 .../reference/contextualTyping40.symbols      |    1 -
 .../reference/contextualTyping6.symbols       |    2 -
 .../reference/contextualTyping7.symbols       |    1 -
 .../reference/contextualTyping8.symbols       |    1 -
 .../reference/contextualTyping9.symbols       |    2 -
 .../contextualTypingArrayOfLambdas.symbols    |    3 -
 ...xtualTypingOfConditionalExpression.symbols |    4 -
 ...pingOfLambdaWithMultipleSignatures.symbols |    1 -
 ...ingOfLambdaWithMultipleSignatures2.symbols |    1 -
 ...ingTwoInstancesOfSameTypeParameter.symbols |    2 -
 ...gWithGenericAndNonGenericSignature.symbols |    2 -
 ...ntextualTypingWithGenericSignature.symbols |    1 -
 ...ionExpressionsAndReturnAnnotations.symbols |    3 -
 .../contextuallyTypingOrOperator.symbols      |   10 -
 .../contextuallyTypingOrOperator2.symbols     |    6 -
 tests/baselines/reference/covariance1.symbols |    2 -
 .../reference/crashInResolveInterface.symbols |    1 -
 .../baselines/reference/debuggerEmit.symbols  |    1 -
 ...eAssignmentInObjectLiteralProperty.symbols |    3 -
 .../reference/declFileRegressionTests.symbols |    2 -
 ...arametersOfFunctionAndFunctionType.symbols |    1 -
 .../declFileTypeAnnotationArrayType.symbols   |    2 -
 .../declFileTypeAnnotationParenType.symbols   |    4 -
 .../declFileTypeAnnotationTupleType.symbols   |    1 -
 .../declFileTypeAnnotationUnionType.symbols   |    2 -
 ...AnnotationVisibilityErrorAccessors.symbols |  182 --
 ...VisibilityErrorParameterOfFunction.symbols |   95 -
 .../reference/declFileTypeofFunction.symbols  |    2 -
 .../declFileTypeofInAnonymousType.symbols     |    6 -
 tests/baselines/reference/declInput3.symbols  |    1 -
 .../declarationEmitDestructuring4.symbols     |    1 -
 ...tionEmitDestructuringArrayPattern2.symbols |    3 -
 ...tDestructuringObjectLiteralPattern.symbols |   11 -
 ...DestructuringObjectLiteralPattern1.symbols |    7 -
 ...DestructuringObjectLiteralPattern2.symbols |    4 -
 ...ationEmitDestructuringPrivacyError.symbols |   13 -
 ...InstantiateModulesInFunctionBodies.symbols |    2 -
 .../decrementOperatorWithAnyOtherType.symbols |    1 -
 .../reference/defaultIndexProps1.symbols      |    1 -
 .../reference/defaultIndexProps2.symbols      |    1 -
 .../deleteOperatorWithBooleanType.symbols     |    1 -
 .../deleteOperatorWithNumberType.symbols      |    3 -
 .../deleteOperatorWithStringType.symbols      |    3 -
 .../reference/derivedClasses.symbols          |    2 -
 ...ddenBaseCallViaSuperPropertyAccess.symbols |    3 -
 ...ectBindingPatternAndAssignment1ES5.symbols |   15 -
 ...ectBindingPatternAndAssignment1ES6.symbols |   15 -
 ...structuringVariableDeclaration1ES5.symbols |   15 -
 ...structuringVariableDeclaration1ES6.symbols |   15 -
 ...tachedCommentAtStartOfConstructor1.symbols |    1 -
 ...tachedCommentAtStartOfConstructor2.symbols |    1 -
 ...hedCommentAtStartOfLambdaFunction1.symbols |    1 -
 ...hedCommentAtStartOfLambdaFunction2.symbols |    1 -
 ...nAtObjectLiteralPropertyAssignment.symbols |    2 -
 .../reference/doWhileBreakStatements.symbols  |    1 -
 .../doWhileContinueStatements.symbols         |    1 -
 .../reference/dottedSymbolResolution1.symbols |    1 -
 .../reference/downlevelLetConst12.symbols     |    2 -
 .../reference/downlevelLetConst13.symbols     |    4 -
 .../reference/downlevelLetConst14.symbols     |    4 -
 .../reference/downlevelLetConst15.symbols     |    6 -
 ...plicateOverloadInTypeAugmentation1.symbols |    1 -
 .../reference/emitArrowFunction.symbols       |    6 -
 .../reference/emitArrowFunctionAsIs.symbols   |    3 -
 .../emitArrowFunctionAsIsES6.symbols          |    3 -
 .../reference/emitArrowFunctionES6.symbols    |   17 -
 .../emitArrowFunctionThisCapturing.symbols    |    3 -
 .../emitArrowFunctionThisCapturingES6.symbols |    3 -
 ...owFunctionWhenUsingArguments01_ES6.symbols |    8 -
 ...owFunctionWhenUsingArguments02_ES6.symbols |    1 -
 ...owFunctionWhenUsingArguments03_ES6.symbols |    1 -
 ...owFunctionWhenUsingArguments04_ES6.symbols |    1 -
 ...owFunctionWhenUsingArguments05_ES6.symbols |    1 -
 ...owFunctionWhenUsingArguments06_ES6.symbols |    2 -
 ...owFunctionWhenUsingArguments07_ES6.symbols |    2 -
 ...tArrowFunctionWhenUsingArguments08.symbols |    2 -
 ...owFunctionWhenUsingArguments08_ES6.symbols |    2 -
 ...owFunctionWhenUsingArguments09_ES6.symbols |    2 -
 ...owFunctionWhenUsingArguments10_ES6.symbols |    2 -
 ...owFunctionWhenUsingArguments11_ES6.symbols |    2 -
 ...tArrowFunctionWhenUsingArguments13.symbols |    2 -
 ...owFunctionWhenUsingArguments13_ES6.symbols |    2 -
 ...owFunctionWhenUsingArguments14_ES6.symbols |    1 -
 ...owFunctionWhenUsingArguments15_ES6.symbols |    1 -
 ...owFunctionWhenUsingArguments16_ES6.symbols |    1 -
 ...owFunctionWhenUsingArguments17_ES6.symbols |    2 -
 ...owFunctionWhenUsingArguments18_ES6.symbols |    2 -
 ...owFunctionWhenUsingArguments19_ES6.symbols |    1 -
 .../reference/emitArrowFunctionsAsIs.symbols  |    3 -
 .../emitArrowFunctionsAsIsES6.symbols         |    3 -
 ...ssDeclarationWithSuperMethodCall01.symbols |    1 -
 ...efaultParametersFunctionExpression.symbols |    7 -
 ...ultParametersFunctionExpressionES6.symbols |    7 -
 ...tDefaultParametersFunctionProperty.symbols |    1 -
 ...faultParametersFunctionPropertyES6.symbols |    1 -
 ...itRestParametersFunctionExpression.symbols |    4 -
 ...estParametersFunctionExpressionES6.symbols |    4 -
 ...emitRestParametersFunctionProperty.symbols |    1 -
 ...tRestParametersFunctionPropertyES6.symbols |    1 -
 tests/baselines/reference/emptyExpr.symbols   |    3 +-
 ...ptyObjectBindingPatternParameter04.symbols |    1 -
 tests/baselines/reference/enumIndexer.symbols |    3 -
 .../baselines/reference/es6ClassTest5.symbols |    1 -
 .../baselines/reference/es6ClassTest8.symbols |    1 -
 .../reference/escapedIdentifiers.symbols      |    4 -
 ...pedReservedCompilerNamedIdentifier.symbols |    6 -
 ...ryTypeWithAnnotationAndInitializer.symbols |    3 -
 .../everyTypeWithInitializer.symbols          |    2 -
 .../exportAssignmentMergedInterface.symbols   |    1 -
 ...exportAssignmentWithoutIdentifier1.symbols |    1 -
 .../exportImportNonInstantiatedModule.symbols |    1 -
 ...exportImportNonInstantiatedModule2.symbols |    1 -
 .../reference/exportedVariable1.symbols       |    1 -
 ...ingClassFromAliasAndUsageInIndexer.symbols |    1 -
 .../baselines/reference/fatArrowSelf.symbols  |    1 -
 .../reference/fatArrowfunctionAsType.symbols  |    1 -
 .../reference/fatarrowfunctions.symbols       |   22 -
 ...nctionsInFunctionParameterDefaults.symbols |    1 -
 .../fatarrowfunctionsInFunctions.symbols      |    3 -
 tests/baselines/reference/for-of18.symbols    |    2 -
 tests/baselines/reference/for-of19.symbols    |    2 -
 tests/baselines/reference/for-of20.symbols    |    2 -
 tests/baselines/reference/for-of21.symbols    |    2 -
 tests/baselines/reference/for-of22.symbols    |    2 -
 tests/baselines/reference/for-of23.symbols    |    2 -
 tests/baselines/reference/for-of41.symbols    |    2 -
 tests/baselines/reference/for-of42.symbols    |    1 -
 .../reference/forBreakStatements.symbols      |    1 -
 .../reference/forContinueStatements.symbols   |    1 -
 .../reference/forInBreakStatements.symbols    |   12 -
 .../reference/forInContinueStatements.symbols |   12 -
 .../baselines/reference/forStatements.symbols |    3 -
 .../forStatementsMultipleValidDecl.symbols    |    7 -
 tests/baselines/reference/funcdecl.symbols    |    2 -
 .../reference/functionAssignmentError.symbols |    2 -
 .../functionConstraintSatisfaction.symbols    |    8 -
 .../functionConstraintSatisfaction3.symbols   |    6 -
 ...ExpressionAndLambdaMatchesFunction.symbols |    2 -
 ...unctionExpressionContextualTyping1.symbols |   12 -
 .../functionExpressionReturningItself.symbols |    1 -
 ...thResolutionOfTypeNamedArguments01.symbols |    1 -
 ...onWithResolutionOfTypeOfSameName01.symbols |    1 -
 ...onWithResolutionOfTypeOfSameName02.symbols |    1 -
 .../reference/functionImplementations.symbols |   20 -
 .../reference/functionLiteral.symbols         |    2 -
 .../functionLiteralForOverloads.symbols       |    4 -
 .../reference/functionOverloads14.symbols     |    1 -
 .../reference/functionOverloads24.symbols     |    1 -
 .../reference/functionOverloads35.symbols     |    1 -
 .../reference/functionOverloads36.symbols     |    1 -
 .../reference/functionOverloads38.symbols     |    1 -
 .../reference/functionOverloads39.symbols     |    1 -
 .../reference/functionOverloads42.symbols     |    1 -
 ...AnyReturnTypeAndNoReturnExpression.symbols |    2 -
 .../generatedContextualTyping.symbols         |  368 ---
 .../reference/generatorES6_3.symbols          |    1 -
 .../reference/generatorES6_4.symbols          |    1 -
 .../reference/generatorTypeCheck26.symbols    |    3 -
 .../reference/generatorTypeCheck27.symbols    |    3 -
 .../reference/generatorTypeCheck28.symbols    |    3 -
 .../reference/generatorTypeCheck29.symbols    |    3 -
 .../reference/generatorTypeCheck30.symbols    |    3 -
 .../reference/generatorTypeCheck41.symbols    |    1 -
 .../reference/generatorTypeCheck42.symbols    |    1 -
 .../reference/generatorTypeCheck43.symbols    |    1 -
 .../reference/generatorTypeCheck44.symbols    |    1 -
 .../reference/generatorTypeCheck45.symbols    |    3 -
 .../reference/generatorTypeCheck46.symbols    |    5 -
 .../baselines/reference/genericArray1.symbols |    1 -
 .../genericBaseClassLiteralProperty2.symbols  |    1 -
 .../genericCallWithObjectTypeArgs2.symbols    |    4 -
 ...lWithObjectTypeArgsAndConstraints2.symbols |    5 -
 ...thOverloadedFunctionTypedArguments.symbols |    8 -
 .../genericCallbacksAndClassHierarchy.symbols |    2 -
 ...ericContextualTypingSpecialization.symbols |    1 -
 .../genericFunctionHasFreshTypeArgs.symbols   |    2 -
 .../reference/genericFunctions2.symbols       |    1 -
 ...icFunctionsWithOptionalParameters3.symbols |    6 -
 .../reference/genericInference1.symbols       |    1 -
 .../reference/genericInference2.symbols       |    1 -
 .../genericInterfaceTypeCall.symbols          |    2 -
 .../genericMethodOverspecialization.symbols   |    3 -
 .../genericObjectLitReturnType.symbols        |    1 -
 .../genericParameterAssignability1.symbols    |    1 -
 .../reference/genericTypeAliases.symbols      |   10 -
 .../reference/genericTypeAssertions3.symbols  |    2 -
 .../genericTypeParameterEquivalence2.symbols  |    4 -
 ...ricWithIndexerOfTypeParameterType1.symbols |    1 -
 .../genericsAndHigherOrderFunctions.symbols   |    6 -
 .../reference/getterSetterNonAccessor.symbols |    2 -
 .../reference/globalThisCapture.symbols       |    1 -
 .../heterogeneousArrayLiterals.symbols        |   56 -
 .../reference/ifDoWhileStatements.symbols     |   15 -
 .../implicitAnyAnyReturningFunction.symbols   |    2 -
 .../reference/importAliasIdentifiers.symbols  |    3 -
 .../reference/importInTypePosition.symbols    |    1 -
 .../reference/importStatements.symbols        |    1 -
 .../reference/inOperatorWithFunction.symbols  |    2 -
 .../inOperatorWithValidOperands.symbols       |    1 -
 .../incrementOperatorWithAnyOtherType.symbols |    1 -
 .../indexSignaturesInferentialTyping.symbols  |    4 -
 tests/baselines/reference/indexer.symbols     |    3 -
 tests/baselines/reference/indexer2.symbols    |    1 -
 tests/baselines/reference/indexer3.symbols    |    1 -
 tests/baselines/reference/indexerA.symbols    |    3 -
 .../reference/inferSecondaryParameter.symbols |    3 -
 .../inferenceFromParameterlessLambda.symbols  |    2 -
 ...erentialTypingObjectLiteralMethod1.symbols |    2 -
 ...erentialTypingObjectLiteralMethod2.symbols |    2 -
 ...entialTypingWithFunctionTypeNested.symbols |    2 -
 ...WithFunctionTypeSyntacticScenarios.symbols |    2 -
 ...tedFunctionAssignmentCompatibility.symbols |    2 -
 ...initializePropertiesWithRenamedLet.symbols |    8 -
 .../reference/innerBoundLambdaEmit.symbols    |    1 -
 .../reference/instantiatedModule.symbols      |    1 -
 tests/baselines/reference/interface0.symbols  |    1 -
 .../reference/interfaceContextualType.symbols |    4 -
 .../interfaceWithPropertyOfEveryType.symbols  |    6 -
 .../reference/invalidUndefinedValues.symbols  |    1 -
 tests/baselines/reference/ipromise2.symbols   |    1 -
 tests/baselines/reference/ipromise3.symbols   |    1 -
 tests/baselines/reference/ipromise4.symbols   |    3 -
 .../reference/iterableArrayPattern1.symbols   |    2 -
 .../reference/iterableArrayPattern11.symbols  |    2 -
 .../reference/iterableArrayPattern12.symbols  |    2 -
 .../reference/iterableArrayPattern13.symbols  |    2 -
 .../reference/iterableArrayPattern2.symbols   |    2 -
 .../reference/iterableArrayPattern3.symbols   |    2 -
 .../reference/iterableArrayPattern4.symbols   |    2 -
 .../reference/iterableArrayPattern9.symbols   |    2 -
 .../iterableContextualTyping1.symbols         |    1 -
 .../reference/iteratorSpreadInArray.symbols   |    2 -
 .../reference/iteratorSpreadInArray2.symbols  |    4 -
 .../reference/iteratorSpreadInArray3.symbols  |    2 -
 .../reference/iteratorSpreadInArray4.symbols  |    2 -
 .../reference/iteratorSpreadInArray7.symbols  |    2 -
 .../reference/iteratorSpreadInCall11.symbols  |    2 -
 .../reference/iteratorSpreadInCall12.symbols  |    4 -
 .../reference/iteratorSpreadInCall3.symbols   |    2 -
 .../reference/iteratorSpreadInCall5.symbols   |    4 -
 .../reference/jsxReactTestSuite.symbols       |    1 -
 .../baselines/reference/keywordField.symbols  |    2 -
 .../baselines/reference/lambdaASIEmit.symbols |    1 -
 .../reference/lambdaExpression.symbols        |    4 -
 .../reference/letDeclarations-es5.symbols     |    1 -
 .../reference/letDeclarations.symbols         |    1 -
 .../reference/letInNonStrictMode.symbols      |    1 -
 tests/baselines/reference/localTypes1.symbols |    2 -
 tests/baselines/reference/localTypes5.symbols |    1 -
 .../logicalNotOperatorWithBooleanType.symbols |    1 -
 .../logicalNotOperatorWithNumberType.symbols  |    3 -
 .../logicalNotOperatorWithStringType.symbols  |    3 -
 ...calOrExpressionIsContextuallyTyped.symbols |    2 -
 ...OrExpressionIsNotContextuallyTyped.symbols |    1 -
 ...ogicalOrOperatorWithTypeParameters.symbols |    1 -
 tests/baselines/reference/m7Bugs.symbols      |    3 -
 .../reference/mergedDeclarations1.symbols     |    1 -
 .../methodContainingLocalFunction.symbols     |    2 -
 tests/baselines/reference/missingSelf.symbols |    1 -
 .../reference/modFunctionCrash.symbols        |    1 -
 .../moduleWithStatementsOfEveryKind.symbols   |    4 -
 .../reference/multiCallOverloads.symbols      |    4 -
 .../reference/multiImportExport.symbols       |    1 -
 ...ameCollisionsInPropertyAssignments.symbols |    1 -
 ...nExpressionAssignedToClassProperty.symbols |    1 -
 .../namedFunctionExpressionCall.symbols       |    2 -
 .../namedFunctionExpressionInModule.symbols   |    1 -
 .../negateOperatorWithAnyOtherType.symbols    |    2 -
 .../negateOperatorWithBooleanType.symbols     |    1 -
 .../negateOperatorWithNumberType.symbols      |    3 -
 .../negateOperatorWithStringType.symbols      |    3 -
 .../baselines/reference/nestedModules.symbols |    1 -
 .../reference/nestedRecursiveLambda.symbols   |    8 -
 tests/baselines/reference/nestedSelf.symbols  |    1 -
 ...sionThisExpressionAndClassInGlobal.symbols |    1 -
 ...ExpressionAndLocalVarInConstructor.symbols |    6 -
 ...hisExpressionAndLocalVarInFunction.symbols |    1 -
 ...nThisExpressionAndLocalVarInLambda.symbols |    4 -
 ...nThisExpressionAndLocalVarInMethod.symbols |    8 -
 ...hisExpressionAndLocalVarInProperty.symbols |    6 -
 ...lisionThisExpressionAndVarInGlobal.symbols |    1 -
 ...ExpressionInFunctionAndVarInGlobal.symbols |    1 -
 ...citAnyFunctionExpressionAssignment.symbols |    2 -
 ...nContextuallyTypesFunctionParamter.symbols |    1 -
 .../noImplicitAnyIndexingSuppressed.symbols   |    4 -
 .../reference/nonInstantiatedModule.symbols   |    1 -
 .../reference/nonIterableRestElement1.symbols |    1 -
 .../reference/nonIterableRestElement2.symbols |    1 -
 tests/baselines/reference/null.symbols        |    1 -
 ...lIsSubtypeOfEverythingButUndefined.symbols |    8 -
 .../numericIndexerConstraint4.symbols         |    1 -
 .../reference/numericIndexingResults.symbols  |    2 -
 ...BindingPatternKeywordIdentifiers05.symbols |    1 -
 ...BindingPatternKeywordIdentifiers06.symbols |    1 -
 .../baselines/reference/objectIndexer.symbols |    1 -
 .../reference/objectLitGetterSetter.symbols   |    4 -
 .../reference/objectLiteral1.symbols          |    1 -
 .../reference/objectLiteral2.symbols          |    1 -
 .../objectLiteralArraySpecialization.symbols  |    3 -
 .../objectLiteralContextualTyping.symbols     |    5 -
 .../objectLiteralIndexerNoImplicitAny.symbols |    1 -
 .../reference/objectLiteralIndexers.symbols   |    3 -
 .../objectLiteralShorthandProperties.symbols  |    3 -
 ...teralShorthandPropertiesAssignment.symbols |    4 -
 ...alShorthandPropertiesAssignmentES6.symbols |    4 -
 ...bjectLiteralShorthandPropertiesES6.symbols |    3 -
 ...horthandPropertiesFunctionArgument.symbols |    2 -
 ...teralShorthandPropertiesWithModule.symbols |    1 -
 ...alShorthandPropertiesWithModuleES6.symbols |    1 -
 .../reference/objectLiteralWidened.symbols    |    3 -
 .../objectTypeHidingMembersOfObject.symbols   |    2 -
 .../objectTypePropertyAccess.symbols          |    1 -
 .../objectTypeWithNumericProperty.symbols     |    1 -
 ...TypeWithStringNamedNumericProperty.symbols |    1 -
 ...ngNamedPropertyOfIllegalCharacters.symbols |    1 -
 .../reference/objectTypesIdentity.symbols     |    1 -
 .../reference/objectTypesIdentity2.symbols    |    1 -
 ...ectTypesIdentityWithCallSignatures.symbols |    1 -
 ...ctTypesIdentityWithCallSignatures2.symbols |    1 -
 ...CallSignaturesDifferingParamCounts.symbols |    1 -
 ...ityWithCallSignaturesWithOverloads.symbols |    1 -
 ...esIdentityWithConstructSignatures2.symbols |    1 -
 ...ructSignaturesDifferingParamCounts.symbols |    1 -
 ...sIdentityWithGenericCallSignatures.symbols |    1 -
 ...IdentityWithGenericCallSignatures2.symbols |    1 -
 ...llSignaturesDifferingByConstraints.symbols |    1 -
 ...allSignaturesDifferingByReturnType.symbols |    1 -
 ...llSignaturesDifferingByReturnType2.symbols |    1 -
 ...aturesDifferingTypeParameterCounts.symbols |    1 -
 ...naturesDifferingTypeParameterNames.symbols |    1 -
 ...enericCallSignaturesOptionalParams.symbols |    1 -
 ...nericCallSignaturesOptionalParams2.symbols |    1 -
 ...nericCallSignaturesOptionalParams3.symbols |    1 -
 ...ctSignaturesDifferingByConstraints.symbols |    1 -
 ...uctSignaturesDifferingByReturnType.symbols |    1 -
 ...ctSignaturesDifferingByReturnType2.symbols |    1 -
 ...aturesDifferingTypeParameterCounts.symbols |    1 -
 ...naturesDifferingTypeParameterNames.symbols |    1 -
 ...cConstructSignaturesOptionalParams.symbols |    1 -
 ...ConstructSignaturesOptionalParams2.symbols |    1 -
 ...ConstructSignaturesOptionalParams3.symbols |    1 -
 ...tTypesIdentityWithNumericIndexers1.symbols |    1 -
 ...tTypesIdentityWithNumericIndexers2.symbols |    1 -
 ...tTypesIdentityWithNumericIndexers3.symbols |    1 -
 ...objectTypesIdentityWithOptionality.symbols |    1 -
 .../objectTypesIdentityWithPrivates.symbols   |    1 -
 .../objectTypesIdentityWithPublics.symbols    |    1 -
 ...ectTypesIdentityWithStringIndexers.symbols |    1 -
 ...ctTypesIdentityWithStringIndexers2.symbols |    1 -
 .../reference/octalIntegerLiteral.symbols     |    2 -
 .../reference/octalIntegerLiteralES6.symbols  |    2 -
 .../optionalAccessorsInInterface1.symbols     |    6 -
 ...BindingAcrossDeclarationBoundaries.symbols |    3 -
 ...indingAcrossDeclarationBoundaries2.symbols |    3 -
 ...overloadResolutionOverNonCTLambdas.symbols |    2 -
 ...erloadResolutionOverNonCTObjectLit.symbols |    2 -
 ...acksWithDifferingOptionalityOnArgs.symbols |    2 -
 .../parametersWithNoAnnotationAreAny.symbols  |    6 -
 .../parenthesizedContexualTyping1.symbols     |   30 -
 .../parenthesizedContexualTyping2.symbols     |   30 -
 .../parenthesizedContexualTyping3.symbols     |   13 -
 .../reference/parserAccessors4.symbols        |    1 -
 .../parserFunctionPropertyAssignment1.symbols |    1 -
 .../parserFunctionPropertyAssignment2.symbols |    1 -
 .../parserFunctionPropertyAssignment3.symbols |    1 -
 .../parserFunctionPropertyAssignment4.symbols |    1 -
 .../parserKeywordsAsIdentifierName1.symbols   |    1 -
 .../reference/parserObjectLiterals1.symbols   |    1 -
 .../reference/parserX_ArrowFunction4.symbols  |    1 -
 .../plusOperatorWithBooleanType.symbols       |    1 -
 .../plusOperatorWithNumberType.symbols        |    3 -
 .../plusOperatorWithStringType.symbols        |    3 -
 .../prespecializedGenericMembers1.symbols     |    1 -
 .../reference/privacyAccessorDeclFile.symbols | 2217 -----------------
 ...acyCheckAnonymousFunctionParameter.symbols |    1 -
 .../privacyClassExtendsClauseDeclFile.symbols |  177 --
 ...ivacyClassImplementsClauseDeclFile.symbols |  169 --
 .../privacyFunctionParameterDeclFile.symbols  | 1968 ---------------
 ...vacyInterfaceExtendsClauseDeclFile.symbols |  169 --
 ...lInternalReferenceImportWithExport.symbols |  510 ----
 ...lInternalReferenceImportWithExport.symbols |  297 ---
 .../reference/promiseChaining.symbols         |    3 -
 tests/baselines/reference/promiseTest.symbols |    1 -
 .../reference/promiseTypeInference.symbols    |    1 -
 .../promiseVoidErrorCallback.symbols          |   15 -
 ...propagationOfPromiseInitialization.symbols |    2 -
 ...cessOnTypeParameterWithConstraints.symbols |    2 -
 ...essOnTypeParameterWithConstraints2.symbols |    2 -
 ...sOnTypeParameterWithoutConstraints.symbols |    2 -
 .../propertyNameWithoutTypeAnnotation.symbols |    1 -
 ...ClassPropertyAccessibleWithinClass.symbols |    7 -
 .../protoAsIndexInIndexExpression.symbols     |    3 -
 .../reference/quotedPropertyName3.symbols     |    1 -
 tests/baselines/reference/recur1.symbols      |    2 -
 .../reference/recursiveInitializer.symbols    |    1 -
 .../reference/recursiveObjectLiteral.symbols  |    1 -
 .../baselines/reference/reservedWords.symbols |    2 -
 .../reference/returnStatement1.symbols        |    1 -
 .../reference/returnStatements.symbols        |    1 -
 .../returnTypeParameterWithModules.symbols    |    1 -
 .../reference/selfInCallback.symbols          |    1 -
 .../baselines/reference/selfInLambdas.symbols |    6 -
 ...arameterReferencedInObjectLiteral1.symbols |    3 -
 ...onstructorAndCapturedThisStatement.symbols |    1 -
 ...ceMapValidationFunctionExpressions.symbols |    2 -
 ...lidationFunctionPropertyAssignment.symbols |    1 -
 ...eMapWithMultipleFilesWithCopyright.symbols |    1 -
 ...alizationsShouldNotAffectEachOther.symbols |    2 -
 .../specializedInheritedConstructors1.symbols |    2 -
 .../strictModeUseContextualKeyword.symbols    |    1 -
 .../reference/stringIndexingResults.symbols   |    1 -
 ...ngLiteralObjectLiteralDeclaration1.symbols |    1 -
 ...lPropertyNameWithLineContinuation1.symbols |    1 -
 .../stringNamedPropertyAccess.symbols         |    1 -
 .../reference/stringPropCodeGen.symbols       |    3 -
 tests/baselines/reference/structural1.symbols |    1 -
 .../subtypingWithCallSignatures.symbols       |    4 -
 .../subtypingWithCallSignatures2.symbols      |   38 -
 .../subtypingWithCallSignatures3.symbols      |   26 -
 .../subtypingWithCallSignatures4.symbols      |   20 -
 ...typingWithObjectMembersOptionality.symbols |    2 -
 .../subtypingWithOptionalProperties.symbols   |    1 -
 .../reference/superAccessInFatArrow1.symbols  |    1 -
 ...uperCallParameterContextualTyping1.symbols |    1 -
 ...uperCallParameterContextualTyping3.symbols |    2 -
 .../reference/switchBreakStatements.symbols   |    1 -
 .../reference/switchStatements.symbols        |   11 -
 .../reference/symbolDeclarationEmit10.symbols |    1 -
 .../reference/symbolDeclarationEmit8.symbols  |    1 -
 .../reference/symbolDeclarationEmit9.symbols  |    1 -
 .../reference/symbolProperty1.symbols         |    1 -
 .../reference/symbolProperty18.symbols        |    1 -
 .../reference/symbolProperty19.symbols        |   15 -
 .../reference/symbolProperty2.symbols         |    1 -
 .../reference/symbolProperty20.symbols        |    8 -
 .../reference/symbolProperty21.symbols        |    1 -
 .../reference/symbolProperty22.symbols        |    8 -
 .../reference/symbolProperty27.symbols        |    1 -
 .../reference/symbolProperty28.symbols        |    1 -
 .../reference/symbolProperty4.symbols         |    1 -
 .../reference/symbolProperty5.symbols         |    1 -
 .../reference/symbolProperty55.symbols        |    1 -
 .../reference/symbolProperty56.symbols        |    1 -
 .../reference/symbolProperty57.symbols        |    1 -
 .../baselines/reference/symbolType11.symbols  |    1 -
 .../reference/systemModule13.symbols          |    2 -
 .../baselines/reference/systemModule8.symbols |    2 -
 .../taggedTemplateContextualTyping1.symbols   |    7 -
 .../taggedTemplateContextualTyping2.symbols   |    4 -
 .../reference/targetTypeArgs.symbols          |    7 -
 .../reference/targetTypeCalls.symbols         |   10 -
 .../reference/targetTypeObjectLiteral.symbols |    2 -
 .../targetTypeObjectLiteralToAny.symbols      |    2 -
 .../reference/targetTypingOnFunctions.symbols |    2 -
 .../templateStringInArrowFunction.symbols     |    1 -
 .../templateStringInArrowFunctionES6.symbols  |    1 -
 ...templateStringInFunctionExpression.symbols |    1 -
 ...plateStringInFunctionExpressionES6.symbols |    1 -
 .../templateStringInInOperator.symbols        |    1 -
 .../templateStringInInOperatorES6.symbols     |    1 -
 ...templateStringInPropertyAssignment.symbols |    1 -
 ...plateStringInPropertyAssignmentES6.symbols |    1 -
 ...ateStringWithEmbeddedArrowFunction.symbols |    1 -
 ...StringWithEmbeddedArrowFunctionES6.symbols |    1 -
 ...ringWithEmbeddedFunctionExpression.symbols |    1 -
 ...gWithEmbeddedFunctionExpressionES6.symbols |    1 -
 ...mplateStringWithEmbeddedInOperator.symbols |    1 -
 ...ateStringWithEmbeddedInOperatorES6.symbols |    1 -
 ...ateStringWithEmbeddedObjectLiteral.symbols |    1 -
 ...StringWithEmbeddedObjectLiteralES6.symbols |    1 -
 .../ternaryExpressionSourceMap.symbols        |    2 -
 .../baselines/reference/thisBinding2.symbols  |    5 -
 .../baselines/reference/thisCapture1.symbols  |    1 -
 .../thisExpressionInIndexExpression.symbols   |    1 -
 .../thisExpressionOfGenericObject.symbols     |    1 -
 .../reference/thisInInnerFunctions.symbols    |    4 -
 .../baselines/reference/thisInLambda.symbols  |    3 -
 .../reference/thisInObjectLiterals.symbols    |    2 -
 .../thisInPropertyBoundDeclarations.symbols   |   28 -
 ...ncedInFunctionInsideArrowFunction1.symbols |    4 -
 .../throwInEnclosingStatements.symbols        |    3 -
 .../reference/throwStatements.symbols         |    6 -
 ...entsInGenericFunctionTypedArgument.symbols |    2 -
 .../reference/topLevelLambda2.symbols         |    1 -
 .../reference/topLevelLambda3.symbols         |    1 -
 .../reference/topLevelLambda4.symbols         |    1 -
 .../reference/trailingCommasES3.symbols       |    4 -
 .../reference/trailingCommasES5.symbols       |    4 -
 tests/baselines/reference/tsxEmit1.symbols    |    4 -
 .../tsxGenericArrowFunctionParsing.symbols    |    2 -
 .../reference/tsxInArrowFunction.symbols      |    4 -
 .../baselines/reference/tsxReactEmit1.symbols |   20 -
 .../baselines/reference/tsxTypeErrors.symbols |    2 -
 ...tationBestCommonTypeInArrayLiteral.symbols |    4 -
 .../reference/typeArgInference.symbols        |    1 -
 .../typeArgInferenceWithNull.symbols          |    4 -
 ...typeArgumentsInFunctionExpressions.symbols |    2 -
 .../reference/typeGuardFunction.symbols       |    2 -
 .../reference/typeGuardsDefeat.symbols        |    2 -
 .../reference/typeGuardsInFunction.symbols    |    2 -
 ...typeGuardsInFunctionAndModuleBlock.symbols |    5 -
 .../reference/typeGuardsObjectMethods.symbols |    1 -
 .../reference/typeInferenceFixEarly.symbols   |    1 -
 .../typeInferenceReturnTypeCallback.symbols   |    1 -
 .../typeInferenceWithTypeAnnotation.symbols   |    1 -
 .../reference/typeLiteralCallback.symbols     |    2 -
 .../typeOfThisInFunctionExpression.symbols    |    6 -
 ...ypeParameterConstraintTransitively.symbols |    8 -
 ...peParameterConstraintTransitively2.symbols |    7 -
 ...erCompatibilityAccrossDeclarations.symbols |    4 -
 ...typeParameterFixingWithConstraints.symbols |    3 -
 ...ixingWithContextSensitiveArguments.symbols |    3 -
 ...xingWithContextSensitiveArguments4.symbols |    2 -
 ...xingWithContextSensitiveArguments5.symbols |    2 -
 ...peParametersAvailableInNestedScope.symbols |    1 -
 tests/baselines/reference/typeVal.symbols     |    1 -
 .../reference/typeofInterface.symbols         |    1 -
 .../typeofOperatorWithBooleanType.symbols     |    2 -
 .../typeofOperatorWithNumberType.symbols      |    4 -
 .../typeofOperatorWithStringType.symbols      |    4 -
 .../typesWithOptionalProperty.symbols         |    4 -
 .../reference/uncaughtCompilerError1.symbols  |    2 -
 .../undefinedArgumentInference.symbols        |    1 -
 .../reference/underscoreTest1.symbols         |   75 -
 .../untypedArgumentInLambdaExpression.symbols |    1 -
 .../reference/unusedImportDeclaration.symbols |    1 -
 .../validMultipleVariableDeclarations.symbols |    7 -
 .../reference/validUseOfThisInSuper.symbols   |    1 -
 .../reference/varArgParamTypeCheck.symbols    |    5 -
 .../varInFunctionInVarInitializer.symbols     |    1 -
 tests/baselines/reference/vardecl.symbols     |    2 -
 .../reference/variableDeclarator1.symbols     |    1 -
 .../voidFunctionAssignmentCompat.symbols      |   14 -
 .../voidOperatorWithBooleanType.symbols       |    1 -
 .../voidOperatorWithNumberType.symbols        |    3 -
 .../voidOperatorWithStringType.symbols        |    3 -
 .../reference/whileBreakStatements.symbols    |    1 -
 .../reference/whileContinueStatements.symbols |    1 -
 .../baselines/reference/widenedTypes1.symbols |    3 -
 .../reference/withImportDecl.symbols          |    3 -
 .../wrappedAndRecursiveConstraints3.symbols   |    3 -
 757 files changed, 3 insertions(+), 8390 deletions(-)
 delete mode 100644 tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.symbols
 delete mode 100644 tests/baselines/reference/declFileTypeAnnotationVisibilityErrorParameterOfFunction.symbols
 delete mode 100644 tests/baselines/reference/declarationEmitDestructuringPrivacyError.symbols
 delete mode 100644 tests/baselines/reference/privacyAccessorDeclFile.symbols
 delete mode 100644 tests/baselines/reference/privacyClassExtendsClauseDeclFile.symbols
 delete mode 100644 tests/baselines/reference/privacyClassImplementsClauseDeclFile.symbols
 delete mode 100644 tests/baselines/reference/privacyFunctionParameterDeclFile.symbols
 delete mode 100644 tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.symbols
 delete mode 100644 tests/baselines/reference/privacyLocalInternalReferenceImportWithExport.symbols
 delete mode 100644 tests/baselines/reference/privacyTopLevelInternalReferenceImportWithExport.symbols

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index a6f77f2db45a4..cef4f048f2106 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -13744,7 +13744,7 @@ namespace ts {
                     }
                     break;
             }
-            return getSymbolOfNode(node);
+            return undefined;
         }
 
         function getShorthandAssignmentValueSymbol(location: Node): Symbol {
diff --git a/tests/baselines/reference/2dArrays.symbols b/tests/baselines/reference/2dArrays.symbols
index a1123888f4f93..c069f2dae8c9d 100644
--- a/tests/baselines/reference/2dArrays.symbols
+++ b/tests/baselines/reference/2dArrays.symbols
@@ -30,7 +30,6 @@ class Board {
 >this : Symbol(Board, Decl(2dArrays.ts, 5, 1))
 >ships : Symbol(ships, Decl(2dArrays.ts, 7, 13))
 >every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
->function (val) { return val.isSunk; } : Symbol((Anonymous function), Decl(2dArrays.ts, 12, 32))
 >val : Symbol(val, Decl(2dArrays.ts, 12, 42))
 >val.isSunk : Symbol(Ship.isSunk, Decl(2dArrays.ts, 3, 12))
 >val : Symbol(val, Decl(2dArrays.ts, 12, 42))
diff --git a/tests/baselines/reference/AmbientModuleAndNonAmbientFunctionWithTheSameNameAndCommonRoot.symbols b/tests/baselines/reference/AmbientModuleAndNonAmbientFunctionWithTheSameNameAndCommonRoot.symbols
index c5fca19c76f18..ccb8662712faa 100644
--- a/tests/baselines/reference/AmbientModuleAndNonAmbientFunctionWithTheSameNameAndCommonRoot.symbols
+++ b/tests/baselines/reference/AmbientModuleAndNonAmbientFunctionWithTheSameNameAndCommonRoot.symbols
@@ -13,7 +13,6 @@ function Point() {
 >Point : Symbol(Point, Decl(module.d.ts, 0, 0), Decl(function.ts, 0, 0))
 
     return { x: 0, y: 0 };
->{ x: 0, y: 0 } : Symbol(, Decl(function.ts, 1, 10))
 >x : Symbol(x, Decl(function.ts, 1, 12))
 >y : Symbol(y, Decl(function.ts, 1, 18))
 }
diff --git a/tests/baselines/reference/ArrowFunction4.symbols b/tests/baselines/reference/ArrowFunction4.symbols
index 70abc1151373d..cd19b8cdac9d1 100644
--- a/tests/baselines/reference/ArrowFunction4.symbols
+++ b/tests/baselines/reference/ArrowFunction4.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrowFunctions/ArrowFunction4.ts ===
 var v = (a, b) => {
 >v : Symbol(v, Decl(ArrowFunction4.ts, 0, 3))
->(a, b) => {   } : Symbol((Anonymous function), Decl(ArrowFunction4.ts, 0, 7))
 >a : Symbol(a, Decl(ArrowFunction4.ts, 0, 9))
 >b : Symbol(b, Decl(ArrowFunction4.ts, 0, 11))
    
diff --git a/tests/baselines/reference/ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.symbols b/tests/baselines/reference/ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.symbols
index e006b55595243..1c75c33a278ff 100644
--- a/tests/baselines/reference/ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.symbols
+++ b/tests/baselines/reference/ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.symbols
@@ -9,7 +9,6 @@ class Point {
     static Origin(): Point { return { x: 0, y: 0 }; }
 >Origin : Symbol(Point.Origin, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 1, 55))
 >Point : Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 0, 0), Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 4, 1))
->{ x: 0, y: 0 } : Symbol(, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 3, 35))
 >x : Symbol(x, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 3, 37))
 >y : Symbol(y, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 3, 43))
 }
@@ -35,7 +34,6 @@ module A {
         static Origin(): Point { return { x: 0, y: 0 }; }
 >Origin : Symbol(Point.Origin, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 13, 59))
 >Point : Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 11, 10), Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 16, 5))
->{ x: 0, y: 0 } : Symbol(, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 15, 39))
 >x : Symbol(x, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 15, 41))
 >y : Symbol(y, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 15, 47))
     }
diff --git a/tests/baselines/reference/ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.symbols b/tests/baselines/reference/ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.symbols
index 56c0f0d589188..046b92fd6eed6 100644
--- a/tests/baselines/reference/ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.symbols
+++ b/tests/baselines/reference/ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.symbols
@@ -9,7 +9,6 @@ class Point {
     static Origin: Point = { x: 0, y: 0 };
 >Origin : Symbol(Point.Origin, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 1, 55))
 >Point : Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 0, 0), Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 4, 1))
->{ x: 0, y: 0 } : Symbol(, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 3, 26))
 >x : Symbol(x, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 3, 28))
 >y : Symbol(y, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 3, 34))
 }
@@ -35,7 +34,6 @@ module A {
         static Origin: Point = { x: 0, y: 0 };
 >Origin : Symbol(Point.Origin, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 13, 59))
 >Point : Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 11, 10), Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 16, 5))
->{ x: 0, y: 0 } : Symbol(, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 15, 30))
 >x : Symbol(x, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 15, 32))
 >y : Symbol(y, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 15, 38))
     }
diff --git a/tests/baselines/reference/ES5For-of10.symbols b/tests/baselines/reference/ES5For-of10.symbols
index 7bb66d0ab083a..302db0a5ec7a6 100644
--- a/tests/baselines/reference/ES5For-of10.symbols
+++ b/tests/baselines/reference/ES5For-of10.symbols
@@ -3,7 +3,6 @@ function foo() {
 >foo : Symbol(foo, Decl(ES5For-of10.ts, 0, 0))
 
     return { x: 0 };
->{ x: 0 } : Symbol(, Decl(ES5For-of10.ts, 1, 10))
 >x : Symbol(x, Decl(ES5For-of10.ts, 1, 12))
 }
 for (foo().x of []) {
diff --git a/tests/baselines/reference/ES5For-of9.symbols b/tests/baselines/reference/ES5For-of9.symbols
index 7712a10d3b1af..426a5442ecbd5 100644
--- a/tests/baselines/reference/ES5For-of9.symbols
+++ b/tests/baselines/reference/ES5For-of9.symbols
@@ -3,7 +3,6 @@ function foo() {
 >foo : Symbol(foo, Decl(ES5For-of9.ts, 0, 0))
 
     return { x: 0 };
->{ x: 0 } : Symbol(, Decl(ES5For-of9.ts, 1, 10))
 >x : Symbol(x, Decl(ES5For-of9.ts, 1, 12))
 }
 for (foo().x of []) {
diff --git a/tests/baselines/reference/ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.symbols b/tests/baselines/reference/ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.symbols
index df8cdce648191..2802e6aa3921e 100644
--- a/tests/baselines/reference/ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.symbols
+++ b/tests/baselines/reference/ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.symbols
@@ -15,7 +15,6 @@ module A {
     export var Origin: Point = { x: 0, y: 0 };
 >Origin : Symbol(Origin, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 14))
 >Point : Symbol(Point, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 0, 10))
->{ x: 0, y: 0 } : Symbol(, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 30))
 >x : Symbol(x, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 32))
 >y : Symbol(y, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 38))
 
@@ -30,7 +29,6 @@ module A {
     export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
 >Origin3d : Symbol(Origin3d, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 14))
 >Point3d : Symbol(Point3d, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 46))
->{ x: 0, y: 0, z: 0 } : Symbol(, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 34))
 >x : Symbol(x, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 36))
 >y : Symbol(y, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 42))
 >z : Symbol(z, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 48))
diff --git a/tests/baselines/reference/ExportClassWithInaccessibleTypeInTypeParameterConstraint.symbols b/tests/baselines/reference/ExportClassWithInaccessibleTypeInTypeParameterConstraint.symbols
index 69bd69c8eab2b..e1044bd2442d9 100644
--- a/tests/baselines/reference/ExportClassWithInaccessibleTypeInTypeParameterConstraint.symbols
+++ b/tests/baselines/reference/ExportClassWithInaccessibleTypeInTypeParameterConstraint.symbols
@@ -15,7 +15,6 @@ module A {
     export var Origin: Point = { x: 0, y: 0 };
 >Origin : Symbol(Origin, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 14))
 >Point : Symbol(Point, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 0, 10))
->{ x: 0, y: 0 } : Symbol(, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 30))
 >x : Symbol(x, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 32))
 >y : Symbol(y, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 38))
 
@@ -30,7 +29,6 @@ module A {
     export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
 >Origin3d : Symbol(Origin3d, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 14))
 >Point3d : Symbol(Point3d, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 46))
->{ x: 0, y: 0, z: 0 } : Symbol(, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 34))
 >x : Symbol(x, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 36))
 >y : Symbol(y, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 42))
 >z : Symbol(z, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 48))
diff --git a/tests/baselines/reference/ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.symbols b/tests/baselines/reference/ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.symbols
index dd8bec1e65308..37b6da18c375c 100644
--- a/tests/baselines/reference/ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.symbols
+++ b/tests/baselines/reference/ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.symbols
@@ -30,7 +30,6 @@ module A {
 
         return new Line({ x: 0, y: 0 }, p);
 >Line : Symbol(Line, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 5, 5))
->{ x: 0, y: 0 } : Symbol(, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 12, 24))
 >x : Symbol(x, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 12, 25))
 >y : Symbol(y, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 12, 31))
 >p : Symbol(p, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 11, 31))
diff --git a/tests/baselines/reference/ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.symbols b/tests/baselines/reference/ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.symbols
index fa99b4f38a149..41993ebf48fef 100644
--- a/tests/baselines/reference/ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.symbols
+++ b/tests/baselines/reference/ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.symbols
@@ -30,7 +30,6 @@ module A {
 
         return new Line({ x: 0, y: 0 }, p);
 >Line : Symbol(Line, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 5, 5))
->{ x: 0, y: 0 } : Symbol(, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 12, 24))
 >x : Symbol(x, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 12, 25))
 >y : Symbol(y, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 12, 31))
 >p : Symbol(p, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 11, 31))
diff --git a/tests/baselines/reference/ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.symbols b/tests/baselines/reference/ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.symbols
index 54835e551ffeb..77d5721579515 100644
--- a/tests/baselines/reference/ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.symbols
+++ b/tests/baselines/reference/ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.symbols
@@ -30,7 +30,6 @@ module A {
 
         return new Line({ x: 0, y: 0 }, p);
 >Line : Symbol(Line, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 5, 5))
->{ x: 0, y: 0 } : Symbol(, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 12, 24))
 >x : Symbol(x, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 12, 25))
 >y : Symbol(y, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 12, 31))
 >p : Symbol(p, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 11, 31))
diff --git a/tests/baselines/reference/ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.symbols b/tests/baselines/reference/ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.symbols
index eaa42d6fbaac3..31b978c85f934 100644
--- a/tests/baselines/reference/ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.symbols
+++ b/tests/baselines/reference/ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.symbols
@@ -15,7 +15,6 @@ module A {
     export var Origin: Point = { x: 0, y: 0 };
 >Origin : Symbol(Origin, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 14))
 >Point : Symbol(Point, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 0, 10))
->{ x: 0, y: 0 } : Symbol(, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 30))
 >x : Symbol(x, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 32))
 >y : Symbol(y, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 38))
 
@@ -30,7 +29,6 @@ module A {
     export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
 >Origin3d : Symbol(Origin3d, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 14))
 >Point3d : Symbol(Point3d, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 46))
->{ x: 0, y: 0, z: 0 } : Symbol(, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 34))
 >x : Symbol(x, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 36))
 >y : Symbol(y, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 42))
 >z : Symbol(z, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 48))
diff --git a/tests/baselines/reference/ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.symbols b/tests/baselines/reference/ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.symbols
index 169f5ff240679..7ee70a0c77bbe 100644
--- a/tests/baselines/reference/ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.symbols
+++ b/tests/baselines/reference/ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.symbols
@@ -15,7 +15,6 @@ module A {
     export var Origin: Point = { x: 0, y: 0 };
 >Origin : Symbol(Origin, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 14))
 >Point : Symbol(Point, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 0, 10))
->{ x: 0, y: 0 } : Symbol(, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 30))
 >x : Symbol(x, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 32))
 >y : Symbol(y, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 38))
 
@@ -30,7 +29,6 @@ module A {
     export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
 >Origin3d : Symbol(Origin3d, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 14))
 >Point3d : Symbol(Point3d, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 46))
->{ x: 0, y: 0, z: 0 } : Symbol(, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 34))
 >x : Symbol(x, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 36))
 >y : Symbol(y, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 42))
 >z : Symbol(z, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 48))
diff --git a/tests/baselines/reference/ExportModuleWithAccessibleTypesOnItsExportedMembers.symbols b/tests/baselines/reference/ExportModuleWithAccessibleTypesOnItsExportedMembers.symbols
index a6ba88fb27c6a..acf6a1caef4c8 100644
--- a/tests/baselines/reference/ExportModuleWithAccessibleTypesOnItsExportedMembers.symbols
+++ b/tests/baselines/reference/ExportModuleWithAccessibleTypesOnItsExportedMembers.symbols
@@ -36,7 +36,6 @@ module A {
 
                 return new Line({ x: 0, y: 0 }, p);
 >Line : Symbol(Line, Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts, 7, 51))
->{ x: 0, y: 0 } : Symbol(, Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts, 15, 32))
 >x : Symbol(x, Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts, 15, 33))
 >y : Symbol(y, Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts, 15, 39))
 >p : Symbol(p, Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts, 14, 30))
diff --git a/tests/baselines/reference/ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.symbols b/tests/baselines/reference/ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.symbols
index 2e7410e19a45c..dccc613aca931 100644
--- a/tests/baselines/reference/ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.symbols
+++ b/tests/baselines/reference/ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.symbols
@@ -13,13 +13,11 @@ module A {
     export var Origin: Point = { x: 0, y: 0 };
 >Origin : Symbol(Origin, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 6, 14))
 >Point : Symbol(Point, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 0, 10))
->{ x: 0, y: 0 } : Symbol(, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 6, 30))
 >x : Symbol(x, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 6, 32))
 >y : Symbol(y, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 6, 38))
 
     export var Unity = { start: new Point(0, 0), end: new Point(1, 0) };
 >Unity : Symbol(Unity, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 8, 14))
->{ start: new Point(0, 0), end: new Point(1, 0) } : Symbol(, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 8, 22))
 >start : Symbol(start, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 8, 24))
 >Point : Symbol(Point, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 0, 10))
 >end : Symbol(end, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 8, 48))
diff --git a/tests/baselines/reference/ExportVariableWithAccessibleTypeInTypeAnnotation.symbols b/tests/baselines/reference/ExportVariableWithAccessibleTypeInTypeAnnotation.symbols
index 600bcc08a2d80..55ba5fd0cf348 100644
--- a/tests/baselines/reference/ExportVariableWithAccessibleTypeInTypeAnnotation.symbols
+++ b/tests/baselines/reference/ExportVariableWithAccessibleTypeInTypeAnnotation.symbols
@@ -16,7 +16,6 @@ module A {
     export var Origin: Point = { x: 0, y: 0 };
 >Origin : Symbol(Origin, Decl(ExportVariableWithAccessibleTypeInTypeAnnotation.ts, 8, 14))
 >Point : Symbol(Point, Decl(ExportVariableWithAccessibleTypeInTypeAnnotation.ts, 0, 10))
->{ x: 0, y: 0 } : Symbol(, Decl(ExportVariableWithAccessibleTypeInTypeAnnotation.ts, 8, 30))
 >x : Symbol(x, Decl(ExportVariableWithAccessibleTypeInTypeAnnotation.ts, 8, 32))
 >y : Symbol(y, Decl(ExportVariableWithAccessibleTypeInTypeAnnotation.ts, 8, 38))
 }
diff --git a/tests/baselines/reference/ExportVariableWithInaccessibleTypeInTypeAnnotation.symbols b/tests/baselines/reference/ExportVariableWithInaccessibleTypeInTypeAnnotation.symbols
index b1b8bb2e97f22..ac43ccea789a3 100644
--- a/tests/baselines/reference/ExportVariableWithInaccessibleTypeInTypeAnnotation.symbols
+++ b/tests/baselines/reference/ExportVariableWithInaccessibleTypeInTypeAnnotation.symbols
@@ -16,7 +16,6 @@ module A {
     export var Origin: Point = { x: 0, y: 0 };
 >Origin : Symbol(Origin, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 8, 14))
 >Point : Symbol(Point, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 0, 10))
->{ x: 0, y: 0 } : Symbol(, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 8, 30))
 >x : Symbol(x, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 8, 32))
 >y : Symbol(y, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 8, 38))
 
@@ -32,7 +31,6 @@ module A {
     export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
 >Origin3d : Symbol(Origin3d, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 15, 14))
 >Point3d : Symbol(Point3d, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 8, 46))
->{ x: 0, y: 0, z: 0 } : Symbol(, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 15, 34))
 >x : Symbol(x, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 15, 36))
 >y : Symbol(y, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 15, 42))
 >z : Symbol(z, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 15, 48))
diff --git a/tests/baselines/reference/FunctionAndModuleWithSameNameAndDifferentCommonRoot.symbols b/tests/baselines/reference/FunctionAndModuleWithSameNameAndDifferentCommonRoot.symbols
index 090eadfa60b3b..96963246d26d9 100644
--- a/tests/baselines/reference/FunctionAndModuleWithSameNameAndDifferentCommonRoot.symbols
+++ b/tests/baselines/reference/FunctionAndModuleWithSameNameAndDifferentCommonRoot.symbols
@@ -6,7 +6,6 @@ module A {
 >Point : Symbol(Point, Decl(function.ts, 0, 10))
 
         return { x: 0, y: 0 };
->{ x: 0, y: 0 } : Symbol(, Decl(function.ts, 2, 14))
 >x : Symbol(x, Decl(function.ts, 2, 16))
 >y : Symbol(y, Decl(function.ts, 2, 22))
     }
@@ -21,7 +20,6 @@ module B {
 
         export var Origin = { x: 0, y: 0 };
 >Origin : Symbol(Origin, Decl(module.ts, 2, 18))
->{ x: 0, y: 0 } : Symbol(, Decl(module.ts, 2, 27))
 >x : Symbol(x, Decl(module.ts, 2, 29))
 >y : Symbol(y, Decl(module.ts, 2, 35))
     }
diff --git a/tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.symbols b/tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.symbols
index 45ca47dfc375c..c9e2c124e9d0a 100644
--- a/tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.symbols
+++ b/tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.symbols
@@ -26,7 +26,6 @@ module A {
 >Point : Symbol(Point, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 0, 10))
 
             return { x: p.x, y: p.y };
->{ x: p.x, y: p.y } : Symbol(, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 10, 18))
 >x : Symbol(x, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 10, 20))
 >p.x : Symbol(Point.x, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 1, 24))
 >p : Symbol(p, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 9, 23))
diff --git a/tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedLocalVarsOfTheSameName.symbols b/tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedLocalVarsOfTheSameName.symbols
index 8135100bfae4b..b7402952dff61 100644
--- a/tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedLocalVarsOfTheSameName.symbols
+++ b/tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedLocalVarsOfTheSameName.symbols
@@ -23,7 +23,6 @@ module A {
 >T : Symbol(T, Decl(part1.ts, 7, 31))
 
             return { x: p.y, y: p.x };
->{ x: p.y, y: p.x } : Symbol(, Decl(part1.ts, 8, 18))
 >x : Symbol(x, Decl(part1.ts, 8, 20))
 >p.y : Symbol(Point.y, Decl(part1.ts, 2, 18))
 >p : Symbol(p, Decl(part1.ts, 7, 48))
@@ -37,7 +36,6 @@ module A {
     export var Origin: Point = { x: 0, y: 0 };
 >Origin : Symbol(Origin, Decl(part1.ts, 11, 14))
 >Point : Symbol(Point, Decl(part1.ts, 0, 10))
->{ x: 0, y: 0 } : Symbol(, Decl(part1.ts, 11, 30))
 >x : Symbol(x, Decl(part1.ts, 11, 32))
 >y : Symbol(y, Decl(part1.ts, 11, 38))
 }
@@ -116,7 +114,6 @@ var p = new A.Utils.Plane(o, { x: 1, y: 1 });
 >Utils : Symbol(A.Utils, Decl(part1.ts, 4, 5), Decl(part2.ts, 2, 31))
 >Plane : Symbol(A.Utils.Plane, Decl(part2.ts, 4, 25))
 >o : Symbol(o, Decl(part3.ts, 2, 3), Decl(part3.ts, 3, 3), Decl(part3.ts, 4, 3), Decl(part3.ts, 5, 3))
->{ x: 1, y: 1 } : Symbol(, Decl(part3.ts, 9, 28))
 >x : Symbol(x, Decl(part3.ts, 9, 30))
 >y : Symbol(y, Decl(part3.ts, 9, 36))
 
diff --git a/tests/baselines/reference/TwoInternalModulesWithTheSameNameAndDifferentCommonRoot.symbols b/tests/baselines/reference/TwoInternalModulesWithTheSameNameAndDifferentCommonRoot.symbols
index b71ceddd77575..5c533273fa68e 100644
--- a/tests/baselines/reference/TwoInternalModulesWithTheSameNameAndDifferentCommonRoot.symbols
+++ b/tests/baselines/reference/TwoInternalModulesWithTheSameNameAndDifferentCommonRoot.symbols
@@ -26,7 +26,6 @@ module Root {
 >T : Symbol(T, Decl(part1.ts, 8, 35))
 
                 return { x: p.y, y: p.x };
->{ x: p.y, y: p.x } : Symbol(, Decl(part1.ts, 9, 22))
 >x : Symbol(x, Decl(part1.ts, 9, 24))
 >p.y : Symbol(Point.y, Decl(part1.ts, 3, 22))
 >p : Symbol(p, Decl(part1.ts, 8, 52))
@@ -53,7 +52,6 @@ module otherRoot {
 >Root : Symbol(Root, Decl(part1.ts, 0, 0))
 >A : Symbol(Root.A, Decl(part1.ts, 0, 13))
 >Point : Symbol(Root.A.Point, Decl(part1.ts, 1, 21))
->{ x: 0, y: 0 } : Symbol(, Decl(part2.ts, 3, 41))
 >x : Symbol(x, Decl(part2.ts, 3, 43))
 >y : Symbol(y, Decl(part2.ts, 3, 49))
 
diff --git a/tests/baselines/reference/TwoInternalModulesWithTheSameNameAndSameCommonRoot.symbols b/tests/baselines/reference/TwoInternalModulesWithTheSameNameAndSameCommonRoot.symbols
index d334b85a91db0..34abd4ecd65d5 100644
--- a/tests/baselines/reference/TwoInternalModulesWithTheSameNameAndSameCommonRoot.symbols
+++ b/tests/baselines/reference/TwoInternalModulesWithTheSameNameAndSameCommonRoot.symbols
@@ -23,7 +23,6 @@ module A {
 >T : Symbol(T, Decl(part1.ts, 7, 31))
 
             return { x: p.y, y: p.x };
->{ x: p.y, y: p.x } : Symbol(, Decl(part1.ts, 8, 18))
 >x : Symbol(x, Decl(part1.ts, 8, 20))
 >p.y : Symbol(Point.y, Decl(part1.ts, 2, 18))
 >p : Symbol(p, Decl(part1.ts, 7, 48))
@@ -43,7 +42,6 @@ module A {
     export var Origin: Point = { x: 0, y: 0 };
 >Origin : Symbol(Origin, Decl(part2.ts, 1, 14))
 >Point : Symbol(Point, Decl(part1.ts, 0, 10))
->{ x: 0, y: 0 } : Symbol(, Decl(part2.ts, 1, 30))
 >x : Symbol(x, Decl(part2.ts, 1, 32))
 >y : Symbol(y, Decl(part2.ts, 1, 38))
 
@@ -113,7 +111,6 @@ var p = new A.Utils.Plane(o, { x: 1, y: 1 });
 >Utils : Symbol(A.Utils, Decl(part1.ts, 4, 5), Decl(part2.ts, 1, 46))
 >Plane : Symbol(A.Utils.Plane, Decl(part2.ts, 3, 25))
 >o : Symbol(o, Decl(part3.ts, 2, 3), Decl(part3.ts, 3, 3), Decl(part3.ts, 4, 3), Decl(part3.ts, 5, 3))
->{ x: 1, y: 1 } : Symbol(, Decl(part3.ts, 9, 28))
 >x : Symbol(x, Decl(part3.ts, 9, 30))
 >y : Symbol(y, Decl(part3.ts, 9, 36))
 
diff --git a/tests/baselines/reference/accessorWithES5.symbols b/tests/baselines/reference/accessorWithES5.symbols
index a1529ee1797dc..dccbd8180bb5d 100644
--- a/tests/baselines/reference/accessorWithES5.symbols
+++ b/tests/baselines/reference/accessorWithES5.symbols
@@ -21,7 +21,6 @@ class D {
 
 var x = {
 >x : Symbol(x, Decl(accessorWithES5.ts, 12, 3))
->{    get a() { return 1 }} : Symbol(, Decl(accessorWithES5.ts, 12, 7))
 
     get a() { return 1 }
 >a : Symbol(a, Decl(accessorWithES5.ts, 12, 9))
@@ -29,7 +28,6 @@ var x = {
 
 var y = {
 >y : Symbol(y, Decl(accessorWithES5.ts, 16, 3))
->{    set b(v) { }} : Symbol(, Decl(accessorWithES5.ts, 16, 7))
 
     set b(v) { }
 >b : Symbol(b, Decl(accessorWithES5.ts, 16, 9))
diff --git a/tests/baselines/reference/additionOperatorWithAnyAndEveryType.symbols b/tests/baselines/reference/additionOperatorWithAnyAndEveryType.symbols
index 0ad3373bde4f8..eff45630aae8e 100644
--- a/tests/baselines/reference/additionOperatorWithAnyAndEveryType.symbols
+++ b/tests/baselines/reference/additionOperatorWithAnyAndEveryType.symbols
@@ -133,13 +133,11 @@ var r18 = a + 123;
 var r19 = a + { a: '' };
 >r19 : Symbol(r19, Decl(additionOperatorWithAnyAndEveryType.ts, 37, 3))
 >a : Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 8, 3))
->{ a: '' } : Symbol(, Decl(additionOperatorWithAnyAndEveryType.ts, 37, 13))
 >a : Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 37, 15))
 
 var r20 = a + ((a: string) => { return a });
 >r20 : Symbol(r20, Decl(additionOperatorWithAnyAndEveryType.ts, 38, 3))
 >a : Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 8, 3))
->(a: string) => { return a } : Symbol((Anonymous function), Decl(additionOperatorWithAnyAndEveryType.ts, 38, 15))
 >a : Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 38, 16))
 >a : Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 38, 16))
 
diff --git a/tests/baselines/reference/additionOperatorWithStringAndEveryType.symbols b/tests/baselines/reference/additionOperatorWithStringAndEveryType.symbols
index 1b8a1c5d50acc..0fb0f428716b4 100644
--- a/tests/baselines/reference/additionOperatorWithStringAndEveryType.symbols
+++ b/tests/baselines/reference/additionOperatorWithStringAndEveryType.symbols
@@ -128,7 +128,6 @@ var r18 = x + 0;
 var r19 = x + { a: '' };
 >r19 : Symbol(r19, Decl(additionOperatorWithStringAndEveryType.ts, 36, 3))
 >x : Symbol(x, Decl(additionOperatorWithStringAndEveryType.ts, 10, 3))
->{ a: '' } : Symbol(, Decl(additionOperatorWithStringAndEveryType.ts, 36, 13))
 >a : Symbol(a, Decl(additionOperatorWithStringAndEveryType.ts, 36, 15))
 
 var r20 = x + [];
diff --git a/tests/baselines/reference/aliasUsageInFunctionExpression.symbols b/tests/baselines/reference/aliasUsageInFunctionExpression.symbols
index 8f12b3d3390af..2afb6be55c557 100644
--- a/tests/baselines/reference/aliasUsageInFunctionExpression.symbols
+++ b/tests/baselines/reference/aliasUsageInFunctionExpression.symbols
@@ -16,14 +16,12 @@ interface IHasVisualizationModel {
 }
 var f = (x: IHasVisualizationModel) => x;
 >f : Symbol(f, Decl(aliasUsageInFunctionExpression_main.ts, 5, 3))
->(x: IHasVisualizationModel) => x : Symbol((Anonymous function), Decl(aliasUsageInFunctionExpression_main.ts, 5, 7))
 >x : Symbol(x, Decl(aliasUsageInFunctionExpression_main.ts, 5, 9))
 >IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInFunctionExpression_main.ts, 1, 67))
 >x : Symbol(x, Decl(aliasUsageInFunctionExpression_main.ts, 5, 9))
 
 f = (x) => moduleA;
 >f : Symbol(f, Decl(aliasUsageInFunctionExpression_main.ts, 5, 3))
->(x) => moduleA : Symbol((Anonymous function), Decl(aliasUsageInFunctionExpression_main.ts, 6, 3))
 >x : Symbol(x, Decl(aliasUsageInFunctionExpression_main.ts, 6, 5))
 >moduleA : Symbol(moduleA, Decl(aliasUsageInFunctionExpression_main.ts, 0, 69))
 
diff --git a/tests/baselines/reference/aliasUsageInGenericFunction.symbols b/tests/baselines/reference/aliasUsageInGenericFunction.symbols
index bf67e5d8ad8f3..3f001e8bd1a98 100644
--- a/tests/baselines/reference/aliasUsageInGenericFunction.symbols
+++ b/tests/baselines/reference/aliasUsageInGenericFunction.symbols
@@ -28,14 +28,12 @@ function foo<T extends { a: IHasVisualizationModel }>(x: T) {
 var r = foo({ a: moduleA });
 >r : Symbol(r, Decl(aliasUsageInGenericFunction_main.ts, 8, 3))
 >foo : Symbol(foo, Decl(aliasUsageInGenericFunction_main.ts, 4, 1))
->{ a: moduleA } : Symbol(, Decl(aliasUsageInGenericFunction_main.ts, 8, 12))
 >a : Symbol(a, Decl(aliasUsageInGenericFunction_main.ts, 8, 13))
 >moduleA : Symbol(moduleA, Decl(aliasUsageInGenericFunction_main.ts, 0, 66))
 
 var r2 = foo({ a: <IHasVisualizationModel>null });
 >r2 : Symbol(r2, Decl(aliasUsageInGenericFunction_main.ts, 9, 3))
 >foo : Symbol(foo, Decl(aliasUsageInGenericFunction_main.ts, 4, 1))
->{ a: <IHasVisualizationModel>null } : Symbol(, Decl(aliasUsageInGenericFunction_main.ts, 9, 13))
 >a : Symbol(a, Decl(aliasUsageInGenericFunction_main.ts, 9, 14))
 >IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInGenericFunction_main.ts, 1, 64))
 
diff --git a/tests/baselines/reference/aliasUsageInObjectLiteral.symbols b/tests/baselines/reference/aliasUsageInObjectLiteral.symbols
index 8b18f768285c1..a508e9fafc173 100644
--- a/tests/baselines/reference/aliasUsageInObjectLiteral.symbols
+++ b/tests/baselines/reference/aliasUsageInObjectLiteral.symbols
@@ -18,7 +18,6 @@ var a: { x: typeof moduleA } = { x: moduleA };
 >a : Symbol(a, Decl(aliasUsageInObjectLiteral_main.ts, 5, 3))
 >x : Symbol(x, Decl(aliasUsageInObjectLiteral_main.ts, 5, 8))
 >moduleA : Symbol(moduleA, Decl(aliasUsageInObjectLiteral_main.ts, 0, 64))
->{ x: moduleA } : Symbol(, Decl(aliasUsageInObjectLiteral_main.ts, 5, 30))
 >x : Symbol(x, Decl(aliasUsageInObjectLiteral_main.ts, 5, 32))
 >moduleA : Symbol(moduleA, Decl(aliasUsageInObjectLiteral_main.ts, 0, 64))
 
@@ -26,7 +25,6 @@ var b: { x: IHasVisualizationModel } = { x: moduleA };
 >b : Symbol(b, Decl(aliasUsageInObjectLiteral_main.ts, 6, 3))
 >x : Symbol(x, Decl(aliasUsageInObjectLiteral_main.ts, 6, 8))
 >IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInObjectLiteral_main.ts, 1, 62))
->{ x: moduleA } : Symbol(, Decl(aliasUsageInObjectLiteral_main.ts, 6, 38))
 >x : Symbol(x, Decl(aliasUsageInObjectLiteral_main.ts, 6, 40))
 >moduleA : Symbol(moduleA, Decl(aliasUsageInObjectLiteral_main.ts, 0, 64))
 
@@ -35,9 +33,7 @@ var c: { y: { z: IHasVisualizationModel } } = { y: { z: moduleA } };
 >y : Symbol(y, Decl(aliasUsageInObjectLiteral_main.ts, 7, 8))
 >z : Symbol(z, Decl(aliasUsageInObjectLiteral_main.ts, 7, 13))
 >IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInObjectLiteral_main.ts, 1, 62))
->{ y: { z: moduleA } } : Symbol(, Decl(aliasUsageInObjectLiteral_main.ts, 7, 45))
 >y : Symbol(y, Decl(aliasUsageInObjectLiteral_main.ts, 7, 47))
->{ z: moduleA } : Symbol(, Decl(aliasUsageInObjectLiteral_main.ts, 7, 50))
 >z : Symbol(z, Decl(aliasUsageInObjectLiteral_main.ts, 7, 52))
 >moduleA : Symbol(moduleA, Decl(aliasUsageInObjectLiteral_main.ts, 0, 64))
 
diff --git a/tests/baselines/reference/aliasUsageInOrExpression.symbols b/tests/baselines/reference/aliasUsageInOrExpression.symbols
index 2e628b6960850..adfba01a1190c 100644
--- a/tests/baselines/reference/aliasUsageInOrExpression.symbols
+++ b/tests/baselines/reference/aliasUsageInOrExpression.symbols
@@ -41,7 +41,6 @@ var e: { x: IHasVisualizationModel } = <{ x: IHasVisualizationModel }>null || {
 >IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInOrExpression_main.ts, 1, 61))
 >x : Symbol(x, Decl(aliasUsageInOrExpression_main.ts, 9, 41))
 >IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInOrExpression_main.ts, 1, 61))
->{ x: moduleA } : Symbol(, Decl(aliasUsageInOrExpression_main.ts, 9, 77))
 >x : Symbol(x, Decl(aliasUsageInOrExpression_main.ts, 9, 79))
 >moduleA : Symbol(moduleA, Decl(aliasUsageInOrExpression_main.ts, 0, 63))
 
@@ -51,7 +50,6 @@ var f: { x: IHasVisualizationModel } = <{ x: IHasVisualizationModel }>null ? { x
 >IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInOrExpression_main.ts, 1, 61))
 >x : Symbol(x, Decl(aliasUsageInOrExpression_main.ts, 10, 41))
 >IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInOrExpression_main.ts, 1, 61))
->{ x: moduleA } : Symbol(, Decl(aliasUsageInOrExpression_main.ts, 10, 76))
 >x : Symbol(x, Decl(aliasUsageInOrExpression_main.ts, 10, 78))
 >moduleA : Symbol(moduleA, Decl(aliasUsageInOrExpression_main.ts, 0, 63))
 
diff --git a/tests/baselines/reference/aliasUsedAsNameValue.symbols b/tests/baselines/reference/aliasUsedAsNameValue.symbols
index 62e36c6c9076b..a816e2b2c63e6 100644
--- a/tests/baselines/reference/aliasUsedAsNameValue.symbols
+++ b/tests/baselines/reference/aliasUsedAsNameValue.symbols
@@ -9,7 +9,6 @@ import b = require("aliasUsedAsNameValue_1");
  
 export var a = function () {
 >a : Symbol(a, Decl(aliasUsedAsNameValue_2.ts, 5, 10))
->function () {    //var x = mod.id; // TODO needed hack that mod is loaded    b.b(mod);} : Symbol((Anonymous function), Decl(aliasUsedAsNameValue_2.ts, 5, 14))
 
     //var x = mod.id; // TODO needed hack that mod is loaded
     b.b(mod);
diff --git a/tests/baselines/reference/amdImportNotAsPrimaryExpression.symbols b/tests/baselines/reference/amdImportNotAsPrimaryExpression.symbols
index 8748a877c0323..68a852c6165aa 100644
--- a/tests/baselines/reference/amdImportNotAsPrimaryExpression.symbols
+++ b/tests/baselines/reference/amdImportNotAsPrimaryExpression.symbols
@@ -18,7 +18,6 @@ var x: foo.C1 = <{m1: number}>{};
 >foo : Symbol(foo, Decl(foo_1.ts, 0, 0))
 >C1 : Symbol(foo.C1, Decl(foo_0.ts, 0, 0))
 >m1 : Symbol(m1, Decl(foo_1.ts, 4, 18))
->{} : Symbol(, Decl(foo_1.ts, 4, 30))
 
 var y: typeof foo.C1.s1 = false;
 >y : Symbol(y, Decl(foo_1.ts, 5, 3))
diff --git a/tests/baselines/reference/anonterface.symbols b/tests/baselines/reference/anonterface.symbols
index ee3a9a6737c20..fccd48043cf01 100644
--- a/tests/baselines/reference/anonterface.symbols
+++ b/tests/baselines/reference/anonterface.symbols
@@ -28,7 +28,6 @@ c.m(function(n) { return "hello: "+n; },18);
 >c.m : Symbol(M.C.m, Decl(anonterface.ts, 1, 20))
 >c : Symbol(c, Decl(anonterface.ts, 8, 3))
 >m : Symbol(M.C.m, Decl(anonterface.ts, 1, 20))
->function(n) { return "hello: "+n; } : Symbol((Anonymous function), Decl(anonterface.ts, 9, 4))
 >n : Symbol(n, Decl(anonterface.ts, 9, 13))
 >n : Symbol(n, Decl(anonterface.ts, 9, 13))
 
diff --git a/tests/baselines/reference/anonymousClassExpression1.symbols b/tests/baselines/reference/anonymousClassExpression1.symbols
index 25d7b9a1e0af5..114bfc96097a2 100644
--- a/tests/baselines/reference/anonymousClassExpression1.symbols
+++ b/tests/baselines/reference/anonymousClassExpression1.symbols
@@ -3,5 +3,4 @@ function f() {
 >f : Symbol(f, Decl(anonymousClassExpression1.ts, 0, 0))
 
     return typeof class {} === "function";
->class {} : Symbol((Anonymous class), Decl(anonymousClassExpression1.ts, 1, 17))
 }
diff --git a/tests/baselines/reference/anyInferenceAnonymousFunctions.symbols b/tests/baselines/reference/anyInferenceAnonymousFunctions.symbols
index 8e3d27d33bfdb..daf7947e69437 100644
--- a/tests/baselines/reference/anyInferenceAnonymousFunctions.symbols
+++ b/tests/baselines/reference/anyInferenceAnonymousFunctions.symbols
@@ -6,13 +6,11 @@ paired.reduce(function (a1, a2) {
 >paired.reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120))
 >paired : Symbol(paired, Decl(anyInferenceAnonymousFunctions.ts, 0, 3))
 >reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120))
->function (a1, a2) {    return a1.concat({});} : Symbol((Anonymous function), Decl(anyInferenceAnonymousFunctions.ts, 2, 14))
 >a1 : Symbol(a1, Decl(anyInferenceAnonymousFunctions.ts, 2, 24))
 >a2 : Symbol(a2, Decl(anyInferenceAnonymousFunctions.ts, 2, 27))
 
     return a1.concat({});
 >a1 : Symbol(a1, Decl(anyInferenceAnonymousFunctions.ts, 2, 24))
->{} : Symbol(, Decl(anyInferenceAnonymousFunctions.ts, 4, 21))
 
 } , []);
 
@@ -20,13 +18,11 @@ paired.reduce((b1, b2) => {
 >paired.reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120))
 >paired : Symbol(paired, Decl(anyInferenceAnonymousFunctions.ts, 0, 3))
 >reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120))
->(b1, b2) => {    return b1.concat({});} : Symbol((Anonymous function), Decl(anyInferenceAnonymousFunctions.ts, 8, 14))
 >b1 : Symbol(b1, Decl(anyInferenceAnonymousFunctions.ts, 8, 15))
 >b2 : Symbol(b2, Decl(anyInferenceAnonymousFunctions.ts, 8, 18))
 
     return b1.concat({});
 >b1 : Symbol(b1, Decl(anyInferenceAnonymousFunctions.ts, 8, 15))
->{} : Symbol(, Decl(anyInferenceAnonymousFunctions.ts, 10, 21))
 
 } , []);
 
@@ -34,17 +30,14 @@ paired.reduce((b3, b4) => b3.concat({}), []);
 >paired.reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120))
 >paired : Symbol(paired, Decl(anyInferenceAnonymousFunctions.ts, 0, 3))
 >reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120))
->(b3, b4) => b3.concat({}) : Symbol((Anonymous function), Decl(anyInferenceAnonymousFunctions.ts, 13, 14))
 >b3 : Symbol(b3, Decl(anyInferenceAnonymousFunctions.ts, 13, 15))
 >b4 : Symbol(b4, Decl(anyInferenceAnonymousFunctions.ts, 13, 18))
 >b3 : Symbol(b3, Decl(anyInferenceAnonymousFunctions.ts, 13, 15))
->{} : Symbol(, Decl(anyInferenceAnonymousFunctions.ts, 13, 36))
 
 paired.map((c1) => c1.count);
 >paired.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
 >paired : Symbol(paired, Decl(anyInferenceAnonymousFunctions.ts, 0, 3))
 >map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
->(c1) => c1.count : Symbol((Anonymous function), Decl(anyInferenceAnonymousFunctions.ts, 15, 11))
 >c1 : Symbol(c1, Decl(anyInferenceAnonymousFunctions.ts, 15, 12))
 >c1 : Symbol(c1, Decl(anyInferenceAnonymousFunctions.ts, 15, 12))
 
@@ -52,7 +45,6 @@ paired.map(function (c2) { return c2.count; });
 >paired.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
 >paired : Symbol(paired, Decl(anyInferenceAnonymousFunctions.ts, 0, 3))
 >map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
->function (c2) { return c2.count; } : Symbol((Anonymous function), Decl(anyInferenceAnonymousFunctions.ts, 16, 11))
 >c2 : Symbol(c2, Decl(anyInferenceAnonymousFunctions.ts, 16, 21))
 >c2 : Symbol(c2, Decl(anyInferenceAnonymousFunctions.ts, 16, 21))
 
diff --git a/tests/baselines/reference/argumentsUsedInObjectLiteralProperty.symbols b/tests/baselines/reference/argumentsUsedInObjectLiteralProperty.symbols
index 0da8f2dd87856..1c3b54ef427e2 100644
--- a/tests/baselines/reference/argumentsUsedInObjectLiteralProperty.symbols
+++ b/tests/baselines/reference/argumentsUsedInObjectLiteralProperty.symbols
@@ -8,8 +8,6 @@ class A {
 >selectedValue : Symbol(selectedValue, Decl(argumentsUsedInObjectLiteralProperty.ts, 1, 63))
 
         return {
->{            selectedValue: arguments.length        } : Symbol(, Decl(argumentsUsedInObjectLiteralProperty.ts, 2, 14))
-
             selectedValue: arguments.length
 >selectedValue : Symbol(selectedValue, Decl(argumentsUsedInObjectLiteralProperty.ts, 2, 16))
 >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, 272, 25))
diff --git a/tests/baselines/reference/arrayBestCommonTypes.symbols b/tests/baselines/reference/arrayBestCommonTypes.symbols
index 03d5c0b342e66..c4b42f66991ab 100644
--- a/tests/baselines/reference/arrayBestCommonTypes.symbols
+++ b/tests/baselines/reference/arrayBestCommonTypes.symbols
@@ -121,11 +121,9 @@ module EmptyTypes {
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 31, 21))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 31, 32))
 >base : Symbol(base, Decl(arrayBestCommonTypes.ts, 1, 23))
->{ x: 7, y: new derived() } : Symbol(, Decl(arrayBestCommonTypes.ts, 31, 49))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 31, 50))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 31, 56))
 >derived : Symbol(derived, Decl(arrayBestCommonTypes.ts, 3, 36))
->{ x: 5, y: new base() } : Symbol(, Decl(arrayBestCommonTypes.ts, 31, 76))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 31, 78))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 31, 84))
 >base : Symbol(base, Decl(arrayBestCommonTypes.ts, 1, 23))
@@ -135,11 +133,9 @@ module EmptyTypes {
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 32, 21))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 32, 33))
 >base : Symbol(base, Decl(arrayBestCommonTypes.ts, 1, 23))
->{ x: true, y: new derived() } : Symbol(, Decl(arrayBestCommonTypes.ts, 32, 50))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 32, 51))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 32, 60))
 >derived : Symbol(derived, Decl(arrayBestCommonTypes.ts, 3, 36))
->{ x: false, y: new base() } : Symbol(, Decl(arrayBestCommonTypes.ts, 32, 80))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 32, 82))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 32, 92))
 >base : Symbol(base, Decl(arrayBestCommonTypes.ts, 1, 23))
@@ -149,12 +145,10 @@ module EmptyTypes {
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 33, 21))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 33, 32))
 >base : Symbol(base, Decl(arrayBestCommonTypes.ts, 1, 23))
->{ x: undefined, y: new base() } : Symbol(, Decl(arrayBestCommonTypes.ts, 33, 49))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 33, 50))
 >undefined : Symbol(undefined)
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 33, 64))
 >base : Symbol(base, Decl(arrayBestCommonTypes.ts, 1, 23))
->{ x: '', y: new derived() } : Symbol(, Decl(arrayBestCommonTypes.ts, 33, 81))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 33, 83))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 33, 90))
 >derived : Symbol(derived, Decl(arrayBestCommonTypes.ts, 3, 36))
@@ -165,40 +159,31 @@ module EmptyTypes {
             // Order matters here so test all the variants
             var a1 = [{ x: 0, y: 'a' }, { x: 'a', y: 'a' }, { x: anyObj, y: 'a' }];
 >a1 : Symbol(a1, Decl(arrayBestCommonTypes.ts, 37, 15))
->{ x: 0, y: 'a' } : Symbol(, Decl(arrayBestCommonTypes.ts, 37, 22))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 37, 23))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 37, 29))
->{ x: 'a', y: 'a' } : Symbol(, Decl(arrayBestCommonTypes.ts, 37, 39))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 37, 41))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 37, 49))
->{ x: anyObj, y: 'a' } : Symbol(, Decl(arrayBestCommonTypes.ts, 37, 59))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 37, 61))
 >anyObj : Symbol(anyObj, Decl(arrayBestCommonTypes.ts, 35, 15))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 37, 72))
 
             var a2 = [{ x: anyObj, y: 'a' }, { x: 0, y: 'a' }, { x: 'a', y: 'a' }];
 >a2 : Symbol(a2, Decl(arrayBestCommonTypes.ts, 38, 15))
->{ x: anyObj, y: 'a' } : Symbol(, Decl(arrayBestCommonTypes.ts, 38, 22))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 38, 23))
 >anyObj : Symbol(anyObj, Decl(arrayBestCommonTypes.ts, 35, 15))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 38, 34))
->{ x: 0, y: 'a' } : Symbol(, Decl(arrayBestCommonTypes.ts, 38, 44))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 38, 46))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 38, 52))
->{ x: 'a', y: 'a' } : Symbol(, Decl(arrayBestCommonTypes.ts, 38, 62))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 38, 64))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 38, 72))
 
             var a3 = [{ x: 0, y: 'a' }, { x: anyObj, y: 'a' }, { x: 'a', y: 'a' }];
 >a3 : Symbol(a3, Decl(arrayBestCommonTypes.ts, 39, 15))
->{ x: 0, y: 'a' } : Symbol(, Decl(arrayBestCommonTypes.ts, 39, 22))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 39, 23))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 39, 29))
->{ x: anyObj, y: 'a' } : Symbol(, Decl(arrayBestCommonTypes.ts, 39, 39))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 39, 41))
 >anyObj : Symbol(anyObj, Decl(arrayBestCommonTypes.ts, 35, 15))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 39, 52))
->{ x: 'a', y: 'a' } : Symbol(, Decl(arrayBestCommonTypes.ts, 39, 62))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 39, 64))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 39, 72))
 
@@ -369,11 +354,9 @@ module NonEmptyTypes {
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 84, 21))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 84, 32))
 >base : Symbol(base, Decl(arrayBestCommonTypes.ts, 54, 34))
->{ x: 7, y: new derived() } : Symbol(, Decl(arrayBestCommonTypes.ts, 84, 49))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 84, 50))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 84, 56))
 >derived : Symbol(derived, Decl(arrayBestCommonTypes.ts, 56, 58))
->{ x: 5, y: new base() } : Symbol(, Decl(arrayBestCommonTypes.ts, 84, 76))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 84, 78))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 84, 84))
 >base : Symbol(base, Decl(arrayBestCommonTypes.ts, 54, 34))
@@ -383,11 +366,9 @@ module NonEmptyTypes {
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 85, 21))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 85, 33))
 >base : Symbol(base, Decl(arrayBestCommonTypes.ts, 54, 34))
->{ x: true, y: new derived() } : Symbol(, Decl(arrayBestCommonTypes.ts, 85, 50))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 85, 51))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 85, 60))
 >derived : Symbol(derived, Decl(arrayBestCommonTypes.ts, 56, 58))
->{ x: false, y: new base() } : Symbol(, Decl(arrayBestCommonTypes.ts, 85, 80))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 85, 82))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 85, 92))
 >base : Symbol(base, Decl(arrayBestCommonTypes.ts, 54, 34))
@@ -397,12 +378,10 @@ module NonEmptyTypes {
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 86, 21))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 86, 32))
 >base : Symbol(base, Decl(arrayBestCommonTypes.ts, 54, 34))
->{ x: undefined, y: new base() } : Symbol(, Decl(arrayBestCommonTypes.ts, 86, 49))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 86, 50))
 >undefined : Symbol(undefined)
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 86, 64))
 >base : Symbol(base, Decl(arrayBestCommonTypes.ts, 54, 34))
->{ x: '', y: new derived() } : Symbol(, Decl(arrayBestCommonTypes.ts, 86, 81))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 86, 83))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 86, 90))
 >derived : Symbol(derived, Decl(arrayBestCommonTypes.ts, 56, 58))
@@ -413,40 +392,31 @@ module NonEmptyTypes {
             // Order matters here so test all the variants
             var a1 = [{ x: 0, y: 'a' }, { x: 'a', y: 'a' }, { x: anyObj, y: 'a' }];
 >a1 : Symbol(a1, Decl(arrayBestCommonTypes.ts, 90, 15))
->{ x: 0, y: 'a' } : Symbol(, Decl(arrayBestCommonTypes.ts, 90, 22))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 90, 23))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 90, 29))
->{ x: 'a', y: 'a' } : Symbol(, Decl(arrayBestCommonTypes.ts, 90, 39))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 90, 41))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 90, 49))
->{ x: anyObj, y: 'a' } : Symbol(, Decl(arrayBestCommonTypes.ts, 90, 59))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 90, 61))
 >anyObj : Symbol(anyObj, Decl(arrayBestCommonTypes.ts, 88, 15))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 90, 72))
 
             var a2 = [{ x: anyObj, y: 'a' }, { x: 0, y: 'a' }, { x: 'a', y: 'a' }];
 >a2 : Symbol(a2, Decl(arrayBestCommonTypes.ts, 91, 15))
->{ x: anyObj, y: 'a' } : Symbol(, Decl(arrayBestCommonTypes.ts, 91, 22))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 91, 23))
 >anyObj : Symbol(anyObj, Decl(arrayBestCommonTypes.ts, 88, 15))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 91, 34))
->{ x: 0, y: 'a' } : Symbol(, Decl(arrayBestCommonTypes.ts, 91, 44))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 91, 46))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 91, 52))
->{ x: 'a', y: 'a' } : Symbol(, Decl(arrayBestCommonTypes.ts, 91, 62))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 91, 64))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 91, 72))
 
             var a3 = [{ x: 0, y: 'a' }, { x: anyObj, y: 'a' }, { x: 'a', y: 'a' }];
 >a3 : Symbol(a3, Decl(arrayBestCommonTypes.ts, 92, 15))
->{ x: 0, y: 'a' } : Symbol(, Decl(arrayBestCommonTypes.ts, 92, 22))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 92, 23))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 92, 29))
->{ x: anyObj, y: 'a' } : Symbol(, Decl(arrayBestCommonTypes.ts, 92, 39))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 92, 41))
 >anyObj : Symbol(anyObj, Decl(arrayBestCommonTypes.ts, 88, 15))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 92, 52))
->{ x: 'a', y: 'a' } : Symbol(, Decl(arrayBestCommonTypes.ts, 92, 62))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 92, 64))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 92, 72))
 
diff --git a/tests/baselines/reference/arrayBindingPatternOmittedExpressions.symbols b/tests/baselines/reference/arrayBindingPatternOmittedExpressions.symbols
index e506d62e60fae..41d04ee623a05 100644
--- a/tests/baselines/reference/arrayBindingPatternOmittedExpressions.symbols
+++ b/tests/baselines/reference/arrayBindingPatternOmittedExpressions.symbols
@@ -11,7 +11,6 @@ var results: string[];
 
     let x = {
 >x : Symbol(x, Decl(arrayBindingPatternOmittedExpressions.ts, 5, 7))
->{        a,        b    } : Symbol(, Decl(arrayBindingPatternOmittedExpressions.ts, 5, 11))
 
         a,
 >a : Symbol(a, Decl(arrayBindingPatternOmittedExpressions.ts, 5, 13))
diff --git a/tests/baselines/reference/arrayConcatMap.symbols b/tests/baselines/reference/arrayConcatMap.symbols
index e6ecc2a9432da..1ff4bc3bff56c 100644
--- a/tests/baselines/reference/arrayConcatMap.symbols
+++ b/tests/baselines/reference/arrayConcatMap.symbols
@@ -4,14 +4,11 @@ var x = [].concat([{ a: 1 }], [{ a: 2 }])
 >[].concat([{ a: 1 }], [{ a: 2 }])          .map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
 >[].concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
 >concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
->{ a: 1 } : Symbol(, Decl(arrayConcatMap.ts, 0, 19))
 >a : Symbol(a, Decl(arrayConcatMap.ts, 0, 20))
->{ a: 2 } : Symbol(, Decl(arrayConcatMap.ts, 0, 31))
 >a : Symbol(a, Decl(arrayConcatMap.ts, 0, 32))
 
           .map(b => b.a);
 >map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
->b => b.a : Symbol((Anonymous function), Decl(arrayConcatMap.ts, 1, 15))
 >b : Symbol(b, Decl(arrayConcatMap.ts, 1, 15))
 >b : Symbol(b, Decl(arrayConcatMap.ts, 1, 15))
 
diff --git a/tests/baselines/reference/arrayLiteralTypeInference.symbols b/tests/baselines/reference/arrayLiteralTypeInference.symbols
index ff5d62c2f3450..005cb57f6c402 100644
--- a/tests/baselines/reference/arrayLiteralTypeInference.symbols
+++ b/tests/baselines/reference/arrayLiteralTypeInference.symbols
@@ -27,12 +27,10 @@ var x1: Action[] = [
 >Action : Symbol(Action, Decl(arrayLiteralTypeInference.ts, 0, 0))
 
     { id: 2, trueness: false },
->{ id: 2, trueness: false } : Symbol(, Decl(arrayLiteralTypeInference.ts, 12, 20))
 >id : Symbol(id, Decl(arrayLiteralTypeInference.ts, 13, 5))
 >trueness : Symbol(trueness, Decl(arrayLiteralTypeInference.ts, 13, 12))
 
     { id: 3, name: "three" }
->{ id: 3, name: "three" } : Symbol(, Decl(arrayLiteralTypeInference.ts, 13, 31))
 >id : Symbol(id, Decl(arrayLiteralTypeInference.ts, 14, 5))
 >name : Symbol(name, Decl(arrayLiteralTypeInference.ts, 14, 12))
 
@@ -71,12 +69,10 @@ var z1: { id: number }[] =
 
     [
         { id: 2, trueness: false },
->{ id: 2, trueness: false } : Symbol(, Decl(arrayLiteralTypeInference.ts, 29, 5))
 >id : Symbol(id, Decl(arrayLiteralTypeInference.ts, 30, 9))
 >trueness : Symbol(trueness, Decl(arrayLiteralTypeInference.ts, 30, 16))
 
         { id: 3, name: "three" }
->{ id: 3, name: "three" } : Symbol(, Decl(arrayLiteralTypeInference.ts, 30, 35))
 >id : Symbol(id, Decl(arrayLiteralTypeInference.ts, 31, 9))
 >name : Symbol(name, Decl(arrayLiteralTypeInference.ts, 31, 16))
 
diff --git a/tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.symbols b/tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.symbols
index cb01e8fbb718b..071596c9af1e0 100644
--- a/tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.symbols
+++ b/tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.symbols
@@ -34,38 +34,30 @@ var cs = [a, b, c]; // { x: number; y?: number };[]
 
 var ds = [(x: Object) => 1, (x: string) => 2]; // { (x:Object) => number }[]
 >ds : Symbol(ds, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 10, 3))
->(x: Object) => 1 : Symbol((Anonymous function), Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 10, 10))
 >x : Symbol(x, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 10, 11))
 >Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
->(x: string) => 2 : Symbol((Anonymous function), Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 10, 27))
 >x : Symbol(x, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 10, 29))
 
 var es = [(x: string) => 2, (x: Object) => 1]; // { (x:string) => number }[]
 >es : Symbol(es, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 11, 3))
->(x: string) => 2 : Symbol((Anonymous function), Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 11, 10))
 >x : Symbol(x, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 11, 11))
->(x: Object) => 1 : Symbol((Anonymous function), Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 11, 27))
 >x : Symbol(x, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 11, 29))
 >Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
 
 var fs = [(a: { x: number; y?: number }) => 1, (b: { x: number; z?: number }) => 2]; // (a: { x: number; y?: number }) => number[]
 >fs : Symbol(fs, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 12, 3))
->(a: { x: number; y?: number }) => 1 : Symbol((Anonymous function), Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 12, 10))
 >a : Symbol(a, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 12, 11))
 >x : Symbol(x, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 12, 15))
 >y : Symbol(y, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 12, 26))
->(b: { x: number; z?: number }) => 2 : Symbol((Anonymous function), Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 12, 46))
 >b : Symbol(b, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 12, 48))
 >x : Symbol(x, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 12, 52))
 >z : Symbol(z, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 12, 63))
 
 var gs = [(b: { x: number; z?: number }) => 2, (a: { x: number; y?: number }) => 1]; // (b: { x: number; z?: number }) => number[]
 >gs : Symbol(gs, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 13, 3))
->(b: { x: number; z?: number }) => 2 : Symbol((Anonymous function), Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 13, 10))
 >b : Symbol(b, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 13, 11))
 >x : Symbol(x, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 13, 15))
 >z : Symbol(z, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 13, 26))
->(a: { x: number; y?: number }) => 1 : Symbol((Anonymous function), Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 13, 46))
 >a : Symbol(a, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 13, 48))
 >x : Symbol(x, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 13, 52))
 >y : Symbol(y, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 13, 63))
diff --git a/tests/baselines/reference/arrayLiterals.symbols b/tests/baselines/reference/arrayLiterals.symbols
index cb8b309307527..b338e7ff6e6c5 100644
--- a/tests/baselines/reference/arrayLiterals.symbols
+++ b/tests/baselines/reference/arrayLiterals.symbols
@@ -47,22 +47,18 @@ var context1: { [n: number]: { a: string; b: number; }; } = [{ a: '', b: 0, c: '
 >n : Symbol(n, Decl(arrayLiterals.ts, 23, 17))
 >a : Symbol(a, Decl(arrayLiterals.ts, 23, 30))
 >b : Symbol(b, Decl(arrayLiterals.ts, 23, 41))
->{ a: '', b: 0, c: '' } : Symbol(, Decl(arrayLiterals.ts, 23, 61))
 >a : Symbol(a, Decl(arrayLiterals.ts, 23, 62))
 >b : Symbol(b, Decl(arrayLiterals.ts, 23, 69))
 >c : Symbol(c, Decl(arrayLiterals.ts, 23, 75))
->{ a: "", b: 3, c: 0 } : Symbol(, Decl(arrayLiterals.ts, 23, 84))
 >a : Symbol(a, Decl(arrayLiterals.ts, 23, 86))
 >b : Symbol(b, Decl(arrayLiterals.ts, 23, 93))
 >c : Symbol(c, Decl(arrayLiterals.ts, 23, 99))
 
 var context2 = [{ a: '', b: 0, c: '' }, { a: "", b: 3, c: 0 }];
 >context2 : Symbol(context2, Decl(arrayLiterals.ts, 24, 3))
->{ a: '', b: 0, c: '' } : Symbol(, Decl(arrayLiterals.ts, 24, 16))
 >a : Symbol(a, Decl(arrayLiterals.ts, 24, 17))
 >b : Symbol(b, Decl(arrayLiterals.ts, 24, 24))
 >c : Symbol(c, Decl(arrayLiterals.ts, 24, 30))
->{ a: "", b: 3, c: 0 } : Symbol(, Decl(arrayLiterals.ts, 24, 39))
 >a : Symbol(a, Decl(arrayLiterals.ts, 24, 41))
 >b : Symbol(b, Decl(arrayLiterals.ts, 24, 48))
 >c : Symbol(c, Decl(arrayLiterals.ts, 24, 54))
diff --git a/tests/baselines/reference/arrayLiterals2ES5.symbols b/tests/baselines/reference/arrayLiterals2ES5.symbols
index baaacdda2764f..c69b79de2724d 100644
--- a/tests/baselines/reference/arrayLiterals2ES5.symbols
+++ b/tests/baselines/reference/arrayLiterals2ES5.symbols
@@ -24,7 +24,6 @@ var a3 = [,, ...a0]
 
 var a4 = [() => 1, ];
 >a4 : Symbol(a4, Decl(arrayLiterals2ES5.ts, 13, 3))
->() => 1 : Symbol((Anonymous function), Decl(arrayLiterals2ES5.ts, 13, 10))
 
 var a5 = [...a0, , ]
 >a5 : Symbol(a5, Decl(arrayLiterals2ES5.ts, 14, 3))
diff --git a/tests/baselines/reference/arrayLiterals2ES6.symbols b/tests/baselines/reference/arrayLiterals2ES6.symbols
index c95ffffd3c95f..faf0b13073815 100644
--- a/tests/baselines/reference/arrayLiterals2ES6.symbols
+++ b/tests/baselines/reference/arrayLiterals2ES6.symbols
@@ -24,7 +24,6 @@ var a3 = [, , ...a0]
 
 var a4 = [() => 1, ];
 >a4 : Symbol(a4, Decl(arrayLiterals2ES6.ts, 13, 3))
->() => 1 : Symbol((Anonymous function), Decl(arrayLiterals2ES6.ts, 13, 10))
 
 var a5 = [...a0, , ]
 >a5 : Symbol(a5, Decl(arrayLiterals2ES6.ts, 14, 3))
diff --git a/tests/baselines/reference/arrayOfFunctionTypes3.symbols b/tests/baselines/reference/arrayOfFunctionTypes3.symbols
index f2bf4a72e0022..d26effeb5b77b 100644
--- a/tests/baselines/reference/arrayOfFunctionTypes3.symbols
+++ b/tests/baselines/reference/arrayOfFunctionTypes3.symbols
@@ -3,8 +3,6 @@
 
 var x = [() => 1, () => { }];
 >x : Symbol(x, Decl(arrayOfFunctionTypes3.ts, 2, 3))
->() => 1 : Symbol((Anonymous function), Decl(arrayOfFunctionTypes3.ts, 2, 9))
->() => { } : Symbol((Anonymous function), Decl(arrayOfFunctionTypes3.ts, 2, 17))
 
 var r2 = x[0]();
 >r2 : Symbol(r2, Decl(arrayOfFunctionTypes3.ts, 3, 3))
diff --git a/tests/baselines/reference/arrayconcat.symbols b/tests/baselines/reference/arrayconcat.symbols
index ac87eb46a3202..64e63d7c2ecc0 100644
--- a/tests/baselines/reference/arrayconcat.symbols
+++ b/tests/baselines/reference/arrayconcat.symbols
@@ -44,7 +44,6 @@ class parser {
 >this : Symbol(parser, Decl(arrayconcat.ts, 8, 1))
 >options : Symbol(options, Decl(arrayconcat.ts, 10, 14))
 >sort : Symbol(Array.sort, Decl(lib.d.ts, 1054, 45))
->function(a, b) {            var aName = a.name.toLowerCase();            var bName = b.name.toLowerCase();            if (aName > bName) {                return 1;            } else if (aName < bName) {                return -1;            } else {                return 0;            }        } : Symbol((Anonymous function), Decl(arrayconcat.ts, 14, 35))
 >a : Symbol(a, Decl(arrayconcat.ts, 14, 44))
 >b : Symbol(b, Decl(arrayconcat.ts, 14, 46))
 
diff --git a/tests/baselines/reference/arrowFunctionExpressions.symbols b/tests/baselines/reference/arrowFunctionExpressions.symbols
index 4ade530993569..28945e1179f63 100644
--- a/tests/baselines/reference/arrowFunctionExpressions.symbols
+++ b/tests/baselines/reference/arrowFunctionExpressions.symbols
@@ -2,7 +2,6 @@
 // ArrowFormalParameters => AssignmentExpression is equivalent to ArrowFormalParameters => { return AssignmentExpression; }
 var a = (p: string) => p.length;
 >a : Symbol(a, Decl(arrowFunctionExpressions.ts, 1, 3), Decl(arrowFunctionExpressions.ts, 2, 3))
->(p: string) => p.length : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 1, 7))
 >p : Symbol(p, Decl(arrowFunctionExpressions.ts, 1, 9))
 >p.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >p : Symbol(p, Decl(arrowFunctionExpressions.ts, 1, 9))
@@ -10,7 +9,6 @@ var a = (p: string) => p.length;
 
 var a = (p: string) => { return p.length; }
 >a : Symbol(a, Decl(arrowFunctionExpressions.ts, 1, 3), Decl(arrowFunctionExpressions.ts, 2, 3))
->(p: string) => { return p.length; } : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 2, 7))
 >p : Symbol(p, Decl(arrowFunctionExpressions.ts, 2, 9))
 >p.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >p : Symbol(p, Decl(arrowFunctionExpressions.ts, 2, 9))
@@ -19,12 +17,10 @@ var a = (p: string) => { return p.length; }
 // Identifier => Block is equivalent to(Identifier) => Block
 var b = j => { return 0; }
 >b : Symbol(b, Decl(arrowFunctionExpressions.ts, 5, 3), Decl(arrowFunctionExpressions.ts, 6, 3))
->j => { return 0; } : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 5, 7))
 >j : Symbol(j, Decl(arrowFunctionExpressions.ts, 5, 7))
 
 var b = (j) => { return 0; }
 >b : Symbol(b, Decl(arrowFunctionExpressions.ts, 5, 3), Decl(arrowFunctionExpressions.ts, 6, 3))
->(j) => { return 0; } : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 6, 7))
 >j : Symbol(j, Decl(arrowFunctionExpressions.ts, 6, 9))
 
 // Identifier => AssignmentExpression is equivalent to(Identifier) => AssignmentExpression
@@ -33,14 +29,12 @@ var c: number;
 
 var d = n => c = n;
 >d : Symbol(d, Decl(arrowFunctionExpressions.ts, 10, 3), Decl(arrowFunctionExpressions.ts, 11, 3), Decl(arrowFunctionExpressions.ts, 12, 3))
->n => c = n : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 10, 7))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 10, 7))
 >c : Symbol(c, Decl(arrowFunctionExpressions.ts, 9, 3))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 10, 7))
 
 var d = (n) => c = n;
 >d : Symbol(d, Decl(arrowFunctionExpressions.ts, 10, 3), Decl(arrowFunctionExpressions.ts, 11, 3), Decl(arrowFunctionExpressions.ts, 12, 3))
->(n) => c = n : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 11, 7))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 11, 9))
 >c : Symbol(c, Decl(arrowFunctionExpressions.ts, 9, 3))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 11, 9))
@@ -52,54 +46,43 @@ var d: (n: any) => any;
 // Binding patterns in arrow functions
 var p1 = ([a]) => { };
 >p1 : Symbol(p1, Decl(arrowFunctionExpressions.ts, 15, 3))
->([a]) => { } : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 15, 8))
 >a : Symbol(a, Decl(arrowFunctionExpressions.ts, 15, 11))
 
 var p2 = ([...a]) => { };
 >p2 : Symbol(p2, Decl(arrowFunctionExpressions.ts, 16, 3))
->([...a]) => { } : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 16, 8))
 >a : Symbol(a, Decl(arrowFunctionExpressions.ts, 16, 11))
 
 var p3 = ([, a]) => { };
 >p3 : Symbol(p3, Decl(arrowFunctionExpressions.ts, 17, 3))
->([, a]) => { } : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 17, 8))
 >a : Symbol(a, Decl(arrowFunctionExpressions.ts, 17, 12))
 
 var p4 = ([, ...a]) => { };
 >p4 : Symbol(p4, Decl(arrowFunctionExpressions.ts, 18, 3))
->([, ...a]) => { } : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 18, 8))
 >a : Symbol(a, Decl(arrowFunctionExpressions.ts, 18, 12))
 
 var p5 = ([a = 1]) => { };
 >p5 : Symbol(p5, Decl(arrowFunctionExpressions.ts, 19, 3))
->([a = 1]) => { } : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 19, 8))
 >a : Symbol(a, Decl(arrowFunctionExpressions.ts, 19, 11))
 
 var p6 = ({ a }) => { };
 >p6 : Symbol(p6, Decl(arrowFunctionExpressions.ts, 20, 3))
->({ a }) => { } : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 20, 8))
 >a : Symbol(a, Decl(arrowFunctionExpressions.ts, 20, 11))
 
 var p7 = ({ a: { b } }) => { };
 >p7 : Symbol(p7, Decl(arrowFunctionExpressions.ts, 21, 3))
->({ a: { b } }) => { } : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 21, 8))
 >b : Symbol(b, Decl(arrowFunctionExpressions.ts, 21, 16))
 
 var p8 = ({ a = 1 }) => { };
 >p8 : Symbol(p8, Decl(arrowFunctionExpressions.ts, 22, 3))
->({ a = 1 }) => { } : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 22, 8))
 >a : Symbol(a, Decl(arrowFunctionExpressions.ts, 22, 11))
 
 var p9 = ({ a: { b = 1 } = { b: 1 } }) => { };
 >p9 : Symbol(p9, Decl(arrowFunctionExpressions.ts, 23, 3))
->({ a: { b = 1 } = { b: 1 } }) => { } : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 23, 8))
 >b : Symbol(b, Decl(arrowFunctionExpressions.ts, 23, 16))
->{ b: 1 } : Symbol(, Decl(arrowFunctionExpressions.ts, 23, 26))
 >b : Symbol(b, Decl(arrowFunctionExpressions.ts, 23, 28))
 
 var p10 = ([{ value, done }]) => { };
 >p10 : Symbol(p10, Decl(arrowFunctionExpressions.ts, 24, 3))
->([{ value, done }]) => { } : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 24, 9))
 >value : Symbol(value, Decl(arrowFunctionExpressions.ts, 24, 13))
 >done : Symbol(done, Decl(arrowFunctionExpressions.ts, 24, 20))
 
@@ -110,13 +93,11 @@ class MyClass {
 
     m = (n) => n + 1;
 >m : Symbol(m, Decl(arrowFunctionExpressions.ts, 28, 15))
->(n) => n + 1 : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 29, 7))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 29, 9))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 29, 9))
 
     p = (n) => n && this;
 >p : Symbol(p, Decl(arrowFunctionExpressions.ts, 29, 21))
->(n) => n && this : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 30, 7))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 30, 9))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 30, 9))
 >this : Symbol(MyClass, Decl(arrowFunctionExpressions.ts, 24, 37))
@@ -126,13 +107,11 @@ class MyClass {
 
         var m = (n) => n + 1;
 >m : Symbol(m, Decl(arrowFunctionExpressions.ts, 33, 11))
->(n) => n + 1 : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 33, 15))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 33, 17))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 33, 17))
 
         var p = (n) => n && this;
 >p : Symbol(p, Decl(arrowFunctionExpressions.ts, 34, 11))
->(n) => n && this : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 34, 15))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 34, 17))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 34, 17))
 >this : Symbol(MyClass, Decl(arrowFunctionExpressions.ts, 24, 37))
@@ -142,11 +121,7 @@ class MyClass {
 // Arrow function used in arrow function
 var arrrr = () => (m: number) => () => (n: number) => m + n;
 >arrrr : Symbol(arrrr, Decl(arrowFunctionExpressions.ts, 39, 3))
->() => (m: number) => () => (n: number) => m + n : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 39, 11))
->(m: number) => () => (n: number) => m + n : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 39, 17))
 >m : Symbol(m, Decl(arrowFunctionExpressions.ts, 39, 19))
->() => (n: number) => m + n : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 39, 32))
->(n: number) => m + n : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 39, 38))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 39, 40))
 >m : Symbol(m, Decl(arrowFunctionExpressions.ts, 39, 19))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 39, 40))
@@ -164,9 +139,7 @@ function someFn() {
 
     var arr = (n: number) => (p: number) => p * n;
 >arr : Symbol(arr, Decl(arrowFunctionExpressions.ts, 45, 7))
->(n: number) => (p: number) => p * n : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 45, 13))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 45, 15))
->(p: number) => p * n : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 45, 28))
 >p : Symbol(p, Decl(arrowFunctionExpressions.ts, 45, 30))
 >p : Symbol(p, Decl(arrowFunctionExpressions.ts, 45, 30))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 45, 15))
@@ -183,7 +156,6 @@ function someOtherFn() {
 
     var arr = (n: number) => '' + n;
 >arr : Symbol(arr, Decl(arrowFunctionExpressions.ts, 51, 7))
->(n: number) => '' + n : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 51, 13))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 51, 15))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 51, 15))
 
@@ -202,7 +174,6 @@ function outerFn() {
 
         var arrowFn = () => { };
 >arrowFn : Symbol(arrowFn, Decl(arrowFunctionExpressions.ts, 58, 11))
->() => { } : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 58, 21))
 
         var p = arrowFn();
 >p : Symbol(p, Decl(arrowFunctionExpressions.ts, 59, 11), Decl(arrowFunctionExpressions.ts, 60, 11))
@@ -216,7 +187,6 @@ function outerFn() {
 // Arrow function used in nested function in arrow function
 var f = (n: string) => {
 >f : Symbol(f, Decl(arrowFunctionExpressions.ts, 65, 3))
->(n: string) => {    function fn(x: number) {        return () => n + x;    }    return fn(4);} : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 65, 7))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 65, 9))
 
     function fn(x: number) {
@@ -224,7 +194,6 @@ var f = (n: string) => {
 >x : Symbol(x, Decl(arrowFunctionExpressions.ts, 66, 16))
 
         return () => n + x;
->() => n + x : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 67, 14))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 65, 9))
 >x : Symbol(x, Decl(arrowFunctionExpressions.ts, 66, 16))
     }
@@ -245,14 +214,12 @@ function someOuterFn() {
 
     var arr = (n: string) => {
 >arr : Symbol(arr, Decl(arrowFunctionExpressions.ts, 77, 7))
->(n: string) => {        function innerFn() {            return () => n.length;        }        return innerFn;    } : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 77, 13))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 77, 15))
 
         function innerFn() {
 >innerFn : Symbol(innerFn, Decl(arrowFunctionExpressions.ts, 77, 30))
 
             return () => n.length;
->() => n.length : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 79, 18))
 >n.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 77, 15))
 >length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
@@ -279,20 +246,17 @@ function tryCatchFn() {
     try {
         var x = () => this;
 >x : Symbol(x, Decl(arrowFunctionExpressions.ts, 91, 11))
->() => this : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 91, 15))
 
     } catch (e) {
 >e : Symbol(e, Decl(arrowFunctionExpressions.ts, 92, 13))
 
         var t = () => e + this;
 >t : Symbol(t, Decl(arrowFunctionExpressions.ts, 93, 11))
->() => e + this : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 93, 15))
 >e : Symbol(e, Decl(arrowFunctionExpressions.ts, 92, 13))
 
     } finally {
         var m = () => this + '';
 >m : Symbol(m, Decl(arrowFunctionExpressions.ts, 95, 11))
->() => this + '' : Symbol((Anonymous function), Decl(arrowFunctionExpressions.ts, 95, 15))
     }
 }
 
diff --git a/tests/baselines/reference/arrowFunctionInExpressionStatement1.symbols b/tests/baselines/reference/arrowFunctionInExpressionStatement1.symbols
index 71b1c40082454..690ff3500c8ee 100644
--- a/tests/baselines/reference/arrowFunctionInExpressionStatement1.symbols
+++ b/tests/baselines/reference/arrowFunctionInExpressionStatement1.symbols
@@ -1,4 +1,3 @@
 === tests/cases/compiler/arrowFunctionInExpressionStatement1.ts ===
 () => 0;
->() => 0 : Symbol((Anonymous function), Decl(arrowFunctionInExpressionStatement1.ts, 0, 0))
-
+No type information for this code.
\ No newline at end of file
diff --git a/tests/baselines/reference/arrowFunctionInExpressionStatement2.symbols b/tests/baselines/reference/arrowFunctionInExpressionStatement2.symbols
index 4578a253dd484..c9bbfde997418 100644
--- a/tests/baselines/reference/arrowFunctionInExpressionStatement2.symbols
+++ b/tests/baselines/reference/arrowFunctionInExpressionStatement2.symbols
@@ -3,5 +3,4 @@ module M {
 >M : Symbol(M, Decl(arrowFunctionInExpressionStatement2.ts, 0, 0))
 
     () => 0;
->() => 0 : Symbol((Anonymous function), Decl(arrowFunctionInExpressionStatement2.ts, 0, 10))
 }
diff --git a/tests/baselines/reference/arrowFunctionWithObjectLiteralBody1.symbols b/tests/baselines/reference/arrowFunctionWithObjectLiteralBody1.symbols
index 6df9ee96795bf..b4f68e045fe54 100644
--- a/tests/baselines/reference/arrowFunctionWithObjectLiteralBody1.symbols
+++ b/tests/baselines/reference/arrowFunctionWithObjectLiteralBody1.symbols
@@ -1,7 +1,5 @@
 === tests/cases/compiler/arrowFunctionWithObjectLiteralBody1.ts ===
 var v = a => <any>{}
 >v : Symbol(v, Decl(arrowFunctionWithObjectLiteralBody1.ts, 0, 3))
->a => <any>{} : Symbol((Anonymous function), Decl(arrowFunctionWithObjectLiteralBody1.ts, 0, 7))
 >a : Symbol(a, Decl(arrowFunctionWithObjectLiteralBody1.ts, 0, 7))
->{} : Symbol(, Decl(arrowFunctionWithObjectLiteralBody1.ts, 0, 18))
 
diff --git a/tests/baselines/reference/arrowFunctionWithObjectLiteralBody2.symbols b/tests/baselines/reference/arrowFunctionWithObjectLiteralBody2.symbols
index 092f79bc962bf..1f8b83a23f158 100644
--- a/tests/baselines/reference/arrowFunctionWithObjectLiteralBody2.symbols
+++ b/tests/baselines/reference/arrowFunctionWithObjectLiteralBody2.symbols
@@ -1,7 +1,5 @@
 === tests/cases/compiler/arrowFunctionWithObjectLiteralBody2.ts ===
 var v = a => <any><any>{}
 >v : Symbol(v, Decl(arrowFunctionWithObjectLiteralBody2.ts, 0, 3))
->a => <any><any>{} : Symbol((Anonymous function), Decl(arrowFunctionWithObjectLiteralBody2.ts, 0, 7))
 >a : Symbol(a, Decl(arrowFunctionWithObjectLiteralBody2.ts, 0, 7))
->{} : Symbol(, Decl(arrowFunctionWithObjectLiteralBody2.ts, 0, 23))
 
diff --git a/tests/baselines/reference/arrowFunctionWithObjectLiteralBody3.symbols b/tests/baselines/reference/arrowFunctionWithObjectLiteralBody3.symbols
index 7d7c06e8a7a98..92122d16fc993 100644
--- a/tests/baselines/reference/arrowFunctionWithObjectLiteralBody3.symbols
+++ b/tests/baselines/reference/arrowFunctionWithObjectLiteralBody3.symbols
@@ -1,7 +1,5 @@
 === tests/cases/compiler/arrowFunctionWithObjectLiteralBody3.ts ===
 var v = a => <any>{}
 >v : Symbol(v, Decl(arrowFunctionWithObjectLiteralBody3.ts, 0, 3))
->a => <any>{} : Symbol((Anonymous function), Decl(arrowFunctionWithObjectLiteralBody3.ts, 0, 7))
 >a : Symbol(a, Decl(arrowFunctionWithObjectLiteralBody3.ts, 0, 7))
->{} : Symbol(, Decl(arrowFunctionWithObjectLiteralBody3.ts, 0, 18))
 
diff --git a/tests/baselines/reference/arrowFunctionWithObjectLiteralBody4.symbols b/tests/baselines/reference/arrowFunctionWithObjectLiteralBody4.symbols
index c33c65df9a912..74a6b6a2b9d0e 100644
--- a/tests/baselines/reference/arrowFunctionWithObjectLiteralBody4.symbols
+++ b/tests/baselines/reference/arrowFunctionWithObjectLiteralBody4.symbols
@@ -1,7 +1,5 @@
 === tests/cases/compiler/arrowFunctionWithObjectLiteralBody4.ts ===
 var v = a => <any><any>{}
 >v : Symbol(v, Decl(arrowFunctionWithObjectLiteralBody4.ts, 0, 3))
->a => <any><any>{} : Symbol((Anonymous function), Decl(arrowFunctionWithObjectLiteralBody4.ts, 0, 7))
 >a : Symbol(a, Decl(arrowFunctionWithObjectLiteralBody4.ts, 0, 7))
->{} : Symbol(, Decl(arrowFunctionWithObjectLiteralBody4.ts, 0, 23))
 
diff --git a/tests/baselines/reference/arrowFunctionWithObjectLiteralBody5.symbols b/tests/baselines/reference/arrowFunctionWithObjectLiteralBody5.symbols
index ff74ff4744b84..c1d1cf40d9096 100644
--- a/tests/baselines/reference/arrowFunctionWithObjectLiteralBody5.symbols
+++ b/tests/baselines/reference/arrowFunctionWithObjectLiteralBody5.symbols
@@ -1,32 +1,24 @@
 === tests/cases/compiler/arrowFunctionWithObjectLiteralBody5.ts ===
 var a = () => <Error>{ name: "foo", message: "bar" };      
 >a : Symbol(a, Decl(arrowFunctionWithObjectLiteralBody5.ts, 0, 3))
->() => <Error>{ name: "foo", message: "bar" } : Symbol((Anonymous function), Decl(arrowFunctionWithObjectLiteralBody5.ts, 0, 7))
 >Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11))
->{ name: "foo", message: "bar" } : Symbol(, Decl(arrowFunctionWithObjectLiteralBody5.ts, 0, 21))
 >name : Symbol(name, Decl(arrowFunctionWithObjectLiteralBody5.ts, 0, 22))
 >message : Symbol(message, Decl(arrowFunctionWithObjectLiteralBody5.ts, 0, 35))
 
 var b = () => (<Error>{ name: "foo", message: "bar" });    
 >b : Symbol(b, Decl(arrowFunctionWithObjectLiteralBody5.ts, 2, 3))
->() => (<Error>{ name: "foo", message: "bar" }) : Symbol((Anonymous function), Decl(arrowFunctionWithObjectLiteralBody5.ts, 2, 7))
 >Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11))
->{ name: "foo", message: "bar" } : Symbol(, Decl(arrowFunctionWithObjectLiteralBody5.ts, 2, 22))
 >name : Symbol(name, Decl(arrowFunctionWithObjectLiteralBody5.ts, 2, 23))
 >message : Symbol(message, Decl(arrowFunctionWithObjectLiteralBody5.ts, 2, 36))
 
 var c = () => ({ name: "foo", message: "bar" });           
 >c : Symbol(c, Decl(arrowFunctionWithObjectLiteralBody5.ts, 4, 3))
->() => ({ name: "foo", message: "bar" }) : Symbol((Anonymous function), Decl(arrowFunctionWithObjectLiteralBody5.ts, 4, 7))
->{ name: "foo", message: "bar" } : Symbol(, Decl(arrowFunctionWithObjectLiteralBody5.ts, 4, 15))
 >name : Symbol(name, Decl(arrowFunctionWithObjectLiteralBody5.ts, 4, 16))
 >message : Symbol(message, Decl(arrowFunctionWithObjectLiteralBody5.ts, 4, 29))
 
 var d = () => ((<Error>({ name: "foo", message: "bar" })));
 >d : Symbol(d, Decl(arrowFunctionWithObjectLiteralBody5.ts, 6, 3))
->() => ((<Error>({ name: "foo", message: "bar" }))) : Symbol((Anonymous function), Decl(arrowFunctionWithObjectLiteralBody5.ts, 6, 7))
 >Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11))
->{ name: "foo", message: "bar" } : Symbol(, Decl(arrowFunctionWithObjectLiteralBody5.ts, 6, 24))
 >name : Symbol(name, Decl(arrowFunctionWithObjectLiteralBody5.ts, 6, 25))
 >message : Symbol(message, Decl(arrowFunctionWithObjectLiteralBody5.ts, 6, 38))
 
diff --git a/tests/baselines/reference/arrowFunctionWithObjectLiteralBody6.symbols b/tests/baselines/reference/arrowFunctionWithObjectLiteralBody6.symbols
index f57005868b461..80530cde01629 100644
--- a/tests/baselines/reference/arrowFunctionWithObjectLiteralBody6.symbols
+++ b/tests/baselines/reference/arrowFunctionWithObjectLiteralBody6.symbols
@@ -1,32 +1,24 @@
 === tests/cases/compiler/arrowFunctionWithObjectLiteralBody6.ts ===
 var a = () => <Error>{ name: "foo", message: "bar" };      
 >a : Symbol(a, Decl(arrowFunctionWithObjectLiteralBody6.ts, 0, 3))
->() => <Error>{ name: "foo", message: "bar" } : Symbol((Anonymous function), Decl(arrowFunctionWithObjectLiteralBody6.ts, 0, 7))
 >Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11))
->{ name: "foo", message: "bar" } : Symbol(, Decl(arrowFunctionWithObjectLiteralBody6.ts, 0, 21))
 >name : Symbol(name, Decl(arrowFunctionWithObjectLiteralBody6.ts, 0, 22))
 >message : Symbol(message, Decl(arrowFunctionWithObjectLiteralBody6.ts, 0, 35))
 
 var b = () => (<Error>{ name: "foo", message: "bar" });    
 >b : Symbol(b, Decl(arrowFunctionWithObjectLiteralBody6.ts, 2, 3))
->() => (<Error>{ name: "foo", message: "bar" }) : Symbol((Anonymous function), Decl(arrowFunctionWithObjectLiteralBody6.ts, 2, 7))
 >Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11))
->{ name: "foo", message: "bar" } : Symbol(, Decl(arrowFunctionWithObjectLiteralBody6.ts, 2, 22))
 >name : Symbol(name, Decl(arrowFunctionWithObjectLiteralBody6.ts, 2, 23))
 >message : Symbol(message, Decl(arrowFunctionWithObjectLiteralBody6.ts, 2, 36))
 
 var c = () => ({ name: "foo", message: "bar" });           
 >c : Symbol(c, Decl(arrowFunctionWithObjectLiteralBody6.ts, 4, 3))
->() => ({ name: "foo", message: "bar" }) : Symbol((Anonymous function), Decl(arrowFunctionWithObjectLiteralBody6.ts, 4, 7))
->{ name: "foo", message: "bar" } : Symbol(, Decl(arrowFunctionWithObjectLiteralBody6.ts, 4, 15))
 >name : Symbol(name, Decl(arrowFunctionWithObjectLiteralBody6.ts, 4, 16))
 >message : Symbol(message, Decl(arrowFunctionWithObjectLiteralBody6.ts, 4, 29))
 
 var d = () => ((<Error>({ name: "foo", message: "bar" })));
 >d : Symbol(d, Decl(arrowFunctionWithObjectLiteralBody6.ts, 6, 3))
->() => ((<Error>({ name: "foo", message: "bar" }))) : Symbol((Anonymous function), Decl(arrowFunctionWithObjectLiteralBody6.ts, 6, 7))
 >Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11))
->{ name: "foo", message: "bar" } : Symbol(, Decl(arrowFunctionWithObjectLiteralBody6.ts, 6, 24))
 >name : Symbol(name, Decl(arrowFunctionWithObjectLiteralBody6.ts, 6, 25))
 >message : Symbol(message, Decl(arrowFunctionWithObjectLiteralBody6.ts, 6, 38))
 
diff --git a/tests/baselines/reference/asiInES6Classes.symbols b/tests/baselines/reference/asiInES6Classes.symbols
index d59ca0eb52210..e6af356008d0a 100644
--- a/tests/baselines/reference/asiInES6Classes.symbols
+++ b/tests/baselines/reference/asiInES6Classes.symbols
@@ -6,7 +6,6 @@ class Foo {
 
     defaults = {
 >defaults : Symbol(defaults, Decl(asiInES6Classes.ts, 0, 11))
->{        done: false    } : Symbol(, Decl(asiInES6Classes.ts, 4, 14))
 
         done: false
 >done : Symbol(done, Decl(asiInES6Classes.ts, 4, 16))
diff --git a/tests/baselines/reference/asiPreventsParsingAsNamespace04.symbols b/tests/baselines/reference/asiPreventsParsingAsNamespace04.symbols
index 557048ed2d644..60d1f8fcc48ff 100644
--- a/tests/baselines/reference/asiPreventsParsingAsNamespace04.symbols
+++ b/tests/baselines/reference/asiPreventsParsingAsNamespace04.symbols
@@ -5,5 +5,4 @@ let module = 10;
 
 module in {}
 >module : Symbol(module, Decl(asiPreventsParsingAsNamespace04.ts, 1, 3))
->{} : Symbol(, Decl(asiPreventsParsingAsNamespace04.ts, 2, 9))
 
diff --git a/tests/baselines/reference/assign1.symbols b/tests/baselines/reference/assign1.symbols
index 98b2e0123dfcd..f434da7267023 100644
--- a/tests/baselines/reference/assign1.symbols
+++ b/tests/baselines/reference/assign1.symbols
@@ -15,7 +15,6 @@ module M {
     var x:I={salt:2,pepper:0};
 >x : Symbol(x, Decl(assign1.ts, 6, 7))
 >I : Symbol(I, Decl(assign1.ts, 0, 10))
->{salt:2,pepper:0} : Symbol(, Decl(assign1.ts, 6, 12))
 >salt : Symbol(salt, Decl(assign1.ts, 6, 13))
 >pepper : Symbol(pepper, Decl(assign1.ts, 6, 20))
 }
diff --git a/tests/baselines/reference/assignEveryTypeToAny.symbols b/tests/baselines/reference/assignEveryTypeToAny.symbols
index 8e43f9fb77950..145e19664fd92 100644
--- a/tests/baselines/reference/assignEveryTypeToAny.symbols
+++ b/tests/baselines/reference/assignEveryTypeToAny.symbols
@@ -119,12 +119,10 @@ x = i;
 
 x = { f() { return 1; } }
 >x : Symbol(x, Decl(assignEveryTypeToAny.ts, 2, 3))
->{ f() { return 1; } } : Symbol(, Decl(assignEveryTypeToAny.ts, 49, 3))
 >f : Symbol(f, Decl(assignEveryTypeToAny.ts, 49, 5))
 
 x = { f<T>(x: T) { return x; } }
 >x : Symbol(x, Decl(assignEveryTypeToAny.ts, 2, 3))
->{ f<T>(x: T) { return x; } } : Symbol(, Decl(assignEveryTypeToAny.ts, 50, 3))
 >f : Symbol(f, Decl(assignEveryTypeToAny.ts, 50, 5))
 >T : Symbol(T, Decl(assignEveryTypeToAny.ts, 50, 8))
 >x : Symbol(x, Decl(assignEveryTypeToAny.ts, 50, 11))
diff --git a/tests/baselines/reference/assignToPrototype1.symbols b/tests/baselines/reference/assignToPrototype1.symbols
index 08da73e3e868d..ddb8e915043d9 100644
--- a/tests/baselines/reference/assignToPrototype1.symbols
+++ b/tests/baselines/reference/assignToPrototype1.symbols
@@ -14,7 +14,6 @@ Point.prototype.add = function(dx, dy) {
 >Point : Symbol(Point, Decl(assignToPrototype1.ts, 0, 0))
 >prototype : Symbol(Point.prototype)
 >add : Symbol(Point.add, Decl(assignToPrototype1.ts, 0, 21))
->function(dx, dy) {} : Symbol((Anonymous function), Decl(assignToPrototype1.ts, 4, 21))
 >dx : Symbol(dx, Decl(assignToPrototype1.ts, 4, 31))
 >dy : Symbol(dy, Decl(assignToPrototype1.ts, 4, 34))
 
diff --git a/tests/baselines/reference/assignmentCompatForEnums.symbols b/tests/baselines/reference/assignmentCompatForEnums.symbols
index 33b484e734b20..510c08e61f692 100644
--- a/tests/baselines/reference/assignmentCompatForEnums.symbols
+++ b/tests/baselines/reference/assignmentCompatForEnums.symbols
@@ -6,7 +6,6 @@ enum TokenType { One, Two };
 
 var list = {};
 >list : Symbol(list, Decl(assignmentCompatForEnums.ts, 2, 3))
->{} : Symbol(, Decl(assignmentCompatForEnums.ts, 2, 10))
 
 
 function returnType(): TokenType { return null; }
diff --git a/tests/baselines/reference/assignmentCompatWithObjectMembers.symbols b/tests/baselines/reference/assignmentCompatWithObjectMembers.symbols
index e7a040e4ca755..181c4db641a12 100644
--- a/tests/baselines/reference/assignmentCompatWithObjectMembers.symbols
+++ b/tests/baselines/reference/assignmentCompatWithObjectMembers.symbols
@@ -47,12 +47,10 @@ module SimpleTypes {
 
     var a2 = { foo: '' };
 >a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembers.ts, 17, 7))
->{ foo: '' } : Symbol(, Decl(assignmentCompatWithObjectMembers.ts, 17, 12))
 >foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers.ts, 17, 14))
 
     var b2 = { foo: '' };
 >b2 : Symbol(b2, Decl(assignmentCompatWithObjectMembers.ts, 18, 7))
->{ foo: '' } : Symbol(, Decl(assignmentCompatWithObjectMembers.ts, 18, 12))
 >foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers.ts, 18, 14))
 
     s = t;
@@ -183,13 +181,11 @@ module ObjectTypes {
 
     var a2 = { foo: a2 };
 >a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembers.ts, 58, 7))
->{ foo: a2 } : Symbol(, Decl(assignmentCompatWithObjectMembers.ts, 58, 12))
 >foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers.ts, 58, 14))
 >a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembers.ts, 58, 7))
 
     var b2 = { foo: b2 };
 >b2 : Symbol(b2, Decl(assignmentCompatWithObjectMembers.ts, 59, 7))
->{ foo: b2 } : Symbol(, Decl(assignmentCompatWithObjectMembers.ts, 59, 12))
 >foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers.ts, 59, 14))
 >b2 : Symbol(b2, Decl(assignmentCompatWithObjectMembers.ts, 59, 7))
 
diff --git a/tests/baselines/reference/assignmentCompatWithObjectMembers2.symbols b/tests/baselines/reference/assignmentCompatWithObjectMembers2.symbols
index 20de0bffa9c0e..ab3301c5e93e7 100644
--- a/tests/baselines/reference/assignmentCompatWithObjectMembers2.symbols
+++ b/tests/baselines/reference/assignmentCompatWithObjectMembers2.symbols
@@ -48,12 +48,10 @@ var b: { foo: string; baz?: string }
 
 var a2 = { foo: '' };
 >a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembers2.ts, 16, 3))
->{ foo: '' } : Symbol(, Decl(assignmentCompatWithObjectMembers2.ts, 16, 8))
 >foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers2.ts, 16, 10))
 
 var b2 = { foo: '' };
 >b2 : Symbol(b2, Decl(assignmentCompatWithObjectMembers2.ts, 17, 3))
->{ foo: '' } : Symbol(, Decl(assignmentCompatWithObjectMembers2.ts, 17, 8))
 >foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers2.ts, 17, 10))
 
 s = t;
diff --git a/tests/baselines/reference/assignmentCompatWithObjectMembers3.symbols b/tests/baselines/reference/assignmentCompatWithObjectMembers3.symbols
index 631630e5b1cd7..861d38530bbbf 100644
--- a/tests/baselines/reference/assignmentCompatWithObjectMembers3.symbols
+++ b/tests/baselines/reference/assignmentCompatWithObjectMembers3.symbols
@@ -51,13 +51,11 @@ var b: { foo: string; baz?: string }
 var a2: S2 = { foo: '' };
 >a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembers3.ts, 16, 3))
 >S2 : Symbol(S2, Decl(assignmentCompatWithObjectMembers3.ts, 6, 9))
->{ foo: '' } : Symbol(, Decl(assignmentCompatWithObjectMembers3.ts, 16, 12))
 >foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers3.ts, 16, 14))
 
 var b2: T2 = { foo: '' };
 >b2 : Symbol(b2, Decl(assignmentCompatWithObjectMembers3.ts, 17, 3))
 >T2 : Symbol(T2, Decl(assignmentCompatWithObjectMembers3.ts, 8, 42))
->{ foo: '' } : Symbol(, Decl(assignmentCompatWithObjectMembers3.ts, 17, 12))
 >foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers3.ts, 17, 14))
 
 s = t;
diff --git a/tests/baselines/reference/assignmentCompatWithObjectMembersNumericNames.symbols b/tests/baselines/reference/assignmentCompatWithObjectMembersNumericNames.symbols
index 0a8089c8ac908..e01bcee21c050 100644
--- a/tests/baselines/reference/assignmentCompatWithObjectMembersNumericNames.symbols
+++ b/tests/baselines/reference/assignmentCompatWithObjectMembersNumericNames.symbols
@@ -42,11 +42,9 @@ var b: { 1.0: string; baz?: string }
 
 var a2 = { 1.0: '' };
 >a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembersNumericNames.ts, 16, 3))
->{ 1.0: '' } : Symbol(, Decl(assignmentCompatWithObjectMembersNumericNames.ts, 16, 8))
 
 var b2 = { 1: '' };
 >b2 : Symbol(b2, Decl(assignmentCompatWithObjectMembersNumericNames.ts, 17, 3))
->{ 1: '' } : Symbol(, Decl(assignmentCompatWithObjectMembersNumericNames.ts, 17, 8))
 
 s = t;
 >s : Symbol(s, Decl(assignmentCompatWithObjectMembersNumericNames.ts, 5, 3))
diff --git a/tests/baselines/reference/assignmentCompatability1.symbols b/tests/baselines/reference/assignmentCompatability1.symbols
index 8ccb6468cc01c..07d3cf4c0298d 100644
--- a/tests/baselines/reference/assignmentCompatability1.symbols
+++ b/tests/baselines/reference/assignmentCompatability1.symbols
@@ -12,7 +12,6 @@ module __test1__ {
 >U : Symbol(U, Decl(assignmentCompatability1.ts, 1, 54))
 >obj4 : Symbol(obj4, Decl(assignmentCompatability1.ts, 1, 83))
 >interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability1.ts, 0, 18))
->{ one: 1 } : Symbol(, Decl(assignmentCompatability1.ts, 1, 137))
 >one : Symbol(one, Decl(assignmentCompatability1.ts, 1, 139))
 
     export var __val__obj4 = obj4;
@@ -24,7 +23,6 @@ module __test2__ {
 
     export var aa = {};;
 >aa : Symbol(aa, Decl(assignmentCompatability1.ts, 5, 14))
->{} : Symbol(, Decl(assignmentCompatability1.ts, 5, 19))
 
     export var __val__aa = aa;
 >__val__aa : Symbol(__val__aa, Decl(assignmentCompatability1.ts, 6, 14))
diff --git a/tests/baselines/reference/assignmentCompatability2.symbols b/tests/baselines/reference/assignmentCompatability2.symbols
index 180815c0f92fa..1ed6dd3c6396a 100644
--- a/tests/baselines/reference/assignmentCompatability2.symbols
+++ b/tests/baselines/reference/assignmentCompatability2.symbols
@@ -12,7 +12,6 @@ module __test1__ {
 >U : Symbol(U, Decl(assignmentCompatability2.ts, 1, 54))
 >obj4 : Symbol(obj4, Decl(assignmentCompatability2.ts, 1, 83))
 >interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability2.ts, 0, 18))
->{ one: 1 } : Symbol(, Decl(assignmentCompatability2.ts, 1, 137))
 >one : Symbol(one, Decl(assignmentCompatability2.ts, 1, 139))
 
     export var __val__obj4 = obj4;
diff --git a/tests/baselines/reference/assignmentCompatability3.symbols b/tests/baselines/reference/assignmentCompatability3.symbols
index 15eb2cc991a20..c31d69e2f1287 100644
--- a/tests/baselines/reference/assignmentCompatability3.symbols
+++ b/tests/baselines/reference/assignmentCompatability3.symbols
@@ -12,7 +12,6 @@ module __test1__ {
 >U : Symbol(U, Decl(assignmentCompatability3.ts, 1, 54))
 >obj4 : Symbol(obj4, Decl(assignmentCompatability3.ts, 1, 83))
 >interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability3.ts, 0, 18))
->{ one: 1 } : Symbol(, Decl(assignmentCompatability3.ts, 1, 137))
 >one : Symbol(one, Decl(assignmentCompatability3.ts, 1, 139))
 
     export var __val__obj4 = obj4;
@@ -24,7 +23,6 @@ module __test2__ {
 
     export var obj = {one: 1};
 >obj : Symbol(obj, Decl(assignmentCompatability3.ts, 5, 14))
->{one: 1} : Symbol(, Decl(assignmentCompatability3.ts, 5, 20))
 >one : Symbol(one, Decl(assignmentCompatability3.ts, 5, 22))
 
     export var __val__obj = obj;
diff --git a/tests/baselines/reference/assignmentCompatability4.symbols b/tests/baselines/reference/assignmentCompatability4.symbols
index e0d6d011ceb18..fe5e4a32deeb4 100644
--- a/tests/baselines/reference/assignmentCompatability4.symbols
+++ b/tests/baselines/reference/assignmentCompatability4.symbols
@@ -12,7 +12,6 @@ module __test1__ {
 >U : Symbol(U, Decl(assignmentCompatability4.ts, 1, 54))
 >obj4 : Symbol(obj4, Decl(assignmentCompatability4.ts, 1, 83))
 >interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability4.ts, 0, 18))
->{ one: 1 } : Symbol(, Decl(assignmentCompatability4.ts, 1, 137))
 >one : Symbol(one, Decl(assignmentCompatability4.ts, 1, 139))
 
     export var __val__obj4 = obj4;
diff --git a/tests/baselines/reference/assignmentCompatability5.symbols b/tests/baselines/reference/assignmentCompatability5.symbols
index a727e9d796091..15885d078923e 100644
--- a/tests/baselines/reference/assignmentCompatability5.symbols
+++ b/tests/baselines/reference/assignmentCompatability5.symbols
@@ -12,7 +12,6 @@ module __test1__ {
 >U : Symbol(U, Decl(assignmentCompatability5.ts, 1, 54))
 >obj4 : Symbol(obj4, Decl(assignmentCompatability5.ts, 1, 83))
 >interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability5.ts, 0, 18))
->{ one: 1 } : Symbol(, Decl(assignmentCompatability5.ts, 1, 137))
 >one : Symbol(one, Decl(assignmentCompatability5.ts, 1, 139))
 
     export var __val__obj4 = obj4;
@@ -29,7 +28,6 @@ module __test2__ {
 >T : Symbol(T, Decl(assignmentCompatability5.ts, 5, 52))
 >obj1 : Symbol(obj1, Decl(assignmentCompatability5.ts, 5, 86))
 >interfaceOne : Symbol(interfaceOne, Decl(assignmentCompatability5.ts, 4, 18))
->{ one: 1 } : Symbol(, Decl(assignmentCompatability5.ts, 5, 115))
 >one : Symbol(one, Decl(assignmentCompatability5.ts, 5, 117))
 
     export var __val__obj1 = obj1;
diff --git a/tests/baselines/reference/assignmentCompatability6.symbols b/tests/baselines/reference/assignmentCompatability6.symbols
index 40bea435bc726..4ddacd5cd8c82 100644
--- a/tests/baselines/reference/assignmentCompatability6.symbols
+++ b/tests/baselines/reference/assignmentCompatability6.symbols
@@ -12,7 +12,6 @@ module __test1__ {
 >U : Symbol(U, Decl(assignmentCompatability6.ts, 1, 54))
 >obj4 : Symbol(obj4, Decl(assignmentCompatability6.ts, 1, 83))
 >interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability6.ts, 0, 18))
->{ one: 1 } : Symbol(, Decl(assignmentCompatability6.ts, 1, 137))
 >one : Symbol(one, Decl(assignmentCompatability6.ts, 1, 139))
 
     export var __val__obj4 = obj4;
@@ -29,7 +28,6 @@ module __test2__ {
 >T : Symbol(T, Decl(assignmentCompatability6.ts, 5, 52))
 >obj3 : Symbol(obj3, Decl(assignmentCompatability6.ts, 5, 86))
 >interfaceWithOptional : Symbol(interfaceWithOptional, Decl(assignmentCompatability6.ts, 4, 18))
->{ } : Symbol(, Decl(assignmentCompatability6.ts, 5, 124))
 
     export var __val__obj3 = obj3;
 >__val__obj3 : Symbol(__val__obj3, Decl(assignmentCompatability6.ts, 6, 14))
diff --git a/tests/baselines/reference/assignmentCompatability7.symbols b/tests/baselines/reference/assignmentCompatability7.symbols
index e21e602170cb8..32a5be9f87f9c 100644
--- a/tests/baselines/reference/assignmentCompatability7.symbols
+++ b/tests/baselines/reference/assignmentCompatability7.symbols
@@ -12,7 +12,6 @@ module __test1__ {
 >U : Symbol(U, Decl(assignmentCompatability7.ts, 1, 54))
 >obj4 : Symbol(obj4, Decl(assignmentCompatability7.ts, 1, 83))
 >interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability7.ts, 0, 18))
->{ one: 1 } : Symbol(, Decl(assignmentCompatability7.ts, 1, 137))
 >one : Symbol(one, Decl(assignmentCompatability7.ts, 1, 139))
 
     export var __val__obj4 = obj4;
@@ -32,7 +31,6 @@ module __test2__ {
 >U : Symbol(U, Decl(assignmentCompatability7.ts, 5, 54))
 >obj4 : Symbol(obj4, Decl(assignmentCompatability7.ts, 5, 83))
 >interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability7.ts, 4, 18))
->{ one: 1 } : Symbol(, Decl(assignmentCompatability7.ts, 5, 137))
 >one : Symbol(one, Decl(assignmentCompatability7.ts, 5, 139))
 
     export var __val__obj4 = obj4;
diff --git a/tests/baselines/reference/assignmentCompatability8.symbols b/tests/baselines/reference/assignmentCompatability8.symbols
index 8440fffd1c434..ba30e4fee9415 100644
--- a/tests/baselines/reference/assignmentCompatability8.symbols
+++ b/tests/baselines/reference/assignmentCompatability8.symbols
@@ -12,7 +12,6 @@ module __test1__ {
 >U : Symbol(U, Decl(assignmentCompatability8.ts, 1, 54))
 >obj4 : Symbol(obj4, Decl(assignmentCompatability8.ts, 1, 83))
 >interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability8.ts, 0, 18))
->{ one: 1 } : Symbol(, Decl(assignmentCompatability8.ts, 1, 137))
 >one : Symbol(one, Decl(assignmentCompatability8.ts, 1, 139))
 
     export var __val__obj4 = obj4;
diff --git a/tests/baselines/reference/assignmentCompatability9.symbols b/tests/baselines/reference/assignmentCompatability9.symbols
index a104205be7970..7c49da7fea2f1 100644
--- a/tests/baselines/reference/assignmentCompatability9.symbols
+++ b/tests/baselines/reference/assignmentCompatability9.symbols
@@ -12,7 +12,6 @@ module __test1__ {
 >U : Symbol(U, Decl(assignmentCompatability9.ts, 1, 54))
 >obj4 : Symbol(obj4, Decl(assignmentCompatability9.ts, 1, 83))
 >interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability9.ts, 0, 18))
->{ one: 1 } : Symbol(, Decl(assignmentCompatability9.ts, 1, 137))
 >one : Symbol(one, Decl(assignmentCompatability9.ts, 1, 139))
 
     export var __val__obj4 = obj4;
diff --git a/tests/baselines/reference/augmentedTypeBracketAccessIndexSignature.symbols b/tests/baselines/reference/augmentedTypeBracketAccessIndexSignature.symbols
index 28030536a88e9..81c8b13d207dd 100644
--- a/tests/baselines/reference/augmentedTypeBracketAccessIndexSignature.symbols
+++ b/tests/baselines/reference/augmentedTypeBracketAccessIndexSignature.symbols
@@ -25,9 +25,7 @@ interface Function {
 
 var a = {}[0]; // Should be Foo
 >a : Symbol(a, Decl(augmentedTypeBracketAccessIndexSignature.ts, 11, 3))
->{} : Symbol(, Decl(augmentedTypeBracketAccessIndexSignature.ts, 11, 7))
 
 var b = (() => { })[0]; // Should be Bar
 >b : Symbol(b, Decl(augmentedTypeBracketAccessIndexSignature.ts, 12, 3))
->() => { } : Symbol((Anonymous function), Decl(augmentedTypeBracketAccessIndexSignature.ts, 12, 9))
 
diff --git a/tests/baselines/reference/augmentedTypeBracketNamedPropertyAccess.symbols b/tests/baselines/reference/augmentedTypeBracketNamedPropertyAccess.symbols
index 3d6392660f466..cc9c2ba62ef3f 100644
--- a/tests/baselines/reference/augmentedTypeBracketNamedPropertyAccess.symbols
+++ b/tests/baselines/reference/augmentedTypeBracketNamedPropertyAccess.symbols
@@ -13,11 +13,9 @@ interface Function {
 }
 var o = {};
 >o : Symbol(o, Decl(augmentedTypeBracketNamedPropertyAccess.ts, 6, 3))
->{} : Symbol(, Decl(augmentedTypeBracketNamedPropertyAccess.ts, 6, 7))
 
 var f = function () { };
 >f : Symbol(f, Decl(augmentedTypeBracketNamedPropertyAccess.ts, 7, 3))
->function () { } : Symbol((Anonymous function), Decl(augmentedTypeBracketNamedPropertyAccess.ts, 7, 7))
 
 var r1 = o['data']; // Should be number
 >r1 : Symbol(r1, Decl(augmentedTypeBracketNamedPropertyAccess.ts, 9, 3))
diff --git a/tests/baselines/reference/badOverloadError.symbols b/tests/baselines/reference/badOverloadError.symbols
index 43cd3a3846137..86c0a332f8ff1 100644
--- a/tests/baselines/reference/badOverloadError.symbols
+++ b/tests/baselines/reference/badOverloadError.symbols
@@ -5,6 +5,5 @@ function method() {
     var dictionary = <{ [index: string]: string; }>{};
 >dictionary : Symbol(dictionary, Decl(badOverloadError.ts, 1, 7))
 >index : Symbol(index, Decl(badOverloadError.ts, 1, 25))
->{} : Symbol(, Decl(badOverloadError.ts, 1, 51))
 }
 
diff --git a/tests/baselines/reference/badThisBinding.symbols b/tests/baselines/reference/badThisBinding.symbols
index 23d4c281955b2..c1ca8d1f48137 100644
--- a/tests/baselines/reference/badThisBinding.symbols
+++ b/tests/baselines/reference/badThisBinding.symbols
@@ -13,11 +13,9 @@ class Greeter {
     constructor() {
 		foo(() => {
 >foo : Symbol(foo, Decl(badThisBinding.ts, 0, 0))
->() => {            bar(() => {                var x = this;			});		} : Symbol((Anonymous function), Decl(badThisBinding.ts, 5, 6))
 
             bar(() => {
 >bar : Symbol(bar, Decl(badThisBinding.ts, 0, 33))
->() => {                var x = this;			} : Symbol((Anonymous function), Decl(badThisBinding.ts, 6, 16))
 
                 var x = this;
 >x : Symbol(x, Decl(badThisBinding.ts, 7, 19))
diff --git a/tests/baselines/reference/bestCommonTypeOfConditionalExpressions.symbols b/tests/baselines/reference/bestCommonTypeOfConditionalExpressions.symbols
index b5916bd2ee341..e6b6def094457 100644
--- a/tests/baselines/reference/bestCommonTypeOfConditionalExpressions.symbols
+++ b/tests/baselines/reference/bestCommonTypeOfConditionalExpressions.symbols
@@ -43,7 +43,6 @@ var r = true ? 1 : 2;
 
 var r3 = true ? 1 : {};
 >r3 : Symbol(r3, Decl(bestCommonTypeOfConditionalExpressions.ts, 14, 3))
->{} : Symbol(, Decl(bestCommonTypeOfConditionalExpressions.ts, 14, 19))
 
 var r4 = true ? a : b; // typeof a
 >r4 : Symbol(r4, Decl(bestCommonTypeOfConditionalExpressions.ts, 15, 3))
@@ -57,9 +56,7 @@ var r5 = true ? b : a; // typeof b
 
 var r6 = true ? (x: number) => { } : (x: Object) => { }; // returns number => void
 >r6 : Symbol(r6, Decl(bestCommonTypeOfConditionalExpressions.ts, 17, 3))
->(x: number) => { } : Symbol((Anonymous function), Decl(bestCommonTypeOfConditionalExpressions.ts, 17, 15))
 >x : Symbol(x, Decl(bestCommonTypeOfConditionalExpressions.ts, 17, 17))
->(x: Object) => { } : Symbol((Anonymous function), Decl(bestCommonTypeOfConditionalExpressions.ts, 17, 36))
 >x : Symbol(x, Decl(bestCommonTypeOfConditionalExpressions.ts, 17, 38))
 >Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
 
@@ -67,18 +64,14 @@ var r7: (x: Object) => void = true ? (x: number) => { } : (x: Object) => { };
 >r7 : Symbol(r7, Decl(bestCommonTypeOfConditionalExpressions.ts, 18, 3))
 >x : Symbol(x, Decl(bestCommonTypeOfConditionalExpressions.ts, 18, 9))
 >Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
->(x: number) => { } : Symbol((Anonymous function), Decl(bestCommonTypeOfConditionalExpressions.ts, 18, 36))
 >x : Symbol(x, Decl(bestCommonTypeOfConditionalExpressions.ts, 18, 38))
->(x: Object) => { } : Symbol((Anonymous function), Decl(bestCommonTypeOfConditionalExpressions.ts, 18, 57))
 >x : Symbol(x, Decl(bestCommonTypeOfConditionalExpressions.ts, 18, 59))
 >Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
 
 var r8 = true ? (x: Object) => { } : (x: number) => { }; // returns Object => void
 >r8 : Symbol(r8, Decl(bestCommonTypeOfConditionalExpressions.ts, 19, 3))
->(x: Object) => { } : Symbol((Anonymous function), Decl(bestCommonTypeOfConditionalExpressions.ts, 19, 15))
 >x : Symbol(x, Decl(bestCommonTypeOfConditionalExpressions.ts, 19, 17))
 >Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
->(x: number) => { } : Symbol((Anonymous function), Decl(bestCommonTypeOfConditionalExpressions.ts, 19, 36))
 >x : Symbol(x, Decl(bestCommonTypeOfConditionalExpressions.ts, 19, 38))
 
 var r10: Base = true ? derived : derived2; // no error since we use the contextual type in BCT
diff --git a/tests/baselines/reference/bestCommonTypeWithContextualTyping.symbols b/tests/baselines/reference/bestCommonTypeWithContextualTyping.symbols
index fb169d3eda0fb..cfa5310bd3c97 100644
--- a/tests/baselines/reference/bestCommonTypeWithContextualTyping.symbols
+++ b/tests/baselines/reference/bestCommonTypeWithContextualTyping.symbols
@@ -35,7 +35,6 @@ var obj: { [s: string]: Contextual } = { s: e }; // { s: Ellement; [s: string]:
 >obj : Symbol(obj, Decl(bestCommonTypeWithContextualTyping.ts, 16, 3))
 >s : Symbol(s, Decl(bestCommonTypeWithContextualTyping.ts, 16, 12))
 >Contextual : Symbol(Contextual, Decl(bestCommonTypeWithContextualTyping.ts, 0, 0))
->{ s: e } : Symbol(, Decl(bestCommonTypeWithContextualTyping.ts, 16, 38))
 >s : Symbol(s, Decl(bestCommonTypeWithContextualTyping.ts, 16, 40))
 >e : Symbol(e, Decl(bestCommonTypeWithContextualTyping.ts, 10, 3))
 
diff --git a/tests/baselines/reference/binaryIntegerLiteral.symbols b/tests/baselines/reference/binaryIntegerLiteral.symbols
index 25a48c0cdd6f0..31e28819657b0 100644
--- a/tests/baselines/reference/binaryIntegerLiteral.symbols
+++ b/tests/baselines/reference/binaryIntegerLiteral.symbols
@@ -13,7 +13,6 @@ var bin4 = 0B1111111111111111111111111111111111111111111111111111111111111111111
 
 var obj1 = {
 >obj1 : Symbol(obj1, Decl(binaryIntegerLiteral.ts, 5, 3))
->{    0b11010: "Hello",    a: bin1,    bin1,    b: 0b11010,    0B111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111101001010100000010111110001111111111: true,} : Symbol(, Decl(binaryIntegerLiteral.ts, 5, 10))
 
     0b11010: "Hello",
     a: bin1,
@@ -31,7 +30,6 @@ var obj1 = {
 
 var obj2 = {
 >obj2 : Symbol(obj2, Decl(binaryIntegerLiteral.ts, 13, 3))
->{    0B11010: "World",    a: bin2,    bin2,    b: 0B11010,    0B11111111111111111111111111111111111111111111111101001010100000010111110001111111111: false,} : Symbol(, Decl(binaryIntegerLiteral.ts, 13, 10))
 
     0B11010: "World",
     a: bin2,
diff --git a/tests/baselines/reference/binaryIntegerLiteralES6.symbols b/tests/baselines/reference/binaryIntegerLiteralES6.symbols
index 48ea403f81b3a..4fb7aaff82dcf 100644
--- a/tests/baselines/reference/binaryIntegerLiteralES6.symbols
+++ b/tests/baselines/reference/binaryIntegerLiteralES6.symbols
@@ -13,7 +13,6 @@ var bin4 = 0B1111111111111111111111111111111111111111111111111111111111111111111
 
 var obj1 = {
 >obj1 : Symbol(obj1, Decl(binaryIntegerLiteralES6.ts, 5, 3))
->{    0b11010: "Hello",    a: bin1,    bin1,    b: 0b11010,    0B111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111101001010100000010111110001111111111: true,} : Symbol(, Decl(binaryIntegerLiteralES6.ts, 5, 10))
 
     0b11010: "Hello",
     a: bin1,
@@ -31,7 +30,6 @@ var obj1 = {
 
 var obj2 = {
 >obj2 : Symbol(obj2, Decl(binaryIntegerLiteralES6.ts, 13, 3))
->{    0B11010: "World",    a: bin2,    bin2,    b: 0B11010,    0B11111111111111111111111111111111111111111111111101001010100000010111110001111111111: false,} : Symbol(, Decl(binaryIntegerLiteralES6.ts, 13, 10))
 
     0B11010: "World",
     a: bin2,
diff --git a/tests/baselines/reference/bitwiseNotOperatorWithBooleanType.symbols b/tests/baselines/reference/bitwiseNotOperatorWithBooleanType.symbols
index e93a939997f89..d6a29a11980a6 100644
--- a/tests/baselines/reference/bitwiseNotOperatorWithBooleanType.symbols
+++ b/tests/baselines/reference/bitwiseNotOperatorWithBooleanType.symbols
@@ -37,7 +37,6 @@ var ResultIsNumber2 = ~true;
 
 var ResultIsNumber3 = ~{ x: true, y: false };
 >ResultIsNumber3 : Symbol(ResultIsNumber3, Decl(bitwiseNotOperatorWithBooleanType.ts, 20, 3))
->{ x: true, y: false } : Symbol(, Decl(bitwiseNotOperatorWithBooleanType.ts, 20, 23))
 >x : Symbol(x, Decl(bitwiseNotOperatorWithBooleanType.ts, 20, 24))
 >y : Symbol(y, Decl(bitwiseNotOperatorWithBooleanType.ts, 20, 33))
 
diff --git a/tests/baselines/reference/bitwiseNotOperatorWithNumberType.symbols b/tests/baselines/reference/bitwiseNotOperatorWithNumberType.symbols
index 9c5c5ba6665c7..2cb37660135eb 100644
--- a/tests/baselines/reference/bitwiseNotOperatorWithNumberType.symbols
+++ b/tests/baselines/reference/bitwiseNotOperatorWithNumberType.symbols
@@ -44,16 +44,13 @@ var ResultIsNumber3 = ~1;
 
 var ResultIsNumber4 = ~{ x: 1, y: 2};
 >ResultIsNumber4 : Symbol(ResultIsNumber4, Decl(bitwiseNotOperatorWithNumberType.ts, 22, 3))
->{ x: 1, y: 2} : Symbol(, Decl(bitwiseNotOperatorWithNumberType.ts, 22, 23))
 >x : Symbol(x, Decl(bitwiseNotOperatorWithNumberType.ts, 22, 24))
 >y : Symbol(y, Decl(bitwiseNotOperatorWithNumberType.ts, 22, 30))
 
 var ResultIsNumber5 = ~{ x: 1, y: (n: number) => { return n; } };
 >ResultIsNumber5 : Symbol(ResultIsNumber5, Decl(bitwiseNotOperatorWithNumberType.ts, 23, 3))
->{ x: 1, y: (n: number) => { return n; } } : Symbol(, Decl(bitwiseNotOperatorWithNumberType.ts, 23, 23))
 >x : Symbol(x, Decl(bitwiseNotOperatorWithNumberType.ts, 23, 24))
 >y : Symbol(y, Decl(bitwiseNotOperatorWithNumberType.ts, 23, 30))
->(n: number) => { return n; } : Symbol((Anonymous function), Decl(bitwiseNotOperatorWithNumberType.ts, 23, 33))
 >n : Symbol(n, Decl(bitwiseNotOperatorWithNumberType.ts, 23, 35))
 >n : Symbol(n, Decl(bitwiseNotOperatorWithNumberType.ts, 23, 35))
 
diff --git a/tests/baselines/reference/bitwiseNotOperatorWithStringType.symbols b/tests/baselines/reference/bitwiseNotOperatorWithStringType.symbols
index f0fddda8b3bf4..1e2d28f51c20d 100644
--- a/tests/baselines/reference/bitwiseNotOperatorWithStringType.symbols
+++ b/tests/baselines/reference/bitwiseNotOperatorWithStringType.symbols
@@ -44,16 +44,13 @@ var ResultIsNumber3 = ~"";
 
 var ResultIsNumber4 = ~{ x: "", y: "" };
 >ResultIsNumber4 : Symbol(ResultIsNumber4, Decl(bitwiseNotOperatorWithStringType.ts, 22, 3))
->{ x: "", y: "" } : Symbol(, Decl(bitwiseNotOperatorWithStringType.ts, 22, 23))
 >x : Symbol(x, Decl(bitwiseNotOperatorWithStringType.ts, 22, 24))
 >y : Symbol(y, Decl(bitwiseNotOperatorWithStringType.ts, 22, 31))
 
 var ResultIsNumber5 = ~{ x: "", y: (s: string) => { return s; } };
 >ResultIsNumber5 : Symbol(ResultIsNumber5, Decl(bitwiseNotOperatorWithStringType.ts, 23, 3))
->{ x: "", y: (s: string) => { return s; } } : Symbol(, Decl(bitwiseNotOperatorWithStringType.ts, 23, 23))
 >x : Symbol(x, Decl(bitwiseNotOperatorWithStringType.ts, 23, 24))
 >y : Symbol(y, Decl(bitwiseNotOperatorWithStringType.ts, 23, 31))
->(s: string) => { return s; } : Symbol((Anonymous function), Decl(bitwiseNotOperatorWithStringType.ts, 23, 34))
 >s : Symbol(s, Decl(bitwiseNotOperatorWithStringType.ts, 23, 36))
 >s : Symbol(s, Decl(bitwiseNotOperatorWithStringType.ts, 23, 36))
 
diff --git a/tests/baselines/reference/callGenericFunctionWithZeroTypeArguments.symbols b/tests/baselines/reference/callGenericFunctionWithZeroTypeArguments.symbols
index c141bb80f23df..107650c530eed 100644
--- a/tests/baselines/reference/callGenericFunctionWithZeroTypeArguments.symbols
+++ b/tests/baselines/reference/callGenericFunctionWithZeroTypeArguments.symbols
@@ -14,7 +14,6 @@ var r = f(1);
 
 var f2 = <T>(x: T): T => { return null; }
 >f2 : Symbol(f2, Decl(callGenericFunctionWithZeroTypeArguments.ts, 5, 3))
-><T>(x: T): T => { return null; } : Symbol((Anonymous function), Decl(callGenericFunctionWithZeroTypeArguments.ts, 5, 8))
 >T : Symbol(T, Decl(callGenericFunctionWithZeroTypeArguments.ts, 5, 10))
 >x : Symbol(x, Decl(callGenericFunctionWithZeroTypeArguments.ts, 5, 13))
 >T : Symbol(T, Decl(callGenericFunctionWithZeroTypeArguments.ts, 5, 10))
diff --git a/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.symbols b/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.symbols
index be1bdba158800..1c5a6786ab707 100644
--- a/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.symbols
+++ b/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.symbols
@@ -97,7 +97,6 @@ function foo8(x: number) {
 >x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 50, 14))
 
     return { x: x };
->{ x: x } : Symbol(, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 51, 10))
 >x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 51, 12))
 >x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 50, 14))
 }
diff --git a/tests/baselines/reference/callSignaturesWithOptionalParameters.symbols b/tests/baselines/reference/callSignaturesWithOptionalParameters.symbols
index 914420002e174..542bd425fb121 100644
--- a/tests/baselines/reference/callSignaturesWithOptionalParameters.symbols
+++ b/tests/baselines/reference/callSignaturesWithOptionalParameters.symbols
@@ -7,13 +7,11 @@ function foo(x?: number) { }
 
 var f = function foo(x?: number) { }
 >f : Symbol(f, Decl(callSignaturesWithOptionalParameters.ts, 3, 3))
->function foo(x?: number) { } : Symbol(foo, Decl(callSignaturesWithOptionalParameters.ts, 3, 7))
 >foo : Symbol(foo, Decl(callSignaturesWithOptionalParameters.ts, 3, 7))
 >x : Symbol(x, Decl(callSignaturesWithOptionalParameters.ts, 3, 21))
 
 var f2 = (x: number, y?: number) => { }
 >f2 : Symbol(f2, Decl(callSignaturesWithOptionalParameters.ts, 4, 3))
->(x: number, y?: number) => { } : Symbol((Anonymous function), Decl(callSignaturesWithOptionalParameters.ts, 4, 8))
 >x : Symbol(x, Decl(callSignaturesWithOptionalParameters.ts, 4, 10))
 >y : Symbol(y, Decl(callSignaturesWithOptionalParameters.ts, 4, 20))
 
@@ -118,7 +116,6 @@ a.foo(1);
 
 var b = {
 >b : Symbol(b, Decl(callSignaturesWithOptionalParameters.ts, 42, 3))
->{    foo(x?: number) { },    a: function foo(x: number, y?: number) { },    b: (x?: number) => { }} : Symbol(, Decl(callSignaturesWithOptionalParameters.ts, 42, 7))
 
     foo(x?: number) { },
 >foo : Symbol(foo, Decl(callSignaturesWithOptionalParameters.ts, 42, 9))
@@ -126,14 +123,12 @@ var b = {
 
     a: function foo(x: number, y?: number) { },
 >a : Symbol(a, Decl(callSignaturesWithOptionalParameters.ts, 43, 24))
->function foo(x: number, y?: number) { } : Symbol(foo, Decl(callSignaturesWithOptionalParameters.ts, 44, 6))
 >foo : Symbol(foo, Decl(callSignaturesWithOptionalParameters.ts, 44, 6))
 >x : Symbol(x, Decl(callSignaturesWithOptionalParameters.ts, 44, 20))
 >y : Symbol(y, Decl(callSignaturesWithOptionalParameters.ts, 44, 30))
 
     b: (x?: number) => { }
 >b : Symbol(b, Decl(callSignaturesWithOptionalParameters.ts, 44, 47))
->(x?: number) => { } : Symbol((Anonymous function), Decl(callSignaturesWithOptionalParameters.ts, 45, 6))
 >x : Symbol(x, Decl(callSignaturesWithOptionalParameters.ts, 45, 8))
 }
 
diff --git a/tests/baselines/reference/callbacksDontShareTypes.symbols b/tests/baselines/reference/callbacksDontShareTypes.symbols
index ee84869c72853..80a5f234d383e 100644
--- a/tests/baselines/reference/callbacksDontShareTypes.symbols
+++ b/tests/baselines/reference/callbacksDontShareTypes.symbols
@@ -55,7 +55,6 @@ var c2: Collection<number>;
 
 var rf1 = (x: number) => { return x.toFixed() };
 >rf1 : Symbol(rf1, Decl(callbacksDontShareTypes.ts, 13, 3))
->(x: number) => { return x.toFixed() } : Symbol((Anonymous function), Decl(callbacksDontShareTypes.ts, 13, 9))
 >x : Symbol(x, Decl(callbacksDontShareTypes.ts, 13, 11))
 >x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
 >x : Symbol(x, Decl(callbacksDontShareTypes.ts, 13, 11))
@@ -67,7 +66,6 @@ var r1a = _.map(c2, (x) => { return x.toFixed() });
 >_ : Symbol(_, Decl(callbacksDontShareTypes.ts, 10, 3))
 >map : Symbol(Combinators.map, Decl(callbacksDontShareTypes.ts, 5, 23), Decl(callbacksDontShareTypes.ts, 6, 63))
 >c2 : Symbol(c2, Decl(callbacksDontShareTypes.ts, 11, 3))
->(x) => { return x.toFixed() } : Symbol((Anonymous function), Decl(callbacksDontShareTypes.ts, 14, 19))
 >x : Symbol(x, Decl(callbacksDontShareTypes.ts, 14, 21))
 >x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
 >x : Symbol(x, Decl(callbacksDontShareTypes.ts, 14, 21))
@@ -87,7 +85,6 @@ var r5a = _.map<number, string>(c2, (x) => { return x.toFixed() });
 >_ : Symbol(_, Decl(callbacksDontShareTypes.ts, 10, 3))
 >map : Symbol(Combinators.map, Decl(callbacksDontShareTypes.ts, 5, 23), Decl(callbacksDontShareTypes.ts, 6, 63))
 >c2 : Symbol(c2, Decl(callbacksDontShareTypes.ts, 11, 3))
->(x) => { return x.toFixed() } : Symbol((Anonymous function), Decl(callbacksDontShareTypes.ts, 16, 35))
 >x : Symbol(x, Decl(callbacksDontShareTypes.ts, 16, 37))
 >x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
 >x : Symbol(x, Decl(callbacksDontShareTypes.ts, 16, 37))
diff --git a/tests/baselines/reference/captureThisInSuperCall.symbols b/tests/baselines/reference/captureThisInSuperCall.symbols
index 88f41d4365f19..bf1fd151b3c49 100644
--- a/tests/baselines/reference/captureThisInSuperCall.symbols
+++ b/tests/baselines/reference/captureThisInSuperCall.symbols
@@ -12,9 +12,7 @@ class B extends A {
 
     constructor() { super({ test: () => this.someMethod()}); } 
 >super : Symbol(A, Decl(captureThisInSuperCall.ts, 0, 0))
->{ test: () => this.someMethod()} : Symbol(, Decl(captureThisInSuperCall.ts, 5, 26))
 >test : Symbol(test, Decl(captureThisInSuperCall.ts, 5, 27))
->() => this.someMethod() : Symbol((Anonymous function), Decl(captureThisInSuperCall.ts, 5, 33))
 >this.someMethod : Symbol(someMethod, Decl(captureThisInSuperCall.ts, 5, 62))
 >this : Symbol(B, Decl(captureThisInSuperCall.ts, 2, 1))
 >someMethod : Symbol(someMethod, Decl(captureThisInSuperCall.ts, 5, 62))
diff --git a/tests/baselines/reference/castExpressionParentheses.symbols b/tests/baselines/reference/castExpressionParentheses.symbols
index c21b34c1e8154..7bc8169e40fe9 100644
--- a/tests/baselines/reference/castExpressionParentheses.symbols
+++ b/tests/baselines/reference/castExpressionParentheses.symbols
@@ -5,7 +5,6 @@ declare var a;
 // parentheses should be omitted
 // literals
 (<any>{a:0});  
->{a:0} : Symbol(, Decl(castExpressionParentheses.ts, 4, 6))
 >a : Symbol(a, Decl(castExpressionParentheses.ts, 4, 7))
 
 (<any>[1,3,]); 
@@ -50,11 +49,9 @@ new (<any>A());
 >A : Symbol(A, Decl(castExpressionParentheses.ts, 21, 11))
 
 (<Tany>()=> {})();
-><Tany>()=> {} : Symbol((Anonymous function), Decl(castExpressionParentheses.ts, 28, 1))
 >Tany : Symbol(Tany, Decl(castExpressionParentheses.ts, 28, 2))
 
 (<any>function foo() { })();
->function foo() { } : Symbol(foo, Decl(castExpressionParentheses.ts, 29, 6))
 >foo : Symbol(foo, Decl(castExpressionParentheses.ts, 29, 6))
 
 (<any><number><any>-A).x; 
diff --git a/tests/baselines/reference/castTest.symbols b/tests/baselines/reference/castTest.symbols
index fe2027627b24a..e0bf154820e52 100644
--- a/tests/baselines/reference/castTest.symbols
+++ b/tests/baselines/reference/castTest.symbols
@@ -57,7 +57,6 @@ declare class Point
 var p_cast = <Point> ({
 >p_cast : Symbol(p_cast, Decl(castTest.ts, 22, 3))
 >Point : Symbol(Point, Decl(castTest.ts, 11, 37))
->{    x: 0,    y: 0,    add: function(dx, dy) {        return new Point(this.x + dx, this.y + dy);    },    mult: function(p) { return p; }} : Symbol(, Decl(castTest.ts, 22, 22))
 
     x: 0,
 >x : Symbol(x, Decl(castTest.ts, 22, 23))
@@ -67,7 +66,6 @@ var p_cast = <Point> ({
 
     add: function(dx, dy) {
 >add : Symbol(add, Decl(castTest.ts, 24, 9))
->function(dx, dy) {        return new Point(this.x + dx, this.y + dy);    } : Symbol((Anonymous function), Decl(castTest.ts, 25, 8))
 >dx : Symbol(dx, Decl(castTest.ts, 25, 18))
 >dy : Symbol(dy, Decl(castTest.ts, 25, 21))
 
@@ -79,7 +77,6 @@ var p_cast = <Point> ({
     },
     mult: function(p) { return p; }
 >mult : Symbol(mult, Decl(castTest.ts, 27, 6))
->function(p) { return p; } : Symbol((Anonymous function), Decl(castTest.ts, 28, 9))
 >p : Symbol(p, Decl(castTest.ts, 28, 19))
 >p : Symbol(p, Decl(castTest.ts, 28, 19))
 
diff --git a/tests/baselines/reference/chainedSpecializationToObjectTypeLiteral.symbols b/tests/baselines/reference/chainedSpecializationToObjectTypeLiteral.symbols
index 194ed5d574e10..5eb563d3ef615 100644
--- a/tests/baselines/reference/chainedSpecializationToObjectTypeLiteral.symbols
+++ b/tests/baselines/reference/chainedSpecializationToObjectTypeLiteral.symbols
@@ -50,7 +50,6 @@ var s2 = s.groupBy(s => s.length);
 >s.groupBy : Symbol(Sequence.groupBy, Decl(chainedSpecializationToObjectTypeLiteral.ts, 3, 57))
 >s : Symbol(s, Decl(chainedSpecializationToObjectTypeLiteral.ts, 7, 3))
 >groupBy : Symbol(Sequence.groupBy, Decl(chainedSpecializationToObjectTypeLiteral.ts, 3, 57))
->s => s.length : Symbol((Anonymous function), Decl(chainedSpecializationToObjectTypeLiteral.ts, 8, 19))
 >s : Symbol(s, Decl(chainedSpecializationToObjectTypeLiteral.ts, 8, 19))
 >s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >s : Symbol(s, Decl(chainedSpecializationToObjectTypeLiteral.ts, 8, 19))
@@ -61,7 +60,6 @@ var s3 = s2.each(x => { x.key /* Type is K, should be number */ });
 >s2.each : Symbol(Sequence.each, Decl(chainedSpecializationToObjectTypeLiteral.ts, 0, 23))
 >s2 : Symbol(s2, Decl(chainedSpecializationToObjectTypeLiteral.ts, 8, 3))
 >each : Symbol(Sequence.each, Decl(chainedSpecializationToObjectTypeLiteral.ts, 0, 23))
->x => { x.key /* Type is K, should be number */ } : Symbol((Anonymous function), Decl(chainedSpecializationToObjectTypeLiteral.ts, 9, 17))
 >x : Symbol(x, Decl(chainedSpecializationToObjectTypeLiteral.ts, 9, 17))
 >x.key : Symbol(key, Decl(chainedSpecializationToObjectTypeLiteral.ts, 4, 56))
 >x : Symbol(x, Decl(chainedSpecializationToObjectTypeLiteral.ts, 9, 17))
diff --git a/tests/baselines/reference/classExpression.symbols b/tests/baselines/reference/classExpression.symbols
index 131659fe9244e..f4d4423649983 100644
--- a/tests/baselines/reference/classExpression.symbols
+++ b/tests/baselines/reference/classExpression.symbols
@@ -1,17 +1,14 @@
 === tests/cases/conformance/classes/classExpression.ts ===
 var x = class C {
 >x : Symbol(x, Decl(classExpression.ts, 0, 3))
->class C {} : Symbol(C, Decl(classExpression.ts, 0, 7))
 >C : Symbol(C, Decl(classExpression.ts, 0, 7))
 }
 
 var y = {
 >y : Symbol(y, Decl(classExpression.ts, 3, 3))
->{    foo: class C2 {    }} : Symbol(, Decl(classExpression.ts, 3, 7))
 
     foo: class C2 {
 >foo : Symbol(foo, Decl(classExpression.ts, 3, 9))
->class C2 {    } : Symbol(C2, Decl(classExpression.ts, 4, 8))
 >C2 : Symbol(C2, Decl(classExpression.ts, 4, 8))
     }
 }
@@ -21,7 +18,6 @@ module M {
 
     var z = class C4 {
 >z : Symbol(z, Decl(classExpression.ts, 9, 7))
->class C4 {    } : Symbol(C4, Decl(classExpression.ts, 9, 11))
 >C4 : Symbol(C4, Decl(classExpression.ts, 9, 11))
     }
 }
diff --git a/tests/baselines/reference/classExpression1.symbols b/tests/baselines/reference/classExpression1.symbols
index 719ee3971f4b6..8d3bad269b4f4 100644
--- a/tests/baselines/reference/classExpression1.symbols
+++ b/tests/baselines/reference/classExpression1.symbols
@@ -1,6 +1,5 @@
 === tests/cases/conformance/classes/classExpressions/classExpression1.ts ===
 var v = class C {};
 >v : Symbol(v, Decl(classExpression1.ts, 0, 3))
->class C {} : Symbol(C, Decl(classExpression1.ts, 0, 7))
 >C : Symbol(C, Decl(classExpression1.ts, 0, 7))
 
diff --git a/tests/baselines/reference/classExpression2.symbols b/tests/baselines/reference/classExpression2.symbols
index a82fb2eef3a8c..11c78a2cad2b0 100644
--- a/tests/baselines/reference/classExpression2.symbols
+++ b/tests/baselines/reference/classExpression2.symbols
@@ -4,7 +4,6 @@ class D { }
 
 var v = class C extends D {};
 >v : Symbol(v, Decl(classExpression2.ts, 1, 3))
->class C extends D {} : Symbol(C, Decl(classExpression2.ts, 1, 7))
 >C : Symbol(C, Decl(classExpression2.ts, 1, 7))
 >D : Symbol(D, Decl(classExpression2.ts, 0, 0))
 
diff --git a/tests/baselines/reference/classExpression3.symbols b/tests/baselines/reference/classExpression3.symbols
index 1fe7d3362b6d8..bc1b263a00044 100644
--- a/tests/baselines/reference/classExpression3.symbols
+++ b/tests/baselines/reference/classExpression3.symbols
@@ -1,9 +1,6 @@
 === tests/cases/conformance/classes/classExpressions/classExpression3.ts ===
 let C = class extends class extends class { a = 1 } { b = 2 } { c = 3 };
 >C : Symbol(C, Decl(classExpression3.ts, 0, 3))
->class extends class extends class { a = 1 } { b = 2 } { c = 3 } : Symbol((Anonymous class), Decl(classExpression3.ts, 0, 7))
->class extends class { a = 1 } { b = 2 } : Symbol((Anonymous class), Decl(classExpression3.ts, 0, 21))
->class { a = 1 } : Symbol((Anonymous class), Decl(classExpression3.ts, 0, 35))
 >a : Symbol((Anonymous class).a, Decl(classExpression3.ts, 0, 43))
 >b : Symbol((Anonymous class).b, Decl(classExpression3.ts, 0, 53))
 >c : Symbol((Anonymous class).c, Decl(classExpression3.ts, 0, 63))
diff --git a/tests/baselines/reference/classExpression4.symbols b/tests/baselines/reference/classExpression4.symbols
index 34cd362f5f6d4..4df5302cecc56 100644
--- a/tests/baselines/reference/classExpression4.symbols
+++ b/tests/baselines/reference/classExpression4.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/classes/classExpressions/classExpression4.ts ===
 let C = class {
 >C : Symbol(C, Decl(classExpression4.ts, 0, 3))
->class {    foo() {        return new C();    }} : Symbol((Anonymous class), Decl(classExpression4.ts, 0, 7))
 
     foo() {
 >foo : Symbol((Anonymous class).foo, Decl(classExpression4.ts, 0, 15))
diff --git a/tests/baselines/reference/classExpressionES61.symbols b/tests/baselines/reference/classExpressionES61.symbols
index 7a8cf95402b16..1f49229fbc738 100644
--- a/tests/baselines/reference/classExpressionES61.symbols
+++ b/tests/baselines/reference/classExpressionES61.symbols
@@ -1,6 +1,5 @@
 === tests/cases/conformance/es6/classExpressions/classExpressionES61.ts ===
 var v = class C {};
 >v : Symbol(v, Decl(classExpressionES61.ts, 0, 3))
->class C {} : Symbol(C, Decl(classExpressionES61.ts, 0, 7))
 >C : Symbol(C, Decl(classExpressionES61.ts, 0, 7))
 
diff --git a/tests/baselines/reference/classExpressionES62.symbols b/tests/baselines/reference/classExpressionES62.symbols
index aa612d33e0b89..18e1a48ca30d7 100644
--- a/tests/baselines/reference/classExpressionES62.symbols
+++ b/tests/baselines/reference/classExpressionES62.symbols
@@ -4,7 +4,6 @@ class D { }
 
 var v = class C extends D {};
 >v : Symbol(v, Decl(classExpressionES62.ts, 1, 3))
->class C extends D {} : Symbol(C, Decl(classExpressionES62.ts, 1, 7))
 >C : Symbol(C, Decl(classExpressionES62.ts, 1, 7))
 >D : Symbol(D, Decl(classExpressionES62.ts, 0, 0))
 
diff --git a/tests/baselines/reference/classExpressionES63.symbols b/tests/baselines/reference/classExpressionES63.symbols
index 4ea70feb3bf78..4e52d5ee9ddc1 100644
--- a/tests/baselines/reference/classExpressionES63.symbols
+++ b/tests/baselines/reference/classExpressionES63.symbols
@@ -1,9 +1,6 @@
 === tests/cases/conformance/es6/classExpressions/classExpressionES63.ts ===
 let C = class extends class extends class { a = 1 } { b = 2 } { c = 3 };
 >C : Symbol(C, Decl(classExpressionES63.ts, 0, 3))
->class extends class extends class { a = 1 } { b = 2 } { c = 3 } : Symbol((Anonymous class), Decl(classExpressionES63.ts, 0, 7))
->class extends class { a = 1 } { b = 2 } : Symbol((Anonymous class), Decl(classExpressionES63.ts, 0, 21))
->class { a = 1 } : Symbol((Anonymous class), Decl(classExpressionES63.ts, 0, 35))
 >a : Symbol((Anonymous class).a, Decl(classExpressionES63.ts, 0, 43))
 >b : Symbol((Anonymous class).b, Decl(classExpressionES63.ts, 0, 53))
 >c : Symbol((Anonymous class).c, Decl(classExpressionES63.ts, 0, 63))
diff --git a/tests/baselines/reference/classExpressionTest1.symbols b/tests/baselines/reference/classExpressionTest1.symbols
index 96a5f48dda264..684ee3028957d 100644
--- a/tests/baselines/reference/classExpressionTest1.symbols
+++ b/tests/baselines/reference/classExpressionTest1.symbols
@@ -19,7 +19,6 @@ function M() {
 >X : Symbol(X, Decl(classExpressionTest1.ts, 1, 12))
 
             return { t, x };
->{ t, x } : Symbol(, Decl(classExpressionTest1.ts, 5, 18))
 >t : Symbol(t, Decl(classExpressionTest1.ts, 5, 20))
 >x : Symbol(x, Decl(classExpressionTest1.ts, 5, 23))
         }
diff --git a/tests/baselines/reference/classExpressionTest2.symbols b/tests/baselines/reference/classExpressionTest2.symbols
index 0fbfb11544662..62143cf0b9f08 100644
--- a/tests/baselines/reference/classExpressionTest2.symbols
+++ b/tests/baselines/reference/classExpressionTest2.symbols
@@ -4,7 +4,6 @@ function M() {
 
     var m = class C<X> {
 >m : Symbol(m, Decl(classExpressionTest2.ts, 1, 7))
->class C<X> {        f<T>() {            var t: T;            var x: X;            return { t, x };        }    } : Symbol(C, Decl(classExpressionTest2.ts, 1, 11))
 >C : Symbol(C, Decl(classExpressionTest2.ts, 1, 11))
 >X : Symbol(X, Decl(classExpressionTest2.ts, 1, 20))
 
@@ -21,7 +20,6 @@ function M() {
 >X : Symbol(X, Decl(classExpressionTest2.ts, 1, 20))
 
             return { t, x };
->{ t, x } : Symbol(, Decl(classExpressionTest2.ts, 5, 18))
 >t : Symbol(t, Decl(classExpressionTest2.ts, 5, 20))
 >x : Symbol(x, Decl(classExpressionTest2.ts, 5, 23))
         }
diff --git a/tests/baselines/reference/classExpressionWithResolutionOfNamespaceOfSameName01.symbols b/tests/baselines/reference/classExpressionWithResolutionOfNamespaceOfSameName01.symbols
index 0db0c1df64d29..fcd4f0388db3e 100644
--- a/tests/baselines/reference/classExpressionWithResolutionOfNamespaceOfSameName01.symbols
+++ b/tests/baselines/reference/classExpressionWithResolutionOfNamespaceOfSameName01.symbols
@@ -9,7 +9,6 @@ namespace C {
 
 var x = class C {
 >x : Symbol(x, Decl(classExpressionWithResolutionOfNamespaceOfSameName01.ts, 5, 3))
->class C {    prop: C.type;} : Symbol(C, Decl(classExpressionWithResolutionOfNamespaceOfSameName01.ts, 5, 7))
 >C : Symbol(C, Decl(classExpressionWithResolutionOfNamespaceOfSameName01.ts, 5, 7))
 
     prop: C.type;
diff --git a/tests/baselines/reference/classExpressionWithStaticProperties1.symbols b/tests/baselines/reference/classExpressionWithStaticProperties1.symbols
index f73ca19352112..d4c811daebec3 100644
--- a/tests/baselines/reference/classExpressionWithStaticProperties1.symbols
+++ b/tests/baselines/reference/classExpressionWithStaticProperties1.symbols
@@ -1,7 +1,6 @@
 === tests/cases/compiler/classExpressionWithStaticProperties1.ts ===
 var v = class C { static a = 1; static b = 2 };
 >v : Symbol(v, Decl(classExpressionWithStaticProperties1.ts, 0, 3))
->class C { static a = 1; static b = 2 } : Symbol(C, Decl(classExpressionWithStaticProperties1.ts, 0, 7))
 >C : Symbol(C, Decl(classExpressionWithStaticProperties1.ts, 0, 7))
 >a : Symbol(C.a, Decl(classExpressionWithStaticProperties1.ts, 0, 17))
 >b : Symbol(C.b, Decl(classExpressionWithStaticProperties1.ts, 0, 31))
diff --git a/tests/baselines/reference/classExpressionWithStaticProperties2.symbols b/tests/baselines/reference/classExpressionWithStaticProperties2.symbols
index 8f6ef450318a0..480123a1c3bfb 100644
--- a/tests/baselines/reference/classExpressionWithStaticProperties2.symbols
+++ b/tests/baselines/reference/classExpressionWithStaticProperties2.symbols
@@ -1,7 +1,6 @@
 === tests/cases/compiler/classExpressionWithStaticProperties2.ts ===
 var v = class C { static a = 1; static b };
 >v : Symbol(v, Decl(classExpressionWithStaticProperties2.ts, 0, 3))
->class C { static a = 1; static b } : Symbol(C, Decl(classExpressionWithStaticProperties2.ts, 0, 7))
 >C : Symbol(C, Decl(classExpressionWithStaticProperties2.ts, 0, 7))
 >a : Symbol(C.a, Decl(classExpressionWithStaticProperties2.ts, 0, 17))
 >b : Symbol(C.b, Decl(classExpressionWithStaticProperties2.ts, 0, 31))
diff --git a/tests/baselines/reference/classExpressionWithStaticPropertiesES61.symbols b/tests/baselines/reference/classExpressionWithStaticPropertiesES61.symbols
index 7c48d34b981d8..c5f53e19bffb1 100644
--- a/tests/baselines/reference/classExpressionWithStaticPropertiesES61.symbols
+++ b/tests/baselines/reference/classExpressionWithStaticPropertiesES61.symbols
@@ -1,7 +1,6 @@
 === tests/cases/compiler/classExpressionWithStaticPropertiesES61.ts ===
 var v = class C { static a = 1; static b = 2 };
 >v : Symbol(v, Decl(classExpressionWithStaticPropertiesES61.ts, 0, 3))
->class C { static a = 1; static b = 2 } : Symbol(C, Decl(classExpressionWithStaticPropertiesES61.ts, 0, 7))
 >C : Symbol(C, Decl(classExpressionWithStaticPropertiesES61.ts, 0, 7))
 >a : Symbol(C.a, Decl(classExpressionWithStaticPropertiesES61.ts, 0, 17))
 >b : Symbol(C.b, Decl(classExpressionWithStaticPropertiesES61.ts, 0, 31))
diff --git a/tests/baselines/reference/classExpressionWithStaticPropertiesES62.symbols b/tests/baselines/reference/classExpressionWithStaticPropertiesES62.symbols
index 3de3d399ecad8..be57a289f533b 100644
--- a/tests/baselines/reference/classExpressionWithStaticPropertiesES62.symbols
+++ b/tests/baselines/reference/classExpressionWithStaticPropertiesES62.symbols
@@ -1,7 +1,6 @@
 === tests/cases/compiler/classExpressionWithStaticPropertiesES62.ts ===
 var v = class C { static a = 1; static b };
 >v : Symbol(v, Decl(classExpressionWithStaticPropertiesES62.ts, 0, 3))
->class C { static a = 1; static b } : Symbol(C, Decl(classExpressionWithStaticPropertiesES62.ts, 0, 7))
 >C : Symbol(C, Decl(classExpressionWithStaticPropertiesES62.ts, 0, 7))
 >a : Symbol(C.a, Decl(classExpressionWithStaticPropertiesES62.ts, 0, 17))
 >b : Symbol(C.b, Decl(classExpressionWithStaticPropertiesES62.ts, 0, 31))
diff --git a/tests/baselines/reference/classMemberInitializerWithLamdaScoping5.symbols b/tests/baselines/reference/classMemberInitializerWithLamdaScoping5.symbols
index 76f349ecc7553..585bae5b3c347 100644
--- a/tests/baselines/reference/classMemberInitializerWithLamdaScoping5.symbols
+++ b/tests/baselines/reference/classMemberInitializerWithLamdaScoping5.symbols
@@ -17,7 +17,6 @@ class Greeter {
 
     messageHandler = (message: string) => {
 >messageHandler : Symbol(messageHandler, Decl(classMemberInitializerWithLamdaScoping5.ts, 5, 5))
->(message: string) => {        console.log(message); // This shouldnt be error    } : Symbol((Anonymous function), Decl(classMemberInitializerWithLamdaScoping5.ts, 7, 20))
 >message : Symbol(message, Decl(classMemberInitializerWithLamdaScoping5.ts, 7, 22))
 
         console.log(message); // This shouldnt be error
diff --git a/tests/baselines/reference/classWithEmptyBody.symbols b/tests/baselines/reference/classWithEmptyBody.symbols
index 2dbd2a42926c8..e08b0fe03af17 100644
--- a/tests/baselines/reference/classWithEmptyBody.symbols
+++ b/tests/baselines/reference/classWithEmptyBody.symbols
@@ -16,12 +16,10 @@ c = 1;
 
 c = { foo: '' }
 >c : Symbol(c, Decl(classWithEmptyBody.ts, 3, 3))
->{ foo: '' } : Symbol(, Decl(classWithEmptyBody.ts, 6, 3))
 >foo : Symbol(foo, Decl(classWithEmptyBody.ts, 6, 5))
 
 c = () => { }
 >c : Symbol(c, Decl(classWithEmptyBody.ts, 3, 3))
->() => { } : Symbol((Anonymous function), Decl(classWithEmptyBody.ts, 7, 3))
 
 class D {
 >D : Symbol(D, Decl(classWithEmptyBody.ts, 7, 13))
@@ -44,10 +42,8 @@ d = 1;
 
 d = { foo: '' }
 >d : Symbol(d, Decl(classWithEmptyBody.ts, 15, 3))
->{ foo: '' } : Symbol(, Decl(classWithEmptyBody.ts, 18, 3))
 >foo : Symbol(foo, Decl(classWithEmptyBody.ts, 18, 5))
 
 d = () => { }
 >d : Symbol(d, Decl(classWithEmptyBody.ts, 15, 3))
->() => { } : Symbol((Anonymous function), Decl(classWithEmptyBody.ts, 19, 3))
 
diff --git a/tests/baselines/reference/classWithProtectedProperty.symbols b/tests/baselines/reference/classWithProtectedProperty.symbols
index e71b5d6e2c949..017233081b25c 100644
--- a/tests/baselines/reference/classWithProtectedProperty.symbols
+++ b/tests/baselines/reference/classWithProtectedProperty.symbols
@@ -18,7 +18,6 @@ class C {
 
     protected d = () => '';
 >d : Symbol(d, Decl(classWithProtectedProperty.ts, 6, 31))
->() => '' : Symbol((Anonymous function), Decl(classWithProtectedProperty.ts, 7, 17))
 
     protected static e;
 >e : Symbol(C.e, Decl(classWithProtectedProperty.ts, 7, 27))
@@ -28,7 +27,6 @@ class C {
 
     protected static g = () => '';
 >g : Symbol(C.g, Decl(classWithProtectedProperty.ts, 9, 38))
->() => '' : Symbol((Anonymous function), Decl(classWithProtectedProperty.ts, 10, 24))
 }
 
 class D extends C {
diff --git a/tests/baselines/reference/classWithPublicProperty.symbols b/tests/baselines/reference/classWithPublicProperty.symbols
index 9e461a0c7c69a..0e3aa272e5d3f 100644
--- a/tests/baselines/reference/classWithPublicProperty.symbols
+++ b/tests/baselines/reference/classWithPublicProperty.symbols
@@ -16,7 +16,6 @@ class C {
 
     public d = () => '';
 >d : Symbol(d, Decl(classWithPublicProperty.ts, 4, 28))
->() => '' : Symbol((Anonymous function), Decl(classWithPublicProperty.ts, 5, 14))
 
     public static e;
 >e : Symbol(C.e, Decl(classWithPublicProperty.ts, 5, 24))
@@ -26,7 +25,6 @@ class C {
 
     public static g = () => '';
 >g : Symbol(C.g, Decl(classWithPublicProperty.ts, 7, 35))
->() => '' : Symbol((Anonymous function), Decl(classWithPublicProperty.ts, 8, 21))
 }
 
 // all of these are valid
diff --git a/tests/baselines/reference/collisionRestParameterArrowFunctions.symbols b/tests/baselines/reference/collisionRestParameterArrowFunctions.symbols
index c1fc705a8ad9d..9a44f92b1f511 100644
--- a/tests/baselines/reference/collisionRestParameterArrowFunctions.symbols
+++ b/tests/baselines/reference/collisionRestParameterArrowFunctions.symbols
@@ -1,7 +1,6 @@
 === tests/cases/compiler/collisionRestParameterArrowFunctions.ts ===
 var f1 = (_i: number, ...restParameters) => { //_i is error
 >f1 : Symbol(f1, Decl(collisionRestParameterArrowFunctions.ts, 0, 3))
->(_i: number, ...restParameters) => { //_i is error    var _i = 10; // no error} : Symbol((Anonymous function), Decl(collisionRestParameterArrowFunctions.ts, 0, 8))
 >_i : Symbol(_i, Decl(collisionRestParameterArrowFunctions.ts, 0, 10), Decl(collisionRestParameterArrowFunctions.ts, 1, 7))
 >restParameters : Symbol(restParameters, Decl(collisionRestParameterArrowFunctions.ts, 0, 21))
 
@@ -10,7 +9,6 @@ var f1 = (_i: number, ...restParameters) => { //_i is error
 }
 var f1NoError = (_i: number) => { // no error
 >f1NoError : Symbol(f1NoError, Decl(collisionRestParameterArrowFunctions.ts, 3, 3))
->(_i: number) => { // no error    var _i = 10; // no error} : Symbol((Anonymous function), Decl(collisionRestParameterArrowFunctions.ts, 3, 15))
 >_i : Symbol(_i, Decl(collisionRestParameterArrowFunctions.ts, 3, 17), Decl(collisionRestParameterArrowFunctions.ts, 4, 7))
 
     var _i = 10; // no error
@@ -19,7 +17,6 @@ var f1NoError = (_i: number) => { // no error
 
 var f2 = (...restParameters) => {
 >f2 : Symbol(f2, Decl(collisionRestParameterArrowFunctions.ts, 7, 3))
->(...restParameters) => {    var _i = 10; // No Error} : Symbol((Anonymous function), Decl(collisionRestParameterArrowFunctions.ts, 7, 8))
 >restParameters : Symbol(restParameters, Decl(collisionRestParameterArrowFunctions.ts, 7, 10))
 
     var _i = 10; // No Error
@@ -27,7 +24,6 @@ var f2 = (...restParameters) => {
 }
 var f2NoError = () => {
 >f2NoError : Symbol(f2NoError, Decl(collisionRestParameterArrowFunctions.ts, 10, 3))
->() => {    var _i = 10; // no error} : Symbol((Anonymous function), Decl(collisionRestParameterArrowFunctions.ts, 10, 15))
 
     var _i = 10; // no error
 >_i : Symbol(_i, Decl(collisionRestParameterArrowFunctions.ts, 11, 7))
diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.symbols b/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.symbols
index 54baebcf26f3b..42f24f77d5061 100644
--- a/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.symbols
+++ b/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.symbols
@@ -78,8 +78,6 @@ ANY = null, OBJECT
 >OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3))
 
 true, {}
->{} : Symbol(, Decl(commaOperatorWithSecondOperandObjectType.ts, 27, 5))
-
 !BOOLEAN, []
 >BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandObjectType.ts, 1, 3))
 
@@ -103,12 +101,10 @@ var resultIsObject7 = (ANY = null, OBJECT);
 
 var resultIsObject8 = (true, {});
 >resultIsObject8 : Symbol(resultIsObject8, Decl(commaOperatorWithSecondOperandObjectType.ts, 34, 3))
->{} : Symbol(, Decl(commaOperatorWithSecondOperandObjectType.ts, 34, 28))
 
 var resultIsObject9 = (!BOOLEAN, { a: 1, b: "s" });
 >resultIsObject9 : Symbol(resultIsObject9, Decl(commaOperatorWithSecondOperandObjectType.ts, 35, 3))
 >BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandObjectType.ts, 1, 3))
->{ a: 1, b: "s" } : Symbol(, Decl(commaOperatorWithSecondOperandObjectType.ts, 35, 32))
 >a : Symbol(a, Decl(commaOperatorWithSecondOperandObjectType.ts, 35, 34))
 >b : Symbol(b, Decl(commaOperatorWithSecondOperandObjectType.ts, 35, 40))
 
diff --git a/tests/baselines/reference/commentInMethodCall.symbols b/tests/baselines/reference/commentInMethodCall.symbols
index 47caf88f31f17..ff286983e23a0 100644
--- a/tests/baselines/reference/commentInMethodCall.symbols
+++ b/tests/baselines/reference/commentInMethodCall.symbols
@@ -9,5 +9,4 @@ s.map(// do something
 >map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
 
     function () { });
->function () { } : Symbol((Anonymous function), Decl(commentInMethodCall.ts, 2, 6))
 
diff --git a/tests/baselines/reference/commentOnSimpleArrowFunctionBody1.symbols b/tests/baselines/reference/commentOnSimpleArrowFunctionBody1.symbols
index 31657df746a8c..efbcb08496dc5 100644
--- a/tests/baselines/reference/commentOnSimpleArrowFunctionBody1.symbols
+++ b/tests/baselines/reference/commentOnSimpleArrowFunctionBody1.symbols
@@ -7,7 +7,6 @@ function Foo(x: any)
  
 Foo(() =>
 >Foo : Symbol(Foo, Decl(commentOnSimpleArrowFunctionBody1.ts, 0, 0))
->() =>    // do something    127 : Symbol((Anonymous function), Decl(commentOnSimpleArrowFunctionBody1.ts, 4, 4))
 
     // do something
     127);
diff --git a/tests/baselines/reference/commentsBeforeFunctionExpression1.symbols b/tests/baselines/reference/commentsBeforeFunctionExpression1.symbols
index d0622bebe78b7..adeea60711e27 100644
--- a/tests/baselines/reference/commentsBeforeFunctionExpression1.symbols
+++ b/tests/baselines/reference/commentsBeforeFunctionExpression1.symbols
@@ -1,11 +1,9 @@
 === tests/cases/compiler/commentsBeforeFunctionExpression1.ts ===
 var v = {
 >v : Symbol(v, Decl(commentsBeforeFunctionExpression1.ts, 0, 3))
->{    f: /**own f*/ (a) => 0} : Symbol(, Decl(commentsBeforeFunctionExpression1.ts, 0, 7))
 
     f: /**own f*/ (a) => 0
 >f : Symbol(f, Decl(commentsBeforeFunctionExpression1.ts, 0, 9))
->(a) => 0 : Symbol((Anonymous function), Decl(commentsBeforeFunctionExpression1.ts, 1, 6))
 >a : Symbol(a, Decl(commentsBeforeFunctionExpression1.ts, 1, 19))
 }
 
diff --git a/tests/baselines/reference/commentsFunction.symbols b/tests/baselines/reference/commentsFunction.symbols
index 53d6f1a6613e6..dfc68eb6743e1 100644
--- a/tests/baselines/reference/commentsFunction.symbols
+++ b/tests/baselines/reference/commentsFunction.symbols
@@ -30,7 +30,6 @@ fooWithParameters("a", 10);
  */
 var fooFunc = function FooFunctionValue(/** fooFunctionValue param */ b: string) {
 >fooFunc : Symbol(fooFunc, Decl(commentsFunction.ts, 15, 3))
->function FooFunctionValue(/** fooFunctionValue param */ b: string) {    return b;} : Symbol(FooFunctionValue, Decl(commentsFunction.ts, 15, 13))
 >FooFunctionValue : Symbol(FooFunctionValue, Decl(commentsFunction.ts, 15, 13))
 >b : Symbol(b, Decl(commentsFunction.ts, 15, 40))
 
@@ -41,7 +40,6 @@ var fooFunc = function FooFunctionValue(/** fooFunctionValue param */ b: string)
 /// lamdaFoo var comment
 var lambdaFoo = /** this is lambda comment*/ (/**param a*/a: number, /**param b*/b: number) => a + b;
 >lambdaFoo : Symbol(lambdaFoo, Decl(commentsFunction.ts, 20, 3))
->(/**param a*/a: number, /**param b*/b: number) => a + b : Symbol((Anonymous function), Decl(commentsFunction.ts, 20, 15))
 >a : Symbol(a, Decl(commentsFunction.ts, 20, 46))
 >b : Symbol(b, Decl(commentsFunction.ts, 20, 68))
 >a : Symbol(a, Decl(commentsFunction.ts, 20, 46))
@@ -49,7 +47,6 @@ var lambdaFoo = /** this is lambda comment*/ (/**param a*/a: number, /**param b*
 
 var lambddaNoVarComment = /** this is lambda multiplication*/ (/**param a*/a: number, /**param b*/b: number) => a * b;
 >lambddaNoVarComment : Symbol(lambddaNoVarComment, Decl(commentsFunction.ts, 21, 3))
->(/**param a*/a: number, /**param b*/b: number) => a * b : Symbol((Anonymous function), Decl(commentsFunction.ts, 21, 25))
 >a : Symbol(a, Decl(commentsFunction.ts, 21, 63))
 >b : Symbol(b, Decl(commentsFunction.ts, 21, 85))
 >a : Symbol(a, Decl(commentsFunction.ts, 21, 63))
@@ -82,17 +79,13 @@ function blah3(a: string // trailing commen single line
 
 lambdaFoo = (a, b) => a * b; // This is trailing comment
 >lambdaFoo : Symbol(lambdaFoo, Decl(commentsFunction.ts, 20, 3))
->(a, b) => a * b : Symbol((Anonymous function), Decl(commentsFunction.ts, 36, 11))
 >a : Symbol(a, Decl(commentsFunction.ts, 36, 13))
 >b : Symbol(b, Decl(commentsFunction.ts, 36, 15))
 >a : Symbol(a, Decl(commentsFunction.ts, 36, 13))
 >b : Symbol(b, Decl(commentsFunction.ts, 36, 15))
 
 /*leading comment*/() => 0; // Needs to be wrapped in parens to be a valid expression (not declaration)
->() => 0 : Symbol((Anonymous function), Decl(commentsFunction.ts, 36, 28))
-
 /*leading comment*/(() => 0); //trailing comment
->() => 0 : Symbol((Anonymous function), Decl(commentsFunction.ts, 39, 20))
 
 function blah4(/*1*/a: string/*2*/,/*3*/b: string/*4*/) {
 >blah4 : Symbol(blah4, Decl(commentsFunction.ts, 39, 29))
diff --git a/tests/baselines/reference/commentsInterface.symbols b/tests/baselines/reference/commentsInterface.symbols
index fe957ee4f8041..78d89989ed186 100644
--- a/tests/baselines/reference/commentsInterface.symbols
+++ b/tests/baselines/reference/commentsInterface.symbols
@@ -179,11 +179,9 @@ var i3_i: i3;
 
 i3_i = {
 >i3_i : Symbol(i3_i, Decl(commentsInterface.ts, 54, 3))
->{    f: /**own f*/ (/**i3_i a*/a: number) => "Hello" + a,    l: this.f,    /** own x*/    x: this.f(10),    nc_x: this.l(this.x),    nc_f: this.f,    nc_l: this.l} : Symbol(, Decl(commentsInterface.ts, 55, 6))
 
     f: /**own f*/ (/**i3_i a*/a: number) => "Hello" + a,
 >f : Symbol(f, Decl(commentsInterface.ts, 55, 8))
->(/**i3_i a*/a: number) => "Hello" + a : Symbol((Anonymous function), Decl(commentsInterface.ts, 56, 6))
 >a : Symbol(a, Decl(commentsInterface.ts, 56, 19))
 >a : Symbol(a, Decl(commentsInterface.ts, 56, 19))
 
diff --git a/tests/baselines/reference/commentsOnObjectLiteral3.symbols b/tests/baselines/reference/commentsOnObjectLiteral3.symbols
index 0612853f4b1ee..3d58fe2d6d7eb 100644
--- a/tests/baselines/reference/commentsOnObjectLiteral3.symbols
+++ b/tests/baselines/reference/commentsOnObjectLiteral3.symbols
@@ -2,7 +2,6 @@
 
 var v = {
 >v : Symbol(v, Decl(commentsOnObjectLiteral3.ts, 1, 3))
->{ //property prop: 1 /* multiple trailing comments */ /*trailing comments*/, //property func: function () { }, //PropertyName + CallSignature func1() { }, //getter get a() {  return this.prop; } /*trailing 1*/, //setter set a(value) {  this.prop = value; } // trailing 2} : Symbol(, Decl(commentsOnObjectLiteral3.ts, 1, 7))
 
  //property
  prop: 1 /* multiple trailing comments */ /*trailing comments*/,
@@ -11,7 +10,6 @@ var v = {
  //property
  func: function () {
 >func : Symbol(func, Decl(commentsOnObjectLiteral3.ts, 3, 64))
->function () { } : Symbol((Anonymous function), Decl(commentsOnObjectLiteral3.ts, 5, 6))
 
  },
  //PropertyName + CallSignature
diff --git a/tests/baselines/reference/commentsOnObjectLiteral4.symbols b/tests/baselines/reference/commentsOnObjectLiteral4.symbols
index b9236e7a760de..c1762cb75c8e8 100644
--- a/tests/baselines/reference/commentsOnObjectLiteral4.symbols
+++ b/tests/baselines/reference/commentsOnObjectLiteral4.symbols
@@ -2,7 +2,6 @@
 
 var v = {
 >v : Symbol(v, Decl(commentsOnObjectLiteral4.ts, 1, 3))
->{ /**  * @type {number}  */ get bar(): number {  return this._bar; }} : Symbol(, Decl(commentsOnObjectLiteral4.ts, 1, 7))
 
  /**
   * @type {number}
diff --git a/tests/baselines/reference/commentsPropertySignature1.symbols b/tests/baselines/reference/commentsPropertySignature1.symbols
index 45419ed3cbf1e..2e97f70187152 100644
--- a/tests/baselines/reference/commentsPropertySignature1.symbols
+++ b/tests/baselines/reference/commentsPropertySignature1.symbols
@@ -1,7 +1,6 @@
 === tests/cases/compiler/commentsPropertySignature1.ts ===
 var a = {
 >a : Symbol(a, Decl(commentsPropertySignature1.ts, 0, 3))
->{    /** own x*/    x: 0} : Symbol(, Decl(commentsPropertySignature1.ts, 0, 7))
 
     /** own x*/
     x: 0
diff --git a/tests/baselines/reference/commentsVarDecl.symbols b/tests/baselines/reference/commentsVarDecl.symbols
index b606e689f5e31..d2ec3d4edcdfd 100644
--- a/tests/baselines/reference/commentsVarDecl.symbols
+++ b/tests/baselines/reference/commentsVarDecl.symbols
@@ -48,7 +48,6 @@ var yy =
 /** comment2 */
 var z = /** lambda comment */ (x: number, y: number) => x + y;
 >z : Symbol(z, Decl(commentsVarDecl.ts, 35, 3))
->(x: number, y: number) => x + y : Symbol((Anonymous function), Decl(commentsVarDecl.ts, 35, 7))
 >x : Symbol(x, Decl(commentsVarDecl.ts, 35, 31))
 >y : Symbol(y, Decl(commentsVarDecl.ts, 35, 41))
 >x : Symbol(x, Decl(commentsVarDecl.ts, 35, 31))
diff --git a/tests/baselines/reference/commonJSImportNotAsPrimaryExpression.symbols b/tests/baselines/reference/commonJSImportNotAsPrimaryExpression.symbols
index 8748a877c0323..68a852c6165aa 100644
--- a/tests/baselines/reference/commonJSImportNotAsPrimaryExpression.symbols
+++ b/tests/baselines/reference/commonJSImportNotAsPrimaryExpression.symbols
@@ -18,7 +18,6 @@ var x: foo.C1 = <{m1: number}>{};
 >foo : Symbol(foo, Decl(foo_1.ts, 0, 0))
 >C1 : Symbol(foo.C1, Decl(foo_0.ts, 0, 0))
 >m1 : Symbol(m1, Decl(foo_1.ts, 4, 18))
->{} : Symbol(, Decl(foo_1.ts, 4, 30))
 
 var y: typeof foo.C1.s1 = false;
 >y : Symbol(y, Decl(foo_1.ts, 5, 3))
diff --git a/tests/baselines/reference/complexClassRelationships.symbols b/tests/baselines/reference/complexClassRelationships.symbols
index df591cef6b13b..533c5171cf8b5 100644
--- a/tests/baselines/reference/complexClassRelationships.symbols
+++ b/tests/baselines/reference/complexClassRelationships.symbols
@@ -26,7 +26,6 @@ class BaseCollection<T extends Base> {
 >T : Symbol(T, Decl(complexClassRelationships.ts, 7, 21))
 
         (item: Thing) => { return [item.Components]; };
->(item: Thing) => { return [item.Components]; } : Symbol((Anonymous function), Decl(complexClassRelationships.ts, 8, 29))
 >item : Symbol(item, Decl(complexClassRelationships.ts, 9, 9))
 >Thing : Symbol(Thing, Decl(complexClassRelationships.ts, 14, 1))
 >item.Components : Symbol(Thing.Components, Decl(complexClassRelationships.ts, 16, 13))
diff --git a/tests/baselines/reference/compoundAdditionAssignmentLHSCanBeAssigned.symbols b/tests/baselines/reference/compoundAdditionAssignmentLHSCanBeAssigned.symbols
index 983ac8c025300..cb2a0975e0ba0 100644
--- a/tests/baselines/reference/compoundAdditionAssignmentLHSCanBeAssigned.symbols
+++ b/tests/baselines/reference/compoundAdditionAssignmentLHSCanBeAssigned.symbols
@@ -38,7 +38,6 @@ x1 += E.a;
 
 x1 += {};
 >x1 : Symbol(x1, Decl(compoundAdditionAssignmentLHSCanBeAssigned.ts, 5, 3))
->{} : Symbol(, Decl(compoundAdditionAssignmentLHSCanBeAssigned.ts, 12, 5))
 
 x1 += null;
 >x1 : Symbol(x1, Decl(compoundAdditionAssignmentLHSCanBeAssigned.ts, 5, 3))
@@ -75,7 +74,6 @@ x2 += E.a;
 
 x2 += {};
 >x2 : Symbol(x2, Decl(compoundAdditionAssignmentLHSCanBeAssigned.ts, 16, 3))
->{} : Symbol(, Decl(compoundAdditionAssignmentLHSCanBeAssigned.ts, 23, 5))
 
 x2 += null;
 >x2 : Symbol(x2, Decl(compoundAdditionAssignmentLHSCanBeAssigned.ts, 16, 3))
diff --git a/tests/baselines/reference/computedPropertyNames10_ES5.symbols b/tests/baselines/reference/computedPropertyNames10_ES5.symbols
index 7bc820fa278b4..17d1f7ca11757 100644
--- a/tests/baselines/reference/computedPropertyNames10_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNames10_ES5.symbols
@@ -10,7 +10,6 @@ var a: any;
 
 var v = {
 >v : Symbol(v, Decl(computedPropertyNames10_ES5.ts, 3, 3))
->{    [s]() { },    [n]() { },    [s + s]() { },    [s + n]() { },    [+s]() { },    [""]() { },    [0]() { },    [a]() { },    [<any>true]() { },    [`hello bye`]() { },    [`hello ${a} bye`]() { }} : Symbol(, Decl(computedPropertyNames10_ES5.ts, 3, 7))
 
     [s]() { },
 >s : Symbol(s, Decl(computedPropertyNames10_ES5.ts, 0, 3))
diff --git a/tests/baselines/reference/computedPropertyNames10_ES6.symbols b/tests/baselines/reference/computedPropertyNames10_ES6.symbols
index 7c1a49bbcfb00..4141b7872089c 100644
--- a/tests/baselines/reference/computedPropertyNames10_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNames10_ES6.symbols
@@ -10,7 +10,6 @@ var a: any;
 
 var v = {
 >v : Symbol(v, Decl(computedPropertyNames10_ES6.ts, 3, 3))
->{    [s]() { },    [n]() { },    [s + s]() { },    [s + n]() { },    [+s]() { },    [""]() { },    [0]() { },    [a]() { },    [<any>true]() { },    [`hello bye`]() { },    [`hello ${a} bye`]() { }} : Symbol(, Decl(computedPropertyNames10_ES6.ts, 3, 7))
 
     [s]() { },
 >s : Symbol(s, Decl(computedPropertyNames10_ES6.ts, 0, 3))
diff --git a/tests/baselines/reference/computedPropertyNames11_ES5.symbols b/tests/baselines/reference/computedPropertyNames11_ES5.symbols
index b97586bb5b2b9..34326273e595a 100644
--- a/tests/baselines/reference/computedPropertyNames11_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNames11_ES5.symbols
@@ -10,7 +10,6 @@ var a: any;
 
 var v = {
 >v : Symbol(v, Decl(computedPropertyNames11_ES5.ts, 3, 3))
->{    get [s]() { return 0; },    set [n](v) { },    get [s + s]() { return 0; },    set [s + n](v) { },    get [+s]() { return 0; },    set [""](v) { },    get [0]() { return 0; },    set [a](v) { },    get [<any>true]() { return 0; },    set [`hello bye`](v) { },    get [`hello ${a} bye`]() { return 0; }} : Symbol(, Decl(computedPropertyNames11_ES5.ts, 3, 7))
 
     get [s]() { return 0; },
 >s : Symbol(s, Decl(computedPropertyNames11_ES5.ts, 0, 3))
diff --git a/tests/baselines/reference/computedPropertyNames11_ES6.symbols b/tests/baselines/reference/computedPropertyNames11_ES6.symbols
index 1c77030981b67..73503eb2758eb 100644
--- a/tests/baselines/reference/computedPropertyNames11_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNames11_ES6.symbols
@@ -10,7 +10,6 @@ var a: any;
 
 var v = {
 >v : Symbol(v, Decl(computedPropertyNames11_ES6.ts, 3, 3))
->{    get [s]() { return 0; },    set [n](v) { },    get [s + s]() { return 0; },    set [s + n](v) { },    get [+s]() { return 0; },    set [""](v) { },    get [0]() { return 0; },    set [a](v) { },    get [<any>true]() { return 0; },    set [`hello bye`](v) { },    get [`hello ${a} bye`]() { return 0; }} : Symbol(, Decl(computedPropertyNames11_ES6.ts, 3, 7))
 
     get [s]() { return 0; },
 >s : Symbol(s, Decl(computedPropertyNames11_ES6.ts, 0, 3))
diff --git a/tests/baselines/reference/computedPropertyNames18_ES5.symbols b/tests/baselines/reference/computedPropertyNames18_ES5.symbols
index 26ff3afcb5730..86d706bc44c18 100644
--- a/tests/baselines/reference/computedPropertyNames18_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNames18_ES5.symbols
@@ -4,7 +4,6 @@ function foo() {
 
     var obj = {
 >obj : Symbol(obj, Decl(computedPropertyNames18_ES5.ts, 1, 7))
->{        [this.bar]: 0    } : Symbol(, Decl(computedPropertyNames18_ES5.ts, 1, 13))
 
         [this.bar]: 0
     }
diff --git a/tests/baselines/reference/computedPropertyNames18_ES6.symbols b/tests/baselines/reference/computedPropertyNames18_ES6.symbols
index 20b461c2b1fac..c530d1e811fd5 100644
--- a/tests/baselines/reference/computedPropertyNames18_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNames18_ES6.symbols
@@ -4,7 +4,6 @@ function foo() {
 
     var obj = {
 >obj : Symbol(obj, Decl(computedPropertyNames18_ES6.ts, 1, 7))
->{        [this.bar]: 0    } : Symbol(, Decl(computedPropertyNames18_ES6.ts, 1, 13))
 
         [this.bar]: 0
     }
diff --git a/tests/baselines/reference/computedPropertyNames1_ES5.symbols b/tests/baselines/reference/computedPropertyNames1_ES5.symbols
index 6441781a33f9e..2bc11580c7899 100644
--- a/tests/baselines/reference/computedPropertyNames1_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNames1_ES5.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/computedProperties/computedPropertyNames1_ES5.ts ===
 var v = {
 >v : Symbol(v, Decl(computedPropertyNames1_ES5.ts, 0, 3))
->{    get [0 + 1]() { return 0 },    set [0 + 1](v: string) { } //No error} : Symbol(, Decl(computedPropertyNames1_ES5.ts, 0, 7))
 
     get [0 + 1]() { return 0 },
     set [0 + 1](v: string) { } //No error
diff --git a/tests/baselines/reference/computedPropertyNames1_ES6.symbols b/tests/baselines/reference/computedPropertyNames1_ES6.symbols
index 8713a059541c8..5a1708b927dee 100644
--- a/tests/baselines/reference/computedPropertyNames1_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNames1_ES6.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/computedProperties/computedPropertyNames1_ES6.ts ===
 var v = {
 >v : Symbol(v, Decl(computedPropertyNames1_ES6.ts, 0, 3))
->{    get [0 + 1]() { return 0 },    set [0 + 1](v: string) { } //No error} : Symbol(, Decl(computedPropertyNames1_ES6.ts, 0, 7))
 
     get [0 + 1]() { return 0 },
     set [0 + 1](v: string) { } //No error
diff --git a/tests/baselines/reference/computedPropertyNames20_ES5.symbols b/tests/baselines/reference/computedPropertyNames20_ES5.symbols
index e5686053dbcb5..2ab61faa707cb 100644
--- a/tests/baselines/reference/computedPropertyNames20_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNames20_ES5.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/computedProperties/computedPropertyNames20_ES5.ts ===
 var obj = {
 >obj : Symbol(obj, Decl(computedPropertyNames20_ES5.ts, 0, 3))
->{    [this.bar]: 0} : Symbol(, Decl(computedPropertyNames20_ES5.ts, 0, 9))
 
     [this.bar]: 0
 }
diff --git a/tests/baselines/reference/computedPropertyNames20_ES6.symbols b/tests/baselines/reference/computedPropertyNames20_ES6.symbols
index f472336289b8c..f7ab8c84def49 100644
--- a/tests/baselines/reference/computedPropertyNames20_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNames20_ES6.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/computedProperties/computedPropertyNames20_ES6.ts ===
 var obj = {
 >obj : Symbol(obj, Decl(computedPropertyNames20_ES6.ts, 0, 3))
->{    [this.bar]: 0} : Symbol(, Decl(computedPropertyNames20_ES6.ts, 0, 9))
 
     [this.bar]: 0
 }
diff --git a/tests/baselines/reference/computedPropertyNames22_ES5.symbols b/tests/baselines/reference/computedPropertyNames22_ES5.symbols
index e254f9539020a..a1e08e5f48739 100644
--- a/tests/baselines/reference/computedPropertyNames22_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNames22_ES5.symbols
@@ -7,7 +7,6 @@ class C {
 
         var obj = {
 >obj : Symbol(obj, Decl(computedPropertyNames22_ES5.ts, 2, 11))
->{            [this.bar()]() { }        } : Symbol(, Decl(computedPropertyNames22_ES5.ts, 2, 17))
 
             [this.bar()]() { }
 >this.bar : Symbol(bar, Decl(computedPropertyNames22_ES5.ts, 0, 9))
diff --git a/tests/baselines/reference/computedPropertyNames22_ES6.symbols b/tests/baselines/reference/computedPropertyNames22_ES6.symbols
index ba49cb664354a..5940bfb4cfb70 100644
--- a/tests/baselines/reference/computedPropertyNames22_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNames22_ES6.symbols
@@ -7,7 +7,6 @@ class C {
 
         var obj = {
 >obj : Symbol(obj, Decl(computedPropertyNames22_ES6.ts, 2, 11))
->{            [this.bar()]() { }        } : Symbol(, Decl(computedPropertyNames22_ES6.ts, 2, 17))
 
             [this.bar()]() { }
 >this.bar : Symbol(bar, Decl(computedPropertyNames22_ES6.ts, 0, 9))
diff --git a/tests/baselines/reference/computedPropertyNames25_ES5.symbols b/tests/baselines/reference/computedPropertyNames25_ES5.symbols
index ae0f91f0261da..e11753857cc11 100644
--- a/tests/baselines/reference/computedPropertyNames25_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNames25_ES5.symbols
@@ -17,7 +17,6 @@ class C extends Base {
 
         var obj = {
 >obj : Symbol(obj, Decl(computedPropertyNames25_ES5.ts, 7, 11))
->{            [super.bar()]() { }        } : Symbol(, Decl(computedPropertyNames25_ES5.ts, 7, 17))
 
             [super.bar()]() { }
 >super.bar : Symbol(Base.bar, Decl(computedPropertyNames25_ES5.ts, 0, 12))
diff --git a/tests/baselines/reference/computedPropertyNames25_ES6.symbols b/tests/baselines/reference/computedPropertyNames25_ES6.symbols
index b78e0126aaca3..8eb7393c6ac26 100644
--- a/tests/baselines/reference/computedPropertyNames25_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNames25_ES6.symbols
@@ -17,7 +17,6 @@ class C extends Base {
 
         var obj = {
 >obj : Symbol(obj, Decl(computedPropertyNames25_ES6.ts, 7, 11))
->{            [super.bar()]() { }        } : Symbol(, Decl(computedPropertyNames25_ES6.ts, 7, 17))
 
             [super.bar()]() { }
 >super.bar : Symbol(Base.bar, Decl(computedPropertyNames25_ES6.ts, 0, 12))
diff --git a/tests/baselines/reference/computedPropertyNames28_ES5.symbols b/tests/baselines/reference/computedPropertyNames28_ES5.symbols
index 0036b0c7fc123..2934c3d040194 100644
--- a/tests/baselines/reference/computedPropertyNames28_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNames28_ES5.symbols
@@ -12,7 +12,6 @@ class C extends Base {
 
         var obj = {
 >obj : Symbol(obj, Decl(computedPropertyNames28_ES5.ts, 5, 11))
->{            [(super(), "prop")]() { }        } : Symbol(, Decl(computedPropertyNames28_ES5.ts, 5, 17))
 
             [(super(), "prop")]() { }
 >super : Symbol(Base, Decl(computedPropertyNames28_ES5.ts, 0, 0))
diff --git a/tests/baselines/reference/computedPropertyNames28_ES6.symbols b/tests/baselines/reference/computedPropertyNames28_ES6.symbols
index d50641da5dcea..6824f62e2a595 100644
--- a/tests/baselines/reference/computedPropertyNames28_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNames28_ES6.symbols
@@ -12,7 +12,6 @@ class C extends Base {
 
         var obj = {
 >obj : Symbol(obj, Decl(computedPropertyNames28_ES6.ts, 5, 11))
->{            [(super(), "prop")]() { }        } : Symbol(, Decl(computedPropertyNames28_ES6.ts, 5, 17))
 
             [(super(), "prop")]() { }
 >super : Symbol(Base, Decl(computedPropertyNames28_ES6.ts, 0, 0))
diff --git a/tests/baselines/reference/computedPropertyNames29_ES5.symbols b/tests/baselines/reference/computedPropertyNames29_ES5.symbols
index 21a15057fca64..c33a7390ce80d 100644
--- a/tests/baselines/reference/computedPropertyNames29_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNames29_ES5.symbols
@@ -6,11 +6,8 @@ class C {
 >bar : Symbol(bar, Decl(computedPropertyNames29_ES5.ts, 0, 9))
 
         () => {
->() => {            var obj = {                [this.bar()]() { } // needs capture            };        } : Symbol((Anonymous function), Decl(computedPropertyNames29_ES5.ts, 1, 11))
-
             var obj = {
 >obj : Symbol(obj, Decl(computedPropertyNames29_ES5.ts, 3, 15))
->{                [this.bar()]() { } // needs capture            } : Symbol(, Decl(computedPropertyNames29_ES5.ts, 3, 21))
 
                 [this.bar()]() { } // needs capture
 >this.bar : Symbol(bar, Decl(computedPropertyNames29_ES5.ts, 0, 9))
diff --git a/tests/baselines/reference/computedPropertyNames29_ES6.symbols b/tests/baselines/reference/computedPropertyNames29_ES6.symbols
index e7a47e6760e64..41631ea63bba7 100644
--- a/tests/baselines/reference/computedPropertyNames29_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNames29_ES6.symbols
@@ -6,11 +6,8 @@ class C {
 >bar : Symbol(bar, Decl(computedPropertyNames29_ES6.ts, 0, 9))
 
         () => {
->() => {            var obj = {                [this.bar()]() { } // needs capture            };        } : Symbol((Anonymous function), Decl(computedPropertyNames29_ES6.ts, 1, 11))
-
             var obj = {
 >obj : Symbol(obj, Decl(computedPropertyNames29_ES6.ts, 3, 15))
->{                [this.bar()]() { } // needs capture            } : Symbol(, Decl(computedPropertyNames29_ES6.ts, 3, 21))
 
                 [this.bar()]() { } // needs capture
 >this.bar : Symbol(bar, Decl(computedPropertyNames29_ES6.ts, 0, 9))
diff --git a/tests/baselines/reference/computedPropertyNames31_ES5.symbols b/tests/baselines/reference/computedPropertyNames31_ES5.symbols
index 65a83821ca061..82a6acb286c95 100644
--- a/tests/baselines/reference/computedPropertyNames31_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNames31_ES5.symbols
@@ -16,11 +16,8 @@ class C extends Base {
 >foo : Symbol(foo, Decl(computedPropertyNames31_ES5.ts, 5, 22))
 
         () => {
->() => {            var obj = {                [super.bar()]() { } // needs capture            };        } : Symbol((Anonymous function), Decl(computedPropertyNames31_ES5.ts, 6, 11))
-
             var obj = {
 >obj : Symbol(obj, Decl(computedPropertyNames31_ES5.ts, 8, 15))
->{                [super.bar()]() { } // needs capture            } : Symbol(, Decl(computedPropertyNames31_ES5.ts, 8, 21))
 
                 [super.bar()]() { } // needs capture
 >super.bar : Symbol(Base.bar, Decl(computedPropertyNames31_ES5.ts, 0, 12))
diff --git a/tests/baselines/reference/computedPropertyNames31_ES6.symbols b/tests/baselines/reference/computedPropertyNames31_ES6.symbols
index d85e042c54755..778293bbb885c 100644
--- a/tests/baselines/reference/computedPropertyNames31_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNames31_ES6.symbols
@@ -16,11 +16,8 @@ class C extends Base {
 >foo : Symbol(foo, Decl(computedPropertyNames31_ES6.ts, 5, 22))
 
         () => {
->() => {            var obj = {                [super.bar()]() { } // needs capture            };        } : Symbol((Anonymous function), Decl(computedPropertyNames31_ES6.ts, 6, 11))
-
             var obj = {
 >obj : Symbol(obj, Decl(computedPropertyNames31_ES6.ts, 8, 15))
->{                [super.bar()]() { } // needs capture            } : Symbol(, Decl(computedPropertyNames31_ES6.ts, 8, 21))
 
                 [super.bar()]() { } // needs capture
 >super.bar : Symbol(Base.bar, Decl(computedPropertyNames31_ES6.ts, 0, 12))
diff --git a/tests/baselines/reference/computedPropertyNames33_ES5.symbols b/tests/baselines/reference/computedPropertyNames33_ES5.symbols
index 4bb334d155615..ae6dd01e7bc9d 100644
--- a/tests/baselines/reference/computedPropertyNames33_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNames33_ES5.symbols
@@ -12,7 +12,6 @@ class C<T> {
 
         var obj = {
 >obj : Symbol(obj, Decl(computedPropertyNames33_ES5.ts, 3, 11))
->{            [foo<T>()]() { }        } : Symbol(, Decl(computedPropertyNames33_ES5.ts, 3, 17))
 
             [foo<T>()]() { }
 >foo : Symbol(foo, Decl(computedPropertyNames33_ES5.ts, 0, 0))
diff --git a/tests/baselines/reference/computedPropertyNames33_ES6.symbols b/tests/baselines/reference/computedPropertyNames33_ES6.symbols
index 64c8a00a4684c..cf0b3abde9633 100644
--- a/tests/baselines/reference/computedPropertyNames33_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNames33_ES6.symbols
@@ -12,7 +12,6 @@ class C<T> {
 
         var obj = {
 >obj : Symbol(obj, Decl(computedPropertyNames33_ES6.ts, 3, 11))
->{            [foo<T>()]() { }        } : Symbol(, Decl(computedPropertyNames33_ES6.ts, 3, 17))
 
             [foo<T>()]() { }
 >foo : Symbol(foo, Decl(computedPropertyNames33_ES6.ts, 0, 0))
diff --git a/tests/baselines/reference/computedPropertyNames46_ES5.symbols b/tests/baselines/reference/computedPropertyNames46_ES5.symbols
index d103724e722e4..10a7cf0b528b7 100644
--- a/tests/baselines/reference/computedPropertyNames46_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNames46_ES5.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/computedProperties/computedPropertyNames46_ES5.ts ===
 var o = {
 >o : Symbol(o, Decl(computedPropertyNames46_ES5.ts, 0, 3))
->{    ["" || 0]: 0} : Symbol(, Decl(computedPropertyNames46_ES5.ts, 0, 7))
 
     ["" || 0]: 0
 };
diff --git a/tests/baselines/reference/computedPropertyNames46_ES6.symbols b/tests/baselines/reference/computedPropertyNames46_ES6.symbols
index 6bf06442d9c52..3028eb8e225e0 100644
--- a/tests/baselines/reference/computedPropertyNames46_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNames46_ES6.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/computedProperties/computedPropertyNames46_ES6.ts ===
 var o = {
 >o : Symbol(o, Decl(computedPropertyNames46_ES6.ts, 0, 3))
->{    ["" || 0]: 0} : Symbol(, Decl(computedPropertyNames46_ES6.ts, 0, 7))
 
     ["" || 0]: 0
 };
diff --git a/tests/baselines/reference/computedPropertyNames47_ES5.symbols b/tests/baselines/reference/computedPropertyNames47_ES5.symbols
index 5345933a3372a..c124850e5a614 100644
--- a/tests/baselines/reference/computedPropertyNames47_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNames47_ES5.symbols
@@ -9,7 +9,6 @@ enum E2 { x }
 
 var o = {
 >o : Symbol(o, Decl(computedPropertyNames47_ES5.ts, 2, 3))
->{    [E1.x || E2.x]: 0} : Symbol(, Decl(computedPropertyNames47_ES5.ts, 2, 7))
 
     [E1.x || E2.x]: 0
 >E1.x : Symbol(E1.x, Decl(computedPropertyNames47_ES5.ts, 0, 9))
diff --git a/tests/baselines/reference/computedPropertyNames47_ES6.symbols b/tests/baselines/reference/computedPropertyNames47_ES6.symbols
index f66d92def1fd5..ec0850d5b139a 100644
--- a/tests/baselines/reference/computedPropertyNames47_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNames47_ES6.symbols
@@ -9,7 +9,6 @@ enum E2 { x }
 
 var o = {
 >o : Symbol(o, Decl(computedPropertyNames47_ES6.ts, 2, 3))
->{    [E1.x || E2.x]: 0} : Symbol(, Decl(computedPropertyNames47_ES6.ts, 2, 7))
 
     [E1.x || E2.x]: 0
 >E1.x : Symbol(E1.x, Decl(computedPropertyNames47_ES6.ts, 0, 9))
diff --git a/tests/baselines/reference/computedPropertyNames48_ES5.symbols b/tests/baselines/reference/computedPropertyNames48_ES5.symbols
index 30dba22c873b0..14f7cc6352de9 100644
--- a/tests/baselines/reference/computedPropertyNames48_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNames48_ES5.symbols
@@ -16,7 +16,6 @@ var a: any;
 
 extractIndexer({
 >extractIndexer : Symbol(extractIndexer, Decl(computedPropertyNames48_ES5.ts, 0, 0))
->{    [a]: ""} : Symbol(, Decl(computedPropertyNames48_ES5.ts, 6, 15))
 
     [a]: ""
 >a : Symbol(a, Decl(computedPropertyNames48_ES5.ts, 4, 3))
@@ -25,7 +24,6 @@ extractIndexer({
 
 extractIndexer({
 >extractIndexer : Symbol(extractIndexer, Decl(computedPropertyNames48_ES5.ts, 0, 0))
->{    [E.x]: ""} : Symbol(, Decl(computedPropertyNames48_ES5.ts, 10, 15))
 
     [E.x]: ""
 >E.x : Symbol(E.x, Decl(computedPropertyNames48_ES5.ts, 2, 8))
@@ -36,7 +34,6 @@ extractIndexer({
 
 extractIndexer({
 >extractIndexer : Symbol(extractIndexer, Decl(computedPropertyNames48_ES5.ts, 0, 0))
->{    ["" || 0]: ""} : Symbol(, Decl(computedPropertyNames48_ES5.ts, 14, 15))
 
     ["" || 0]: ""
 }); // Should return any (widened form of undefined)
diff --git a/tests/baselines/reference/computedPropertyNames48_ES6.symbols b/tests/baselines/reference/computedPropertyNames48_ES6.symbols
index dd4d253fe1ffc..5d63c9f495db3 100644
--- a/tests/baselines/reference/computedPropertyNames48_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNames48_ES6.symbols
@@ -16,7 +16,6 @@ var a: any;
 
 extractIndexer({
 >extractIndexer : Symbol(extractIndexer, Decl(computedPropertyNames48_ES6.ts, 0, 0))
->{    [a]: ""} : Symbol(, Decl(computedPropertyNames48_ES6.ts, 6, 15))
 
     [a]: ""
 >a : Symbol(a, Decl(computedPropertyNames48_ES6.ts, 4, 3))
@@ -25,7 +24,6 @@ extractIndexer({
 
 extractIndexer({
 >extractIndexer : Symbol(extractIndexer, Decl(computedPropertyNames48_ES6.ts, 0, 0))
->{    [E.x]: ""} : Symbol(, Decl(computedPropertyNames48_ES6.ts, 10, 15))
 
     [E.x]: ""
 >E.x : Symbol(E.x, Decl(computedPropertyNames48_ES6.ts, 2, 8))
@@ -36,7 +34,6 @@ extractIndexer({
 
 extractIndexer({
 >extractIndexer : Symbol(extractIndexer, Decl(computedPropertyNames48_ES6.ts, 0, 0))
->{    ["" || 0]: ""} : Symbol(, Decl(computedPropertyNames48_ES6.ts, 14, 15))
 
     ["" || 0]: ""
 }); // Should return any (widened form of undefined)
diff --git a/tests/baselines/reference/computedPropertyNames4_ES5.symbols b/tests/baselines/reference/computedPropertyNames4_ES5.symbols
index d0511ec8ec2ea..be2014862864c 100644
--- a/tests/baselines/reference/computedPropertyNames4_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNames4_ES5.symbols
@@ -10,7 +10,6 @@ var a: any;
 
 var v = {
 >v : Symbol(v, Decl(computedPropertyNames4_ES5.ts, 3, 3))
->{    [s]: 0,    [n]: n,    [s + s]: 1,    [s + n]: 2,    [+s]: s,    [""]: 0,    [0]: 0,    [a]: 1,    [<any>true]: 0,    [`hello bye`]: 0,    [`hello ${a} bye`]: 0} : Symbol(, Decl(computedPropertyNames4_ES5.ts, 3, 7))
 
     [s]: 0,
 >s : Symbol(s, Decl(computedPropertyNames4_ES5.ts, 0, 3))
diff --git a/tests/baselines/reference/computedPropertyNames4_ES6.symbols b/tests/baselines/reference/computedPropertyNames4_ES6.symbols
index 1096c4a0b93da..b531a1b3d2844 100644
--- a/tests/baselines/reference/computedPropertyNames4_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNames4_ES6.symbols
@@ -10,7 +10,6 @@ var a: any;
 
 var v = {
 >v : Symbol(v, Decl(computedPropertyNames4_ES6.ts, 3, 3))
->{    [s]: 0,    [n]: n,    [s + s]: 1,    [s + n]: 2,    [+s]: s,    [""]: 0,    [0]: 0,    [a]: 1,    [<any>true]: 0,    [`hello bye`]: 0,    [`hello ${a} bye`]: 0} : Symbol(, Decl(computedPropertyNames4_ES6.ts, 3, 7))
 
     [s]: 0,
 >s : Symbol(s, Decl(computedPropertyNames4_ES6.ts, 0, 3))
diff --git a/tests/baselines/reference/computedPropertyNames7_ES5.symbols b/tests/baselines/reference/computedPropertyNames7_ES5.symbols
index 26a4905708b74..7f5e7c0fd461a 100644
--- a/tests/baselines/reference/computedPropertyNames7_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNames7_ES5.symbols
@@ -7,7 +7,6 @@ enum E {
 }
 var v = {
 >v : Symbol(v, Decl(computedPropertyNames7_ES5.ts, 3, 3))
->{    [E.member]: 0} : Symbol(, Decl(computedPropertyNames7_ES5.ts, 3, 7))
 
     [E.member]: 0
 >E.member : Symbol(E.member, Decl(computedPropertyNames7_ES5.ts, 0, 8))
diff --git a/tests/baselines/reference/computedPropertyNames7_ES6.symbols b/tests/baselines/reference/computedPropertyNames7_ES6.symbols
index f93cf1f1b4d77..b008d47a8438a 100644
--- a/tests/baselines/reference/computedPropertyNames7_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNames7_ES6.symbols
@@ -7,7 +7,6 @@ enum E {
 }
 var v = {
 >v : Symbol(v, Decl(computedPropertyNames7_ES6.ts, 3, 3))
->{    [E.member]: 0} : Symbol(, Decl(computedPropertyNames7_ES6.ts, 3, 7))
 
     [E.member]: 0
 >E.member : Symbol(E.member, Decl(computedPropertyNames7_ES6.ts, 0, 8))
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType1_ES5.symbols b/tests/baselines/reference/computedPropertyNamesContextualType1_ES5.symbols
index fc798c000a8d3..a99a38997256f 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType1_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNamesContextualType1_ES5.symbols
@@ -14,7 +14,6 @@ interface I {
 var o: I = {
 >o : Symbol(o, Decl(computedPropertyNamesContextualType1_ES5.ts, 5, 3))
 >I : Symbol(I, Decl(computedPropertyNamesContextualType1_ES5.ts, 0, 0))
->{    ["" + 0](y) { return y.length; },    ["" + 1]: y => y.length} : Symbol(, Decl(computedPropertyNamesContextualType1_ES5.ts, 5, 10))
 
     ["" + 0](y) { return y.length; },
 >y : Symbol(y, Decl(computedPropertyNamesContextualType1_ES5.ts, 6, 13))
@@ -23,7 +22,6 @@ var o: I = {
 >length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 
     ["" + 1]: y => y.length
->y => y.length : Symbol((Anonymous function), Decl(computedPropertyNamesContextualType1_ES5.ts, 7, 13))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType1_ES5.ts, 7, 13))
 >y.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType1_ES5.ts, 7, 13))
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType1_ES6.symbols b/tests/baselines/reference/computedPropertyNamesContextualType1_ES6.symbols
index 1af11451cb390..e386b8e9efa94 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType1_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNamesContextualType1_ES6.symbols
@@ -14,7 +14,6 @@ interface I {
 var o: I = {
 >o : Symbol(o, Decl(computedPropertyNamesContextualType1_ES6.ts, 5, 3))
 >I : Symbol(I, Decl(computedPropertyNamesContextualType1_ES6.ts, 0, 0))
->{    ["" + 0](y) { return y.length; },    ["" + 1]: y => y.length} : Symbol(, Decl(computedPropertyNamesContextualType1_ES6.ts, 5, 10))
 
     ["" + 0](y) { return y.length; },
 >y : Symbol(y, Decl(computedPropertyNamesContextualType1_ES6.ts, 6, 13))
@@ -23,7 +22,6 @@ var o: I = {
 >length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 
     ["" + 1]: y => y.length
->y => y.length : Symbol((Anonymous function), Decl(computedPropertyNamesContextualType1_ES6.ts, 7, 13))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType1_ES6.ts, 7, 13))
 >y.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType1_ES6.ts, 7, 13))
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType2_ES5.symbols b/tests/baselines/reference/computedPropertyNamesContextualType2_ES5.symbols
index 13eb10f816095..fcd89e032e646 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType2_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNamesContextualType2_ES5.symbols
@@ -14,7 +14,6 @@ interface I {
 var o: I = {
 >o : Symbol(o, Decl(computedPropertyNamesContextualType2_ES5.ts, 5, 3))
 >I : Symbol(I, Decl(computedPropertyNamesContextualType2_ES5.ts, 0, 0))
->{    [+"foo"](y) { return y.length; },    [+"bar"]: y => y.length} : Symbol(, Decl(computedPropertyNamesContextualType2_ES5.ts, 5, 10))
 
     [+"foo"](y) { return y.length; },
 >y : Symbol(y, Decl(computedPropertyNamesContextualType2_ES5.ts, 6, 13))
@@ -23,7 +22,6 @@ var o: I = {
 >length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 
     [+"bar"]: y => y.length
->y => y.length : Symbol((Anonymous function), Decl(computedPropertyNamesContextualType2_ES5.ts, 7, 13))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType2_ES5.ts, 7, 13))
 >y.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType2_ES5.ts, 7, 13))
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType2_ES6.symbols b/tests/baselines/reference/computedPropertyNamesContextualType2_ES6.symbols
index 4554b1d8ecf4d..ce6be5194c055 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType2_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNamesContextualType2_ES6.symbols
@@ -14,7 +14,6 @@ interface I {
 var o: I = {
 >o : Symbol(o, Decl(computedPropertyNamesContextualType2_ES6.ts, 5, 3))
 >I : Symbol(I, Decl(computedPropertyNamesContextualType2_ES6.ts, 0, 0))
->{    [+"foo"](y) { return y.length; },    [+"bar"]: y => y.length} : Symbol(, Decl(computedPropertyNamesContextualType2_ES6.ts, 5, 10))
 
     [+"foo"](y) { return y.length; },
 >y : Symbol(y, Decl(computedPropertyNamesContextualType2_ES6.ts, 6, 13))
@@ -23,7 +22,6 @@ var o: I = {
 >length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 
     [+"bar"]: y => y.length
->y => y.length : Symbol((Anonymous function), Decl(computedPropertyNamesContextualType2_ES6.ts, 7, 13))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType2_ES6.ts, 7, 13))
 >y.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType2_ES6.ts, 7, 13))
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType3_ES5.symbols b/tests/baselines/reference/computedPropertyNamesContextualType3_ES5.symbols
index a7a4daef68f49..d73c9c186d4b4 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType3_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNamesContextualType3_ES5.symbols
@@ -10,7 +10,6 @@ interface I {
 var o: I = {
 >o : Symbol(o, Decl(computedPropertyNamesContextualType3_ES5.ts, 4, 3))
 >I : Symbol(I, Decl(computedPropertyNamesContextualType3_ES5.ts, 0, 0))
->{    [+"foo"](y) { return y.length; },    [+"bar"]: y => y.length} : Symbol(, Decl(computedPropertyNamesContextualType3_ES5.ts, 4, 10))
 
     [+"foo"](y) { return y.length; },
 >y : Symbol(y, Decl(computedPropertyNamesContextualType3_ES5.ts, 5, 13))
@@ -19,7 +18,6 @@ var o: I = {
 >length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 
     [+"bar"]: y => y.length
->y => y.length : Symbol((Anonymous function), Decl(computedPropertyNamesContextualType3_ES5.ts, 6, 13))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType3_ES5.ts, 6, 13))
 >y.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType3_ES5.ts, 6, 13))
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType3_ES6.symbols b/tests/baselines/reference/computedPropertyNamesContextualType3_ES6.symbols
index ebc20976575de..48e93ee62f971 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType3_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNamesContextualType3_ES6.symbols
@@ -10,7 +10,6 @@ interface I {
 var o: I = {
 >o : Symbol(o, Decl(computedPropertyNamesContextualType3_ES6.ts, 4, 3))
 >I : Symbol(I, Decl(computedPropertyNamesContextualType3_ES6.ts, 0, 0))
->{    [+"foo"](y) { return y.length; },    [+"bar"]: y => y.length} : Symbol(, Decl(computedPropertyNamesContextualType3_ES6.ts, 4, 10))
 
     [+"foo"](y) { return y.length; },
 >y : Symbol(y, Decl(computedPropertyNamesContextualType3_ES6.ts, 5, 13))
@@ -19,7 +18,6 @@ var o: I = {
 >length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 
     [+"bar"]: y => y.length
->y => y.length : Symbol((Anonymous function), Decl(computedPropertyNamesContextualType3_ES6.ts, 6, 13))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType3_ES6.ts, 6, 13))
 >y.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType3_ES6.ts, 6, 13))
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType4_ES5.symbols b/tests/baselines/reference/computedPropertyNamesContextualType4_ES5.symbols
index 7441cd39039de..f6f19f3fd61e0 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType4_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNamesContextualType4_ES5.symbols
@@ -12,7 +12,6 @@ interface I {
 var o: I = {
 >o : Symbol(o, Decl(computedPropertyNamesContextualType4_ES5.ts, 5, 3))
 >I : Symbol(I, Decl(computedPropertyNamesContextualType4_ES5.ts, 0, 0))
->{    [""+"foo"]: "",    [""+"bar"]: 0} : Symbol(, Decl(computedPropertyNamesContextualType4_ES5.ts, 5, 10))
 
     [""+"foo"]: "",
     [""+"bar"]: 0
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType4_ES6.symbols b/tests/baselines/reference/computedPropertyNamesContextualType4_ES6.symbols
index 5884b2b60e0e3..184a561425cce 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType4_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNamesContextualType4_ES6.symbols
@@ -12,7 +12,6 @@ interface I {
 var o: I = {
 >o : Symbol(o, Decl(computedPropertyNamesContextualType4_ES6.ts, 5, 3))
 >I : Symbol(I, Decl(computedPropertyNamesContextualType4_ES6.ts, 0, 0))
->{    [""+"foo"]: "",    [""+"bar"]: 0} : Symbol(, Decl(computedPropertyNamesContextualType4_ES6.ts, 5, 10))
 
     [""+"foo"]: "",
     [""+"bar"]: 0
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType5_ES5.symbols b/tests/baselines/reference/computedPropertyNamesContextualType5_ES5.symbols
index 309f0068449db..e93cf3f94a1c7 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType5_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNamesContextualType5_ES5.symbols
@@ -12,7 +12,6 @@ interface I {
 var o: I = {
 >o : Symbol(o, Decl(computedPropertyNamesContextualType5_ES5.ts, 5, 3))
 >I : Symbol(I, Decl(computedPropertyNamesContextualType5_ES5.ts, 0, 0))
->{    [+"foo"]: "",    [+"bar"]: 0} : Symbol(, Decl(computedPropertyNamesContextualType5_ES5.ts, 5, 10))
 
     [+"foo"]: "",
     [+"bar"]: 0
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType5_ES6.symbols b/tests/baselines/reference/computedPropertyNamesContextualType5_ES6.symbols
index 689abee2e6206..46212968874ae 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType5_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNamesContextualType5_ES6.symbols
@@ -12,7 +12,6 @@ interface I {
 var o: I = {
 >o : Symbol(o, Decl(computedPropertyNamesContextualType5_ES6.ts, 5, 3))
 >I : Symbol(I, Decl(computedPropertyNamesContextualType5_ES6.ts, 0, 0))
->{    [+"foo"]: "",    [+"bar"]: 0} : Symbol(, Decl(computedPropertyNamesContextualType5_ES6.ts, 5, 10))
 
     [+"foo"]: "",
     [+"bar"]: 0
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType6_ES5.symbols b/tests/baselines/reference/computedPropertyNamesContextualType6_ES5.symbols
index a4c0516c959a4..fb303b1f8b371 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType6_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNamesContextualType6_ES5.symbols
@@ -18,14 +18,11 @@ declare function foo<T>(obj: I<T>): T
 
 foo({
 >foo : Symbol(foo, Decl(computedPropertyNamesContextualType6_ES5.ts, 2, 1))
->{    p: "",    0: () => { },    ["hi" + "bye"]: true,    [0 + 1]: 0,    [+"hi"]: [0]} : Symbol(, Decl(computedPropertyNamesContextualType6_ES5.ts, 6, 4))
 
     p: "",
 >p : Symbol(p, Decl(computedPropertyNamesContextualType6_ES5.ts, 6, 5))
 
     0: () => { },
->() => { } : Symbol((Anonymous function), Decl(computedPropertyNamesContextualType6_ES5.ts, 8, 6))
-
     ["hi" + "bye"]: true,
     [0 + 1]: 0,
     [+"hi"]: [0]
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType6_ES6.symbols b/tests/baselines/reference/computedPropertyNamesContextualType6_ES6.symbols
index 8e20b6dd344cf..b3e371447e200 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType6_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNamesContextualType6_ES6.symbols
@@ -18,14 +18,11 @@ declare function foo<T>(obj: I<T>): T
 
 foo({
 >foo : Symbol(foo, Decl(computedPropertyNamesContextualType6_ES6.ts, 2, 1))
->{    p: "",    0: () => { },    ["hi" + "bye"]: true,    [0 + 1]: 0,    [+"hi"]: [0]} : Symbol(, Decl(computedPropertyNamesContextualType6_ES6.ts, 6, 4))
 
     p: "",
 >p : Symbol(p, Decl(computedPropertyNamesContextualType6_ES6.ts, 6, 5))
 
     0: () => { },
->() => { } : Symbol((Anonymous function), Decl(computedPropertyNamesContextualType6_ES6.ts, 8, 6))
-
     ["hi" + "bye"]: true,
     [0 + 1]: 0,
     [+"hi"]: [0]
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType7_ES5.symbols b/tests/baselines/reference/computedPropertyNamesContextualType7_ES5.symbols
index 7c930d33aba4f..22e4cf2b45b4e 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType7_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNamesContextualType7_ES5.symbols
@@ -18,14 +18,11 @@ declare function foo<T>(obj: I<T>): T
 
 foo({
 >foo : Symbol(foo, Decl(computedPropertyNamesContextualType7_ES5.ts, 2, 1))
->{    p: "",    0: () => { },    ["hi" + "bye"]: true,    [0 + 1]: 0,    [+"hi"]: [0]} : Symbol(, Decl(computedPropertyNamesContextualType7_ES5.ts, 6, 4))
 
     p: "",
 >p : Symbol(p, Decl(computedPropertyNamesContextualType7_ES5.ts, 6, 5))
 
     0: () => { },
->() => { } : Symbol((Anonymous function), Decl(computedPropertyNamesContextualType7_ES5.ts, 8, 6))
-
     ["hi" + "bye"]: true,
     [0 + 1]: 0,
     [+"hi"]: [0]
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType7_ES6.symbols b/tests/baselines/reference/computedPropertyNamesContextualType7_ES6.symbols
index c83adf9484344..7f33ebf58ad7e 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType7_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNamesContextualType7_ES6.symbols
@@ -18,14 +18,11 @@ declare function foo<T>(obj: I<T>): T
 
 foo({
 >foo : Symbol(foo, Decl(computedPropertyNamesContextualType7_ES6.ts, 2, 1))
->{    p: "",    0: () => { },    ["hi" + "bye"]: true,    [0 + 1]: 0,    [+"hi"]: [0]} : Symbol(, Decl(computedPropertyNamesContextualType7_ES6.ts, 6, 4))
 
     p: "",
 >p : Symbol(p, Decl(computedPropertyNamesContextualType7_ES6.ts, 6, 5))
 
     0: () => { },
->() => { } : Symbol((Anonymous function), Decl(computedPropertyNamesContextualType7_ES6.ts, 8, 6))
-
     ["hi" + "bye"]: true,
     [0 + 1]: 0,
     [+"hi"]: [0]
diff --git a/tests/baselines/reference/computedPropertyNamesDeclarationEmit5_ES5.symbols b/tests/baselines/reference/computedPropertyNamesDeclarationEmit5_ES5.symbols
index 65c62ad7656e0..8d40d4c86c0c1 100644
--- a/tests/baselines/reference/computedPropertyNamesDeclarationEmit5_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNamesDeclarationEmit5_ES5.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/computedProperties/computedPropertyNamesDeclarationEmit5_ES5.ts ===
 var v = {
 >v : Symbol(v, Decl(computedPropertyNamesDeclarationEmit5_ES5.ts, 0, 3))
->{    ["" + ""]: 0,    ["" + ""]() { },    get ["" + ""]() { return 0; },    set ["" + ""](x) { }} : Symbol(, Decl(computedPropertyNamesDeclarationEmit5_ES5.ts, 0, 7))
 
     ["" + ""]: 0,
     ["" + ""]() { },
diff --git a/tests/baselines/reference/computedPropertyNamesDeclarationEmit5_ES6.symbols b/tests/baselines/reference/computedPropertyNamesDeclarationEmit5_ES6.symbols
index 28dabbc42b1ea..e9a7b4b28abbb 100644
--- a/tests/baselines/reference/computedPropertyNamesDeclarationEmit5_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNamesDeclarationEmit5_ES6.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/computedProperties/computedPropertyNamesDeclarationEmit5_ES6.ts ===
 var v = {
 >v : Symbol(v, Decl(computedPropertyNamesDeclarationEmit5_ES6.ts, 0, 3))
->{    ["" + ""]: 0,    ["" + ""]() { },    get ["" + ""]() { return 0; },    set ["" + ""](x) { }} : Symbol(, Decl(computedPropertyNamesDeclarationEmit5_ES6.ts, 0, 7))
 
     ["" + ""]: 0,
     ["" + ""]() { },
diff --git a/tests/baselines/reference/computedPropertyNamesSourceMap2_ES5.symbols b/tests/baselines/reference/computedPropertyNamesSourceMap2_ES5.symbols
index c2e12786494fc..b9a389da6360a 100644
--- a/tests/baselines/reference/computedPropertyNamesSourceMap2_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNamesSourceMap2_ES5.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/computedProperties/computedPropertyNamesSourceMap2_ES5.ts ===
 var v = {
 >v : Symbol(v, Decl(computedPropertyNamesSourceMap2_ES5.ts, 0, 3))
->{    ["hello"]() {        debugger;    }} : Symbol(, Decl(computedPropertyNamesSourceMap2_ES5.ts, 0, 7))
 
     ["hello"]() {
         debugger;
diff --git a/tests/baselines/reference/computedPropertyNamesSourceMap2_ES6.symbols b/tests/baselines/reference/computedPropertyNamesSourceMap2_ES6.symbols
index f4ea7cce4de14..6c9d1e1d5fd34 100644
--- a/tests/baselines/reference/computedPropertyNamesSourceMap2_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNamesSourceMap2_ES6.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/computedProperties/computedPropertyNamesSourceMap2_ES6.ts ===
 var v = {
 >v : Symbol(v, Decl(computedPropertyNamesSourceMap2_ES6.ts, 0, 3))
->{    ["hello"]() {        debugger;    }} : Symbol(, Decl(computedPropertyNamesSourceMap2_ES6.ts, 0, 7))
 
     ["hello"]() {
         debugger;
diff --git a/tests/baselines/reference/conditionalExpressions2.symbols b/tests/baselines/reference/conditionalExpressions2.symbols
index fab59c38fd5f2..63c8b41747756 100644
--- a/tests/baselines/reference/conditionalExpressions2.symbols
+++ b/tests/baselines/reference/conditionalExpressions2.symbols
@@ -21,16 +21,13 @@ var f = false ? null : undefined;
 
 var g = true ? {g:5} : null;
 >g : Symbol(g, Decl(conditionalExpressions2.ts, 6, 3))
->{g:5} : Symbol(, Decl(conditionalExpressions2.ts, 6, 14))
 >g : Symbol(g, Decl(conditionalExpressions2.ts, 6, 16))
 
 var h = [{h:5}, null];
 >h : Symbol(h, Decl(conditionalExpressions2.ts, 7, 3))
->{h:5} : Symbol(, Decl(conditionalExpressions2.ts, 7, 9))
 >h : Symbol(h, Decl(conditionalExpressions2.ts, 7, 10))
 
 function i() { if (true) { return { x: 5 }; } else { return null; } }
 >i : Symbol(i, Decl(conditionalExpressions2.ts, 7, 22))
->{ x: 5 } : Symbol(, Decl(conditionalExpressions2.ts, 8, 33))
 >x : Symbol(x, Decl(conditionalExpressions2.ts, 8, 35))
 
diff --git a/tests/baselines/reference/conditionalOperatorConditionIsObjectType.symbols b/tests/baselines/reference/conditionalOperatorConditionIsObjectType.symbols
index 9a09246d54b31..41f00e53b2627 100644
--- a/tests/baselines/reference/conditionalOperatorConditionIsObjectType.symbols
+++ b/tests/baselines/reference/conditionalOperatorConditionIsObjectType.symbols
@@ -76,7 +76,6 @@ condObject ? exprString1 : exprBoolean1; // union
 
 //Cond is an object type literal
 ((a: string) => a.length) ? exprAny1 : exprAny2;
->(a: string) => a.length : Symbol((Anonymous function), Decl(conditionalOperatorConditionIsObjectType.ts, 27, 1))
 >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 27, 2))
 >a.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 27, 2))
@@ -85,7 +84,6 @@ condObject ? exprString1 : exprBoolean1; // union
 >exprAny2 : Symbol(exprAny2, Decl(conditionalOperatorConditionIsObjectType.ts, 9, 3))
 
 ((a: string) => a.length) ? exprBoolean1 : exprBoolean2;
->(a: string) => a.length : Symbol((Anonymous function), Decl(conditionalOperatorConditionIsObjectType.ts, 28, 1))
 >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 28, 2))
 >a.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 28, 2))
@@ -94,26 +92,22 @@ condObject ? exprString1 : exprBoolean1; // union
 >exprBoolean2 : Symbol(exprBoolean2, Decl(conditionalOperatorConditionIsObjectType.ts, 10, 3))
 
 ({}) ? exprNumber1 : exprNumber2;
->{} : Symbol(, Decl(conditionalOperatorConditionIsObjectType.ts, 29, 1))
 >exprNumber1 : Symbol(exprNumber1, Decl(conditionalOperatorConditionIsObjectType.ts, 5, 3))
 >exprNumber2 : Symbol(exprNumber2, Decl(conditionalOperatorConditionIsObjectType.ts, 11, 3))
 
 ({ a: 1, b: "s" }) ? exprString1 : exprString2;
->{ a: 1, b: "s" } : Symbol(, Decl(conditionalOperatorConditionIsObjectType.ts, 30, 1))
 >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 30, 2))
 >b : Symbol(b, Decl(conditionalOperatorConditionIsObjectType.ts, 30, 8))
 >exprString1 : Symbol(exprString1, Decl(conditionalOperatorConditionIsObjectType.ts, 6, 3))
 >exprString2 : Symbol(exprString2, Decl(conditionalOperatorConditionIsObjectType.ts, 12, 3))
 
 ({ a: 1, b: "s" }) ? exprIsObject1 : exprIsObject2;
->{ a: 1, b: "s" } : Symbol(, Decl(conditionalOperatorConditionIsObjectType.ts, 31, 1))
 >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 31, 2))
 >b : Symbol(b, Decl(conditionalOperatorConditionIsObjectType.ts, 31, 8))
 >exprIsObject1 : Symbol(exprIsObject1, Decl(conditionalOperatorConditionIsObjectType.ts, 7, 3))
 >exprIsObject2 : Symbol(exprIsObject2, Decl(conditionalOperatorConditionIsObjectType.ts, 13, 3))
 
 ({ a: 1, b: "s" }) ? exprString1: exprBoolean1; // union
->{ a: 1, b: "s" } : Symbol(, Decl(conditionalOperatorConditionIsObjectType.ts, 32, 1))
 >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 32, 2))
 >b : Symbol(b, Decl(conditionalOperatorConditionIsObjectType.ts, 32, 8))
 >exprString1 : Symbol(exprString1, Decl(conditionalOperatorConditionIsObjectType.ts, 6, 3))
@@ -193,7 +187,6 @@ var resultIsStringOrBoolean1 = condObject ? exprString1 : exprBoolean1; // union
 
 var resultIsAny2 = ((a: string) => a.length) ? exprAny1 : exprAny2;
 >resultIsAny2 : Symbol(resultIsAny2, Decl(conditionalOperatorConditionIsObjectType.ts, 50, 3))
->(a: string) => a.length : Symbol((Anonymous function), Decl(conditionalOperatorConditionIsObjectType.ts, 50, 20))
 >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 50, 21))
 >a.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 50, 21))
@@ -203,7 +196,6 @@ var resultIsAny2 = ((a: string) => a.length) ? exprAny1 : exprAny2;
 
 var resultIsBoolean2 = ((a: string) => a.length) ? exprBoolean1 : exprBoolean2;
 >resultIsBoolean2 : Symbol(resultIsBoolean2, Decl(conditionalOperatorConditionIsObjectType.ts, 51, 3))
->(a: string) => a.length : Symbol((Anonymous function), Decl(conditionalOperatorConditionIsObjectType.ts, 51, 24))
 >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 51, 25))
 >a.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 51, 25))
@@ -213,13 +205,11 @@ var resultIsBoolean2 = ((a: string) => a.length) ? exprBoolean1 : exprBoolean2;
 
 var resultIsNumber2 = ({}) ? exprNumber1 : exprNumber2;
 >resultIsNumber2 : Symbol(resultIsNumber2, Decl(conditionalOperatorConditionIsObjectType.ts, 52, 3))
->{} : Symbol(, Decl(conditionalOperatorConditionIsObjectType.ts, 52, 23))
 >exprNumber1 : Symbol(exprNumber1, Decl(conditionalOperatorConditionIsObjectType.ts, 5, 3))
 >exprNumber2 : Symbol(exprNumber2, Decl(conditionalOperatorConditionIsObjectType.ts, 11, 3))
 
 var resultIsString2 = ({ a: 1, b: "s" }) ? exprString1 : exprString2;
 >resultIsString2 : Symbol(resultIsString2, Decl(conditionalOperatorConditionIsObjectType.ts, 53, 3))
->{ a: 1, b: "s" } : Symbol(, Decl(conditionalOperatorConditionIsObjectType.ts, 53, 23))
 >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 53, 24))
 >b : Symbol(b, Decl(conditionalOperatorConditionIsObjectType.ts, 53, 30))
 >exprString1 : Symbol(exprString1, Decl(conditionalOperatorConditionIsObjectType.ts, 6, 3))
@@ -227,7 +217,6 @@ var resultIsString2 = ({ a: 1, b: "s" }) ? exprString1 : exprString2;
 
 var resultIsObject2 = ({ a: 1, b: "s" }) ? exprIsObject1 : exprIsObject2;
 >resultIsObject2 : Symbol(resultIsObject2, Decl(conditionalOperatorConditionIsObjectType.ts, 54, 3))
->{ a: 1, b: "s" } : Symbol(, Decl(conditionalOperatorConditionIsObjectType.ts, 54, 23))
 >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 54, 24))
 >b : Symbol(b, Decl(conditionalOperatorConditionIsObjectType.ts, 54, 30))
 >exprIsObject1 : Symbol(exprIsObject1, Decl(conditionalOperatorConditionIsObjectType.ts, 7, 3))
@@ -235,7 +224,6 @@ var resultIsObject2 = ({ a: 1, b: "s" }) ? exprIsObject1 : exprIsObject2;
 
 var resultIsStringOrBoolean2 = ({ a: 1, b: "s" }) ? exprString1 : exprBoolean1; // union
 >resultIsStringOrBoolean2 : Symbol(resultIsStringOrBoolean2, Decl(conditionalOperatorConditionIsObjectType.ts, 55, 3))
->{ a: 1, b: "s" } : Symbol(, Decl(conditionalOperatorConditionIsObjectType.ts, 55, 32))
 >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 55, 33))
 >b : Symbol(b, Decl(conditionalOperatorConditionIsObjectType.ts, 55, 39))
 >exprString1 : Symbol(exprString1, Decl(conditionalOperatorConditionIsObjectType.ts, 6, 3))
diff --git a/tests/baselines/reference/conditionalOperatorWithIdenticalBCT.symbols b/tests/baselines/reference/conditionalOperatorWithIdenticalBCT.symbols
index 61be0bf40e177..e4c2e43013dc2 100644
--- a/tests/baselines/reference/conditionalOperatorWithIdenticalBCT.symbols
+++ b/tests/baselines/reference/conditionalOperatorWithIdenticalBCT.symbols
@@ -41,24 +41,17 @@ var result1 = true ? x : a;
 
 //Expr1 and Expr2 are literals
 true ? {} : 1;
->{} : Symbol(, Decl(conditionalOperatorWithIdenticalBCT.ts, 15, 6))
-
 true ? { a: 1 } : { a: 2, b: 'string' };
->{ a: 1 } : Symbol(, Decl(conditionalOperatorWithIdenticalBCT.ts, 16, 6))
 >a : Symbol(a, Decl(conditionalOperatorWithIdenticalBCT.ts, 16, 8))
->{ a: 2, b: 'string' } : Symbol(, Decl(conditionalOperatorWithIdenticalBCT.ts, 16, 17))
 >a : Symbol(a, Decl(conditionalOperatorWithIdenticalBCT.ts, 16, 19))
 >b : Symbol(b, Decl(conditionalOperatorWithIdenticalBCT.ts, 16, 25))
 
 var result2 = true ? {} : 1;
 >result2 : Symbol(result2, Decl(conditionalOperatorWithIdenticalBCT.ts, 17, 3))
->{} : Symbol(, Decl(conditionalOperatorWithIdenticalBCT.ts, 17, 20))
 
 var result3 = true ? { a: 1 } : { a: 2, b: 'string' };
 >result3 : Symbol(result3, Decl(conditionalOperatorWithIdenticalBCT.ts, 18, 3))
->{ a: 1 } : Symbol(, Decl(conditionalOperatorWithIdenticalBCT.ts, 18, 20))
 >a : Symbol(a, Decl(conditionalOperatorWithIdenticalBCT.ts, 18, 22))
->{ a: 2, b: 'string' } : Symbol(, Decl(conditionalOperatorWithIdenticalBCT.ts, 18, 31))
 >a : Symbol(a, Decl(conditionalOperatorWithIdenticalBCT.ts, 18, 33))
 >b : Symbol(b, Decl(conditionalOperatorWithIdenticalBCT.ts, 18, 39))
 
@@ -73,12 +66,10 @@ var result4: (t: A) => any = true ? (m) => m.propertyX : (n) => n.propertyA;
 >result4 : Symbol(result4, Decl(conditionalOperatorWithIdenticalBCT.ts, 22, 3))
 >t : Symbol(t, Decl(conditionalOperatorWithIdenticalBCT.ts, 22, 14))
 >A : Symbol(A, Decl(conditionalOperatorWithIdenticalBCT.ts, 1, 67))
->(m) => m.propertyX : Symbol((Anonymous function), Decl(conditionalOperatorWithIdenticalBCT.ts, 22, 35))
 >m : Symbol(m, Decl(conditionalOperatorWithIdenticalBCT.ts, 22, 37))
 >m.propertyX : Symbol(X.propertyX, Decl(conditionalOperatorWithIdenticalBCT.ts, 1, 9))
 >m : Symbol(m, Decl(conditionalOperatorWithIdenticalBCT.ts, 22, 37))
 >propertyX : Symbol(X.propertyX, Decl(conditionalOperatorWithIdenticalBCT.ts, 1, 9))
->(n) => n.propertyA : Symbol((Anonymous function), Decl(conditionalOperatorWithIdenticalBCT.ts, 22, 56))
 >n : Symbol(n, Decl(conditionalOperatorWithIdenticalBCT.ts, 22, 58))
 >n.propertyA : Symbol(A.propertyA, Decl(conditionalOperatorWithIdenticalBCT.ts, 2, 19))
 >n : Symbol(n, Decl(conditionalOperatorWithIdenticalBCT.ts, 22, 58))
@@ -97,25 +88,18 @@ var result5 = true ? a : x;
 
 //Expr1 and Expr2 are literals
 true ? 1 : {};
->{} : Symbol(, Decl(conditionalOperatorWithIdenticalBCT.ts, 30, 10))
-
 true ? { a: 2, b: 'string' } : { a: 1 };
->{ a: 2, b: 'string' } : Symbol(, Decl(conditionalOperatorWithIdenticalBCT.ts, 31, 6))
 >a : Symbol(a, Decl(conditionalOperatorWithIdenticalBCT.ts, 31, 8))
 >b : Symbol(b, Decl(conditionalOperatorWithIdenticalBCT.ts, 31, 14))
->{ a: 1 } : Symbol(, Decl(conditionalOperatorWithIdenticalBCT.ts, 31, 30))
 >a : Symbol(a, Decl(conditionalOperatorWithIdenticalBCT.ts, 31, 32))
 
 var result6 = true ? 1 : {};
 >result6 : Symbol(result6, Decl(conditionalOperatorWithIdenticalBCT.ts, 32, 3))
->{} : Symbol(, Decl(conditionalOperatorWithIdenticalBCT.ts, 32, 24))
 
 var result7 = true ? { a: 2, b: 'string' } : { a: 1 };
 >result7 : Symbol(result7, Decl(conditionalOperatorWithIdenticalBCT.ts, 33, 3))
->{ a: 2, b: 'string' } : Symbol(, Decl(conditionalOperatorWithIdenticalBCT.ts, 33, 20))
 >a : Symbol(a, Decl(conditionalOperatorWithIdenticalBCT.ts, 33, 22))
 >b : Symbol(b, Decl(conditionalOperatorWithIdenticalBCT.ts, 33, 28))
->{ a: 1 } : Symbol(, Decl(conditionalOperatorWithIdenticalBCT.ts, 33, 44))
 >a : Symbol(a, Decl(conditionalOperatorWithIdenticalBCT.ts, 33, 46))
 
 //Contextually typed
@@ -129,12 +113,10 @@ var result8: (t: A) => any = true ? (m) => m.propertyA : (n) => n.propertyX;
 >result8 : Symbol(result8, Decl(conditionalOperatorWithIdenticalBCT.ts, 37, 3))
 >t : Symbol(t, Decl(conditionalOperatorWithIdenticalBCT.ts, 37, 14))
 >A : Symbol(A, Decl(conditionalOperatorWithIdenticalBCT.ts, 1, 67))
->(m) => m.propertyA : Symbol((Anonymous function), Decl(conditionalOperatorWithIdenticalBCT.ts, 37, 35))
 >m : Symbol(m, Decl(conditionalOperatorWithIdenticalBCT.ts, 37, 37))
 >m.propertyA : Symbol(A.propertyA, Decl(conditionalOperatorWithIdenticalBCT.ts, 2, 19))
 >m : Symbol(m, Decl(conditionalOperatorWithIdenticalBCT.ts, 37, 37))
 >propertyA : Symbol(A.propertyA, Decl(conditionalOperatorWithIdenticalBCT.ts, 2, 19))
->(n) => n.propertyX : Symbol((Anonymous function), Decl(conditionalOperatorWithIdenticalBCT.ts, 37, 56))
 >n : Symbol(n, Decl(conditionalOperatorWithIdenticalBCT.ts, 37, 58))
 >n.propertyX : Symbol(X.propertyX, Decl(conditionalOperatorWithIdenticalBCT.ts, 1, 9))
 >n : Symbol(n, Decl(conditionalOperatorWithIdenticalBCT.ts, 37, 58))
@@ -152,12 +134,10 @@ var result10: (t: X) => any = true ? (m) => m.propertyX1 : (n) => n.propertyX2;
 >result10 : Symbol(result10, Decl(conditionalOperatorWithIdenticalBCT.ts, 42, 3))
 >t : Symbol(t, Decl(conditionalOperatorWithIdenticalBCT.ts, 42, 15))
 >X : Symbol(X, Decl(conditionalOperatorWithIdenticalBCT.ts, 0, 0))
->(m) => m.propertyX1 : Symbol((Anonymous function), Decl(conditionalOperatorWithIdenticalBCT.ts, 42, 36))
 >m : Symbol(m, Decl(conditionalOperatorWithIdenticalBCT.ts, 42, 38))
 >m.propertyX1 : Symbol(X.propertyX1, Decl(conditionalOperatorWithIdenticalBCT.ts, 1, 25))
 >m : Symbol(m, Decl(conditionalOperatorWithIdenticalBCT.ts, 42, 38))
 >propertyX1 : Symbol(X.propertyX1, Decl(conditionalOperatorWithIdenticalBCT.ts, 1, 25))
->(n) => n.propertyX2 : Symbol((Anonymous function), Decl(conditionalOperatorWithIdenticalBCT.ts, 42, 58))
 >n : Symbol(n, Decl(conditionalOperatorWithIdenticalBCT.ts, 42, 60))
 >n.propertyX2 : Symbol(X.propertyX2, Decl(conditionalOperatorWithIdenticalBCT.ts, 1, 45))
 >n : Symbol(n, Decl(conditionalOperatorWithIdenticalBCT.ts, 42, 60))
diff --git a/tests/baselines/reference/conditionallyDuplicateOverloadsCausedByOverloadResolution.symbols b/tests/baselines/reference/conditionallyDuplicateOverloadsCausedByOverloadResolution.symbols
index d76ca50cb119d..85f6c7ee4eb6f 100644
--- a/tests/baselines/reference/conditionallyDuplicateOverloadsCausedByOverloadResolution.symbols
+++ b/tests/baselines/reference/conditionallyDuplicateOverloadsCausedByOverloadResolution.symbols
@@ -14,7 +14,6 @@ declare function foo(func: (x: string, y: number) => any): string;
 var out = foo((x, y) => {
 >out : Symbol(out, Decl(conditionallyDuplicateOverloadsCausedByOverloadResolution.ts, 3, 3))
 >foo : Symbol(foo, Decl(conditionallyDuplicateOverloadsCausedByOverloadResolution.ts, 0, 0), Decl(conditionallyDuplicateOverloadsCausedByOverloadResolution.ts, 0, 67))
->(x, y) => {    function bar(a: typeof x): void;    function bar(b: typeof y): void;    function bar() { }    return bar;} : Symbol((Anonymous function), Decl(conditionallyDuplicateOverloadsCausedByOverloadResolution.ts, 3, 14))
 >x : Symbol(x, Decl(conditionallyDuplicateOverloadsCausedByOverloadResolution.ts, 3, 15))
 >y : Symbol(y, Decl(conditionallyDuplicateOverloadsCausedByOverloadResolution.ts, 3, 17))
 
@@ -51,7 +50,6 @@ declare function foo2(func: (x: string, y: number) => any): string;
 var out2 = foo2((x, y) => {
 >out2 : Symbol(out2, Decl(conditionallyDuplicateOverloadsCausedByOverloadResolution.ts, 13, 3))
 >foo2 : Symbol(foo2, Decl(conditionallyDuplicateOverloadsCausedByOverloadResolution.ts, 8, 3), Decl(conditionallyDuplicateOverloadsCausedByOverloadResolution.ts, 10, 68))
->(x, y) => {    var bar: {        (a: typeof x): void;        (b: typeof y): void;    };    return bar;} : Symbol((Anonymous function), Decl(conditionallyDuplicateOverloadsCausedByOverloadResolution.ts, 13, 16))
 >x : Symbol(x, Decl(conditionallyDuplicateOverloadsCausedByOverloadResolution.ts, 13, 17))
 >y : Symbol(y, Decl(conditionallyDuplicateOverloadsCausedByOverloadResolution.ts, 13, 19))
 
diff --git a/tests/baselines/reference/constEnumPropertyAccess1.symbols b/tests/baselines/reference/constEnumPropertyAccess1.symbols
index 065e8e367e638..e5f2853f15738 100644
--- a/tests/baselines/reference/constEnumPropertyAccess1.symbols
+++ b/tests/baselines/reference/constEnumPropertyAccess1.symbols
@@ -30,8 +30,6 @@ var o: {
 >idx : Symbol(idx, Decl(constEnumPropertyAccess1.ts, 13, 5))
 
 } = {
->{        1: true    } : Symbol(, Decl(constEnumPropertyAccess1.ts, 14, 3))
-
         1: true
     };
 
diff --git a/tests/baselines/reference/constraintSatisfactionWithEmptyObject.symbols b/tests/baselines/reference/constraintSatisfactionWithEmptyObject.symbols
index b45119e9cb9b4..fd5aae69b86c7 100644
--- a/tests/baselines/reference/constraintSatisfactionWithEmptyObject.symbols
+++ b/tests/baselines/reference/constraintSatisfactionWithEmptyObject.symbols
@@ -12,16 +12,13 @@ function foo<T extends Object>(x: T) { }
 var r = foo({});
 >r : Symbol(r, Decl(constraintSatisfactionWithEmptyObject.ts, 4, 3), Decl(constraintSatisfactionWithEmptyObject.ts, 6, 3), Decl(constraintSatisfactionWithEmptyObject.ts, 21, 3), Decl(constraintSatisfactionWithEmptyObject.ts, 23, 3))
 >foo : Symbol(foo, Decl(constraintSatisfactionWithEmptyObject.ts, 0, 0))
->{} : Symbol(, Decl(constraintSatisfactionWithEmptyObject.ts, 4, 12))
 
 var a = {};
 >a : Symbol(a, Decl(constraintSatisfactionWithEmptyObject.ts, 5, 3), Decl(constraintSatisfactionWithEmptyObject.ts, 22, 3))
->{} : Symbol(, Decl(constraintSatisfactionWithEmptyObject.ts, 5, 7))
 
 var r = foo({});
 >r : Symbol(r, Decl(constraintSatisfactionWithEmptyObject.ts, 4, 3), Decl(constraintSatisfactionWithEmptyObject.ts, 6, 3), Decl(constraintSatisfactionWithEmptyObject.ts, 21, 3), Decl(constraintSatisfactionWithEmptyObject.ts, 23, 3))
 >foo : Symbol(foo, Decl(constraintSatisfactionWithEmptyObject.ts, 0, 0))
->{} : Symbol(, Decl(constraintSatisfactionWithEmptyObject.ts, 6, 12))
 
 class C<T extends Object> {
 >C : Symbol(C, Decl(constraintSatisfactionWithEmptyObject.ts, 6, 16))
@@ -36,7 +33,6 @@ class C<T extends Object> {
 var r2 = new C({});
 >r2 : Symbol(r2, Decl(constraintSatisfactionWithEmptyObject.ts, 12, 3), Decl(constraintSatisfactionWithEmptyObject.ts, 29, 3))
 >C : Symbol(C, Decl(constraintSatisfactionWithEmptyObject.ts, 6, 16))
->{} : Symbol(, Decl(constraintSatisfactionWithEmptyObject.ts, 12, 15))
 
 interface I<T extends Object> {
 >I : Symbol(I, Decl(constraintSatisfactionWithEmptyObject.ts, 12, 19))
@@ -61,16 +57,13 @@ function foo2<T extends {}>(x: T) { }
 var r = foo2({});
 >r : Symbol(r, Decl(constraintSatisfactionWithEmptyObject.ts, 4, 3), Decl(constraintSatisfactionWithEmptyObject.ts, 6, 3), Decl(constraintSatisfactionWithEmptyObject.ts, 21, 3), Decl(constraintSatisfactionWithEmptyObject.ts, 23, 3))
 >foo2 : Symbol(foo2, Decl(constraintSatisfactionWithEmptyObject.ts, 17, 13))
->{} : Symbol(, Decl(constraintSatisfactionWithEmptyObject.ts, 21, 13))
 
 var a = {};
 >a : Symbol(a, Decl(constraintSatisfactionWithEmptyObject.ts, 5, 3), Decl(constraintSatisfactionWithEmptyObject.ts, 22, 3))
->{} : Symbol(, Decl(constraintSatisfactionWithEmptyObject.ts, 22, 7))
 
 var r = foo2({});
 >r : Symbol(r, Decl(constraintSatisfactionWithEmptyObject.ts, 4, 3), Decl(constraintSatisfactionWithEmptyObject.ts, 6, 3), Decl(constraintSatisfactionWithEmptyObject.ts, 21, 3), Decl(constraintSatisfactionWithEmptyObject.ts, 23, 3))
 >foo2 : Symbol(foo2, Decl(constraintSatisfactionWithEmptyObject.ts, 17, 13))
->{} : Symbol(, Decl(constraintSatisfactionWithEmptyObject.ts, 23, 13))
 
 class C2<T extends {}> {
 >C2 : Symbol(C2, Decl(constraintSatisfactionWithEmptyObject.ts, 23, 17))
@@ -84,7 +77,6 @@ class C2<T extends {}> {
 var r2 = new C2({});
 >r2 : Symbol(r2, Decl(constraintSatisfactionWithEmptyObject.ts, 12, 3), Decl(constraintSatisfactionWithEmptyObject.ts, 29, 3))
 >C2 : Symbol(C2, Decl(constraintSatisfactionWithEmptyObject.ts, 23, 17))
->{} : Symbol(, Decl(constraintSatisfactionWithEmptyObject.ts, 29, 16))
 
 interface I2<T extends {}> {
 >I2 : Symbol(I2, Decl(constraintSatisfactionWithEmptyObject.ts, 29, 20))
diff --git a/tests/baselines/reference/contextualSignatureInstantiation1.symbols b/tests/baselines/reference/contextualSignatureInstantiation1.symbols
index 5cfafca9743fd..e56e997cffc8b 100644
--- a/tests/baselines/reference/contextualSignatureInstantiation1.symbols
+++ b/tests/baselines/reference/contextualSignatureInstantiation1.symbols
@@ -13,7 +13,6 @@ declare function map<S, T>(f: (x: S) => T): (a: S[]) => T[];
 
 var e = <K>(x: string, y?: K) => x.length;
 >e : Symbol(e, Decl(contextualSignatureInstantiation1.ts, 1, 3))
-><K>(x: string, y?: K) => x.length : Symbol((Anonymous function), Decl(contextualSignatureInstantiation1.ts, 1, 7))
 >K : Symbol(K, Decl(contextualSignatureInstantiation1.ts, 1, 9))
 >x : Symbol(x, Decl(contextualSignatureInstantiation1.ts, 1, 12))
 >y : Symbol(y, Decl(contextualSignatureInstantiation1.ts, 1, 22))
@@ -42,7 +41,6 @@ declare function map2<S extends { length: number }, T>(f: (x: S) => T): (a: S[])
 
 var e2 = <K>(x: string, y?: K) => x.length;
 >e2 : Symbol(e2, Decl(contextualSignatureInstantiation1.ts, 5, 3))
-><K>(x: string, y?: K) => x.length : Symbol((Anonymous function), Decl(contextualSignatureInstantiation1.ts, 5, 8))
 >K : Symbol(K, Decl(contextualSignatureInstantiation1.ts, 5, 10))
 >x : Symbol(x, Decl(contextualSignatureInstantiation1.ts, 5, 13))
 >y : Symbol(y, Decl(contextualSignatureInstantiation1.ts, 5, 23))
diff --git a/tests/baselines/reference/contextualSignatureInstantiation2.symbols b/tests/baselines/reference/contextualSignatureInstantiation2.symbols
index da7b3c616c14b..62808982eb547 100644
--- a/tests/baselines/reference/contextualSignatureInstantiation2.symbols
+++ b/tests/baselines/reference/contextualSignatureInstantiation2.symbols
@@ -19,14 +19,12 @@ var dot: <T, S>(f: (_: T) => S) => <U>(g: (_: U) => T) => (_: U) => S;
 
 dot = <T, S>(f: (_: T) => S) => <U>(g: (_: U) => T): (r:U) => S => (x) => f(g(x));
 >dot : Symbol(dot, Decl(contextualSignatureInstantiation2.ts, 1, 3))
-><T, S>(f: (_: T) => S) => <U>(g: (_: U) => T): (r:U) => S => (x) => f(g(x)) : Symbol((Anonymous function), Decl(contextualSignatureInstantiation2.ts, 2, 5))
 >T : Symbol(T, Decl(contextualSignatureInstantiation2.ts, 2, 7))
 >S : Symbol(S, Decl(contextualSignatureInstantiation2.ts, 2, 9))
 >f : Symbol(f, Decl(contextualSignatureInstantiation2.ts, 2, 13))
 >_ : Symbol(_, Decl(contextualSignatureInstantiation2.ts, 2, 17))
 >T : Symbol(T, Decl(contextualSignatureInstantiation2.ts, 2, 7))
 >S : Symbol(S, Decl(contextualSignatureInstantiation2.ts, 2, 9))
-><U>(g: (_: U) => T): (r:U) => S => (x) => f(g(x)) : Symbol((Anonymous function), Decl(contextualSignatureInstantiation2.ts, 2, 31))
 >U : Symbol(U, Decl(contextualSignatureInstantiation2.ts, 2, 33))
 >g : Symbol(g, Decl(contextualSignatureInstantiation2.ts, 2, 36))
 >_ : Symbol(_, Decl(contextualSignatureInstantiation2.ts, 2, 40))
@@ -35,7 +33,6 @@ dot = <T, S>(f: (_: T) => S) => <U>(g: (_: U) => T): (r:U) => S => (x) => f(g(x)
 >r : Symbol(r, Decl(contextualSignatureInstantiation2.ts, 2, 54))
 >U : Symbol(U, Decl(contextualSignatureInstantiation2.ts, 2, 33))
 >S : Symbol(S, Decl(contextualSignatureInstantiation2.ts, 2, 9))
->(x) => f(g(x)) : Symbol((Anonymous function), Decl(contextualSignatureInstantiation2.ts, 2, 66))
 >x : Symbol(x, Decl(contextualSignatureInstantiation2.ts, 2, 68))
 >f : Symbol(f, Decl(contextualSignatureInstantiation2.ts, 2, 13))
 >g : Symbol(g, Decl(contextualSignatureInstantiation2.ts, 2, 36))
diff --git a/tests/baselines/reference/contextualTypeAny.symbols b/tests/baselines/reference/contextualTypeAny.symbols
index 702fc34152ebb..5132c948a2e27 100644
--- a/tests/baselines/reference/contextualTypeAny.symbols
+++ b/tests/baselines/reference/contextualTypeAny.symbols
@@ -5,7 +5,6 @@ var x: any;
 var obj: { [s: string]: number } = { p: "", q: x };
 >obj : Symbol(obj, Decl(contextualTypeAny.ts, 2, 3))
 >s : Symbol(s, Decl(contextualTypeAny.ts, 2, 12))
->{ p: "", q: x } : Symbol(, Decl(contextualTypeAny.ts, 2, 34))
 >p : Symbol(p, Decl(contextualTypeAny.ts, 2, 36))
 >q : Symbol(q, Decl(contextualTypeAny.ts, 2, 43))
 >x : Symbol(x, Decl(contextualTypeAny.ts, 0, 3))
diff --git a/tests/baselines/reference/contextualTypeAppliedToVarArgs.symbols b/tests/baselines/reference/contextualTypeAppliedToVarArgs.symbols
index 5b253fcf79796..bf8774cc7f08f 100644
--- a/tests/baselines/reference/contextualTypeAppliedToVarArgs.symbols
+++ b/tests/baselines/reference/contextualTypeAppliedToVarArgs.symbols
@@ -8,7 +8,6 @@ function delegate(instance: any, method: (...args: any[]) => any, data?: any): (
 >args : Symbol(args, Decl(contextualTypeAppliedToVarArgs.ts, 0, 80))
 
     return function () { };
->function () { } : Symbol((Anonymous function), Decl(contextualTypeAppliedToVarArgs.ts, 1, 10))
 }
 
 class Foo{
@@ -21,7 +20,6 @@ class Foo{
         delegate(this, function (source, args2)
 >delegate : Symbol(delegate, Decl(contextualTypeAppliedToVarArgs.ts, 0, 0))
 >this : Symbol(Foo, Decl(contextualTypeAppliedToVarArgs.ts, 2, 1))
->function (source, args2)        {            var a = source.node;            var b = args2.node;        } : Symbol((Anonymous function), Decl(contextualTypeAppliedToVarArgs.ts, 8, 22))
 >source : Symbol(source, Decl(contextualTypeAppliedToVarArgs.ts, 8, 33))
 >args2 : Symbol(args2, Decl(contextualTypeAppliedToVarArgs.ts, 8, 40))
         {
diff --git a/tests/baselines/reference/contextualTypeArrayReturnType.symbols b/tests/baselines/reference/contextualTypeArrayReturnType.symbols
index d7b445a4f9c6a..ed0e22d698ca6 100644
--- a/tests/baselines/reference/contextualTypeArrayReturnType.symbols
+++ b/tests/baselines/reference/contextualTypeArrayReturnType.symbols
@@ -26,17 +26,13 @@ interface Transform3D {
 var style: IBookStyle = {
 >style : Symbol(style, Decl(contextualTypeArrayReturnType.ts, 12, 3))
 >IBookStyle : Symbol(IBookStyle, Decl(contextualTypeArrayReturnType.ts, 0, 0))
->{    initialLeftPageTransforms: (width: number) => {        return [            {'ry': null }        ];    }} : Symbol(, Decl(contextualTypeArrayReturnType.ts, 12, 23))
 
     initialLeftPageTransforms: (width: number) => {
 >initialLeftPageTransforms : Symbol(initialLeftPageTransforms, Decl(contextualTypeArrayReturnType.ts, 12, 25))
->(width: number) => {        return [            {'ry': null }        ];    } : Symbol((Anonymous function), Decl(contextualTypeArrayReturnType.ts, 13, 30))
 >width : Symbol(width, Decl(contextualTypeArrayReturnType.ts, 13, 32))
 
         return [
             {'ry': null }
->{'ry': null } : Symbol(, Decl(contextualTypeArrayReturnType.ts, 14, 16))
-
         ];
     }
 }
diff --git a/tests/baselines/reference/contextualTypeWithUnionTypeCallSignatures.symbols b/tests/baselines/reference/contextualTypeWithUnionTypeCallSignatures.symbols
index 1fdba4e71a604..3e23a7812f5b3 100644
--- a/tests/baselines/reference/contextualTypeWithUnionTypeCallSignatures.symbols
+++ b/tests/baselines/reference/contextualTypeWithUnionTypeCallSignatures.symbols
@@ -46,7 +46,6 @@ var x: IWithNoCallSignatures | IWithCallSignatures = a => a.toString();
 >x : Symbol(x, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 25, 3))
 >IWithNoCallSignatures : Symbol(IWithNoCallSignatures, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 0, 0))
 >IWithCallSignatures : Symbol(IWithCallSignatures, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 9, 1))
->a => a.toString() : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeCallSignatures.ts, 25, 52))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 25, 52))
 >a.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 25, 52))
@@ -57,7 +56,6 @@ var x2: IWithCallSignatures | IWithCallSignatures2 = a => a.toString(); // Like
 >x2 : Symbol(x2, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 28, 3), Decl(contextualTypeWithUnionTypeCallSignatures.ts, 29, 3))
 >IWithCallSignatures : Symbol(IWithCallSignatures, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 9, 1))
 >IWithCallSignatures2 : Symbol(IWithCallSignatures2, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 12, 1))
->a => a.toString() : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeCallSignatures.ts, 28, 52))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 28, 52))
 >a.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 28, 52))
@@ -67,7 +65,6 @@ var x2: IWithCallSignatures | IWithCallSignatures2 = a => a; // Like iWithCallSi
 >x2 : Symbol(x2, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 28, 3), Decl(contextualTypeWithUnionTypeCallSignatures.ts, 29, 3))
 >IWithCallSignatures : Symbol(IWithCallSignatures, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 9, 1))
 >IWithCallSignatures2 : Symbol(IWithCallSignatures2, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 12, 1))
->a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeCallSignatures.ts, 29, 52))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 29, 52))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 29, 52))
 
@@ -76,7 +73,6 @@ var x3: IWithCallSignatures | IWithCallSignatures3 = a => /*here a should be any
 >x3 : Symbol(x3, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 32, 3))
 >IWithCallSignatures : Symbol(IWithCallSignatures, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 9, 1))
 >IWithCallSignatures3 : Symbol(IWithCallSignatures3, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 15, 1))
->a => /*here a should be any*/ a.toString() : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeCallSignatures.ts, 32, 52))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 32, 52))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 32, 52))
 
@@ -85,7 +81,6 @@ var x4: IWithCallSignatures | IWithCallSignatures4 = a => /*here a should be any
 >x4 : Symbol(x4, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 35, 3))
 >IWithCallSignatures : Symbol(IWithCallSignatures, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 9, 1))
 >IWithCallSignatures4 : Symbol(IWithCallSignatures4, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 18, 1))
->a => /*here a should be any*/ a.toString() : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeCallSignatures.ts, 35, 52))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 35, 52))
 >a.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 35, 52))
diff --git a/tests/baselines/reference/contextualTypeWithUnionTypeIndexSignatures.symbols b/tests/baselines/reference/contextualTypeWithUnionTypeIndexSignatures.symbols
index 7e7ce834a13b8..c381377e523f3 100644
--- a/tests/baselines/reference/contextualTypeWithUnionTypeIndexSignatures.symbols
+++ b/tests/baselines/reference/contextualTypeWithUnionTypeIndexSignatures.symbols
@@ -69,9 +69,7 @@ var x: IWithNoStringIndexSignature | IWithStringIndexSignature1 = { z: a => a };
 >x : Symbol(x, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 39, 3), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 40, 3), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 41, 3))
 >IWithNoStringIndexSignature : Symbol(IWithNoStringIndexSignature, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 7, 1))
 >IWithStringIndexSignature1 : Symbol(IWithStringIndexSignature1, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 14, 1))
->{ z: a => a } : Symbol(, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 39, 65))
 >z : Symbol(z, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 39, 67))
->a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 39, 70))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 39, 70))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 39, 70))
 
@@ -79,9 +77,7 @@ var x: IWithNoStringIndexSignature | IWithStringIndexSignature1 = { foo: a => a
 >x : Symbol(x, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 39, 3), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 40, 3), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 41, 3))
 >IWithNoStringIndexSignature : Symbol(IWithNoStringIndexSignature, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 7, 1))
 >IWithStringIndexSignature1 : Symbol(IWithStringIndexSignature1, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 14, 1))
->{ foo: a => a } : Symbol(, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 40, 65))
 >foo : Symbol(foo, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 40, 67))
->a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 40, 72))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 40, 72))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 40, 72))
 
@@ -89,16 +85,13 @@ var x: IWithNoStringIndexSignature | IWithStringIndexSignature1 = { foo: "hello"
 >x : Symbol(x, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 39, 3), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 40, 3), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 41, 3))
 >IWithNoStringIndexSignature : Symbol(IWithNoStringIndexSignature, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 7, 1))
 >IWithStringIndexSignature1 : Symbol(IWithStringIndexSignature1, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 14, 1))
->{ foo: "hello" } : Symbol(, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 41, 65))
 >foo : Symbol(foo, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 41, 67))
 
 var x2: IWithStringIndexSignature1 | IWithStringIndexSignature2 = { z: a => a.toString() }; // a should be number
 >x2 : Symbol(x2, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 42, 3), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 43, 3))
 >IWithStringIndexSignature1 : Symbol(IWithStringIndexSignature1, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 14, 1))
 >IWithStringIndexSignature2 : Symbol(IWithStringIndexSignature2, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 17, 1))
->{ z: a => a.toString() } : Symbol(, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 42, 65))
 >z : Symbol(z, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 42, 67))
->a => a.toString() : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 42, 70))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 42, 70))
 >a.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 42, 70))
@@ -108,9 +101,7 @@ var x2: IWithStringIndexSignature1 | IWithStringIndexSignature2 = { z: a => a };
 >x2 : Symbol(x2, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 42, 3), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 43, 3))
 >IWithStringIndexSignature1 : Symbol(IWithStringIndexSignature1, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 14, 1))
 >IWithStringIndexSignature2 : Symbol(IWithStringIndexSignature2, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 17, 1))
->{ z: a => a } : Symbol(, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 43, 65))
 >z : Symbol(z, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 43, 67))
->a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 43, 70))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 43, 70))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 43, 70))
 
@@ -122,8 +113,6 @@ var x3: IWithNoNumberIndexSignature | IWithNumberIndexSignature1 = { 1: a => a }
 >x3 : Symbol(x3, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 49, 3), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 50, 3), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 51, 3))
 >IWithNoNumberIndexSignature : Symbol(IWithNoNumberIndexSignature, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 11, 1))
 >IWithNumberIndexSignature1 : Symbol(IWithNumberIndexSignature1, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 20, 1))
->{ 1: a => a } : Symbol(, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 49, 66))
->a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 49, 71))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 49, 71))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 49, 71))
 
@@ -131,8 +120,6 @@ var x3: IWithNoNumberIndexSignature | IWithNumberIndexSignature1 = { 0: a => a }
 >x3 : Symbol(x3, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 49, 3), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 50, 3), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 51, 3))
 >IWithNoNumberIndexSignature : Symbol(IWithNoNumberIndexSignature, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 11, 1))
 >IWithNumberIndexSignature1 : Symbol(IWithNumberIndexSignature1, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 20, 1))
->{ 0: a => a } : Symbol(, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 50, 66))
->a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 50, 71))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 50, 71))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 50, 71))
 
@@ -140,14 +127,11 @@ var x3: IWithNoNumberIndexSignature | IWithNumberIndexSignature1 = { 0: "hello"
 >x3 : Symbol(x3, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 49, 3), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 50, 3), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 51, 3))
 >IWithNoNumberIndexSignature : Symbol(IWithNoNumberIndexSignature, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 11, 1))
 >IWithNumberIndexSignature1 : Symbol(IWithNumberIndexSignature1, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 20, 1))
->{ 0: "hello" } : Symbol(, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 51, 66))
 
 var x4: IWithNumberIndexSignature1 | IWithNumberIndexSignature2 = { 1: a => a.toString() }; // a should be number
 >x4 : Symbol(x4, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 52, 3), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 53, 3))
 >IWithNumberIndexSignature1 : Symbol(IWithNumberIndexSignature1, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 20, 1))
 >IWithNumberIndexSignature2 : Symbol(IWithNumberIndexSignature2, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 23, 1))
->{ 1: a => a.toString() } : Symbol(, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 52, 65))
->a => a.toString() : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 52, 70))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 52, 70))
 >a.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 52, 70))
@@ -157,8 +141,6 @@ var x4: IWithNumberIndexSignature1 | IWithNumberIndexSignature2 = { 1: a => a };
 >x4 : Symbol(x4, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 52, 3), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 53, 3))
 >IWithNumberIndexSignature1 : Symbol(IWithNumberIndexSignature1, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 20, 1))
 >IWithNumberIndexSignature2 : Symbol(IWithNumberIndexSignature2, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 23, 1))
->{ 1: a => a } : Symbol(, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 53, 65))
->a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 53, 70))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 53, 70))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 53, 70))
 
diff --git a/tests/baselines/reference/contextualTypeWithUnionTypeMembers.symbols b/tests/baselines/reference/contextualTypeWithUnionTypeMembers.symbols
index 3abdda6c5468a..3d7b8bf5a189d 100644
--- a/tests/baselines/reference/contextualTypeWithUnionTypeMembers.symbols
+++ b/tests/baselines/reference/contextualTypeWithUnionTypeMembers.symbols
@@ -76,26 +76,22 @@ var i1Ori2: I1<number> | I2<number> = { // Like i1
 >i1Ori2 : Symbol(i1Ori2, Decl(contextualTypeWithUnionTypeMembers.ts, 23, 3), Decl(contextualTypeWithUnionTypeMembers.ts, 24, 3), Decl(contextualTypeWithUnionTypeMembers.ts, 25, 3), Decl(contextualTypeWithUnionTypeMembers.ts, 33, 3), Decl(contextualTypeWithUnionTypeMembers.ts, 41, 3))
 >I1 : Symbol(I1, Decl(contextualTypeWithUnionTypeMembers.ts, 0, 0))
 >I2 : Symbol(I2, Decl(contextualTypeWithUnionTypeMembers.ts, 9, 1))
->{ // Like i1    commonPropertyType: "hello",    commonMethodType: a=> a,    commonMethodWithTypeParameter: a => a,    methodOnlyInI1: a => a,    propertyOnlyInI1: "Hello",} : Symbol(, Decl(contextualTypeWithUnionTypeMembers.ts, 25, 37))
 
     commonPropertyType: "hello",
 >commonPropertyType : Symbol(commonPropertyType, Decl(contextualTypeWithUnionTypeMembers.ts, 25, 39))
 
     commonMethodType: a=> a,
 >commonMethodType : Symbol(commonMethodType, Decl(contextualTypeWithUnionTypeMembers.ts, 26, 32))
->a=> a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 27, 21))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 27, 21))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 27, 21))
 
     commonMethodWithTypeParameter: a => a,
 >commonMethodWithTypeParameter : Symbol(commonMethodWithTypeParameter, Decl(contextualTypeWithUnionTypeMembers.ts, 27, 28))
->a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 28, 34))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 28, 34))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 28, 34))
 
     methodOnlyInI1: a => a,
 >methodOnlyInI1 : Symbol(methodOnlyInI1, Decl(contextualTypeWithUnionTypeMembers.ts, 28, 42))
->a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 30, 19))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 30, 19))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 30, 19))
 
@@ -107,26 +103,22 @@ var i1Ori2: I1<number> | I2<number> = { // Like i2
 >i1Ori2 : Symbol(i1Ori2, Decl(contextualTypeWithUnionTypeMembers.ts, 23, 3), Decl(contextualTypeWithUnionTypeMembers.ts, 24, 3), Decl(contextualTypeWithUnionTypeMembers.ts, 25, 3), Decl(contextualTypeWithUnionTypeMembers.ts, 33, 3), Decl(contextualTypeWithUnionTypeMembers.ts, 41, 3))
 >I1 : Symbol(I1, Decl(contextualTypeWithUnionTypeMembers.ts, 0, 0))
 >I2 : Symbol(I2, Decl(contextualTypeWithUnionTypeMembers.ts, 9, 1))
->{ // Like i2    commonPropertyType: "hello",    commonMethodType: a=> a,    commonMethodWithTypeParameter: a => a,    methodOnlyInI2: a => a,    propertyOnlyInI2: "Hello",} : Symbol(, Decl(contextualTypeWithUnionTypeMembers.ts, 33, 37))
 
     commonPropertyType: "hello",
 >commonPropertyType : Symbol(commonPropertyType, Decl(contextualTypeWithUnionTypeMembers.ts, 33, 39))
 
     commonMethodType: a=> a,
 >commonMethodType : Symbol(commonMethodType, Decl(contextualTypeWithUnionTypeMembers.ts, 34, 32))
->a=> a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 35, 21))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 35, 21))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 35, 21))
 
     commonMethodWithTypeParameter: a => a,
 >commonMethodWithTypeParameter : Symbol(commonMethodWithTypeParameter, Decl(contextualTypeWithUnionTypeMembers.ts, 35, 28))
->a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 36, 34))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 36, 34))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 36, 34))
 
     methodOnlyInI2: a => a,
 >methodOnlyInI2 : Symbol(methodOnlyInI2, Decl(contextualTypeWithUnionTypeMembers.ts, 36, 42))
->a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 38, 19))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 38, 19))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 38, 19))
 
@@ -138,26 +130,22 @@ var i1Ori2: I1<number> | I2<number> = { // Like i1 and i2 both
 >i1Ori2 : Symbol(i1Ori2, Decl(contextualTypeWithUnionTypeMembers.ts, 23, 3), Decl(contextualTypeWithUnionTypeMembers.ts, 24, 3), Decl(contextualTypeWithUnionTypeMembers.ts, 25, 3), Decl(contextualTypeWithUnionTypeMembers.ts, 33, 3), Decl(contextualTypeWithUnionTypeMembers.ts, 41, 3))
 >I1 : Symbol(I1, Decl(contextualTypeWithUnionTypeMembers.ts, 0, 0))
 >I2 : Symbol(I2, Decl(contextualTypeWithUnionTypeMembers.ts, 9, 1))
->{ // Like i1 and i2 both    commonPropertyType: "hello",    commonMethodType: a=> a,    commonMethodWithTypeParameter: a => a,    methodOnlyInI1: a => a,    propertyOnlyInI1: "Hello",    methodOnlyInI2: a => a,    propertyOnlyInI2: "Hello",} : Symbol(, Decl(contextualTypeWithUnionTypeMembers.ts, 41, 37))
 
     commonPropertyType: "hello",
 >commonPropertyType : Symbol(commonPropertyType, Decl(contextualTypeWithUnionTypeMembers.ts, 41, 39))
 
     commonMethodType: a=> a,
 >commonMethodType : Symbol(commonMethodType, Decl(contextualTypeWithUnionTypeMembers.ts, 42, 32))
->a=> a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 43, 21))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 43, 21))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 43, 21))
 
     commonMethodWithTypeParameter: a => a,
 >commonMethodWithTypeParameter : Symbol(commonMethodWithTypeParameter, Decl(contextualTypeWithUnionTypeMembers.ts, 43, 28))
->a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 44, 34))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 44, 34))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 44, 34))
 
     methodOnlyInI1: a => a,
 >methodOnlyInI1 : Symbol(methodOnlyInI1, Decl(contextualTypeWithUnionTypeMembers.ts, 44, 42))
->a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 45, 19))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 45, 19))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 45, 19))
 
@@ -166,7 +154,6 @@ var i1Ori2: I1<number> | I2<number> = { // Like i1 and i2 both
 
     methodOnlyInI2: a => a,
 >methodOnlyInI2 : Symbol(methodOnlyInI2, Decl(contextualTypeWithUnionTypeMembers.ts, 46, 30))
->a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 47, 19))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 47, 19))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 47, 19))
 
@@ -182,26 +169,22 @@ var arrayI1OrI2: Array<I1<number> | I2<number>> = [i1, i2, { // Like i1
 >I2 : Symbol(I2, Decl(contextualTypeWithUnionTypeMembers.ts, 9, 1))
 >i1 : Symbol(i1, Decl(contextualTypeWithUnionTypeMembers.ts, 21, 3))
 >i2 : Symbol(i2, Decl(contextualTypeWithUnionTypeMembers.ts, 22, 3))
->{ // Like i1        commonPropertyType: "hello",        commonMethodType: a=> a,        commonMethodWithTypeParameter: a => a,        methodOnlyInI1: a => a,        propertyOnlyInI1: "Hello",    } : Symbol(, Decl(contextualTypeWithUnionTypeMembers.ts, 51, 58))
 
         commonPropertyType: "hello",
 >commonPropertyType : Symbol(commonPropertyType, Decl(contextualTypeWithUnionTypeMembers.ts, 51, 60))
 
         commonMethodType: a=> a,
 >commonMethodType : Symbol(commonMethodType, Decl(contextualTypeWithUnionTypeMembers.ts, 52, 36))
->a=> a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 53, 25))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 53, 25))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 53, 25))
 
         commonMethodWithTypeParameter: a => a,
 >commonMethodWithTypeParameter : Symbol(commonMethodWithTypeParameter, Decl(contextualTypeWithUnionTypeMembers.ts, 53, 32))
->a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 54, 38))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 54, 38))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 54, 38))
 
         methodOnlyInI1: a => a,
 >methodOnlyInI1 : Symbol(methodOnlyInI1, Decl(contextualTypeWithUnionTypeMembers.ts, 54, 46))
->a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 56, 23))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 56, 23))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 56, 23))
 
@@ -210,26 +193,21 @@ var arrayI1OrI2: Array<I1<number> | I2<number>> = [i1, i2, { // Like i1
 
     },
     { // Like i2
->{ // Like i2        commonPropertyType: "hello",        commonMethodType: a=> a,        commonMethodWithTypeParameter: a => a,        methodOnlyInI2: a => a,        propertyOnlyInI2: "Hello",    } : Symbol(, Decl(contextualTypeWithUnionTypeMembers.ts, 58, 6))
-
         commonPropertyType: "hello",
 >commonPropertyType : Symbol(commonPropertyType, Decl(contextualTypeWithUnionTypeMembers.ts, 59, 5))
 
         commonMethodType: a=> a,
 >commonMethodType : Symbol(commonMethodType, Decl(contextualTypeWithUnionTypeMembers.ts, 60, 36))
->a=> a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 61, 25))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 61, 25))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 61, 25))
 
         commonMethodWithTypeParameter: a => a,
 >commonMethodWithTypeParameter : Symbol(commonMethodWithTypeParameter, Decl(contextualTypeWithUnionTypeMembers.ts, 61, 32))
->a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 62, 38))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 62, 38))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 62, 38))
 
         methodOnlyInI2: a => a,
 >methodOnlyInI2 : Symbol(methodOnlyInI2, Decl(contextualTypeWithUnionTypeMembers.ts, 62, 46))
->a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 64, 23))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 64, 23))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 64, 23))
 
@@ -237,26 +215,21 @@ var arrayI1OrI2: Array<I1<number> | I2<number>> = [i1, i2, { // Like i1
 >propertyOnlyInI2 : Symbol(propertyOnlyInI2, Decl(contextualTypeWithUnionTypeMembers.ts, 64, 31))
 
     }, { // Like i1 and i2 both
->{ // Like i1 and i2 both        commonPropertyType: "hello",        commonMethodType: a=> a,        commonMethodWithTypeParameter: a => a,        methodOnlyInI1: a => a,        propertyOnlyInI1: "Hello",        methodOnlyInI2: a => a,        propertyOnlyInI2: "Hello",    } : Symbol(, Decl(contextualTypeWithUnionTypeMembers.ts, 66, 6))
-
         commonPropertyType: "hello",
 >commonPropertyType : Symbol(commonPropertyType, Decl(contextualTypeWithUnionTypeMembers.ts, 66, 8))
 
         commonMethodType: a=> a,
 >commonMethodType : Symbol(commonMethodType, Decl(contextualTypeWithUnionTypeMembers.ts, 67, 36))
->a=> a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 68, 25))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 68, 25))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 68, 25))
 
         commonMethodWithTypeParameter: a => a,
 >commonMethodWithTypeParameter : Symbol(commonMethodWithTypeParameter, Decl(contextualTypeWithUnionTypeMembers.ts, 68, 32))
->a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 69, 38))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 69, 38))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 69, 38))
 
         methodOnlyInI1: a => a,
 >methodOnlyInI1 : Symbol(methodOnlyInI1, Decl(contextualTypeWithUnionTypeMembers.ts, 69, 46))
->a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 70, 23))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 70, 23))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 70, 23))
 
@@ -265,7 +238,6 @@ var arrayI1OrI2: Array<I1<number> | I2<number>> = [i1, i2, { // Like i1
 
         methodOnlyInI2: a => a,
 >methodOnlyInI2 : Symbol(methodOnlyInI2, Decl(contextualTypeWithUnionTypeMembers.ts, 71, 34))
->a => a : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 72, 23))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 72, 23))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 72, 23))
 
@@ -320,12 +292,10 @@ var i11Ori21: I11 | I21 = {
 >i11Ori21 : Symbol(i11Ori21, Decl(contextualTypeWithUnionTypeMembers.ts, 86, 3), Decl(contextualTypeWithUnionTypeMembers.ts, 87, 3), Decl(contextualTypeWithUnionTypeMembers.ts, 88, 3), Decl(contextualTypeWithUnionTypeMembers.ts, 96, 3))
 >I11 : Symbol(I11, Decl(contextualTypeWithUnionTypeMembers.ts, 74, 7))
 >I21 : Symbol(I21, Decl(contextualTypeWithUnionTypeMembers.ts, 79, 1))
->{     // Like i1    commonMethodDifferentReturnType: (a, b) => {        var z = a.charAt(b);        return z;      },    commonPropertyDifferentType: "hello",  } : Symbol(, Decl(contextualTypeWithUnionTypeMembers.ts, 88, 25))
 
     // Like i1
     commonMethodDifferentReturnType: (a, b) => {
 >commonMethodDifferentReturnType : Symbol(commonMethodDifferentReturnType, Decl(contextualTypeWithUnionTypeMembers.ts, 88, 27))
->(a, b) => {        var z = a.charAt(b);        return z;      } : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 90, 36))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 90, 38))
 >b : Symbol(b, Decl(contextualTypeWithUnionTypeMembers.ts, 90, 40))
 
@@ -348,12 +318,10 @@ var i11Ori21: I11 | I21 = {
 >i11Ori21 : Symbol(i11Ori21, Decl(contextualTypeWithUnionTypeMembers.ts, 86, 3), Decl(contextualTypeWithUnionTypeMembers.ts, 87, 3), Decl(contextualTypeWithUnionTypeMembers.ts, 88, 3), Decl(contextualTypeWithUnionTypeMembers.ts, 96, 3))
 >I11 : Symbol(I11, Decl(contextualTypeWithUnionTypeMembers.ts, 74, 7))
 >I21 : Symbol(I21, Decl(contextualTypeWithUnionTypeMembers.ts, 79, 1))
->{     // Like i2    commonMethodDifferentReturnType: (a, b) => {        var z = a.charCodeAt(b);        return z;    },    commonPropertyDifferentType: 10,} : Symbol(, Decl(contextualTypeWithUnionTypeMembers.ts, 96, 25))
 
     // Like i2
     commonMethodDifferentReturnType: (a, b) => {
 >commonMethodDifferentReturnType : Symbol(commonMethodDifferentReturnType, Decl(contextualTypeWithUnionTypeMembers.ts, 96, 27))
->(a, b) => {        var z = a.charCodeAt(b);        return z;    } : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 98, 36))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 98, 38))
 >b : Symbol(b, Decl(contextualTypeWithUnionTypeMembers.ts, 98, 40))
 
@@ -381,12 +349,10 @@ var arrayOrI11OrI21: Array<I11 | I21> = [i11, i21, i11 || i21, {
 >i21 : Symbol(i21, Decl(contextualTypeWithUnionTypeMembers.ts, 85, 3))
 >i11 : Symbol(i11, Decl(contextualTypeWithUnionTypeMembers.ts, 84, 3))
 >i21 : Symbol(i21, Decl(contextualTypeWithUnionTypeMembers.ts, 85, 3))
->{         // Like i1        commonMethodDifferentReturnType: (a, b) => {            var z = a.charAt(b);            return z;        },        commonPropertyDifferentType: "hello",    } : Symbol(, Decl(contextualTypeWithUnionTypeMembers.ts, 104, 62))
 
         // Like i1
         commonMethodDifferentReturnType: (a, b) => {
 >commonMethodDifferentReturnType : Symbol(commonMethodDifferentReturnType, Decl(contextualTypeWithUnionTypeMembers.ts, 104, 64))
->(a, b) => {            var z = a.charAt(b);            return z;        } : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 106, 40))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 106, 42))
 >b : Symbol(b, Decl(contextualTypeWithUnionTypeMembers.ts, 106, 44))
 
@@ -405,12 +371,9 @@ var arrayOrI11OrI21: Array<I11 | I21> = [i11, i21, i11 || i21, {
 >commonPropertyDifferentType : Symbol(commonPropertyDifferentType, Decl(contextualTypeWithUnionTypeMembers.ts, 109, 10))
 
     }, { 
->{         // Like i2        commonMethodDifferentReturnType: (a, b) => {            var z = a.charCodeAt(b);            return z;        },        commonPropertyDifferentType: 10,    } : Symbol(, Decl(contextualTypeWithUnionTypeMembers.ts, 111, 6))
-
         // Like i2
         commonMethodDifferentReturnType: (a, b) => {
 >commonMethodDifferentReturnType : Symbol(commonMethodDifferentReturnType, Decl(contextualTypeWithUnionTypeMembers.ts, 111, 8))
->(a, b) => {            var z = a.charCodeAt(b);            return z;        } : Symbol((Anonymous function), Decl(contextualTypeWithUnionTypeMembers.ts, 113, 40))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 113, 42))
 >b : Symbol(b, Decl(contextualTypeWithUnionTypeMembers.ts, 113, 44))
 
diff --git a/tests/baselines/reference/contextualTyping1.symbols b/tests/baselines/reference/contextualTyping1.symbols
index 446b428a431d7..00c6fd57f2a1d 100644
--- a/tests/baselines/reference/contextualTyping1.symbols
+++ b/tests/baselines/reference/contextualTyping1.symbols
@@ -2,6 +2,5 @@
 var foo: {id:number;} = {id:4};
 >foo : Symbol(foo, Decl(contextualTyping1.ts, 0, 3))
 >id : Symbol(id, Decl(contextualTyping1.ts, 0, 10))
->{id:4} : Symbol(, Decl(contextualTyping1.ts, 0, 23))
 >id : Symbol(id, Decl(contextualTyping1.ts, 0, 25))
 
diff --git a/tests/baselines/reference/contextualTyping10.symbols b/tests/baselines/reference/contextualTyping10.symbols
index 909ea5f534805..130116264e0aa 100644
--- a/tests/baselines/reference/contextualTyping10.symbols
+++ b/tests/baselines/reference/contextualTyping10.symbols
@@ -3,8 +3,6 @@ class foo { public bar:{id:number;}[] = [{id:1}, {id:2}]; }
 >foo : Symbol(foo, Decl(contextualTyping10.ts, 0, 0))
 >bar : Symbol(bar, Decl(contextualTyping10.ts, 0, 11))
 >id : Symbol(id, Decl(contextualTyping10.ts, 0, 24))
->{id:1} : Symbol(, Decl(contextualTyping10.ts, 0, 41))
 >id : Symbol(id, Decl(contextualTyping10.ts, 0, 42))
->{id:2} : Symbol(, Decl(contextualTyping10.ts, 0, 48))
 >id : Symbol(id, Decl(contextualTyping10.ts, 0, 50))
 
diff --git a/tests/baselines/reference/contextualTyping12.symbols b/tests/baselines/reference/contextualTyping12.symbols
index 0e1d377a325c6..bafef4c8e0a00 100644
--- a/tests/baselines/reference/contextualTyping12.symbols
+++ b/tests/baselines/reference/contextualTyping12.symbols
@@ -3,9 +3,7 @@ class foo { public bar:{id:number;}[] = [{id:1}, {id:2, name:"foo"}]; }
 >foo : Symbol(foo, Decl(contextualTyping12.ts, 0, 0))
 >bar : Symbol(bar, Decl(contextualTyping12.ts, 0, 11))
 >id : Symbol(id, Decl(contextualTyping12.ts, 0, 24))
->{id:1} : Symbol(, Decl(contextualTyping12.ts, 0, 41))
 >id : Symbol(id, Decl(contextualTyping12.ts, 0, 42))
->{id:2, name:"foo"} : Symbol(, Decl(contextualTyping12.ts, 0, 48))
 >id : Symbol(id, Decl(contextualTyping12.ts, 0, 50))
 >name : Symbol(name, Decl(contextualTyping12.ts, 0, 55))
 
diff --git a/tests/baselines/reference/contextualTyping13.symbols b/tests/baselines/reference/contextualTyping13.symbols
index 767db204d8b18..e60131e8433fc 100644
--- a/tests/baselines/reference/contextualTyping13.symbols
+++ b/tests/baselines/reference/contextualTyping13.symbols
@@ -2,7 +2,6 @@
 var foo:(a:number)=>number = function(a){return a};
 >foo : Symbol(foo, Decl(contextualTyping13.ts, 0, 3))
 >a : Symbol(a, Decl(contextualTyping13.ts, 0, 9))
->function(a){return a} : Symbol((Anonymous function), Decl(contextualTyping13.ts, 0, 28))
 >a : Symbol(a, Decl(contextualTyping13.ts, 0, 38))
 >a : Symbol(a, Decl(contextualTyping13.ts, 0, 38))
 
diff --git a/tests/baselines/reference/contextualTyping14.symbols b/tests/baselines/reference/contextualTyping14.symbols
index 5f226815f2e74..7de67445ca8c7 100644
--- a/tests/baselines/reference/contextualTyping14.symbols
+++ b/tests/baselines/reference/contextualTyping14.symbols
@@ -3,7 +3,6 @@ class foo { public bar:(a:number)=>number = function(a){return a}; }
 >foo : Symbol(foo, Decl(contextualTyping14.ts, 0, 0))
 >bar : Symbol(bar, Decl(contextualTyping14.ts, 0, 11))
 >a : Symbol(a, Decl(contextualTyping14.ts, 0, 24))
->function(a){return a} : Symbol((Anonymous function), Decl(contextualTyping14.ts, 0, 43))
 >a : Symbol(a, Decl(contextualTyping14.ts, 0, 53))
 >a : Symbol(a, Decl(contextualTyping14.ts, 0, 53))
 
diff --git a/tests/baselines/reference/contextualTyping15.symbols b/tests/baselines/reference/contextualTyping15.symbols
index 746b8c74c210d..902fb03dc70d0 100644
--- a/tests/baselines/reference/contextualTyping15.symbols
+++ b/tests/baselines/reference/contextualTyping15.symbols
@@ -3,5 +3,4 @@ class foo { public bar: { (): number; (i: number): number; } = function() { retu
 >foo : Symbol(foo, Decl(contextualTyping15.ts, 0, 0))
 >bar : Symbol(bar, Decl(contextualTyping15.ts, 0, 11))
 >i : Symbol(i, Decl(contextualTyping15.ts, 0, 39))
->function() { return 1 } : Symbol((Anonymous function), Decl(contextualTyping15.ts, 0, 62))
 
diff --git a/tests/baselines/reference/contextualTyping16.symbols b/tests/baselines/reference/contextualTyping16.symbols
index 90fc6ae552c8a..9f88ce4c151e2 100644
--- a/tests/baselines/reference/contextualTyping16.symbols
+++ b/tests/baselines/reference/contextualTyping16.symbols
@@ -2,9 +2,7 @@
 var foo: {id:number;} = {id:4}; foo = {id:5};
 >foo : Symbol(foo, Decl(contextualTyping16.ts, 0, 3))
 >id : Symbol(id, Decl(contextualTyping16.ts, 0, 10))
->{id:4} : Symbol(, Decl(contextualTyping16.ts, 0, 23))
 >id : Symbol(id, Decl(contextualTyping16.ts, 0, 25))
 >foo : Symbol(foo, Decl(contextualTyping16.ts, 0, 3))
->{id:5} : Symbol(, Decl(contextualTyping16.ts, 0, 37))
 >id : Symbol(id, Decl(contextualTyping16.ts, 0, 39))
 
diff --git a/tests/baselines/reference/contextualTyping17.symbols b/tests/baselines/reference/contextualTyping17.symbols
index 9b530bc9cd09a..55631494105ad 100644
--- a/tests/baselines/reference/contextualTyping17.symbols
+++ b/tests/baselines/reference/contextualTyping17.symbols
@@ -2,10 +2,8 @@
 var foo: {id:number;} = {id:4}; foo = {id: 5, name:"foo"};
 >foo : Symbol(foo, Decl(contextualTyping17.ts, 0, 3))
 >id : Symbol(id, Decl(contextualTyping17.ts, 0, 10))
->{id:4} : Symbol(, Decl(contextualTyping17.ts, 0, 23))
 >id : Symbol(id, Decl(contextualTyping17.ts, 0, 25))
 >foo : Symbol(foo, Decl(contextualTyping17.ts, 0, 3))
->{id: 5, name:"foo"} : Symbol(, Decl(contextualTyping17.ts, 0, 37))
 >id : Symbol(id, Decl(contextualTyping17.ts, 0, 39))
 >name : Symbol(name, Decl(contextualTyping17.ts, 0, 45))
 
diff --git a/tests/baselines/reference/contextualTyping18.symbols b/tests/baselines/reference/contextualTyping18.symbols
index 3ba6839c9745d..a5506cfe9009d 100644
--- a/tests/baselines/reference/contextualTyping18.symbols
+++ b/tests/baselines/reference/contextualTyping18.symbols
@@ -3,8 +3,6 @@ var foo: {id:number;} = <{id:number;}>({ }); foo = {id: 5};
 >foo : Symbol(foo, Decl(contextualTyping18.ts, 0, 3))
 >id : Symbol(id, Decl(contextualTyping18.ts, 0, 10))
 >id : Symbol(id, Decl(contextualTyping18.ts, 0, 26))
->{ } : Symbol(, Decl(contextualTyping18.ts, 0, 39))
 >foo : Symbol(foo, Decl(contextualTyping18.ts, 0, 3))
->{id: 5} : Symbol(, Decl(contextualTyping18.ts, 0, 50))
 >id : Symbol(id, Decl(contextualTyping18.ts, 0, 52))
 
diff --git a/tests/baselines/reference/contextualTyping19.symbols b/tests/baselines/reference/contextualTyping19.symbols
index 2450b141444e8..cee3a6e7d24e9 100644
--- a/tests/baselines/reference/contextualTyping19.symbols
+++ b/tests/baselines/reference/contextualTyping19.symbols
@@ -2,11 +2,8 @@
 var foo:{id:number;}[] = [{id:1}]; foo = [{id:1}, {id:2}];
 >foo : Symbol(foo, Decl(contextualTyping19.ts, 0, 3))
 >id : Symbol(id, Decl(contextualTyping19.ts, 0, 9))
->{id:1} : Symbol(, Decl(contextualTyping19.ts, 0, 26))
 >id : Symbol(id, Decl(contextualTyping19.ts, 0, 27))
 >foo : Symbol(foo, Decl(contextualTyping19.ts, 0, 3))
->{id:1} : Symbol(, Decl(contextualTyping19.ts, 0, 42))
 >id : Symbol(id, Decl(contextualTyping19.ts, 0, 43))
->{id:2} : Symbol(, Decl(contextualTyping19.ts, 0, 49))
 >id : Symbol(id, Decl(contextualTyping19.ts, 0, 51))
 
diff --git a/tests/baselines/reference/contextualTyping2.symbols b/tests/baselines/reference/contextualTyping2.symbols
index ecaa40d969bfb..9c1020929794b 100644
--- a/tests/baselines/reference/contextualTyping2.symbols
+++ b/tests/baselines/reference/contextualTyping2.symbols
@@ -2,7 +2,6 @@
 var foo: {id:number;} = {id:4, name:"foo"};
 >foo : Symbol(foo, Decl(contextualTyping2.ts, 0, 3))
 >id : Symbol(id, Decl(contextualTyping2.ts, 0, 10))
->{id:4, name:"foo"} : Symbol(, Decl(contextualTyping2.ts, 0, 23))
 >id : Symbol(id, Decl(contextualTyping2.ts, 0, 25))
 >name : Symbol(name, Decl(contextualTyping2.ts, 0, 30))
 
diff --git a/tests/baselines/reference/contextualTyping20.symbols b/tests/baselines/reference/contextualTyping20.symbols
index bfe591d12cb55..505c6a04a59f2 100644
--- a/tests/baselines/reference/contextualTyping20.symbols
+++ b/tests/baselines/reference/contextualTyping20.symbols
@@ -2,12 +2,9 @@
 var foo:{id:number;}[] = [{id:1}]; foo = [{id:1}, {id:2, name:"foo"}];
 >foo : Symbol(foo, Decl(contextualTyping20.ts, 0, 3))
 >id : Symbol(id, Decl(contextualTyping20.ts, 0, 9))
->{id:1} : Symbol(, Decl(contextualTyping20.ts, 0, 26))
 >id : Symbol(id, Decl(contextualTyping20.ts, 0, 27))
 >foo : Symbol(foo, Decl(contextualTyping20.ts, 0, 3))
->{id:1} : Symbol(, Decl(contextualTyping20.ts, 0, 42))
 >id : Symbol(id, Decl(contextualTyping20.ts, 0, 43))
->{id:2, name:"foo"} : Symbol(, Decl(contextualTyping20.ts, 0, 49))
 >id : Symbol(id, Decl(contextualTyping20.ts, 0, 51))
 >name : Symbol(name, Decl(contextualTyping20.ts, 0, 56))
 
diff --git a/tests/baselines/reference/contextualTyping22.symbols b/tests/baselines/reference/contextualTyping22.symbols
index ec54714f07a93..9a7817a826063 100644
--- a/tests/baselines/reference/contextualTyping22.symbols
+++ b/tests/baselines/reference/contextualTyping22.symbols
@@ -2,11 +2,9 @@
 var foo:(a:number)=>number = function(a){return a}; foo = function(b){return b};
 >foo : Symbol(foo, Decl(contextualTyping22.ts, 0, 3))
 >a : Symbol(a, Decl(contextualTyping22.ts, 0, 9))
->function(a){return a} : Symbol((Anonymous function), Decl(contextualTyping22.ts, 0, 28))
 >a : Symbol(a, Decl(contextualTyping22.ts, 0, 38))
 >a : Symbol(a, Decl(contextualTyping22.ts, 0, 38))
 >foo : Symbol(foo, Decl(contextualTyping22.ts, 0, 3))
->function(b){return b} : Symbol((Anonymous function), Decl(contextualTyping22.ts, 0, 57))
 >b : Symbol(b, Decl(contextualTyping22.ts, 0, 67))
 >b : Symbol(b, Decl(contextualTyping22.ts, 0, 67))
 
diff --git a/tests/baselines/reference/contextualTyping23.symbols b/tests/baselines/reference/contextualTyping23.symbols
index c8dd900740437..bb0daeeee18ae 100644
--- a/tests/baselines/reference/contextualTyping23.symbols
+++ b/tests/baselines/reference/contextualTyping23.symbols
@@ -4,6 +4,5 @@ var foo:(a:{():number; (i:number):number; })=>number; foo = function(a){return 5
 >a : Symbol(a, Decl(contextualTyping23.ts, 0, 9))
 >i : Symbol(i, Decl(contextualTyping23.ts, 0, 24))
 >foo : Symbol(foo, Decl(contextualTyping23.ts, 0, 3))
->function(a){return 5} : Symbol((Anonymous function), Decl(contextualTyping23.ts, 0, 59))
 >a : Symbol(a, Decl(contextualTyping23.ts, 0, 69))
 
diff --git a/tests/baselines/reference/contextualTyping25.symbols b/tests/baselines/reference/contextualTyping25.symbols
index 2aea0f403f240..5446a3c7515d5 100644
--- a/tests/baselines/reference/contextualTyping25.symbols
+++ b/tests/baselines/reference/contextualTyping25.symbols
@@ -5,5 +5,4 @@ function foo(param:{id:number;}){}; foo(<{id:number;}>({}));
 >id : Symbol(id, Decl(contextualTyping25.ts, 0, 20))
 >foo : Symbol(foo, Decl(contextualTyping25.ts, 0, 0))
 >id : Symbol(id, Decl(contextualTyping25.ts, 0, 42))
->{} : Symbol(, Decl(contextualTyping25.ts, 0, 55))
 
diff --git a/tests/baselines/reference/contextualTyping26.symbols b/tests/baselines/reference/contextualTyping26.symbols
index 5bfd286b016fe..ccecd501837ba 100644
--- a/tests/baselines/reference/contextualTyping26.symbols
+++ b/tests/baselines/reference/contextualTyping26.symbols
@@ -5,5 +5,4 @@ function foo(param:{id:number;}){}; foo(<{id:number;}>({}));
 >id : Symbol(id, Decl(contextualTyping26.ts, 0, 20))
 >foo : Symbol(foo, Decl(contextualTyping26.ts, 0, 0))
 >id : Symbol(id, Decl(contextualTyping26.ts, 0, 42))
->{} : Symbol(, Decl(contextualTyping26.ts, 0, 55))
 
diff --git a/tests/baselines/reference/contextualTyping27.symbols b/tests/baselines/reference/contextualTyping27.symbols
index bceaeeca6386d..0ff8486c1d99d 100644
--- a/tests/baselines/reference/contextualTyping27.symbols
+++ b/tests/baselines/reference/contextualTyping27.symbols
@@ -5,5 +5,4 @@ function foo(param:{id:number;}){}; foo(<{id:number;}>({}));
 >id : Symbol(id, Decl(contextualTyping27.ts, 0, 20))
 >foo : Symbol(foo, Decl(contextualTyping27.ts, 0, 0))
 >id : Symbol(id, Decl(contextualTyping27.ts, 0, 42))
->{} : Symbol(, Decl(contextualTyping27.ts, 0, 55))
 
diff --git a/tests/baselines/reference/contextualTyping3.symbols b/tests/baselines/reference/contextualTyping3.symbols
index 491e6ff0f90ed..584c399e4da6a 100644
--- a/tests/baselines/reference/contextualTyping3.symbols
+++ b/tests/baselines/reference/contextualTyping3.symbols
@@ -3,6 +3,5 @@ class foo { public bar:{id:number;} = {id:5}; }
 >foo : Symbol(foo, Decl(contextualTyping3.ts, 0, 0))
 >bar : Symbol(bar, Decl(contextualTyping3.ts, 0, 11))
 >id : Symbol(id, Decl(contextualTyping3.ts, 0, 24))
->{id:5} : Symbol(, Decl(contextualTyping3.ts, 0, 37))
 >id : Symbol(id, Decl(contextualTyping3.ts, 0, 39))
 
diff --git a/tests/baselines/reference/contextualTyping32.symbols b/tests/baselines/reference/contextualTyping32.symbols
index b8df48e33f6b7..f4ceeb9349151 100644
--- a/tests/baselines/reference/contextualTyping32.symbols
+++ b/tests/baselines/reference/contextualTyping32.symbols
@@ -4,6 +4,4 @@ function foo(param: {():number; (i:number):number; }[]) { }; foo([function(){ret
 >param : Symbol(param, Decl(contextualTyping32.ts, 0, 13))
 >i : Symbol(i, Decl(contextualTyping32.ts, 0, 33))
 >foo : Symbol(foo, Decl(contextualTyping32.ts, 0, 0))
->function(){return 1;} : Symbol((Anonymous function), Decl(contextualTyping32.ts, 0, 66))
->function(){return 4} : Symbol((Anonymous function), Decl(contextualTyping32.ts, 0, 88))
 
diff --git a/tests/baselines/reference/contextualTyping34.symbols b/tests/baselines/reference/contextualTyping34.symbols
index cdc88159f0083..6ea9f09f94b64 100644
--- a/tests/baselines/reference/contextualTyping34.symbols
+++ b/tests/baselines/reference/contextualTyping34.symbols
@@ -2,6 +2,5 @@
 var foo = <{ id: number;}> ({id:4});
 >foo : Symbol(foo, Decl(contextualTyping34.ts, 0, 3))
 >id : Symbol(id, Decl(contextualTyping34.ts, 0, 12))
->{id:4} : Symbol(, Decl(contextualTyping34.ts, 0, 28))
 >id : Symbol(id, Decl(contextualTyping34.ts, 0, 29))
 
diff --git a/tests/baselines/reference/contextualTyping35.symbols b/tests/baselines/reference/contextualTyping35.symbols
index aacf78834ebff..cb98510089176 100644
--- a/tests/baselines/reference/contextualTyping35.symbols
+++ b/tests/baselines/reference/contextualTyping35.symbols
@@ -2,7 +2,6 @@
 var foo = <{ id: number;}> {id:4, name: "as"};
 >foo : Symbol(foo, Decl(contextualTyping35.ts, 0, 3))
 >id : Symbol(id, Decl(contextualTyping35.ts, 0, 12))
->{id:4, name: "as"} : Symbol(, Decl(contextualTyping35.ts, 0, 26))
 >id : Symbol(id, Decl(contextualTyping35.ts, 0, 28))
 >name : Symbol(name, Decl(contextualTyping35.ts, 0, 33))
 
diff --git a/tests/baselines/reference/contextualTyping36.symbols b/tests/baselines/reference/contextualTyping36.symbols
index acaacd2b77c4d..28ceac9738cc3 100644
--- a/tests/baselines/reference/contextualTyping36.symbols
+++ b/tests/baselines/reference/contextualTyping36.symbols
@@ -2,8 +2,6 @@
 var foo = <{ id: number; }[]>[{ id: 4 }, <{ id: number; }>({  })];
 >foo : Symbol(foo, Decl(contextualTyping36.ts, 0, 3))
 >id : Symbol(id, Decl(contextualTyping36.ts, 0, 12))
->{ id: 4 } : Symbol(, Decl(contextualTyping36.ts, 0, 30))
 >id : Symbol(id, Decl(contextualTyping36.ts, 0, 31))
 >id : Symbol(id, Decl(contextualTyping36.ts, 0, 43))
->{  } : Symbol(, Decl(contextualTyping36.ts, 0, 59))
 
diff --git a/tests/baselines/reference/contextualTyping37.symbols b/tests/baselines/reference/contextualTyping37.symbols
index 34cef3cdefe89..083704750cb35 100644
--- a/tests/baselines/reference/contextualTyping37.symbols
+++ b/tests/baselines/reference/contextualTyping37.symbols
@@ -2,7 +2,5 @@
 var foo = <{ id: number; }[]>[{ foo: "s" }, {  }];
 >foo : Symbol(foo, Decl(contextualTyping37.ts, 0, 3))
 >id : Symbol(id, Decl(contextualTyping37.ts, 0, 12))
->{ foo: "s" } : Symbol(, Decl(contextualTyping37.ts, 0, 30))
 >foo : Symbol(foo, Decl(contextualTyping37.ts, 0, 31))
->{  } : Symbol(, Decl(contextualTyping37.ts, 0, 43))
 
diff --git a/tests/baselines/reference/contextualTyping38.symbols b/tests/baselines/reference/contextualTyping38.symbols
index 35bf1def858bd..f208cad698a7f 100644
--- a/tests/baselines/reference/contextualTyping38.symbols
+++ b/tests/baselines/reference/contextualTyping38.symbols
@@ -1,7 +1,6 @@
 === tests/cases/compiler/contextualTyping38.ts ===
 var foo = <{ (): number; }> function(a) { return a };
 >foo : Symbol(foo, Decl(contextualTyping38.ts, 0, 3))
->function(a) { return a } : Symbol((Anonymous function), Decl(contextualTyping38.ts, 0, 27))
 >a : Symbol(a, Decl(contextualTyping38.ts, 0, 37))
 >a : Symbol(a, Decl(contextualTyping38.ts, 0, 37))
 
diff --git a/tests/baselines/reference/contextualTyping4.symbols b/tests/baselines/reference/contextualTyping4.symbols
index a640a8c0701c2..c5dcd4f1577bc 100644
--- a/tests/baselines/reference/contextualTyping4.symbols
+++ b/tests/baselines/reference/contextualTyping4.symbols
@@ -3,7 +3,6 @@ class foo { public bar:{id:number;} = {id:5, name:"foo"}; }
 >foo : Symbol(foo, Decl(contextualTyping4.ts, 0, 0))
 >bar : Symbol(bar, Decl(contextualTyping4.ts, 0, 11))
 >id : Symbol(id, Decl(contextualTyping4.ts, 0, 24))
->{id:5, name:"foo"} : Symbol(, Decl(contextualTyping4.ts, 0, 37))
 >id : Symbol(id, Decl(contextualTyping4.ts, 0, 39))
 >name : Symbol(name, Decl(contextualTyping4.ts, 0, 44))
 
diff --git a/tests/baselines/reference/contextualTyping40.symbols b/tests/baselines/reference/contextualTyping40.symbols
index 10148051f4218..8606cdd4c41b4 100644
--- a/tests/baselines/reference/contextualTyping40.symbols
+++ b/tests/baselines/reference/contextualTyping40.symbols
@@ -2,5 +2,4 @@
 var foo = <{():number; (i:number):number; }> function(){return 1;};
 >foo : Symbol(foo, Decl(contextualTyping40.ts, 0, 3))
 >i : Symbol(i, Decl(contextualTyping40.ts, 0, 24))
->function(){return 1;} : Symbol((Anonymous function), Decl(contextualTyping40.ts, 0, 44))
 
diff --git a/tests/baselines/reference/contextualTyping6.symbols b/tests/baselines/reference/contextualTyping6.symbols
index b8a2e229f8728..23af71d7dba79 100644
--- a/tests/baselines/reference/contextualTyping6.symbols
+++ b/tests/baselines/reference/contextualTyping6.symbols
@@ -2,8 +2,6 @@
 var foo:{id:number;}[] = [{id:1}, {id:2}];
 >foo : Symbol(foo, Decl(contextualTyping6.ts, 0, 3))
 >id : Symbol(id, Decl(contextualTyping6.ts, 0, 9))
->{id:1} : Symbol(, Decl(contextualTyping6.ts, 0, 26))
 >id : Symbol(id, Decl(contextualTyping6.ts, 0, 27))
->{id:2} : Symbol(, Decl(contextualTyping6.ts, 0, 33))
 >id : Symbol(id, Decl(contextualTyping6.ts, 0, 35))
 
diff --git a/tests/baselines/reference/contextualTyping7.symbols b/tests/baselines/reference/contextualTyping7.symbols
index e54d5e60f2591..679c1945f338a 100644
--- a/tests/baselines/reference/contextualTyping7.symbols
+++ b/tests/baselines/reference/contextualTyping7.symbols
@@ -3,5 +3,4 @@ var foo:{id:number;}[] = [<{id:number;}>({})];
 >foo : Symbol(foo, Decl(contextualTyping7.ts, 0, 3))
 >id : Symbol(id, Decl(contextualTyping7.ts, 0, 9))
 >id : Symbol(id, Decl(contextualTyping7.ts, 0, 28))
->{} : Symbol(, Decl(contextualTyping7.ts, 0, 41))
 
diff --git a/tests/baselines/reference/contextualTyping8.symbols b/tests/baselines/reference/contextualTyping8.symbols
index 23505250cc2eb..7dadb937ea1e2 100644
--- a/tests/baselines/reference/contextualTyping8.symbols
+++ b/tests/baselines/reference/contextualTyping8.symbols
@@ -3,5 +3,4 @@ var foo:{id:number;}[] = [<{id:number;}>({})];
 >foo : Symbol(foo, Decl(contextualTyping8.ts, 0, 3))
 >id : Symbol(id, Decl(contextualTyping8.ts, 0, 9))
 >id : Symbol(id, Decl(contextualTyping8.ts, 0, 28))
->{} : Symbol(, Decl(contextualTyping8.ts, 0, 41))
 
diff --git a/tests/baselines/reference/contextualTyping9.symbols b/tests/baselines/reference/contextualTyping9.symbols
index 0984f3cdef620..f9ef2220c2013 100644
--- a/tests/baselines/reference/contextualTyping9.symbols
+++ b/tests/baselines/reference/contextualTyping9.symbols
@@ -2,9 +2,7 @@
 var foo:{id:number;}[] = [{id:1}, {id:2, name:"foo"}];
 >foo : Symbol(foo, Decl(contextualTyping9.ts, 0, 3))
 >id : Symbol(id, Decl(contextualTyping9.ts, 0, 9))
->{id:1} : Symbol(, Decl(contextualTyping9.ts, 0, 26))
 >id : Symbol(id, Decl(contextualTyping9.ts, 0, 27))
->{id:2, name:"foo"} : Symbol(, Decl(contextualTyping9.ts, 0, 33))
 >id : Symbol(id, Decl(contextualTyping9.ts, 0, 35))
 >name : Symbol(name, Decl(contextualTyping9.ts, 0, 40))
 
diff --git a/tests/baselines/reference/contextualTypingArrayOfLambdas.symbols b/tests/baselines/reference/contextualTypingArrayOfLambdas.symbols
index 1cbf653d1d16d..79355e0a7c633 100644
--- a/tests/baselines/reference/contextualTypingArrayOfLambdas.symbols
+++ b/tests/baselines/reference/contextualTypingArrayOfLambdas.symbols
@@ -24,13 +24,10 @@ class C extends A {
 
 var xs = [(x: A) => { }, (x: B) => { }, (x: C) => { }];
 >xs : Symbol(xs, Decl(contextualTypingArrayOfLambdas.ts, 12, 3))
->(x: A) => { } : Symbol((Anonymous function), Decl(contextualTypingArrayOfLambdas.ts, 12, 10))
 >x : Symbol(x, Decl(contextualTypingArrayOfLambdas.ts, 12, 11))
 >A : Symbol(A, Decl(contextualTypingArrayOfLambdas.ts, 0, 0))
->(x: B) => { } : Symbol((Anonymous function), Decl(contextualTypingArrayOfLambdas.ts, 12, 24))
 >x : Symbol(x, Decl(contextualTypingArrayOfLambdas.ts, 12, 26))
 >B : Symbol(B, Decl(contextualTypingArrayOfLambdas.ts, 2, 1))
->(x: C) => { } : Symbol((Anonymous function), Decl(contextualTypingArrayOfLambdas.ts, 12, 39))
 >x : Symbol(x, Decl(contextualTypingArrayOfLambdas.ts, 12, 41))
 >C : Symbol(C, Decl(contextualTypingArrayOfLambdas.ts, 6, 1))
 
diff --git a/tests/baselines/reference/contextualTypingOfConditionalExpression.symbols b/tests/baselines/reference/contextualTypingOfConditionalExpression.symbols
index eb689aeab180c..56c3abe0627d9 100644
--- a/tests/baselines/reference/contextualTypingOfConditionalExpression.symbols
+++ b/tests/baselines/reference/contextualTypingOfConditionalExpression.symbols
@@ -2,12 +2,10 @@
 var x: (a: number) => void = true ? (a) => a.toExponential() : (b) => b.toFixed();
 >x : Symbol(x, Decl(contextualTypingOfConditionalExpression.ts, 0, 3))
 >a : Symbol(a, Decl(contextualTypingOfConditionalExpression.ts, 0, 8))
->(a) => a.toExponential() : Symbol((Anonymous function), Decl(contextualTypingOfConditionalExpression.ts, 0, 35))
 >a : Symbol(a, Decl(contextualTypingOfConditionalExpression.ts, 0, 37))
 >a.toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45))
 >a : Symbol(a, Decl(contextualTypingOfConditionalExpression.ts, 0, 37))
 >toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45))
->(b) => b.toFixed() : Symbol((Anonymous function), Decl(contextualTypingOfConditionalExpression.ts, 0, 62))
 >b : Symbol(b, Decl(contextualTypingOfConditionalExpression.ts, 0, 64))
 >b.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
 >b : Symbol(b, Decl(contextualTypingOfConditionalExpression.ts, 0, 64))
@@ -38,12 +36,10 @@ var x2: (a: A) => void = true ? (a) => a.foo : (b) => b.foo;
 >x2 : Symbol(x2, Decl(contextualTypingOfConditionalExpression.ts, 12, 3))
 >a : Symbol(a, Decl(contextualTypingOfConditionalExpression.ts, 12, 9))
 >A : Symbol(A, Decl(contextualTypingOfConditionalExpression.ts, 0, 82))
->(a) => a.foo : Symbol((Anonymous function), Decl(contextualTypingOfConditionalExpression.ts, 12, 31))
 >a : Symbol(a, Decl(contextualTypingOfConditionalExpression.ts, 12, 33))
 >a.foo : Symbol(A.foo, Decl(contextualTypingOfConditionalExpression.ts, 2, 9))
 >a : Symbol(a, Decl(contextualTypingOfConditionalExpression.ts, 12, 33))
 >foo : Symbol(A.foo, Decl(contextualTypingOfConditionalExpression.ts, 2, 9))
->(b) => b.foo : Symbol((Anonymous function), Decl(contextualTypingOfConditionalExpression.ts, 12, 46))
 >b : Symbol(b, Decl(contextualTypingOfConditionalExpression.ts, 12, 48))
 >b.foo : Symbol(A.foo, Decl(contextualTypingOfConditionalExpression.ts, 2, 9))
 >b : Symbol(b, Decl(contextualTypingOfConditionalExpression.ts, 12, 48))
diff --git a/tests/baselines/reference/contextualTypingOfLambdaWithMultipleSignatures.symbols b/tests/baselines/reference/contextualTypingOfLambdaWithMultipleSignatures.symbols
index 5ec69fd43aa06..3a0c8e5db97a4 100644
--- a/tests/baselines/reference/contextualTypingOfLambdaWithMultipleSignatures.symbols
+++ b/tests/baselines/reference/contextualTypingOfLambdaWithMultipleSignatures.symbols
@@ -19,6 +19,5 @@ foo.getFoo = bar => { };
 >foo.getFoo : Symbol(Foo.getFoo, Decl(contextualTypingOfLambdaWithMultipleSignatures.ts, 0, 15), Decl(contextualTypingOfLambdaWithMultipleSignatures.ts, 1, 28))
 >foo : Symbol(foo, Decl(contextualTypingOfLambdaWithMultipleSignatures.ts, 5, 3))
 >getFoo : Symbol(Foo.getFoo, Decl(contextualTypingOfLambdaWithMultipleSignatures.ts, 0, 15), Decl(contextualTypingOfLambdaWithMultipleSignatures.ts, 1, 28))
->bar => { } : Symbol((Anonymous function), Decl(contextualTypingOfLambdaWithMultipleSignatures.ts, 6, 12))
 >bar : Symbol(bar, Decl(contextualTypingOfLambdaWithMultipleSignatures.ts, 6, 12))
 
diff --git a/tests/baselines/reference/contextualTypingOfLambdaWithMultipleSignatures2.symbols b/tests/baselines/reference/contextualTypingOfLambdaWithMultipleSignatures2.symbols
index edac6b9b1a875..f44d33e1ba8ea 100644
--- a/tests/baselines/reference/contextualTypingOfLambdaWithMultipleSignatures2.symbols
+++ b/tests/baselines/reference/contextualTypingOfLambdaWithMultipleSignatures2.symbols
@@ -12,7 +12,6 @@ var f: {
 
 f = (a) => { return a.asdf }
 >f : Symbol(f, Decl(contextualTypingOfLambdaWithMultipleSignatures2.ts, 0, 3))
->(a) => { return a.asdf } : Symbol((Anonymous function), Decl(contextualTypingOfLambdaWithMultipleSignatures2.ts, 5, 3))
 >a : Symbol(a, Decl(contextualTypingOfLambdaWithMultipleSignatures2.ts, 5, 5))
 >a : Symbol(a, Decl(contextualTypingOfLambdaWithMultipleSignatures2.ts, 5, 5))
 
diff --git a/tests/baselines/reference/contextualTypingTwoInstancesOfSameTypeParameter.symbols b/tests/baselines/reference/contextualTypingTwoInstancesOfSameTypeParameter.symbols
index f2c4121a139be..62870f575c7b0 100644
--- a/tests/baselines/reference/contextualTypingTwoInstancesOfSameTypeParameter.symbols
+++ b/tests/baselines/reference/contextualTypingTwoInstancesOfSameTypeParameter.symbols
@@ -11,10 +11,8 @@ function f6<T>(x: (a: T) => T) {
 } 
 f6(x => f6(y => x = y));
 >f6 : Symbol(f6, Decl(contextualTypingTwoInstancesOfSameTypeParameter.ts, 0, 0))
->x => f6(y => x = y) : Symbol((Anonymous function), Decl(contextualTypingTwoInstancesOfSameTypeParameter.ts, 3, 3))
 >x : Symbol(x, Decl(contextualTypingTwoInstancesOfSameTypeParameter.ts, 3, 3))
 >f6 : Symbol(f6, Decl(contextualTypingTwoInstancesOfSameTypeParameter.ts, 0, 0))
->y => x = y : Symbol((Anonymous function), Decl(contextualTypingTwoInstancesOfSameTypeParameter.ts, 3, 11))
 >y : Symbol(y, Decl(contextualTypingTwoInstancesOfSameTypeParameter.ts, 3, 11))
 >x : Symbol(x, Decl(contextualTypingTwoInstancesOfSameTypeParameter.ts, 3, 3))
 >y : Symbol(y, Decl(contextualTypingTwoInstancesOfSameTypeParameter.ts, 3, 11))
diff --git a/tests/baselines/reference/contextualTypingWithGenericAndNonGenericSignature.symbols b/tests/baselines/reference/contextualTypingWithGenericAndNonGenericSignature.symbols
index d764033e4dae2..d7ba6f0ddc376 100644
--- a/tests/baselines/reference/contextualTypingWithGenericAndNonGenericSignature.symbols
+++ b/tests/baselines/reference/contextualTypingWithGenericAndNonGenericSignature.symbols
@@ -21,7 +21,6 @@ var f2: {
 
 f2 = (x, y) => { return x }
 >f2 : Symbol(f2, Decl(contextualTypingWithGenericAndNonGenericSignature.ts, 2, 3))
->(x, y) => { return x } : Symbol((Anonymous function), Decl(contextualTypingWithGenericAndNonGenericSignature.ts, 7, 4))
 >x : Symbol(x, Decl(contextualTypingWithGenericAndNonGenericSignature.ts, 7, 6))
 >y : Symbol(y, Decl(contextualTypingWithGenericAndNonGenericSignature.ts, 7, 8))
 >x : Symbol(x, Decl(contextualTypingWithGenericAndNonGenericSignature.ts, 7, 6))
@@ -46,7 +45,6 @@ var f3: {
 
 f3 = (x, y) => { return x }
 >f3 : Symbol(f3, Decl(contextualTypingWithGenericAndNonGenericSignature.ts, 9, 3))
->(x, y) => { return x } : Symbol((Anonymous function), Decl(contextualTypingWithGenericAndNonGenericSignature.ts, 14, 4))
 >x : Symbol(x, Decl(contextualTypingWithGenericAndNonGenericSignature.ts, 14, 6))
 >y : Symbol(y, Decl(contextualTypingWithGenericAndNonGenericSignature.ts, 14, 8))
 >x : Symbol(x, Decl(contextualTypingWithGenericAndNonGenericSignature.ts, 14, 6))
diff --git a/tests/baselines/reference/contextualTypingWithGenericSignature.symbols b/tests/baselines/reference/contextualTypingWithGenericSignature.symbols
index c564a3b264c91..c416a5ca19fda 100644
--- a/tests/baselines/reference/contextualTypingWithGenericSignature.symbols
+++ b/tests/baselines/reference/contextualTypingWithGenericSignature.symbols
@@ -17,7 +17,6 @@ var f2: {
 
 f2 = (x, y) => { return x }
 >f2 : Symbol(f2, Decl(contextualTypingWithGenericSignature.ts, 2, 3))
->(x, y) => { return x } : Symbol((Anonymous function), Decl(contextualTypingWithGenericSignature.ts, 6, 4))
 >x : Symbol(x, Decl(contextualTypingWithGenericSignature.ts, 6, 6))
 >y : Symbol(y, Decl(contextualTypingWithGenericSignature.ts, 6, 8))
 >x : Symbol(x, Decl(contextualTypingWithGenericSignature.ts, 6, 6))
diff --git a/tests/baselines/reference/contextuallyTypedFunctionExpressionsAndReturnAnnotations.symbols b/tests/baselines/reference/contextuallyTypedFunctionExpressionsAndReturnAnnotations.symbols
index 1a01e2db77ce3..810f407e1b22f 100644
--- a/tests/baselines/reference/contextuallyTypedFunctionExpressionsAndReturnAnnotations.symbols
+++ b/tests/baselines/reference/contextuallyTypedFunctionExpressionsAndReturnAnnotations.symbols
@@ -8,7 +8,6 @@ declare function foo(x: (y: string) => (y2: number) => void);
 // Contextually type the parameter even if there is a return annotation
 foo((y): (y2: number) => void => {
 >foo : Symbol(foo, Decl(contextuallyTypedFunctionExpressionsAndReturnAnnotations.ts, 0, 0))
->(y): (y2: number) => void => {    var z = y.charAt(0); // Should be string    return null;} : Symbol((Anonymous function), Decl(contextuallyTypedFunctionExpressionsAndReturnAnnotations.ts, 3, 4))
 >y : Symbol(y, Decl(contextuallyTypedFunctionExpressionsAndReturnAnnotations.ts, 3, 5))
 >y2 : Symbol(y2, Decl(contextuallyTypedFunctionExpressionsAndReturnAnnotations.ts, 3, 10))
 
@@ -23,11 +22,9 @@ foo((y): (y2: number) => void => {
 
 foo((y: string) => {
 >foo : Symbol(foo, Decl(contextuallyTypedFunctionExpressionsAndReturnAnnotations.ts, 0, 0))
->(y: string) => {    return y2 => {        var z = y2.toFixed(); // Should be string        return 0;    };} : Symbol((Anonymous function), Decl(contextuallyTypedFunctionExpressionsAndReturnAnnotations.ts, 8, 4))
 >y : Symbol(y, Decl(contextuallyTypedFunctionExpressionsAndReturnAnnotations.ts, 8, 5))
 
     return y2 => {
->y2 => {        var z = y2.toFixed(); // Should be string        return 0;    } : Symbol((Anonymous function), Decl(contextuallyTypedFunctionExpressionsAndReturnAnnotations.ts, 9, 10))
 >y2 : Symbol(y2, Decl(contextuallyTypedFunctionExpressionsAndReturnAnnotations.ts, 9, 10))
 
         var z = y2.toFixed(); // Should be string
diff --git a/tests/baselines/reference/contextuallyTypingOrOperator.symbols b/tests/baselines/reference/contextuallyTypingOrOperator.symbols
index d53a476e049d7..18019aea7cb3e 100644
--- a/tests/baselines/reference/contextuallyTypingOrOperator.symbols
+++ b/tests/baselines/reference/contextuallyTypingOrOperator.symbols
@@ -3,44 +3,34 @@ var v: { a: (_: string) => number } = { a: s => s.length } || { a: s => 1 };
 >v : Symbol(v, Decl(contextuallyTypingOrOperator.ts, 0, 3))
 >a : Symbol(a, Decl(contextuallyTypingOrOperator.ts, 0, 8))
 >_ : Symbol(_, Decl(contextuallyTypingOrOperator.ts, 0, 13))
->{ a: s => s.length } : Symbol(, Decl(contextuallyTypingOrOperator.ts, 0, 37))
 >a : Symbol(a, Decl(contextuallyTypingOrOperator.ts, 0, 39))
->s => s.length : Symbol((Anonymous function), Decl(contextuallyTypingOrOperator.ts, 0, 42))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 0, 42))
 >s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 0, 42))
 >length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
->{ a: s => 1 } : Symbol(, Decl(contextuallyTypingOrOperator.ts, 0, 61))
 >a : Symbol(a, Decl(contextuallyTypingOrOperator.ts, 0, 63))
->s => 1 : Symbol((Anonymous function), Decl(contextuallyTypingOrOperator.ts, 0, 66))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 0, 66))
 
 var v2 = (s: string) => s.length || function (s) { s.length };
 >v2 : Symbol(v2, Decl(contextuallyTypingOrOperator.ts, 2, 3))
->(s: string) => s.length || function (s) { s.length } : Symbol((Anonymous function), Decl(contextuallyTypingOrOperator.ts, 2, 8))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 2, 10))
 >s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 2, 10))
 >length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
->function (s) { s.length } : Symbol((Anonymous function), Decl(contextuallyTypingOrOperator.ts, 2, 35))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 2, 46))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 2, 46))
 
 var v3 = (s: string) => s.length || function (s: number) { return 1 };
 >v3 : Symbol(v3, Decl(contextuallyTypingOrOperator.ts, 4, 3))
->(s: string) => s.length || function (s: number) { return 1 } : Symbol((Anonymous function), Decl(contextuallyTypingOrOperator.ts, 4, 8))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 4, 10))
 >s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 4, 10))
 >length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
->function (s: number) { return 1 } : Symbol((Anonymous function), Decl(contextuallyTypingOrOperator.ts, 4, 35))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 4, 46))
 
 var v4 = (s: number) => 1 || function (s: string) { return s.length };
 >v4 : Symbol(v4, Decl(contextuallyTypingOrOperator.ts, 5, 3))
->(s: number) => 1 || function (s: string) { return s.length } : Symbol((Anonymous function), Decl(contextuallyTypingOrOperator.ts, 5, 8))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 5, 10))
->function (s: string) { return s.length } : Symbol((Anonymous function), Decl(contextuallyTypingOrOperator.ts, 5, 28))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 5, 39))
 >s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 5, 39))
diff --git a/tests/baselines/reference/contextuallyTypingOrOperator2.symbols b/tests/baselines/reference/contextuallyTypingOrOperator2.symbols
index 70e12183c7445..99e328fd64a44 100644
--- a/tests/baselines/reference/contextuallyTypingOrOperator2.symbols
+++ b/tests/baselines/reference/contextuallyTypingOrOperator2.symbols
@@ -3,26 +3,20 @@ var v: { a: (_: string) => number } = { a: s => s.length } || { a: s => 1 };
 >v : Symbol(v, Decl(contextuallyTypingOrOperator2.ts, 0, 3))
 >a : Symbol(a, Decl(contextuallyTypingOrOperator2.ts, 0, 8))
 >_ : Symbol(_, Decl(contextuallyTypingOrOperator2.ts, 0, 13))
->{ a: s => s.length } : Symbol(, Decl(contextuallyTypingOrOperator2.ts, 0, 37))
 >a : Symbol(a, Decl(contextuallyTypingOrOperator2.ts, 0, 39))
->s => s.length : Symbol((Anonymous function), Decl(contextuallyTypingOrOperator2.ts, 0, 42))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator2.ts, 0, 42))
 >s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator2.ts, 0, 42))
 >length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
->{ a: s => 1 } : Symbol(, Decl(contextuallyTypingOrOperator2.ts, 0, 61))
 >a : Symbol(a, Decl(contextuallyTypingOrOperator2.ts, 0, 63))
->s => 1 : Symbol((Anonymous function), Decl(contextuallyTypingOrOperator2.ts, 0, 66))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator2.ts, 0, 66))
 
 var v2 = (s: string) => s.length || function (s) { s.aaa };
 >v2 : Symbol(v2, Decl(contextuallyTypingOrOperator2.ts, 2, 3))
->(s: string) => s.length || function (s) { s.aaa } : Symbol((Anonymous function), Decl(contextuallyTypingOrOperator2.ts, 2, 8))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator2.ts, 2, 10))
 >s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator2.ts, 2, 10))
 >length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
->function (s) { s.aaa } : Symbol((Anonymous function), Decl(contextuallyTypingOrOperator2.ts, 2, 35))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator2.ts, 2, 46))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator2.ts, 2, 46))
 
diff --git a/tests/baselines/reference/covariance1.symbols b/tests/baselines/reference/covariance1.symbols
index 2a7342cd15346..db055e20bc6e3 100644
--- a/tests/baselines/reference/covariance1.symbols
+++ b/tests/baselines/reference/covariance1.symbols
@@ -27,7 +27,6 @@ module M {
 
     f({x:a}); // ok
 >f : Symbol(f, Decl(covariance1.ts, 5, 24))
->{x:a} : Symbol(, Decl(covariance1.ts, 10, 6))
 >x : Symbol(x, Decl(covariance1.ts, 10, 7))
 >a : Symbol(a, Decl(covariance1.ts, 9, 7))
 
@@ -37,7 +36,6 @@ module M {
 
     f({x:b}); // ok covariant subtype
 >f : Symbol(f, Decl(covariance1.ts, 5, 24))
->{x:b} : Symbol(, Decl(covariance1.ts, 13, 6))
 >x : Symbol(x, Decl(covariance1.ts, 13, 7))
 >b : Symbol(b, Decl(covariance1.ts, 12, 7))
 }
diff --git a/tests/baselines/reference/crashInResolveInterface.symbols b/tests/baselines/reference/crashInResolveInterface.symbols
index 0b25f96354d72..c10bf0b26a89a 100644
--- a/tests/baselines/reference/crashInResolveInterface.symbols
+++ b/tests/baselines/reference/crashInResolveInterface.symbols
@@ -42,7 +42,6 @@ var x = q1.each(x => c.log(x));
 >q1.each : Symbol(Q.each, Decl(file1.ts, 0, 16))
 >q1 : Symbol(q1, Decl(file1.ts, 3, 3))
 >each : Symbol(Q.each, Decl(file1.ts, 0, 16))
->x => c.log(x) : Symbol((Anonymous function), Decl(file1.ts, 4, 16))
 >x : Symbol(x, Decl(file1.ts, 4, 16))
 >c.log : Symbol(C.log, Decl(file2.ts, 5, 13))
 >c : Symbol(c, Decl(file2.ts, 1, 11))
diff --git a/tests/baselines/reference/debuggerEmit.symbols b/tests/baselines/reference/debuggerEmit.symbols
index d4688006839e6..b8f6228a99dcd 100644
--- a/tests/baselines/reference/debuggerEmit.symbols
+++ b/tests/baselines/reference/debuggerEmit.symbols
@@ -1,7 +1,6 @@
 === tests/cases/compiler/debuggerEmit.ts ===
 var x = function () { debugger; }
 >x : Symbol(x, Decl(debuggerEmit.ts, 0, 3))
->function () { debugger; } : Symbol((Anonymous function), Decl(debuggerEmit.ts, 0, 7))
 
 x();
 >x : Symbol(x, Decl(debuggerEmit.ts, 0, 3))
diff --git a/tests/baselines/reference/declFileModuleAssignmentInObjectLiteralProperty.symbols b/tests/baselines/reference/declFileModuleAssignmentInObjectLiteralProperty.symbols
index d9ff8d742f75f..b47f6faeb5072 100644
--- a/tests/baselines/reference/declFileModuleAssignmentInObjectLiteralProperty.symbols
+++ b/tests/baselines/reference/declFileModuleAssignmentInObjectLiteralProperty.symbols
@@ -9,17 +9,14 @@ module m1 {
 }
 var d = {
 >d : Symbol(d, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 5, 3))
->{    m1: { m: m1 },    m2: { c: m1.c },} : Symbol(, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 5, 7))
 
     m1: { m: m1 },
 >m1 : Symbol(m1, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 5, 9))
->{ m: m1 } : Symbol(, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 6, 7))
 >m : Symbol(m, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 6, 9))
 >m1 : Symbol(m1, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 0, 0))
 
     m2: { c: m1.c },
 >m2 : Symbol(m2, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 6, 18))
->{ c: m1.c } : Symbol(, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 7, 7))
 >c : Symbol(c, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 7, 9))
 >m1.c : Symbol(m1.c, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 1, 11))
 >m1 : Symbol(m1, Decl(declFileModuleAssignmentInObjectLiteralProperty.ts, 0, 0))
diff --git a/tests/baselines/reference/declFileRegressionTests.symbols b/tests/baselines/reference/declFileRegressionTests.symbols
index 796760cc272f6..ea8f9e2fe2a01 100644
--- a/tests/baselines/reference/declFileRegressionTests.symbols
+++ b/tests/baselines/reference/declFileRegressionTests.symbols
@@ -3,11 +3,9 @@
 // function types not piped through correctly
 var n = { w: null, x: '', y: () => { }, z: 32 };
 >n : Symbol(n, Decl(declFileRegressionTests.ts, 2, 3))
->{ w: null, x: '', y: () => { }, z: 32 } : Symbol(, Decl(declFileRegressionTests.ts, 2, 7))
 >w : Symbol(w, Decl(declFileRegressionTests.ts, 2, 9))
 >x : Symbol(x, Decl(declFileRegressionTests.ts, 2, 18))
 >y : Symbol(y, Decl(declFileRegressionTests.ts, 2, 25))
->() => { } : Symbol((Anonymous function), Decl(declFileRegressionTests.ts, 2, 28))
 >z : Symbol(z, Decl(declFileRegressionTests.ts, 2, 39))
 
 
diff --git a/tests/baselines/reference/declFileRestParametersOfFunctionAndFunctionType.symbols b/tests/baselines/reference/declFileRestParametersOfFunctionAndFunctionType.symbols
index 1c224ef7da278..49758e4ceb1e4 100644
--- a/tests/baselines/reference/declFileRestParametersOfFunctionAndFunctionType.symbols
+++ b/tests/baselines/reference/declFileRestParametersOfFunctionAndFunctionType.symbols
@@ -26,7 +26,6 @@ function f5<T extends { (...args): void }>() { }
 
 var f6 = () => { return [<any>10]; }
 >f6 : Symbol(f6, Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 6, 3))
->() => { return [<any>10]; } : Symbol((Anonymous function), Decl(declFileRestParametersOfFunctionAndFunctionType.ts, 6, 8))
 
 
 
diff --git a/tests/baselines/reference/declFileTypeAnnotationArrayType.symbols b/tests/baselines/reference/declFileTypeAnnotationArrayType.symbols
index f43c1523add64..9092189c3c734 100644
--- a/tests/baselines/reference/declFileTypeAnnotationArrayType.symbols
+++ b/tests/baselines/reference/declFileTypeAnnotationArrayType.symbols
@@ -95,13 +95,11 @@ function foo9(): (()=>c)[] {
 >c : Symbol(c, Decl(declFileTypeAnnotationArrayType.ts, 0, 0))
 
     return [() => new c()];
->() => new c() : Symbol((Anonymous function), Decl(declFileTypeAnnotationArrayType.ts, 46, 12))
 >c : Symbol(c, Decl(declFileTypeAnnotationArrayType.ts, 0, 0))
 }
 function foo10() {
 >foo10 : Symbol(foo10, Decl(declFileTypeAnnotationArrayType.ts, 47, 1))
 
     return [() => new c()];
->() => new c() : Symbol((Anonymous function), Decl(declFileTypeAnnotationArrayType.ts, 49, 12))
 >c : Symbol(c, Decl(declFileTypeAnnotationArrayType.ts, 0, 0))
 }
diff --git a/tests/baselines/reference/declFileTypeAnnotationParenType.symbols b/tests/baselines/reference/declFileTypeAnnotationParenType.symbols
index c7eaf967babbc..bc5668b70bd7e 100644
--- a/tests/baselines/reference/declFileTypeAnnotationParenType.symbols
+++ b/tests/baselines/reference/declFileTypeAnnotationParenType.symbols
@@ -10,22 +10,18 @@ class c {
 var x: (() => c)[] = [() => new c()];
 >x : Symbol(x, Decl(declFileTypeAnnotationParenType.ts, 5, 3))
 >c : Symbol(c, Decl(declFileTypeAnnotationParenType.ts, 0, 0))
->() => new c() : Symbol((Anonymous function), Decl(declFileTypeAnnotationParenType.ts, 5, 22))
 >c : Symbol(c, Decl(declFileTypeAnnotationParenType.ts, 0, 0))
 
 var y = [() => new c()];
 >y : Symbol(y, Decl(declFileTypeAnnotationParenType.ts, 6, 3))
->() => new c() : Symbol((Anonymous function), Decl(declFileTypeAnnotationParenType.ts, 6, 9))
 >c : Symbol(c, Decl(declFileTypeAnnotationParenType.ts, 0, 0))
 
 var k: (() => c) | string = (() => new c()) || "";
 >k : Symbol(k, Decl(declFileTypeAnnotationParenType.ts, 8, 3))
 >c : Symbol(c, Decl(declFileTypeAnnotationParenType.ts, 0, 0))
->() => new c() : Symbol((Anonymous function), Decl(declFileTypeAnnotationParenType.ts, 8, 29))
 >c : Symbol(c, Decl(declFileTypeAnnotationParenType.ts, 0, 0))
 
 var l = (() => new c()) || "";
 >l : Symbol(l, Decl(declFileTypeAnnotationParenType.ts, 9, 3))
->() => new c() : Symbol((Anonymous function), Decl(declFileTypeAnnotationParenType.ts, 9, 9))
 >c : Symbol(c, Decl(declFileTypeAnnotationParenType.ts, 0, 0))
 
diff --git a/tests/baselines/reference/declFileTypeAnnotationTupleType.symbols b/tests/baselines/reference/declFileTypeAnnotationTupleType.symbols
index 3445b419a110a..9eea6dfd9f953 100644
--- a/tests/baselines/reference/declFileTypeAnnotationTupleType.symbols
+++ b/tests/baselines/reference/declFileTypeAnnotationTupleType.symbols
@@ -44,7 +44,6 @@ var x: [g<string>, m.g<number>, () => c] = [new g<string>(), new m.g<number>(),
 >m.g : Symbol(m.g, Decl(declFileTypeAnnotationTupleType.ts, 5, 5))
 >m : Symbol(m, Decl(declFileTypeAnnotationTupleType.ts, 2, 1))
 >g : Symbol(m.g, Decl(declFileTypeAnnotationTupleType.ts, 5, 5))
->() => new c() : Symbol((Anonymous function), Decl(declFileTypeAnnotationTupleType.ts, 16, 79))
 >c : Symbol(c, Decl(declFileTypeAnnotationTupleType.ts, 0, 0))
 
 var y = x;
diff --git a/tests/baselines/reference/declFileTypeAnnotationUnionType.symbols b/tests/baselines/reference/declFileTypeAnnotationUnionType.symbols
index 1ed4129b583e5..f57df197579b6 100644
--- a/tests/baselines/reference/declFileTypeAnnotationUnionType.symbols
+++ b/tests/baselines/reference/declFileTypeAnnotationUnionType.symbols
@@ -59,7 +59,6 @@ var x: g<string> | m.g<number> |  (() => c) = new g<string>() ||  new m.g<number
 >m.g : Symbol(m.g, Decl(declFileTypeAnnotationUnionType.ts, 7, 5))
 >m : Symbol(m, Decl(declFileTypeAnnotationUnionType.ts, 3, 1))
 >g : Symbol(m.g, Decl(declFileTypeAnnotationUnionType.ts, 7, 5))
->() => new c() : Symbol((Anonymous function), Decl(declFileTypeAnnotationUnionType.ts, 20, 88))
 >c : Symbol(c, Decl(declFileTypeAnnotationUnionType.ts, 0, 0))
 
 var y = new g<string>() || new m.g<number>() || (() => new c());
@@ -68,6 +67,5 @@ var y = new g<string>() || new m.g<number>() || (() => new c());
 >m.g : Symbol(m.g, Decl(declFileTypeAnnotationUnionType.ts, 7, 5))
 >m : Symbol(m, Decl(declFileTypeAnnotationUnionType.ts, 3, 1))
 >g : Symbol(m.g, Decl(declFileTypeAnnotationUnionType.ts, 7, 5))
->() => new c() : Symbol((Anonymous function), Decl(declFileTypeAnnotationUnionType.ts, 21, 49))
 >c : Symbol(c, Decl(declFileTypeAnnotationUnionType.ts, 0, 0))
 
diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.symbols b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.symbols
deleted file mode 100644
index da8017f570aa6..0000000000000
--- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.symbols
+++ /dev/null
@@ -1,182 +0,0 @@
-=== tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts ===
-
-module m {
->m : Symbol(m, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 0, 0))
-
-    class private1 {
->private1 : Symbol(private1, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 1, 10))
-    }
-
-    export class public1 {
->public1 : Symbol(public1, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 3, 5))
-    }
-
-    module m2 {
->m2 : Symbol(m2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 6, 5))
-
-        export class public2 {
->public2 : Symbol(public2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 8, 15))
-        }
-    }
-    
-    export class c {
->c : Symbol(c, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 11, 5))
-
-        // getter with annotation
-        get foo1(): private1 {
->foo1 : Symbol(foo1, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 13, 20))
->private1 : Symbol(private1, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 1, 10))
-
-            return;
-        }
-
-        // getter without annotation
-        get foo2() {
->foo2 : Symbol(foo2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 17, 9))
-
-            return new private1();
->private1 : Symbol(private1, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 1, 10))
-        }
-
-        // setter with annotation
-        set foo3(param: private1) {
->foo3 : Symbol(foo3, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 22, 9))
->param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 25, 17))
->private1 : Symbol(private1, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 1, 10))
-        }
-
-        // Both - getter without annotation, setter with annotation
-        get foo4() {
->foo4 : Symbol(foo4, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 26, 9), Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 31, 9))
-
-            return new private1();
->private1 : Symbol(private1, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 1, 10))
-        }
-        set foo4(param: private1) {
->foo4 : Symbol(foo4, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 26, 9), Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 31, 9))
->param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 32, 17))
->private1 : Symbol(private1, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 1, 10))
-        }
-
-        // Both - with annotation
-        get foo5(): private1 {
->foo5 : Symbol(foo5, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 33, 9), Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 38, 9))
->private1 : Symbol(private1, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 1, 10))
-
-            return;
-        }
-        set foo5(param: private1) {
->foo5 : Symbol(foo5, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 33, 9), Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 38, 9))
->param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 39, 17))
->private1 : Symbol(private1, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 1, 10))
-        }
-    
-        // getter with annotation
-        get foo11(): public1 {
->foo11 : Symbol(foo11, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 40, 9))
->public1 : Symbol(public1, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 3, 5))
-
-            return;
-        }
-
-        // getter without annotation
-        get foo12() {
->foo12 : Symbol(foo12, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 45, 9))
-
-            return new public1();
->public1 : Symbol(public1, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 3, 5))
-        }
-
-        // setter with annotation
-        set foo13(param: public1) {
->foo13 : Symbol(foo13, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 50, 9))
->param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 53, 18))
->public1 : Symbol(public1, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 3, 5))
-        }
-
-        // Both - getter without annotation, setter with annotation
-        get foo14() {
->foo14 : Symbol(foo14, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 54, 9), Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 59, 9))
-
-            return new public1();
->public1 : Symbol(public1, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 3, 5))
-        }
-        set foo14(param: public1) {
->foo14 : Symbol(foo14, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 54, 9), Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 59, 9))
->param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 60, 18))
->public1 : Symbol(public1, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 3, 5))
-        }
-
-        // Both - with annotation
-        get foo15(): public1 {
->foo15 : Symbol(foo15, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 61, 9), Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 66, 9))
->public1 : Symbol(public1, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 3, 5))
-
-            return;
-        }
-        set foo15(param: public1) {
->foo15 : Symbol(foo15, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 61, 9), Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 66, 9))
->param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 67, 18))
->public1 : Symbol(public1, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 3, 5))
-        }
-
-        // getter with annotation
-        get foo111(): m2.public2 {
->foo111 : Symbol(foo111, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 68, 9))
->m2 : Symbol(m2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 6, 5))
->public2 : Symbol(m2.public2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 8, 15))
-
-            return;
-        }
-
-        // getter without annotation
-        get foo112() {
->foo112 : Symbol(foo112, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 73, 9))
-
-            return new m2.public2();
->m2.public2 : Symbol(m2.public2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 8, 15))
->m2 : Symbol(m2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 6, 5))
->public2 : Symbol(m2.public2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 8, 15))
-        }
-
-        // setter with annotation
-        set foo113(param: m2.public2) {
->foo113 : Symbol(foo113, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 78, 9))
->param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 81, 19))
->m2 : Symbol(m2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 6, 5))
->public2 : Symbol(m2.public2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 8, 15))
-        }
-
-        // Both - getter without annotation, setter with annotation
-        get foo114() {
->foo114 : Symbol(foo114, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 82, 9), Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 87, 9))
-
-            return new m2.public2();
->m2.public2 : Symbol(m2.public2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 8, 15))
->m2 : Symbol(m2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 6, 5))
->public2 : Symbol(m2.public2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 8, 15))
-        }
-        set foo114(param: m2.public2) {
->foo114 : Symbol(foo114, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 82, 9), Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 87, 9))
->param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 88, 19))
->m2 : Symbol(m2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 6, 5))
->public2 : Symbol(m2.public2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 8, 15))
-        }
-
-        // Both - with annotation
-        get foo115(): m2.public2 {
->foo115 : Symbol(foo115, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 89, 9), Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 94, 9))
->m2 : Symbol(m2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 6, 5))
->public2 : Symbol(m2.public2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 8, 15))
-
-            return;
-        }
-        set foo115(param: m2.public2) {
->foo115 : Symbol(foo115, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 89, 9), Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 94, 9))
->param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 95, 19))
->m2 : Symbol(m2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 6, 5))
->public2 : Symbol(m2.public2, Decl(declFileTypeAnnotationVisibilityErrorAccessors.ts, 8, 15))
-        }
-    }
-}
-
diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorParameterOfFunction.symbols b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorParameterOfFunction.symbols
deleted file mode 100644
index 9bdfecf1f51ca..0000000000000
--- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorParameterOfFunction.symbols
+++ /dev/null
@@ -1,95 +0,0 @@
-=== tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts ===
-
-module m {
->m : Symbol(m, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 0, 0))
-
-    class private1 {
->private1 : Symbol(private1, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 1, 10))
-    }
-
-    export class public1 {
->public1 : Symbol(public1, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 3, 5))
-    }
-
-    // Directly using names from this module
-    function foo1(param: private1) {
->foo1 : Symbol(foo1, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 6, 5))
->param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 9, 18))
->private1 : Symbol(private1, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 1, 10))
-    }
-    function foo2(param = new private1()) {
->foo2 : Symbol(foo2, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 10, 5))
->param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 11, 18))
->private1 : Symbol(private1, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 1, 10))
-    }
-
-    export function foo3(param : private1) {
->foo3 : Symbol(foo3, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 12, 5))
->param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 14, 25))
->private1 : Symbol(private1, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 1, 10))
-    }
-    export function foo4(param = new private1()) {
->foo4 : Symbol(foo4, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 15, 5))
->param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 16, 25))
->private1 : Symbol(private1, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 1, 10))
-    }
-
-    function foo11(param: public1) {
->foo11 : Symbol(foo11, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 17, 5))
->param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 19, 19))
->public1 : Symbol(public1, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 3, 5))
-    }
-    function foo12(param = new public1()) {
->foo12 : Symbol(foo12, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 20, 5))
->param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 21, 19))
->public1 : Symbol(public1, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 3, 5))
-    }
-
-    export function foo13(param: public1) {
->foo13 : Symbol(foo13, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 22, 5))
->param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 24, 26))
->public1 : Symbol(public1, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 3, 5))
-    }
-    export function foo14(param = new public1()) {
->foo14 : Symbol(foo14, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 25, 5))
->param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 26, 26))
->public1 : Symbol(public1, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 3, 5))
-    }
-
-    module m2 {
->m2 : Symbol(m2, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 27, 5))
-
-        export class public2 {
->public2 : Symbol(public2, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 29, 15))
-        }
-    }
-
-    function foo111(param: m2.public2) {
->foo111 : Symbol(foo111, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 32, 5))
->param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 34, 20))
->m2 : Symbol(m2, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 27, 5))
->public2 : Symbol(m2.public2, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 29, 15))
-    }
-    function foo112(param = new m2.public2()) {
->foo112 : Symbol(foo112, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 35, 5))
->param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 36, 20))
->m2.public2 : Symbol(m2.public2, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 29, 15))
->m2 : Symbol(m2, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 27, 5))
->public2 : Symbol(m2.public2, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 29, 15))
-    }
-
-    export function foo113(param: m2.public2) {
->foo113 : Symbol(foo113, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 37, 5))
->param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 39, 27))
->m2 : Symbol(m2, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 27, 5))
->public2 : Symbol(m2.public2, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 29, 15))
-    }
-    export function foo114(param = new m2.public2()) {
->foo114 : Symbol(foo114, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 40, 5))
->param : Symbol(param, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 41, 27))
->m2.public2 : Symbol(m2.public2, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 29, 15))
->m2 : Symbol(m2, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 27, 5))
->public2 : Symbol(m2.public2, Decl(declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts, 29, 15))
-    }
-}
-
diff --git a/tests/baselines/reference/declFileTypeofFunction.symbols b/tests/baselines/reference/declFileTypeofFunction.symbols
index 62a10457029ca..649c09cba0662 100644
--- a/tests/baselines/reference/declFileTypeofFunction.symbols
+++ b/tests/baselines/reference/declFileTypeofFunction.symbols
@@ -55,14 +55,12 @@ var foo2 = foo;
 
 var foo3 = function () {
 >foo3 : Symbol(foo3, Decl(declFileTypeofFunction.ts, 20, 3))
->function () {    return foo3;} : Symbol((Anonymous function), Decl(declFileTypeofFunction.ts, 20, 10))
 
     return foo3;
 >foo3 : Symbol(foo3, Decl(declFileTypeofFunction.ts, 20, 3))
 }
 var x = () => {
 >x : Symbol(x, Decl(declFileTypeofFunction.ts, 23, 3))
->() => {    return x;} : Symbol((Anonymous function), Decl(declFileTypeofFunction.ts, 23, 7))
 
     return x;
 >x : Symbol(x, Decl(declFileTypeofFunction.ts, 23, 3))
diff --git a/tests/baselines/reference/declFileTypeofInAnonymousType.symbols b/tests/baselines/reference/declFileTypeofInAnonymousType.symbols
index 7065168d7259e..426f953d6f214 100644
--- a/tests/baselines/reference/declFileTypeofInAnonymousType.symbols
+++ b/tests/baselines/reference/declFileTypeofInAnonymousType.symbols
@@ -27,7 +27,6 @@ var a: { c: m1.c; };
 
 var b = {
 >b : Symbol(b, Decl(declFileTypeofInAnonymousType.ts, 11, 3))
->{    c: m1.c,    m1: m1} : Symbol(, Decl(declFileTypeofInAnonymousType.ts, 11, 7))
 
     c: m1.c,
 >c : Symbol(c, Decl(declFileTypeofInAnonymousType.ts, 11, 9))
@@ -42,23 +41,19 @@ var b = {
 };
 var c = { m1: m1 };
 >c : Symbol(c, Decl(declFileTypeofInAnonymousType.ts, 15, 3))
->{ m1: m1 } : Symbol(, Decl(declFileTypeofInAnonymousType.ts, 15, 7))
 >m1 : Symbol(m1, Decl(declFileTypeofInAnonymousType.ts, 15, 9))
 >m1 : Symbol(m1, Decl(declFileTypeofInAnonymousType.ts, 0, 0))
 
 var d = {
 >d : Symbol(d, Decl(declFileTypeofInAnonymousType.ts, 16, 3))
->{    m: { mod: m1 },    mc: { cl: m1.c },    me: { en: m1.e },    mh: m1.e.holiday} : Symbol(, Decl(declFileTypeofInAnonymousType.ts, 16, 7))
 
     m: { mod: m1 },
 >m : Symbol(m, Decl(declFileTypeofInAnonymousType.ts, 16, 9))
->{ mod: m1 } : Symbol(, Decl(declFileTypeofInAnonymousType.ts, 17, 6))
 >mod : Symbol(mod, Decl(declFileTypeofInAnonymousType.ts, 17, 8))
 >m1 : Symbol(m1, Decl(declFileTypeofInAnonymousType.ts, 0, 0))
 
     mc: { cl: m1.c },
 >mc : Symbol(mc, Decl(declFileTypeofInAnonymousType.ts, 17, 19))
->{ cl: m1.c } : Symbol(, Decl(declFileTypeofInAnonymousType.ts, 18, 7))
 >cl : Symbol(cl, Decl(declFileTypeofInAnonymousType.ts, 18, 9))
 >m1.c : Symbol(m1.c, Decl(declFileTypeofInAnonymousType.ts, 1, 11))
 >m1 : Symbol(m1, Decl(declFileTypeofInAnonymousType.ts, 0, 0))
@@ -66,7 +61,6 @@ var d = {
 
     me: { en: m1.e },
 >me : Symbol(me, Decl(declFileTypeofInAnonymousType.ts, 18, 21))
->{ en: m1.e } : Symbol(, Decl(declFileTypeofInAnonymousType.ts, 19, 7))
 >en : Symbol(en, Decl(declFileTypeofInAnonymousType.ts, 19, 9))
 >m1.e : Symbol(m1.e, Decl(declFileTypeofInAnonymousType.ts, 3, 5))
 >m1 : Symbol(m1, Decl(declFileTypeofInAnonymousType.ts, 0, 0))
diff --git a/tests/baselines/reference/declInput3.symbols b/tests/baselines/reference/declInput3.symbols
index 40e169510b988..06f35db0164e3 100644
--- a/tests/baselines/reference/declInput3.symbols
+++ b/tests/baselines/reference/declInput3.symbols
@@ -12,7 +12,6 @@ class bar {
 
   public g() { return {a: <bar>null, b: undefined, c: void 4 }; }
 >g : Symbol(g, Decl(declInput3.ts, 5, 27))
->{a: <bar>null, b: undefined, c: void 4 } : Symbol(, Decl(declInput3.ts, 6, 21))
 >a : Symbol(a, Decl(declInput3.ts, 6, 23))
 >bar : Symbol(bar, Decl(declInput3.ts, 2, 1))
 >b : Symbol(b, Decl(declInput3.ts, 6, 36))
diff --git a/tests/baselines/reference/declarationEmitDestructuring4.symbols b/tests/baselines/reference/declarationEmitDestructuring4.symbols
index 29270ecd92f0b..9f2eb162b6fe2 100644
--- a/tests/baselines/reference/declarationEmitDestructuring4.symbols
+++ b/tests/baselines/reference/declarationEmitDestructuring4.symbols
@@ -16,7 +16,6 @@ function baz3({}) { }
 
 function baz4({} = { x: 10 }) { }
 >baz4 : Symbol(baz4, Decl(declarationEmitDestructuring4.ts, 7, 21))
->{ x: 10 } : Symbol(, Decl(declarationEmitDestructuring4.ts, 8, 18))
 >x : Symbol(x, Decl(declarationEmitDestructuring4.ts, 8, 20))
 
 
diff --git a/tests/baselines/reference/declarationEmitDestructuringArrayPattern2.symbols b/tests/baselines/reference/declarationEmitDestructuringArrayPattern2.symbols
index 031e660053ebb..9e0e48f89e8a3 100644
--- a/tests/baselines/reference/declarationEmitDestructuringArrayPattern2.symbols
+++ b/tests/baselines/reference/declarationEmitDestructuringArrayPattern2.symbols
@@ -18,10 +18,8 @@ var [a2, [b2, { x12, y12: c2 }]=["abc", { x12: 10, y12: false }]] = [1, ["hello"
 >b2 : Symbol(b2, Decl(declarationEmitDestructuringArrayPattern2.ts, 5, 10))
 >x12 : Symbol(x12, Decl(declarationEmitDestructuringArrayPattern2.ts, 5, 15))
 >c2 : Symbol(c2, Decl(declarationEmitDestructuringArrayPattern2.ts, 5, 20))
->{ x12: 10, y12: false } : Symbol(, Decl(declarationEmitDestructuringArrayPattern2.ts, 5, 39))
 >x12 : Symbol(x12, Decl(declarationEmitDestructuringArrayPattern2.ts, 5, 41))
 >y12 : Symbol(y12, Decl(declarationEmitDestructuringArrayPattern2.ts, 5, 50))
->{ x12: 5, y12: true } : Symbol(, Decl(declarationEmitDestructuringArrayPattern2.ts, 5, 81))
 >x12 : Symbol(x12, Decl(declarationEmitDestructuringArrayPattern2.ts, 5, 83))
 >y12 : Symbol(y12, Decl(declarationEmitDestructuringArrayPattern2.ts, 5, 91))
 
@@ -34,7 +32,6 @@ var [a3, b3] = [[x13, y13], { x: x13, y: y13 }];
 >b3 : Symbol(b3, Decl(declarationEmitDestructuringArrayPattern2.ts, 8, 8))
 >x13 : Symbol(x13, Decl(declarationEmitDestructuringArrayPattern2.ts, 7, 5))
 >y13 : Symbol(y13, Decl(declarationEmitDestructuringArrayPattern2.ts, 7, 9))
->{ x: x13, y: y13 } : Symbol(, Decl(declarationEmitDestructuringArrayPattern2.ts, 8, 27))
 >x : Symbol(x, Decl(declarationEmitDestructuringArrayPattern2.ts, 8, 29))
 >x13 : Symbol(x13, Decl(declarationEmitDestructuringArrayPattern2.ts, 7, 5))
 >y : Symbol(y, Decl(declarationEmitDestructuringArrayPattern2.ts, 8, 37))
diff --git a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern.symbols b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern.symbols
index bf9a1f31f0581..3cb4ef28c2bbd 100644
--- a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern.symbols
+++ b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern.symbols
@@ -1,45 +1,38 @@
 === tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern.ts ===
 
 var { } = { x: 5, y: "hello" };
->{ x: 5, y: "hello" } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 1, 9))
 >x : Symbol(x, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 1, 11))
 >y : Symbol(y, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 1, 17))
 
 var { x4 } = { x4: 5, y4: "hello" };
 >x4 : Symbol(x4, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 2, 5))
->{ x4: 5, y4: "hello" } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 2, 12))
 >x4 : Symbol(x4, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 2, 14))
 >y4 : Symbol(y4, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 2, 21))
 
 var { y5 } = { x5: 5, y5: "hello" };
 >y5 : Symbol(y5, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 3, 5))
->{ x5: 5, y5: "hello" } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 3, 12))
 >x5 : Symbol(x5, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 3, 14))
 >y5 : Symbol(y5, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 3, 21))
 
 var { x6, y6 } = { x6: 5, y6: "hello" };
 >x6 : Symbol(x6, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 4, 5))
 >y6 : Symbol(y6, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 4, 9))
->{ x6: 5, y6: "hello" } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 4, 16))
 >x6 : Symbol(x6, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 4, 18))
 >y6 : Symbol(y6, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 4, 25))
 
 var { x7: a1 } = { x7: 5, y7: "hello" };
 >a1 : Symbol(a1, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 5, 5))
->{ x7: 5, y7: "hello" } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 5, 16))
 >x7 : Symbol(x7, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 5, 18))
 >y7 : Symbol(y7, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 5, 25))
 
 var { y8: b1 } = { x8: 5, y8: "hello" };
 >b1 : Symbol(b1, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 6, 5))
->{ x8: 5, y8: "hello" } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 6, 16))
 >x8 : Symbol(x8, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 6, 18))
 >y8 : Symbol(y8, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 6, 25))
 
 var { x9: a2, y9: b2 } = { x9: 5, y9: "hello" };
 >a2 : Symbol(a2, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 7, 5))
 >b2 : Symbol(b2, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 7, 13))
->{ x9: 5, y9: "hello" } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 7, 24))
 >x9 : Symbol(x9, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 7, 26))
 >y9 : Symbol(y9, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 7, 33))
 
@@ -47,13 +40,10 @@ var { a: x11, b: { a: y11, b: { a: z11 }}} = { a: 1, b: { a: "hello", b: { a: tr
 >x11 : Symbol(x11, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 9, 5))
 >y11 : Symbol(y11, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 9, 18))
 >z11 : Symbol(z11, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 9, 31))
->{ a: 1, b: { a: "hello", b: { a: true } } } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 9, 44))
 >a : Symbol(a, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 9, 46))
 >b : Symbol(b, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 9, 52))
->{ a: "hello", b: { a: true } } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 9, 55))
 >a : Symbol(a, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 9, 57))
 >b : Symbol(b, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 9, 69))
->{ a: true } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 9, 72))
 >a : Symbol(a, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 9, 74))
 
 function f15() {
@@ -69,7 +59,6 @@ function f15() {
 >c4 : Symbol(c4, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 14, 7))
 
     return { a4, b4, c4 };
->{ a4, b4, c4 } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 15, 10))
 >a4 : Symbol(a4, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 15, 12))
 >b4 : Symbol(b4, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 15, 16))
 >c4 : Symbol(c4, Decl(declarationEmitDestructuringObjectLiteralPattern.ts, 15, 20))
diff --git a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern1.symbols b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern1.symbols
index 51e85849739ad..a4c43a07bc85e 100644
--- a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern1.symbols
+++ b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern1.symbols
@@ -1,45 +1,38 @@
 === tests/cases/compiler/declarationEmitDestructuringObjectLiteralPattern1.ts ===
 
 var { } = { x: 5, y: "hello" };
->{ x: 5, y: "hello" } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 1, 9))
 >x : Symbol(x, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 1, 11))
 >y : Symbol(y, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 1, 17))
 
 var { x4 } = { x4: 5, y4: "hello" };
 >x4 : Symbol(x4, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 2, 5))
->{ x4: 5, y4: "hello" } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 2, 12))
 >x4 : Symbol(x4, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 2, 14))
 >y4 : Symbol(y4, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 2, 21))
 
 var { y5 } = { x5: 5, y5: "hello" };
 >y5 : Symbol(y5, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 3, 5))
->{ x5: 5, y5: "hello" } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 3, 12))
 >x5 : Symbol(x5, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 3, 14))
 >y5 : Symbol(y5, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 3, 21))
 
 var { x6, y6 } = { x6: 5, y6: "hello" };
 >x6 : Symbol(x6, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 4, 5))
 >y6 : Symbol(y6, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 4, 9))
->{ x6: 5, y6: "hello" } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 4, 16))
 >x6 : Symbol(x6, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 4, 18))
 >y6 : Symbol(y6, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 4, 25))
 
 var { x7: a1 } = { x7: 5, y7: "hello" };
 >a1 : Symbol(a1, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 5, 5))
->{ x7: 5, y7: "hello" } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 5, 16))
 >x7 : Symbol(x7, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 5, 18))
 >y7 : Symbol(y7, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 5, 25))
 
 var { y8: b1 } = { x8: 5, y8: "hello" };
 >b1 : Symbol(b1, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 6, 5))
->{ x8: 5, y8: "hello" } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 6, 16))
 >x8 : Symbol(x8, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 6, 18))
 >y8 : Symbol(y8, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 6, 25))
 
 var { x9: a2, y9: b2 } = { x9: 5, y9: "hello" };
 >a2 : Symbol(a2, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 7, 5))
 >b2 : Symbol(b2, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 7, 13))
->{ x9: 5, y9: "hello" } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 7, 24))
 >x9 : Symbol(x9, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 7, 26))
 >y9 : Symbol(y9, Decl(declarationEmitDestructuringObjectLiteralPattern1.ts, 7, 33))
 
diff --git a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern2.symbols b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern2.symbols
index c4af268af2322..76440b600382d 100644
--- a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern2.symbols
+++ b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern2.symbols
@@ -4,13 +4,10 @@ var { a: x11, b: { a: y11, b: { a: z11 }}} = { a: 1, b: { a: "hello", b: { a: tr
 >x11 : Symbol(x11, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 5))
 >y11 : Symbol(y11, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 18))
 >z11 : Symbol(z11, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 31))
->{ a: 1, b: { a: "hello", b: { a: true } } } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 44))
 >a : Symbol(a, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 46))
 >b : Symbol(b, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 52))
->{ a: "hello", b: { a: true } } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 55))
 >a : Symbol(a, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 57))
 >b : Symbol(b, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 69))
->{ a: true } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 72))
 >a : Symbol(a, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 1, 74))
 
 function f15() {
@@ -26,7 +23,6 @@ function f15() {
 >c4 : Symbol(c4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 6, 7))
 
     return { a4, b4, c4 };
->{ a4, b4, c4 } : Symbol(, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 7, 10))
 >a4 : Symbol(a4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 7, 12))
 >b4 : Symbol(b4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 7, 16))
 >c4 : Symbol(c4, Decl(declarationEmitDestructuringObjectLiteralPattern2.ts, 7, 20))
diff --git a/tests/baselines/reference/declarationEmitDestructuringPrivacyError.symbols b/tests/baselines/reference/declarationEmitDestructuringPrivacyError.symbols
deleted file mode 100644
index caca0d45b7b33..0000000000000
--- a/tests/baselines/reference/declarationEmitDestructuringPrivacyError.symbols
+++ /dev/null
@@ -1,13 +0,0 @@
-=== tests/cases/compiler/declarationEmitDestructuringPrivacyError.ts ===
-module m {
->m : Symbol(m, Decl(declarationEmitDestructuringPrivacyError.ts, 0, 0))
-
-    class c {
->c : Symbol(c, Decl(declarationEmitDestructuringPrivacyError.ts, 0, 10))
-    }
-    export var [x, y, z] = [10, new c(), 30];
->x : Symbol(x, Decl(declarationEmitDestructuringPrivacyError.ts, 3, 16))
->y : Symbol(y, Decl(declarationEmitDestructuringPrivacyError.ts, 3, 18))
->z : Symbol(z, Decl(declarationEmitDestructuringPrivacyError.ts, 3, 21))
->c : Symbol(c, Decl(declarationEmitDestructuringPrivacyError.ts, 0, 10))
-}
diff --git a/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.symbols b/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.symbols
index 0702e77f72f0f..f7c96097cafda 100644
--- a/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.symbols
+++ b/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.symbols
@@ -13,7 +13,6 @@ function filter(handler: any) {
 >handler : Symbol(handler, Decl(b.ts, 2, 16))
 
     return function (target: any, propertyKey: string) {
->function (target: any, propertyKey: string) {        // ...    } : Symbol((Anonymous function), Decl(b.ts, 3, 10))
 >target : Symbol(target, Decl(b.ts, 3, 21))
 >propertyKey : Symbol(propertyKey, Decl(b.ts, 3, 33))
 
@@ -26,7 +25,6 @@ class Wat {
 
     @filter(() => test == 'abc')
 >filter : Symbol(filter, Decl(b.ts, 0, 27))
->() => test == 'abc' : Symbol((Anonymous function), Decl(b.ts, 9, 12))
 >test : Symbol(test, Decl(b.ts, 0, 8))
 
     static whatever() {
diff --git a/tests/baselines/reference/decrementOperatorWithAnyOtherType.symbols b/tests/baselines/reference/decrementOperatorWithAnyOtherType.symbols
index fddefe467b072..594e6d50ac475 100644
--- a/tests/baselines/reference/decrementOperatorWithAnyOtherType.symbols
+++ b/tests/baselines/reference/decrementOperatorWithAnyOtherType.symbols
@@ -12,7 +12,6 @@ var ANY2: any[] = ["", ""];
 
 var obj = {x:1,y:null};
 >obj : Symbol(obj, Decl(decrementOperatorWithAnyOtherType.ts, 5, 3))
->{x:1,y:null} : Symbol(, Decl(decrementOperatorWithAnyOtherType.ts, 5, 9))
 >x : Symbol(x, Decl(decrementOperatorWithAnyOtherType.ts, 5, 11))
 >y : Symbol(y, Decl(decrementOperatorWithAnyOtherType.ts, 5, 15))
 
diff --git a/tests/baselines/reference/defaultIndexProps1.symbols b/tests/baselines/reference/defaultIndexProps1.symbols
index 48a3c48c89acd..e294b9e7dba37 100644
--- a/tests/baselines/reference/defaultIndexProps1.symbols
+++ b/tests/baselines/reference/defaultIndexProps1.symbols
@@ -17,7 +17,6 @@ var q = f["v"];
 
 var o = {v:"Yo2"};
 >o : Symbol(o, Decl(defaultIndexProps1.ts, 8, 3))
->{v:"Yo2"} : Symbol(, Decl(defaultIndexProps1.ts, 8, 7))
 >v : Symbol(v, Decl(defaultIndexProps1.ts, 8, 9))
 
 var q2 = o["v"];
diff --git a/tests/baselines/reference/defaultIndexProps2.symbols b/tests/baselines/reference/defaultIndexProps2.symbols
index 0049f3a57907f..53d433351c331 100644
--- a/tests/baselines/reference/defaultIndexProps2.symbols
+++ b/tests/baselines/reference/defaultIndexProps2.symbols
@@ -14,7 +14,6 @@ var f = new Foo();
 
 var o = {v:"Yo2"};
 >o : Symbol(o, Decl(defaultIndexProps2.ts, 8, 3))
->{v:"Yo2"} : Symbol(, Decl(defaultIndexProps2.ts, 8, 7))
 >v : Symbol(v, Decl(defaultIndexProps2.ts, 8, 9))
 
 // WScript.Echo(o[0]);
diff --git a/tests/baselines/reference/deleteOperatorWithBooleanType.symbols b/tests/baselines/reference/deleteOperatorWithBooleanType.symbols
index a02e9e50a06e0..71cb78760f6d2 100644
--- a/tests/baselines/reference/deleteOperatorWithBooleanType.symbols
+++ b/tests/baselines/reference/deleteOperatorWithBooleanType.symbols
@@ -37,7 +37,6 @@ var ResultIsBoolean2 = delete true;
 
 var ResultIsBoolean3 = delete { x: true, y: false };
 >ResultIsBoolean3 : Symbol(ResultIsBoolean3, Decl(deleteOperatorWithBooleanType.ts, 20, 3))
->{ x: true, y: false } : Symbol(, Decl(deleteOperatorWithBooleanType.ts, 20, 29))
 >x : Symbol(x, Decl(deleteOperatorWithBooleanType.ts, 20, 31))
 >y : Symbol(y, Decl(deleteOperatorWithBooleanType.ts, 20, 40))
 
diff --git a/tests/baselines/reference/deleteOperatorWithNumberType.symbols b/tests/baselines/reference/deleteOperatorWithNumberType.symbols
index 42a0709d442be..589b1f91db274 100644
--- a/tests/baselines/reference/deleteOperatorWithNumberType.symbols
+++ b/tests/baselines/reference/deleteOperatorWithNumberType.symbols
@@ -44,16 +44,13 @@ var ResultIsBoolean3 = delete 1;
 
 var ResultIsBoolean4 = delete { x: 1, y: 2};
 >ResultIsBoolean4 : Symbol(ResultIsBoolean4, Decl(deleteOperatorWithNumberType.ts, 22, 3))
->{ x: 1, y: 2} : Symbol(, Decl(deleteOperatorWithNumberType.ts, 22, 29))
 >x : Symbol(x, Decl(deleteOperatorWithNumberType.ts, 22, 31))
 >y : Symbol(y, Decl(deleteOperatorWithNumberType.ts, 22, 37))
 
 var ResultIsBoolean5 = delete { x: 1, y: (n: number) => { return n; } };
 >ResultIsBoolean5 : Symbol(ResultIsBoolean5, Decl(deleteOperatorWithNumberType.ts, 23, 3))
->{ x: 1, y: (n: number) => { return n; } } : Symbol(, Decl(deleteOperatorWithNumberType.ts, 23, 29))
 >x : Symbol(x, Decl(deleteOperatorWithNumberType.ts, 23, 31))
 >y : Symbol(y, Decl(deleteOperatorWithNumberType.ts, 23, 37))
->(n: number) => { return n; } : Symbol((Anonymous function), Decl(deleteOperatorWithNumberType.ts, 23, 40))
 >n : Symbol(n, Decl(deleteOperatorWithNumberType.ts, 23, 42))
 >n : Symbol(n, Decl(deleteOperatorWithNumberType.ts, 23, 42))
 
diff --git a/tests/baselines/reference/deleteOperatorWithStringType.symbols b/tests/baselines/reference/deleteOperatorWithStringType.symbols
index 38a6b057316d6..a13ddd5fa3982 100644
--- a/tests/baselines/reference/deleteOperatorWithStringType.symbols
+++ b/tests/baselines/reference/deleteOperatorWithStringType.symbols
@@ -44,16 +44,13 @@ var ResultIsBoolean3 = delete "";
 
 var ResultIsBoolean4 = delete { x: "", y: "" };
 >ResultIsBoolean4 : Symbol(ResultIsBoolean4, Decl(deleteOperatorWithStringType.ts, 22, 3))
->{ x: "", y: "" } : Symbol(, Decl(deleteOperatorWithStringType.ts, 22, 29))
 >x : Symbol(x, Decl(deleteOperatorWithStringType.ts, 22, 31))
 >y : Symbol(y, Decl(deleteOperatorWithStringType.ts, 22, 38))
 
 var ResultIsBoolean5 = delete { x: "", y: (s: string) => { return s; } };
 >ResultIsBoolean5 : Symbol(ResultIsBoolean5, Decl(deleteOperatorWithStringType.ts, 23, 3))
->{ x: "", y: (s: string) => { return s; } } : Symbol(, Decl(deleteOperatorWithStringType.ts, 23, 29))
 >x : Symbol(x, Decl(deleteOperatorWithStringType.ts, 23, 31))
 >y : Symbol(y, Decl(deleteOperatorWithStringType.ts, 23, 38))
->(s: string) => { return s; } : Symbol((Anonymous function), Decl(deleteOperatorWithStringType.ts, 23, 41))
 >s : Symbol(s, Decl(deleteOperatorWithStringType.ts, 23, 43))
 >s : Symbol(s, Decl(deleteOperatorWithStringType.ts, 23, 43))
 
diff --git a/tests/baselines/reference/derivedClasses.symbols b/tests/baselines/reference/derivedClasses.symbols
index 160738bb02b71..f265c2dce538f 100644
--- a/tests/baselines/reference/derivedClasses.symbols
+++ b/tests/baselines/reference/derivedClasses.symbols
@@ -8,7 +8,6 @@ class Red extends Color {
 
     	var getHue = () => { return this.hue(); };
 >getHue : Symbol(getHue, Decl(derivedClasses.ts, 2, 8))
->() => { return this.hue(); } : Symbol((Anonymous function), Decl(derivedClasses.ts, 2, 17))
 >this.hue : Symbol(Color.hue, Decl(derivedClasses.ts, 8, 43))
 >this : Symbol(Red, Decl(derivedClasses.ts, 0, 0))
 >hue : Symbol(Color.hue, Decl(derivedClasses.ts, 8, 43))
@@ -37,7 +36,6 @@ class Blue extends Color {
 
     	var getHue = () => { return this.hue(); };
 >getHue : Symbol(getHue, Decl(derivedClasses.ts, 15, 8))
->() => { return this.hue(); } : Symbol((Anonymous function), Decl(derivedClasses.ts, 15, 17))
 >this.hue : Symbol(Color.hue, Decl(derivedClasses.ts, 8, 43))
 >this : Symbol(Blue, Decl(derivedClasses.ts, 10, 1))
 >hue : Symbol(Color.hue, Decl(derivedClasses.ts, 8, 43))
diff --git a/tests/baselines/reference/derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.symbols b/tests/baselines/reference/derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.symbols
index f2c8c911109e5..e935d7bf66aa2 100644
--- a/tests/baselines/reference/derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.symbols
+++ b/tests/baselines/reference/derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.symbols
@@ -35,7 +35,6 @@ class Derived extends Base {
 >super.foo : Symbol(Base.foo, Decl(derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.ts, 0, 12))
 >super : Symbol(Base, Decl(derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.ts, 0, 0))
 >foo : Symbol(Base.foo, Decl(derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.ts, 0, 12))
->{ a: 1 } : Symbol(, Decl(derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.ts, 12, 26))
 >a : Symbol(a, Decl(derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.ts, 12, 27))
 
         var r2 = super.foo({ a: 1, b: 2 }); // { a: number }
@@ -43,7 +42,6 @@ class Derived extends Base {
 >super.foo : Symbol(Base.foo, Decl(derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.ts, 0, 12))
 >super : Symbol(Base, Decl(derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.ts, 0, 0))
 >foo : Symbol(Base.foo, Decl(derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.ts, 0, 12))
->{ a: 1, b: 2 } : Symbol(, Decl(derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.ts, 13, 27))
 >a : Symbol(a, Decl(derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.ts, 13, 28))
 >b : Symbol(b, Decl(derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.ts, 13, 34))
 
@@ -52,7 +50,6 @@ class Derived extends Base {
 >this.foo : Symbol(foo, Decl(derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.ts, 6, 28))
 >this : Symbol(Derived, Decl(derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.ts, 4, 1))
 >foo : Symbol(foo, Decl(derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.ts, 6, 28))
->{ a: 1, b: 2 } : Symbol(, Decl(derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.ts, 14, 26))
 >a : Symbol(a, Decl(derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.ts, 14, 27))
 >b : Symbol(b, Decl(derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.ts, 14, 33))
     }
diff --git a/tests/baselines/reference/destructuringObjectBindingPatternAndAssignment1ES5.symbols b/tests/baselines/reference/destructuringObjectBindingPatternAndAssignment1ES5.symbols
index 9f0c56317ecc9..017a7f71e612e 100644
--- a/tests/baselines/reference/destructuringObjectBindingPatternAndAssignment1ES5.symbols
+++ b/tests/baselines/reference/destructuringObjectBindingPatternAndAssignment1ES5.symbols
@@ -10,39 +10,30 @@ var { a1 }: any = undefined;
 
 var { a2 }: any = {};
 >a2 : Symbol(a2, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 6, 5))
->{} : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 6, 17))
 
 // V is an object assignment pattern and, for each assignment property P in V,
 //      S has an apparent property with the property name specified in
 //          P of a type that is assignable to the target given in P, or
 var { b1, } = { b1:1, };
 >b1 : Symbol(b1, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 11, 5))
->{ b1:1, } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 11, 13))
 >b1 : Symbol(b1, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 11, 15))
 
 var { b2: { b21 } = { b21: "string" }  } = { b2: { b21: "world" } };
 >b21 : Symbol(b21, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 12, 11))
->{ b21: "string" } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 12, 19))
 >b21 : Symbol(b21, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 12, 21))
->{ b2: { b21: "world" } } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 12, 42))
 >b2 : Symbol(b2, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 12, 44))
->{ b21: "world" } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 12, 48))
 >b21 : Symbol(b21, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 12, 50))
 
 var {1: b3} = { 1: "string" };
 >b3 : Symbol(b3, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 13, 5))
->{ 1: "string" } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 13, 13))
 
 var {b4 = 1}: any = { b4: 100000 };
 >b4 : Symbol(b4, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 14, 5))
->{ b4: 100000 } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 14, 19))
 >b4 : Symbol(b4, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 14, 21))
 
 var {b5: { b52 }  } = { b5: { b52 } };
 >b52 : Symbol(b52, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 15, 10))
->{ b5: { b52 } } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 15, 21))
 >b5 : Symbol(b5, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 15, 23))
->{ b52 } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 15, 27))
 >b52 : Symbol(b52, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 15, 29))
 
 // V is an object assignment pattern and, for each assignment property P in V,
@@ -61,8 +52,6 @@ function foo(): F {
 >F : Symbol(F, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 15, 38))
 
     return {
->{        1: true    } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 26, 10))
-
         1: true
     };
 }
@@ -72,8 +61,6 @@ function bar(): F {
 >F : Symbol(F, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 15, 38))
 
     return {
->{        2: true    } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 32, 10))
-
         2: true
     };
 }
@@ -100,8 +87,6 @@ function foo1(): F1 {
 >F1 : Symbol(F1, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 37, 20))
 
     return {
->{        "prop1": 2    } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 47, 10))
-
         "prop1": 2
     }
 }
diff --git a/tests/baselines/reference/destructuringObjectBindingPatternAndAssignment1ES6.symbols b/tests/baselines/reference/destructuringObjectBindingPatternAndAssignment1ES6.symbols
index ca8c301f0386b..11289210ee4d4 100644
--- a/tests/baselines/reference/destructuringObjectBindingPatternAndAssignment1ES6.symbols
+++ b/tests/baselines/reference/destructuringObjectBindingPatternAndAssignment1ES6.symbols
@@ -10,39 +10,30 @@ var { a1 }: any = undefined;
 
 var { a2 }: any = {};
 >a2 : Symbol(a2, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 6, 5))
->{} : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 6, 17))
 
 // V is an object assignment pattern and, for each assignment property P in V,
 //      S has an apparent property with the property name specified in
 //          P of a type that is assignable to the target given in P, or
 var { b1, } = { b1:1, };
 >b1 : Symbol(b1, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 11, 5))
->{ b1:1, } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 11, 13))
 >b1 : Symbol(b1, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 11, 15))
 
 var { b2: { b21 } = { b21: "string" }  } = { b2: { b21: "world" } };
 >b21 : Symbol(b21, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 12, 11))
->{ b21: "string" } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 12, 19))
 >b21 : Symbol(b21, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 12, 21))
->{ b2: { b21: "world" } } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 12, 42))
 >b2 : Symbol(b2, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 12, 44))
->{ b21: "world" } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 12, 48))
 >b21 : Symbol(b21, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 12, 50))
 
 var {1: b3} = { 1: "string" };
 >b3 : Symbol(b3, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 13, 5))
->{ 1: "string" } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 13, 13))
 
 var {b4 = 1}: any = { b4: 100000 };
 >b4 : Symbol(b4, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 14, 5))
->{ b4: 100000 } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 14, 19))
 >b4 : Symbol(b4, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 14, 21))
 
 var {b5: { b52 }  } = { b5: { b52 } };
 >b52 : Symbol(b52, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 15, 10))
->{ b5: { b52 } } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 15, 21))
 >b5 : Symbol(b5, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 15, 23))
->{ b52 } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 15, 27))
 >b52 : Symbol(b52, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 15, 29))
 
 // V is an object assignment pattern and, for each assignment property P in V,
@@ -61,8 +52,6 @@ function foo(): F {
 >F : Symbol(F, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 15, 38))
 
     return {
->{        1: true    } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 26, 10))
-
         1: true
     };
 }
@@ -72,8 +61,6 @@ function bar(): F {
 >F : Symbol(F, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 15, 38))
 
     return {
->{        2: true    } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 32, 10))
-
         2: true
     };
 }
@@ -100,8 +87,6 @@ function foo1(): F1 {
 >F1 : Symbol(F1, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 37, 20))
 
     return {
->{        "prop1": 2    } : Symbol(, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 47, 10))
-
         "prop1": 2
     }
 }
diff --git a/tests/baselines/reference/destructuringVariableDeclaration1ES5.symbols b/tests/baselines/reference/destructuringVariableDeclaration1ES5.symbols
index 754235d4e6cca..2a2f2a358ca5b 100644
--- a/tests/baselines/reference/destructuringVariableDeclaration1ES5.symbols
+++ b/tests/baselines/reference/destructuringVariableDeclaration1ES5.symbols
@@ -6,7 +6,6 @@ var {a1, a2}: { a1: number, a2: string } = { a1: 10, a2: "world" }
 >a2 : Symbol(a2, Decl(destructuringVariableDeclaration1ES5.ts, 2, 8))
 >a1 : Symbol(a1, Decl(destructuringVariableDeclaration1ES5.ts, 2, 15))
 >a2 : Symbol(a2, Decl(destructuringVariableDeclaration1ES5.ts, 2, 27))
->{ a1: 10, a2: "world" } : Symbol(, Decl(destructuringVariableDeclaration1ES5.ts, 2, 42))
 >a1 : Symbol(a1, Decl(destructuringVariableDeclaration1ES5.ts, 2, 44))
 >a2 : Symbol(a2, Decl(destructuringVariableDeclaration1ES5.ts, 2, 52))
 
@@ -19,16 +18,12 @@ var [a3, [[a4]], a5]: [number, [[string]], boolean] = [1, [["hello"]], true];
 //      Otherwise, if the declaration includes an initializer expression, T is the type of that initializer expression.
 var { b1: { b11 } = { b11: "string" }  } = { b1: { b11: "world" } };
 >b11 : Symbol(b11, Decl(destructuringVariableDeclaration1ES5.ts, 7, 11))
->{ b11: "string" } : Symbol(, Decl(destructuringVariableDeclaration1ES5.ts, 7, 19))
 >b11 : Symbol(b11, Decl(destructuringVariableDeclaration1ES5.ts, 7, 21))
->{ b1: { b11: "world" } } : Symbol(, Decl(destructuringVariableDeclaration1ES5.ts, 7, 42))
 >b1 : Symbol(b1, Decl(destructuringVariableDeclaration1ES5.ts, 7, 44))
->{ b11: "world" } : Symbol(, Decl(destructuringVariableDeclaration1ES5.ts, 7, 48))
 >b11 : Symbol(b11, Decl(destructuringVariableDeclaration1ES5.ts, 7, 50))
 
 var temp = { t1: true, t2: "false" };
 >temp : Symbol(temp, Decl(destructuringVariableDeclaration1ES5.ts, 8, 3))
->{ t1: true, t2: "false" } : Symbol(, Decl(destructuringVariableDeclaration1ES5.ts, 8, 10))
 >t1 : Symbol(t1, Decl(destructuringVariableDeclaration1ES5.ts, 8, 12))
 >t2 : Symbol(t2, Decl(destructuringVariableDeclaration1ES5.ts, 8, 22))
 
@@ -37,7 +32,6 @@ var [b2 = 3, b3 = true, b4 = temp] = [3, false, { t1: false, t2: "hello" }];
 >b3 : Symbol(b3, Decl(destructuringVariableDeclaration1ES5.ts, 9, 12))
 >b4 : Symbol(b4, Decl(destructuringVariableDeclaration1ES5.ts, 9, 23))
 >temp : Symbol(temp, Decl(destructuringVariableDeclaration1ES5.ts, 8, 3))
->{ t1: false, t2: "hello" } : Symbol(, Decl(destructuringVariableDeclaration1ES5.ts, 9, 47))
 >t1 : Symbol(t1, Decl(destructuringVariableDeclaration1ES5.ts, 9, 49))
 >t2 : Symbol(t2, Decl(destructuringVariableDeclaration1ES5.ts, 9, 60))
 
@@ -83,12 +77,9 @@ var {e: [e1, e2, e3 = { b1: 1000, b4: 200 }]} = { e: [1, 2, { b1: 4, b4: 0 }] };
 >e1 : Symbol(e1, Decl(destructuringVariableDeclaration1ES5.ts, 31, 9))
 >e2 : Symbol(e2, Decl(destructuringVariableDeclaration1ES5.ts, 31, 12))
 >e3 : Symbol(e3, Decl(destructuringVariableDeclaration1ES5.ts, 31, 16))
->{ b1: 1000, b4: 200 } : Symbol(, Decl(destructuringVariableDeclaration1ES5.ts, 31, 21))
 >b1 : Symbol(b1, Decl(destructuringVariableDeclaration1ES5.ts, 31, 23))
 >b4 : Symbol(b4, Decl(destructuringVariableDeclaration1ES5.ts, 31, 33))
->{ e: [1, 2, { b1: 4, b4: 0 }] } : Symbol(, Decl(destructuringVariableDeclaration1ES5.ts, 31, 47))
 >e : Symbol(e, Decl(destructuringVariableDeclaration1ES5.ts, 31, 49))
->{ b1: 4, b4: 0 } : Symbol(, Decl(destructuringVariableDeclaration1ES5.ts, 31, 59))
 >b1 : Symbol(b1, Decl(destructuringVariableDeclaration1ES5.ts, 31, 61))
 >b4 : Symbol(b4, Decl(destructuringVariableDeclaration1ES5.ts, 31, 68))
 
@@ -97,9 +88,7 @@ var {f: [f1, f2, { f3: f4, f5 }, , ]} = { f: [1, 2, { f3: 4, f5: 0 }] };
 >f2 : Symbol(f2, Decl(destructuringVariableDeclaration1ES5.ts, 32, 12))
 >f4 : Symbol(f4, Decl(destructuringVariableDeclaration1ES5.ts, 32, 18))
 >f5 : Symbol(f5, Decl(destructuringVariableDeclaration1ES5.ts, 32, 26))
->{ f: [1, 2, { f3: 4, f5: 0 }] } : Symbol(, Decl(destructuringVariableDeclaration1ES5.ts, 32, 39))
 >f : Symbol(f, Decl(destructuringVariableDeclaration1ES5.ts, 32, 41))
->{ f3: 4, f5: 0 } : Symbol(, Decl(destructuringVariableDeclaration1ES5.ts, 32, 51))
 >f3 : Symbol(f3, Decl(destructuringVariableDeclaration1ES5.ts, 32, 53))
 >f5 : Symbol(f5, Decl(destructuringVariableDeclaration1ES5.ts, 32, 60))
 
@@ -111,9 +100,7 @@ var {g: {g1 = [undefined, null]}}: { g: { g1: any[] } } = { g: { g1: [1, 2] } };
 >undefined : Symbol(undefined)
 >g : Symbol(g, Decl(destructuringVariableDeclaration1ES5.ts, 37, 36))
 >g1 : Symbol(g1, Decl(destructuringVariableDeclaration1ES5.ts, 37, 41))
->{ g: { g1: [1, 2] } } : Symbol(, Decl(destructuringVariableDeclaration1ES5.ts, 37, 57))
 >g : Symbol(g, Decl(destructuringVariableDeclaration1ES5.ts, 37, 59))
->{ g1: [1, 2] } : Symbol(, Decl(destructuringVariableDeclaration1ES5.ts, 37, 62))
 >g1 : Symbol(g1, Decl(destructuringVariableDeclaration1ES5.ts, 37, 64))
 
 var {h: {h1 = [undefined, null]}}: { h: { h1: number[] } } = { h: { h1: [1, 2] } };
@@ -121,9 +108,7 @@ var {h: {h1 = [undefined, null]}}: { h: { h1: number[] } } = { h: { h1: [1, 2] }
 >undefined : Symbol(undefined)
 >h : Symbol(h, Decl(destructuringVariableDeclaration1ES5.ts, 38, 36))
 >h1 : Symbol(h1, Decl(destructuringVariableDeclaration1ES5.ts, 38, 41))
->{ h: { h1: [1, 2] } } : Symbol(, Decl(destructuringVariableDeclaration1ES5.ts, 38, 60))
 >h : Symbol(h, Decl(destructuringVariableDeclaration1ES5.ts, 38, 62))
->{ h1: [1, 2] } : Symbol(, Decl(destructuringVariableDeclaration1ES5.ts, 38, 65))
 >h1 : Symbol(h1, Decl(destructuringVariableDeclaration1ES5.ts, 38, 67))
 
 
diff --git a/tests/baselines/reference/destructuringVariableDeclaration1ES6.symbols b/tests/baselines/reference/destructuringVariableDeclaration1ES6.symbols
index 929cd6222abb9..0350ff3525144 100644
--- a/tests/baselines/reference/destructuringVariableDeclaration1ES6.symbols
+++ b/tests/baselines/reference/destructuringVariableDeclaration1ES6.symbols
@@ -6,7 +6,6 @@ var {a1, a2}: { a1: number, a2: string } = { a1: 10, a2: "world" }
 >a2 : Symbol(a2, Decl(destructuringVariableDeclaration1ES6.ts, 2, 8))
 >a1 : Symbol(a1, Decl(destructuringVariableDeclaration1ES6.ts, 2, 15))
 >a2 : Symbol(a2, Decl(destructuringVariableDeclaration1ES6.ts, 2, 27))
->{ a1: 10, a2: "world" } : Symbol(, Decl(destructuringVariableDeclaration1ES6.ts, 2, 42))
 >a1 : Symbol(a1, Decl(destructuringVariableDeclaration1ES6.ts, 2, 44))
 >a2 : Symbol(a2, Decl(destructuringVariableDeclaration1ES6.ts, 2, 52))
 
@@ -19,16 +18,12 @@ var [a3, [[a4]], a5]: [number, [[string]], boolean] = [1, [["hello"]], true];
 //      Otherwise, if the declaration includes an initializer expression, T is the type of that initializer expression.
 var { b1: { b11 } = { b11: "string" }  } = { b1: { b11: "world" } };
 >b11 : Symbol(b11, Decl(destructuringVariableDeclaration1ES6.ts, 7, 11))
->{ b11: "string" } : Symbol(, Decl(destructuringVariableDeclaration1ES6.ts, 7, 19))
 >b11 : Symbol(b11, Decl(destructuringVariableDeclaration1ES6.ts, 7, 21))
->{ b1: { b11: "world" } } : Symbol(, Decl(destructuringVariableDeclaration1ES6.ts, 7, 42))
 >b1 : Symbol(b1, Decl(destructuringVariableDeclaration1ES6.ts, 7, 44))
->{ b11: "world" } : Symbol(, Decl(destructuringVariableDeclaration1ES6.ts, 7, 48))
 >b11 : Symbol(b11, Decl(destructuringVariableDeclaration1ES6.ts, 7, 50))
 
 var temp = { t1: true, t2: "false" };
 >temp : Symbol(temp, Decl(destructuringVariableDeclaration1ES6.ts, 8, 3))
->{ t1: true, t2: "false" } : Symbol(, Decl(destructuringVariableDeclaration1ES6.ts, 8, 10))
 >t1 : Symbol(t1, Decl(destructuringVariableDeclaration1ES6.ts, 8, 12))
 >t2 : Symbol(t2, Decl(destructuringVariableDeclaration1ES6.ts, 8, 22))
 
@@ -37,7 +32,6 @@ var [b2 = 3, b3 = true, b4 = temp] = [3, false, { t1: false, t2: "hello" }];
 >b3 : Symbol(b3, Decl(destructuringVariableDeclaration1ES6.ts, 9, 12))
 >b4 : Symbol(b4, Decl(destructuringVariableDeclaration1ES6.ts, 9, 23))
 >temp : Symbol(temp, Decl(destructuringVariableDeclaration1ES6.ts, 8, 3))
->{ t1: false, t2: "hello" } : Symbol(, Decl(destructuringVariableDeclaration1ES6.ts, 9, 47))
 >t1 : Symbol(t1, Decl(destructuringVariableDeclaration1ES6.ts, 9, 49))
 >t2 : Symbol(t2, Decl(destructuringVariableDeclaration1ES6.ts, 9, 60))
 
@@ -83,12 +77,9 @@ var {e: [e1, e2, e3 = { b1: 1000, b4: 200 }]} = { e: [1, 2, { b1: 4, b4: 0 }] };
 >e1 : Symbol(e1, Decl(destructuringVariableDeclaration1ES6.ts, 31, 9))
 >e2 : Symbol(e2, Decl(destructuringVariableDeclaration1ES6.ts, 31, 12))
 >e3 : Symbol(e3, Decl(destructuringVariableDeclaration1ES6.ts, 31, 16))
->{ b1: 1000, b4: 200 } : Symbol(, Decl(destructuringVariableDeclaration1ES6.ts, 31, 21))
 >b1 : Symbol(b1, Decl(destructuringVariableDeclaration1ES6.ts, 31, 23))
 >b4 : Symbol(b4, Decl(destructuringVariableDeclaration1ES6.ts, 31, 33))
->{ e: [1, 2, { b1: 4, b4: 0 }] } : Symbol(, Decl(destructuringVariableDeclaration1ES6.ts, 31, 47))
 >e : Symbol(e, Decl(destructuringVariableDeclaration1ES6.ts, 31, 49))
->{ b1: 4, b4: 0 } : Symbol(, Decl(destructuringVariableDeclaration1ES6.ts, 31, 59))
 >b1 : Symbol(b1, Decl(destructuringVariableDeclaration1ES6.ts, 31, 61))
 >b4 : Symbol(b4, Decl(destructuringVariableDeclaration1ES6.ts, 31, 68))
 
@@ -97,9 +88,7 @@ var {f: [f1, f2, { f3: f4, f5 }, , ]} = { f: [1, 2, { f3: 4, f5: 0 }] };
 >f2 : Symbol(f2, Decl(destructuringVariableDeclaration1ES6.ts, 32, 12))
 >f4 : Symbol(f4, Decl(destructuringVariableDeclaration1ES6.ts, 32, 18))
 >f5 : Symbol(f5, Decl(destructuringVariableDeclaration1ES6.ts, 32, 26))
->{ f: [1, 2, { f3: 4, f5: 0 }] } : Symbol(, Decl(destructuringVariableDeclaration1ES6.ts, 32, 39))
 >f : Symbol(f, Decl(destructuringVariableDeclaration1ES6.ts, 32, 41))
->{ f3: 4, f5: 0 } : Symbol(, Decl(destructuringVariableDeclaration1ES6.ts, 32, 51))
 >f3 : Symbol(f3, Decl(destructuringVariableDeclaration1ES6.ts, 32, 53))
 >f5 : Symbol(f5, Decl(destructuringVariableDeclaration1ES6.ts, 32, 60))
 
@@ -111,9 +100,7 @@ var {g: {g1 = [undefined, null]}}: { g: { g1: any[] } } = { g: { g1: [1, 2] } };
 >undefined : Symbol(undefined)
 >g : Symbol(g, Decl(destructuringVariableDeclaration1ES6.ts, 37, 36))
 >g1 : Symbol(g1, Decl(destructuringVariableDeclaration1ES6.ts, 37, 41))
->{ g: { g1: [1, 2] } } : Symbol(, Decl(destructuringVariableDeclaration1ES6.ts, 37, 57))
 >g : Symbol(g, Decl(destructuringVariableDeclaration1ES6.ts, 37, 59))
->{ g1: [1, 2] } : Symbol(, Decl(destructuringVariableDeclaration1ES6.ts, 37, 62))
 >g1 : Symbol(g1, Decl(destructuringVariableDeclaration1ES6.ts, 37, 64))
 
 var {h: {h1 = [undefined, null]}}: { h: { h1: number[] } } = { h: { h1: [1, 2] } };
@@ -121,9 +108,7 @@ var {h: {h1 = [undefined, null]}}: { h: { h1: number[] } } = { h: { h1: [1, 2] }
 >undefined : Symbol(undefined)
 >h : Symbol(h, Decl(destructuringVariableDeclaration1ES6.ts, 38, 36))
 >h1 : Symbol(h1, Decl(destructuringVariableDeclaration1ES6.ts, 38, 41))
->{ h: { h1: [1, 2] } } : Symbol(, Decl(destructuringVariableDeclaration1ES6.ts, 38, 60))
 >h : Symbol(h, Decl(destructuringVariableDeclaration1ES6.ts, 38, 62))
->{ h1: [1, 2] } : Symbol(, Decl(destructuringVariableDeclaration1ES6.ts, 38, 65))
 >h1 : Symbol(h1, Decl(destructuringVariableDeclaration1ES6.ts, 38, 67))
 
 
diff --git a/tests/baselines/reference/detachedCommentAtStartOfConstructor1.symbols b/tests/baselines/reference/detachedCommentAtStartOfConstructor1.symbols
index 3e123c4e08975..9590abaa4608c 100644
--- a/tests/baselines/reference/detachedCommentAtStartOfConstructor1.symbols
+++ b/tests/baselines/reference/detachedCommentAtStartOfConstructor1.symbols
@@ -15,7 +15,6 @@ class TestFile {
         /// <param name="message" type="String" />
         var getMessage = () => message + this.name;
 >getMessage : Symbol(getMessage, Decl(detachedCommentAtStartOfConstructor1.ts, 6, 11))
->() => message + this.name : Symbol((Anonymous function), Decl(detachedCommentAtStartOfConstructor1.ts, 6, 24))
 >message : Symbol(message, Decl(detachedCommentAtStartOfConstructor1.ts, 3, 16))
 >this.name : Symbol(name, Decl(detachedCommentAtStartOfConstructor1.ts, 1, 27))
 >this : Symbol(TestFile, Decl(detachedCommentAtStartOfConstructor1.ts, 0, 0))
diff --git a/tests/baselines/reference/detachedCommentAtStartOfConstructor2.symbols b/tests/baselines/reference/detachedCommentAtStartOfConstructor2.symbols
index af061db4903d9..78af94300342f 100644
--- a/tests/baselines/reference/detachedCommentAtStartOfConstructor2.symbols
+++ b/tests/baselines/reference/detachedCommentAtStartOfConstructor2.symbols
@@ -16,7 +16,6 @@ class TestFile {
 
         var getMessage = () => message + this.name;
 >getMessage : Symbol(getMessage, Decl(detachedCommentAtStartOfConstructor2.ts, 7, 11))
->() => message + this.name : Symbol((Anonymous function), Decl(detachedCommentAtStartOfConstructor2.ts, 7, 24))
 >message : Symbol(message, Decl(detachedCommentAtStartOfConstructor2.ts, 3, 16))
 >this.name : Symbol(name, Decl(detachedCommentAtStartOfConstructor2.ts, 1, 27))
 >this : Symbol(TestFile, Decl(detachedCommentAtStartOfConstructor2.ts, 0, 0))
diff --git a/tests/baselines/reference/detachedCommentAtStartOfLambdaFunction1.symbols b/tests/baselines/reference/detachedCommentAtStartOfLambdaFunction1.symbols
index eb29cbf932fbb..aa34885d79b80 100644
--- a/tests/baselines/reference/detachedCommentAtStartOfLambdaFunction1.symbols
+++ b/tests/baselines/reference/detachedCommentAtStartOfLambdaFunction1.symbols
@@ -10,7 +10,6 @@ class TestFile {
 >message : Symbol(message, Decl(detachedCommentAtStartOfLambdaFunction1.ts, 2, 8))
 
         return (...x: string[]) =>
->(...x: string[]) =>            /// <summary>Test summary</summary>            /// <param name="message" type="String" />            /// <returns type="Function" />            message + this.name : Symbol((Anonymous function), Decl(detachedCommentAtStartOfLambdaFunction1.ts, 3, 14))
 >x : Symbol(x, Decl(detachedCommentAtStartOfLambdaFunction1.ts, 3, 16))
 
             /// <summary>Test summary</summary>
diff --git a/tests/baselines/reference/detachedCommentAtStartOfLambdaFunction2.symbols b/tests/baselines/reference/detachedCommentAtStartOfLambdaFunction2.symbols
index 3cca6c28e5802..29cef430c3a72 100644
--- a/tests/baselines/reference/detachedCommentAtStartOfLambdaFunction2.symbols
+++ b/tests/baselines/reference/detachedCommentAtStartOfLambdaFunction2.symbols
@@ -10,7 +10,6 @@ class TestFile {
 >message : Symbol(message, Decl(detachedCommentAtStartOfLambdaFunction2.ts, 2, 8))
 
         return (...x: string[]) =>
->(...x: string[]) =>            /// <summary>Test summary</summary>            /// <param name="message" type="String" />            /// <returns type="Function" />            message + this.name : Symbol((Anonymous function), Decl(detachedCommentAtStartOfLambdaFunction2.ts, 3, 14))
 >x : Symbol(x, Decl(detachedCommentAtStartOfLambdaFunction2.ts, 3, 16))
 
             /// <summary>Test summary</summary>
diff --git a/tests/baselines/reference/doNotWidenAtObjectLiteralPropertyAssignment.symbols b/tests/baselines/reference/doNotWidenAtObjectLiteralPropertyAssignment.symbols
index 597e269801c72..7aaf3b98f4ae2 100644
--- a/tests/baselines/reference/doNotWidenAtObjectLiteralPropertyAssignment.symbols
+++ b/tests/baselines/reference/doNotWidenAtObjectLiteralPropertyAssignment.symbols
@@ -21,9 +21,7 @@ interface IIntervalTreeNode {
 var test: IIntervalTreeNode[] = [{ interval: { begin: 0 }, children: null }]; // was error here because best common type is {}
 >test : Symbol(test, Decl(doNotWidenAtObjectLiteralPropertyAssignment.ts, 9, 3))
 >IIntervalTreeNode : Symbol(IIntervalTreeNode, Decl(doNotWidenAtObjectLiteralPropertyAssignment.ts, 2, 1))
->{ interval: { begin: 0 }, children: null } : Symbol(, Decl(doNotWidenAtObjectLiteralPropertyAssignment.ts, 9, 33))
 >interval : Symbol(interval, Decl(doNotWidenAtObjectLiteralPropertyAssignment.ts, 9, 34))
->{ begin: 0 } : Symbol(, Decl(doNotWidenAtObjectLiteralPropertyAssignment.ts, 9, 44))
 >begin : Symbol(begin, Decl(doNotWidenAtObjectLiteralPropertyAssignment.ts, 9, 46))
 >children : Symbol(children, Decl(doNotWidenAtObjectLiteralPropertyAssignment.ts, 9, 58))
 
diff --git a/tests/baselines/reference/doWhileBreakStatements.symbols b/tests/baselines/reference/doWhileBreakStatements.symbols
index 5551957f64ff9..7d9db9a5ebb51 100644
--- a/tests/baselines/reference/doWhileBreakStatements.symbols
+++ b/tests/baselines/reference/doWhileBreakStatements.symbols
@@ -35,7 +35,6 @@ EIGHT:
 do{
     var fn = function () { }
 >fn : Symbol(fn, Decl(doWhileBreakStatements.ts, 34, 7))
->function () { } : Symbol((Anonymous function), Decl(doWhileBreakStatements.ts, 34, 12))
 
     break EIGHT;
 }while(true)
diff --git a/tests/baselines/reference/doWhileContinueStatements.symbols b/tests/baselines/reference/doWhileContinueStatements.symbols
index 4236b40de70f8..e4c6d577d5aa4 100644
--- a/tests/baselines/reference/doWhileContinueStatements.symbols
+++ b/tests/baselines/reference/doWhileContinueStatements.symbols
@@ -35,7 +35,6 @@ EIGHT:
 do{
     var fn = function () { }
 >fn : Symbol(fn, Decl(doWhileContinueStatements.ts, 34, 7))
->function () { } : Symbol((Anonymous function), Decl(doWhileContinueStatements.ts, 34, 12))
 
     continue EIGHT;
 }while(true)
diff --git a/tests/baselines/reference/dottedSymbolResolution1.symbols b/tests/baselines/reference/dottedSymbolResolution1.symbols
index b0d8987ff3ef4..25ff8a6fe9200 100644
--- a/tests/baselines/reference/dottedSymbolResolution1.symbols
+++ b/tests/baselines/reference/dottedSymbolResolution1.symbols
@@ -65,7 +65,6 @@ function _setBarAndText(): void {
 >x.find : Symbol(JQuery.find, Decl(dottedSymbolResolution1.ts, 0, 18))
 >x : Symbol(x, Decl(dottedSymbolResolution1.ts, 19, 7))
 >find : Symbol(JQuery.find, Decl(dottedSymbolResolution1.ts, 0, 18))
->function () {        var $this: JQuery = $(''),            thisBar = $this.find(".fx-usagebars-calloutbar-this"); // bug lead to 'could not find dotted symbol' here    } : Symbol((Anonymous function), Decl(dottedSymbolResolution1.ts, 20, 21))
 
         var $this: JQuery = $(''),
 >$this : Symbol($this, Decl(dottedSymbolResolution1.ts, 21, 11))
diff --git a/tests/baselines/reference/downlevelLetConst12.symbols b/tests/baselines/reference/downlevelLetConst12.symbols
index 69b25bb02c969..d1c7fe3ea5b9e 100644
--- a/tests/baselines/reference/downlevelLetConst12.symbols
+++ b/tests/baselines/reference/downlevelLetConst12.symbols
@@ -13,7 +13,6 @@ let [baz] = [];
 
 let {a: baz2} = { a: 1 };
 >baz2 : Symbol(baz2, Decl(downlevelLetConst12.ts, 7, 5))
->{ a: 1 } : Symbol(, Decl(downlevelLetConst12.ts, 7, 15))
 >a : Symbol(a, Decl(downlevelLetConst12.ts, 7, 17))
 
 const [baz3] = []
@@ -21,6 +20,5 @@ const [baz3] = []
 
 const {a: baz4} = { a: 1 };
 >baz4 : Symbol(baz4, Decl(downlevelLetConst12.ts, 10, 7))
->{ a: 1 } : Symbol(, Decl(downlevelLetConst12.ts, 10, 17))
 >a : Symbol(a, Decl(downlevelLetConst12.ts, 10, 19))
 
diff --git a/tests/baselines/reference/downlevelLetConst13.symbols b/tests/baselines/reference/downlevelLetConst13.symbols
index 5408e6bfe96c1..1b06184f2b3d4 100644
--- a/tests/baselines/reference/downlevelLetConst13.symbols
+++ b/tests/baselines/reference/downlevelLetConst13.symbols
@@ -17,12 +17,10 @@ export const [bar2] = [2];
 
 export let {a: bar3} = { a: 1 };
 >bar3 : Symbol(bar3, Decl(downlevelLetConst13.ts, 8, 12))
->{ a: 1 } : Symbol(, Decl(downlevelLetConst13.ts, 8, 22))
 >a : Symbol(a, Decl(downlevelLetConst13.ts, 8, 24))
 
 export const {a: bar4} = { a: 1 };
 >bar4 : Symbol(bar4, Decl(downlevelLetConst13.ts, 9, 14))
->{ a: 1 } : Symbol(, Decl(downlevelLetConst13.ts, 9, 24))
 >a : Symbol(a, Decl(downlevelLetConst13.ts, 9, 26))
 
 export module M {
@@ -42,11 +40,9 @@ export module M {
 
     export let {a: bar7} = { a: 1 };
 >bar7 : Symbol(bar7, Decl(downlevelLetConst13.ts, 16, 16))
->{ a: 1 } : Symbol(, Decl(downlevelLetConst13.ts, 16, 26))
 >a : Symbol(a, Decl(downlevelLetConst13.ts, 16, 28))
 
     export const {a: bar8} = { a: 1 };
 >bar8 : Symbol(bar8, Decl(downlevelLetConst13.ts, 17, 18))
->{ a: 1 } : Symbol(, Decl(downlevelLetConst13.ts, 17, 28))
 >a : Symbol(a, Decl(downlevelLetConst13.ts, 17, 30))
 }
diff --git a/tests/baselines/reference/downlevelLetConst14.symbols b/tests/baselines/reference/downlevelLetConst14.symbols
index ee3d2d6da07c1..bf3450af71cda 100644
--- a/tests/baselines/reference/downlevelLetConst14.symbols
+++ b/tests/baselines/reference/downlevelLetConst14.symbols
@@ -36,7 +36,6 @@ var z0, z1, z2, z3;
 
     let {a: z2} = { a: 1 };
 >z2 : Symbol(z2, Decl(downlevelLetConst14.ts, 13, 9))
->{ a: 1 } : Symbol(, Decl(downlevelLetConst14.ts, 13, 17))
 >a : Symbol(a, Decl(downlevelLetConst14.ts, 13, 19))
 
     use(z2);
@@ -45,7 +44,6 @@ var z0, z1, z2, z3;
 
     let {a: z3} = { a: 1 };
 >z3 : Symbol(z3, Decl(downlevelLetConst14.ts, 15, 9))
->{ a: 1 } : Symbol(, Decl(downlevelLetConst14.ts, 15, 17))
 >a : Symbol(a, Decl(downlevelLetConst14.ts, 15, 19))
 
     use(z3);
@@ -89,7 +87,6 @@ var y = true;
 
         let {a: z6} = {a: 1}
 >z6 : Symbol(z6, Decl(downlevelLetConst14.ts, 30, 13))
->{a: 1} : Symbol(, Decl(downlevelLetConst14.ts, 30, 21))
 >a : Symbol(a, Decl(downlevelLetConst14.ts, 30, 23))
 
         use(y);
@@ -133,7 +130,6 @@ var z5 = 1;
 
         let {a: _z5} = { a: 1 };
 >_z5 : Symbol(_z5, Decl(downlevelLetConst14.ts, 47, 13))
->{ a: 1 } : Symbol(, Decl(downlevelLetConst14.ts, 47, 22))
 >a : Symbol(a, Decl(downlevelLetConst14.ts, 47, 24))
 
         // try to step on generated name
diff --git a/tests/baselines/reference/downlevelLetConst15.symbols b/tests/baselines/reference/downlevelLetConst15.symbols
index b19bb43f36308..159e5a6d67665 100644
--- a/tests/baselines/reference/downlevelLetConst15.symbols
+++ b/tests/baselines/reference/downlevelLetConst15.symbols
@@ -29,7 +29,6 @@ var z0, z1, z2, z3;
 
     const [{a: z1}] = [{a: 1}]
 >z1 : Symbol(z1, Decl(downlevelLetConst15.ts, 11, 12))
->{a: 1} : Symbol(, Decl(downlevelLetConst15.ts, 11, 23))
 >a : Symbol(a, Decl(downlevelLetConst15.ts, 11, 24))
 
     use(z1);
@@ -38,7 +37,6 @@ var z0, z1, z2, z3;
 
     const {a: z2} = { a: 1 };
 >z2 : Symbol(z2, Decl(downlevelLetConst15.ts, 13, 11))
->{ a: 1 } : Symbol(, Decl(downlevelLetConst15.ts, 13, 19))
 >a : Symbol(a, Decl(downlevelLetConst15.ts, 13, 21))
 
     use(z2);
@@ -47,9 +45,7 @@ var z0, z1, z2, z3;
 
     const {a: {b: z3}} = { a: {b: 1} };
 >z3 : Symbol(z3, Decl(downlevelLetConst15.ts, 15, 15))
->{ a: {b: 1} } : Symbol(, Decl(downlevelLetConst15.ts, 15, 24))
 >a : Symbol(a, Decl(downlevelLetConst15.ts, 15, 26))
->{b: 1} : Symbol(, Decl(downlevelLetConst15.ts, 15, 29))
 >b : Symbol(b, Decl(downlevelLetConst15.ts, 15, 31))
 
     use(z3);
@@ -93,7 +89,6 @@ var y = true;
 
         const {a: z6} = { a: 1 }
 >z6 : Symbol(z6, Decl(downlevelLetConst15.ts, 30, 15))
->{ a: 1 } : Symbol(, Decl(downlevelLetConst15.ts, 30, 23))
 >a : Symbol(a, Decl(downlevelLetConst15.ts, 30, 25))
 
         use(y);
@@ -137,7 +132,6 @@ var z5 = 1;
 
         const {a: _z5} = { a: 1 };
 >_z5 : Symbol(_z5, Decl(downlevelLetConst15.ts, 47, 15))
->{ a: 1 } : Symbol(, Decl(downlevelLetConst15.ts, 47, 24))
 >a : Symbol(a, Decl(downlevelLetConst15.ts, 47, 26))
 
         // try to step on generated name
diff --git a/tests/baselines/reference/duplicateOverloadInTypeAugmentation1.symbols b/tests/baselines/reference/duplicateOverloadInTypeAugmentation1.symbols
index a075f319a0632..4191616255387 100644
--- a/tests/baselines/reference/duplicateOverloadInTypeAugmentation1.symbols
+++ b/tests/baselines/reference/duplicateOverloadInTypeAugmentation1.symbols
@@ -47,7 +47,6 @@ var r5 = a.reduce((x, y) => x + y);
 >a.reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 20), Decl(duplicateOverloadInTypeAugmentation1.ts, 2, 29))
 >a : Symbol(a, Decl(duplicateOverloadInTypeAugmentation1.ts, 6, 3))
 >reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 20), Decl(duplicateOverloadInTypeAugmentation1.ts, 2, 29))
->(x, y) => x + y : Symbol((Anonymous function), Decl(duplicateOverloadInTypeAugmentation1.ts, 7, 18))
 >x : Symbol(x, Decl(duplicateOverloadInTypeAugmentation1.ts, 7, 19))
 >y : Symbol(y, Decl(duplicateOverloadInTypeAugmentation1.ts, 7, 21))
 >x : Symbol(x, Decl(duplicateOverloadInTypeAugmentation1.ts, 7, 19))
diff --git a/tests/baselines/reference/emitArrowFunction.symbols b/tests/baselines/reference/emitArrowFunction.symbols
index 6e7993150b596..33de13d877c68 100644
--- a/tests/baselines/reference/emitArrowFunction.symbols
+++ b/tests/baselines/reference/emitArrowFunction.symbols
@@ -1,24 +1,20 @@
 === tests/cases/conformance/es6/arrowFunction/emitArrowFunction.ts ===
 var f1 = () => { }
 >f1 : Symbol(f1, Decl(emitArrowFunction.ts, 0, 3))
->() => { } : Symbol((Anonymous function), Decl(emitArrowFunction.ts, 0, 8))
 
 var f2 = (x: string, y: string) => { }
 >f2 : Symbol(f2, Decl(emitArrowFunction.ts, 1, 3))
->(x: string, y: string) => { } : Symbol((Anonymous function), Decl(emitArrowFunction.ts, 1, 8))
 >x : Symbol(x, Decl(emitArrowFunction.ts, 1, 10))
 >y : Symbol(y, Decl(emitArrowFunction.ts, 1, 20))
 
 var f3 = (x: string, y: number, ...rest) => { }
 >f3 : Symbol(f3, Decl(emitArrowFunction.ts, 2, 3))
->(x: string, y: number, ...rest) => { } : Symbol((Anonymous function), Decl(emitArrowFunction.ts, 2, 8))
 >x : Symbol(x, Decl(emitArrowFunction.ts, 2, 10))
 >y : Symbol(y, Decl(emitArrowFunction.ts, 2, 20))
 >rest : Symbol(rest, Decl(emitArrowFunction.ts, 2, 31))
 
 var f4 = (x: string, y: number, z = 10) => { }
 >f4 : Symbol(f4, Decl(emitArrowFunction.ts, 3, 3))
->(x: string, y: number, z = 10) => { } : Symbol((Anonymous function), Decl(emitArrowFunction.ts, 3, 8))
 >x : Symbol(x, Decl(emitArrowFunction.ts, 3, 10))
 >y : Symbol(y, Decl(emitArrowFunction.ts, 3, 20))
 >z : Symbol(z, Decl(emitArrowFunction.ts, 3, 31))
@@ -29,9 +25,7 @@ function foo(func: () => boolean) { }
 
 foo(() => true);
 >foo : Symbol(foo, Decl(emitArrowFunction.ts, 3, 46))
->() => true : Symbol((Anonymous function), Decl(emitArrowFunction.ts, 5, 4))
 
 foo(() => { return false; });
 >foo : Symbol(foo, Decl(emitArrowFunction.ts, 3, 46))
->() => { return false; } : Symbol((Anonymous function), Decl(emitArrowFunction.ts, 6, 4))
 
diff --git a/tests/baselines/reference/emitArrowFunctionAsIs.symbols b/tests/baselines/reference/emitArrowFunctionAsIs.symbols
index 360cfb19f1036..d853996ccd9b9 100644
--- a/tests/baselines/reference/emitArrowFunctionAsIs.symbols
+++ b/tests/baselines/reference/emitArrowFunctionAsIs.symbols
@@ -1,17 +1,14 @@
 === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionAsIs.ts ===
 var arrow1 = a => { };
 >arrow1 : Symbol(arrow1, Decl(emitArrowFunctionAsIs.ts, 0, 3))
->a => { } : Symbol((Anonymous function), Decl(emitArrowFunctionAsIs.ts, 0, 12))
 >a : Symbol(a, Decl(emitArrowFunctionAsIs.ts, 0, 12))
 
 var arrow2 = (a) => { };
 >arrow2 : Symbol(arrow2, Decl(emitArrowFunctionAsIs.ts, 1, 3))
->(a) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionAsIs.ts, 1, 12))
 >a : Symbol(a, Decl(emitArrowFunctionAsIs.ts, 1, 14))
 
 var arrow3 = (a, b) => { };
 >arrow3 : Symbol(arrow3, Decl(emitArrowFunctionAsIs.ts, 3, 3))
->(a, b) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionAsIs.ts, 3, 12))
 >a : Symbol(a, Decl(emitArrowFunctionAsIs.ts, 3, 14))
 >b : Symbol(b, Decl(emitArrowFunctionAsIs.ts, 3, 16))
 
diff --git a/tests/baselines/reference/emitArrowFunctionAsIsES6.symbols b/tests/baselines/reference/emitArrowFunctionAsIsES6.symbols
index 331ce889a6523..c435db556484a 100644
--- a/tests/baselines/reference/emitArrowFunctionAsIsES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionAsIsES6.symbols
@@ -1,17 +1,14 @@
 === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionAsIsES6.ts ===
 var arrow1 =  a => { };
 >arrow1 : Symbol(arrow1, Decl(emitArrowFunctionAsIsES6.ts, 0, 3))
->a => { } : Symbol((Anonymous function), Decl(emitArrowFunctionAsIsES6.ts, 0, 12))
 >a : Symbol(a, Decl(emitArrowFunctionAsIsES6.ts, 0, 12))
 
 var arrow2 = (a) => { };
 >arrow2 : Symbol(arrow2, Decl(emitArrowFunctionAsIsES6.ts, 1, 3))
->(a) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionAsIsES6.ts, 1, 12))
 >a : Symbol(a, Decl(emitArrowFunctionAsIsES6.ts, 1, 14))
 
 var arrow3 = (a, b) => { };
 >arrow3 : Symbol(arrow3, Decl(emitArrowFunctionAsIsES6.ts, 3, 3))
->(a, b) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionAsIsES6.ts, 3, 12))
 >a : Symbol(a, Decl(emitArrowFunctionAsIsES6.ts, 3, 14))
 >b : Symbol(b, Decl(emitArrowFunctionAsIsES6.ts, 3, 16))
 
diff --git a/tests/baselines/reference/emitArrowFunctionES6.symbols b/tests/baselines/reference/emitArrowFunctionES6.symbols
index 1b5a018dbc42d..06f83f7f6f0b3 100644
--- a/tests/baselines/reference/emitArrowFunctionES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionES6.symbols
@@ -1,24 +1,20 @@
 === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionES6.ts ===
 var f1 = () => { }
 >f1 : Symbol(f1, Decl(emitArrowFunctionES6.ts, 0, 3))
->() => { } : Symbol((Anonymous function), Decl(emitArrowFunctionES6.ts, 0, 8))
 
 var f2 = (x: string, y: string) => { }
 >f2 : Symbol(f2, Decl(emitArrowFunctionES6.ts, 1, 3))
->(x: string, y: string) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionES6.ts, 1, 8))
 >x : Symbol(x, Decl(emitArrowFunctionES6.ts, 1, 10))
 >y : Symbol(y, Decl(emitArrowFunctionES6.ts, 1, 20))
 
 var f3 = (x: string, y: number, ...rest) => { }
 >f3 : Symbol(f3, Decl(emitArrowFunctionES6.ts, 2, 3))
->(x: string, y: number, ...rest) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionES6.ts, 2, 8))
 >x : Symbol(x, Decl(emitArrowFunctionES6.ts, 2, 10))
 >y : Symbol(y, Decl(emitArrowFunctionES6.ts, 2, 20))
 >rest : Symbol(rest, Decl(emitArrowFunctionES6.ts, 2, 31))
 
 var f4 = (x: string, y: number, z=10) => { }
 >f4 : Symbol(f4, Decl(emitArrowFunctionES6.ts, 3, 3))
->(x: string, y: number, z=10) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionES6.ts, 3, 8))
 >x : Symbol(x, Decl(emitArrowFunctionES6.ts, 3, 10))
 >y : Symbol(y, Decl(emitArrowFunctionES6.ts, 3, 20))
 >z : Symbol(z, Decl(emitArrowFunctionES6.ts, 3, 31))
@@ -29,63 +25,50 @@ function foo(func: () => boolean) { }
 
 foo(() => true);
 >foo : Symbol(foo, Decl(emitArrowFunctionES6.ts, 3, 44))
->() => true : Symbol((Anonymous function), Decl(emitArrowFunctionES6.ts, 5, 4))
 
 foo(() => { return false; });
 >foo : Symbol(foo, Decl(emitArrowFunctionES6.ts, 3, 44))
->() => { return false; } : Symbol((Anonymous function), Decl(emitArrowFunctionES6.ts, 6, 4))
 
 // Binding patterns in arrow functions
 var p1 = ([a]) => { };
 >p1 : Symbol(p1, Decl(emitArrowFunctionES6.ts, 9, 3))
->([a]) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionES6.ts, 9, 8))
 >a : Symbol(a, Decl(emitArrowFunctionES6.ts, 9, 11))
 
 var p2 = ([...a]) => { };
 >p2 : Symbol(p2, Decl(emitArrowFunctionES6.ts, 10, 3))
->([...a]) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionES6.ts, 10, 8))
 >a : Symbol(a, Decl(emitArrowFunctionES6.ts, 10, 11))
 
 var p3 = ([, a]) => { };
 >p3 : Symbol(p3, Decl(emitArrowFunctionES6.ts, 11, 3))
->([, a]) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionES6.ts, 11, 8))
 >a : Symbol(a, Decl(emitArrowFunctionES6.ts, 11, 12))
 
 var p4 = ([, ...a]) => { };
 >p4 : Symbol(p4, Decl(emitArrowFunctionES6.ts, 12, 3))
->([, ...a]) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionES6.ts, 12, 8))
 >a : Symbol(a, Decl(emitArrowFunctionES6.ts, 12, 12))
 
 var p5 = ([a = 1]) => { };
 >p5 : Symbol(p5, Decl(emitArrowFunctionES6.ts, 13, 3))
->([a = 1]) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionES6.ts, 13, 8))
 >a : Symbol(a, Decl(emitArrowFunctionES6.ts, 13, 11))
 
 var p6 = ({ a }) => { };
 >p6 : Symbol(p6, Decl(emitArrowFunctionES6.ts, 14, 3))
->({ a }) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionES6.ts, 14, 8))
 >a : Symbol(a, Decl(emitArrowFunctionES6.ts, 14, 11))
 
 var p7 = ({ a: { b } }) => { };
 >p7 : Symbol(p7, Decl(emitArrowFunctionES6.ts, 15, 3))
->({ a: { b } }) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionES6.ts, 15, 8))
 >b : Symbol(b, Decl(emitArrowFunctionES6.ts, 15, 16))
 
 var p8 = ({ a = 1 }) => { };
 >p8 : Symbol(p8, Decl(emitArrowFunctionES6.ts, 16, 3))
->({ a = 1 }) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionES6.ts, 16, 8))
 >a : Symbol(a, Decl(emitArrowFunctionES6.ts, 16, 11))
 
 var p9 = ({ a: { b = 1 } = { b: 1 } }) => { };
 >p9 : Symbol(p9, Decl(emitArrowFunctionES6.ts, 17, 3))
->({ a: { b = 1 } = { b: 1 } }) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionES6.ts, 17, 8))
 >b : Symbol(b, Decl(emitArrowFunctionES6.ts, 17, 16))
->{ b: 1 } : Symbol(, Decl(emitArrowFunctionES6.ts, 17, 26))
 >b : Symbol(b, Decl(emitArrowFunctionES6.ts, 17, 28))
 
 var p10 = ([{ value, done }]) => { };
 >p10 : Symbol(p10, Decl(emitArrowFunctionES6.ts, 18, 3))
->([{ value, done }]) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionES6.ts, 18, 9))
 >value : Symbol(value, Decl(emitArrowFunctionES6.ts, 18, 13))
 >done : Symbol(done, Decl(emitArrowFunctionES6.ts, 18, 20))
 
diff --git a/tests/baselines/reference/emitArrowFunctionThisCapturing.symbols b/tests/baselines/reference/emitArrowFunctionThisCapturing.symbols
index 4e2b2a74b9640..ad62a0df5be92 100644
--- a/tests/baselines/reference/emitArrowFunctionThisCapturing.symbols
+++ b/tests/baselines/reference/emitArrowFunctionThisCapturing.symbols
@@ -1,14 +1,12 @@
 === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionThisCapturing.ts ===
 var f1 = () => {
 >f1 : Symbol(f1, Decl(emitArrowFunctionThisCapturing.ts, 0, 3))
->() => {    this.age = 10} : Symbol((Anonymous function), Decl(emitArrowFunctionThisCapturing.ts, 0, 8))
 
     this.age = 10
 };
 
 var f2 = (x: string) => {
 >f2 : Symbol(f2, Decl(emitArrowFunctionThisCapturing.ts, 4, 3))
->(x: string) => {    this.name = x} : Symbol((Anonymous function), Decl(emitArrowFunctionThisCapturing.ts, 4, 8))
 >x : Symbol(x, Decl(emitArrowFunctionThisCapturing.ts, 4, 10))
 
     this.name = x
@@ -21,7 +19,6 @@ function foo(func: () => boolean) { }
 
 foo(() => {
 >foo : Symbol(foo, Decl(emitArrowFunctionThisCapturing.ts, 6, 1))
->() => {    this.age = 100;    return true;} : Symbol((Anonymous function), Decl(emitArrowFunctionThisCapturing.ts, 9, 4))
 
     this.age = 100;
     return true;
diff --git a/tests/baselines/reference/emitArrowFunctionThisCapturingES6.symbols b/tests/baselines/reference/emitArrowFunctionThisCapturingES6.symbols
index 62bb2428731f6..0e8855dd680c5 100644
--- a/tests/baselines/reference/emitArrowFunctionThisCapturingES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionThisCapturingES6.symbols
@@ -1,14 +1,12 @@
 === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionThisCapturingES6.ts ===
 var f1 = () => {
 >f1 : Symbol(f1, Decl(emitArrowFunctionThisCapturingES6.ts, 0, 3))
->() => {    this.age = 10} : Symbol((Anonymous function), Decl(emitArrowFunctionThisCapturingES6.ts, 0, 8))
 
     this.age = 10
 };
 
 var f2 = (x: string) => {
 >f2 : Symbol(f2, Decl(emitArrowFunctionThisCapturingES6.ts, 4, 3))
->(x: string) => {    this.name = x} : Symbol((Anonymous function), Decl(emitArrowFunctionThisCapturingES6.ts, 4, 8))
 >x : Symbol(x, Decl(emitArrowFunctionThisCapturingES6.ts, 4, 10))
 
     this.name = x
@@ -21,7 +19,6 @@ function foo(func: () => boolean){ }
 
 foo(() => {
 >foo : Symbol(foo, Decl(emitArrowFunctionThisCapturingES6.ts, 6, 1))
->() => {    this.age = 100;    return true;} : Symbol((Anonymous function), Decl(emitArrowFunctionThisCapturingES6.ts, 9, 4))
 
     this.age = 100;
     return true;
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments01_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments01_ES6.symbols
index ef80a7dc44240..698b32da7ad98 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments01_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments01_ES6.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments01_ES6.ts ===
 var a = () => {
 >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 0, 3))
->() => {    var arg = arguments[0];  // error} : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 0, 7))
 
     var arg = arguments[0];  // error
 >arg : Symbol(arg, Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 1, 7))
@@ -10,11 +9,9 @@ var a = () => {
 
 var b = function () {
 >b : Symbol(b, Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 4, 3))
->function () {    var a = () => {        var arg = arguments[0];  // error    }} : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 4, 7))
 
     var a = () => {
 >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 5, 7))
->() => {        var arg = arguments[0];  // error    } : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 5, 11))
 
         var arg = arguments[0];  // error
 >arg : Symbol(arg, Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 6, 11))
@@ -26,8 +23,6 @@ function baz() {
 >baz : Symbol(baz, Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 8, 1))
 
 	() => {
->() => {		var arg = arguments[0];	} : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 10, 16))
-
 		var arg = arguments[0];
 >arg : Symbol(arg, Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 12, 5))
 >arguments : Symbol(arguments)
@@ -40,7 +35,6 @@ function foo(inputFunc: () => void) { }
 
 foo(() => {
 >foo : Symbol(foo, Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 14, 1))
->() => {    var arg = arguments[0];  // error} : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 17, 4))
 
     var arg = arguments[0];  // error
 >arg : Symbol(arg, Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 18, 7))
@@ -58,8 +52,6 @@ function bar() {
 
 
 () => {
->() => {	function foo() {		var arg = arguments[0];  // no error	}} : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 23, 1))
-
 	function foo() {
 >foo : Symbol(foo, Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 26, 7))
 
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.symbols
index d10756fa50a00..e403a2c3da1a9 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.symbols
@@ -2,6 +2,5 @@
 
 var a = () => arguments;
 >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments02_ES6.ts, 1, 3))
->() => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments02_ES6.ts, 1, 7))
 >arguments : Symbol(arguments)
 
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.symbols
index 23c5592b8471b..08bae3827942b 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.symbols
@@ -5,6 +5,5 @@ var arguments;
 
 var a = () => arguments;
 >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments03_ES6.ts, 2, 3))
->() => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments03_ES6.ts, 2, 7))
 >arguments : Symbol(arguments)
 
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.symbols
index 37b20c805c1af..708615a95c606 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.symbols
@@ -8,6 +8,5 @@ function f() {
 
     var a = () => arguments;
 >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments04_ES6.ts, 3, 7))
->() => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments04_ES6.ts, 3, 11))
 >arguments : Symbol(arguments)
 }
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.symbols
index a3b38fdf93620..379a5cf92f128 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.symbols
@@ -6,6 +6,5 @@ function f(arguments) {
 
     var a = () => arguments;
 >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments05_ES6.ts, 2, 7))
->() => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments05_ES6.ts, 2, 11))
 >arguments : Symbol(arguments)
 }
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.symbols
index 6dd11e6c544b2..e59f487f86405 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.symbols
@@ -6,7 +6,5 @@ function f(arguments) {
 
     var a = () => () => arguments;
 >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments06_ES6.ts, 2, 7))
->() => () => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments06_ES6.ts, 2, 11))
->() => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments06_ES6.ts, 2, 17))
 >arguments : Symbol(arguments)
 }
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.symbols
index d157f1fa08dd9..5de21ffbebd53 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.symbols
@@ -6,8 +6,6 @@ function f(arguments) {
 
     var a = (arguments) => () => arguments;
 >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments07_ES6.ts, 2, 7))
->(arguments) => () => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments07_ES6.ts, 2, 11))
 >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments07_ES6.ts, 2, 13))
->() => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments07_ES6.ts, 2, 26))
 >arguments : Symbol(arguments)
 }
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.symbols
index 65df0ec716fd6..80f7f5079788d 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.symbols
@@ -6,8 +6,6 @@ function f(arguments) {
 
     var a = () => (arguments) => arguments;
 >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments08.ts, 2, 7))
->() => (arguments) => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments08.ts, 2, 11))
->(arguments) => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments08.ts, 2, 17))
 >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments08.ts, 2, 19))
 >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments08.ts, 2, 19))
 }
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.symbols
index 4ac4d6633bb43..bfbb055cc3249 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.symbols
@@ -6,8 +6,6 @@ function f(arguments) {
 
     var a = () => (arguments) => arguments;
 >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments08_ES6.ts, 2, 7))
->() => (arguments) => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments08_ES6.ts, 2, 11))
->(arguments) => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments08_ES6.ts, 2, 17))
 >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments08_ES6.ts, 2, 19))
 >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments08_ES6.ts, 2, 19))
 }
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.symbols
index dae7fe8e40b9f..ff8f114c052e8 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.symbols
@@ -6,7 +6,5 @@ function f(_arguments) {
 
     var a = () => () => arguments;
 >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments09_ES6.ts, 2, 7))
->() => () => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments09_ES6.ts, 2, 11))
->() => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments09_ES6.ts, 2, 17))
 >arguments : Symbol(arguments)
 }
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.symbols
index 8bb64294ea621..1d9965fa6adc0 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.symbols
@@ -8,7 +8,5 @@ function f() {
 
     var a = () => () => arguments;
 >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments10_ES6.ts, 3, 7))
->() => () => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments10_ES6.ts, 3, 11))
->() => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments10_ES6.ts, 3, 17))
 >arguments : Symbol(arguments)
 }
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.symbols
index 291b3a84d16cf..a8f9c86c1b212 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.symbols
@@ -9,7 +9,5 @@ function f(arguments) {
 
     var a = () => () => arguments;
 >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments11_ES6.ts, 3, 7))
->() => () => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments11_ES6.ts, 3, 11))
->() => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments11_ES6.ts, 3, 17))
 >arguments : Symbol(arguments)
 }
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.symbols
index c78ff46979b6a..b46d8ab1a63e9 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.symbols
@@ -8,8 +8,6 @@ function f() {
 
     var a = (arguments) => () => _arguments;
 >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments13.ts, 3, 7))
->(arguments) => () => _arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments13.ts, 3, 11))
 >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments13.ts, 3, 13))
->() => _arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments13.ts, 3, 26))
 >_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments13.ts, 2, 7))
 }
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.symbols
index 0b2e7f14c18ca..5c4ec4cb687f8 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.symbols
@@ -8,8 +8,6 @@ function f() {
 
     var a = (arguments) => () => _arguments;
 >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments13_ES6.ts, 3, 7))
->(arguments) => () => _arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments13_ES6.ts, 3, 11))
 >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments13_ES6.ts, 3, 13))
->() => _arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments13_ES6.ts, 3, 26))
 >_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments13_ES6.ts, 2, 7))
 }
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols
index b18d2bc2c7fa8..ad1482e7f1afd 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols
@@ -12,7 +12,6 @@ function f() {
 >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments14_ES6.ts, 3, 11))
 
         return () => arguments;
->() => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments14_ES6.ts, 4, 14))
 >arguments : Symbol(arguments)
     }
 }
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols
index 9f6c1f9aa3585..42db5aeaa859f 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols
@@ -15,7 +15,6 @@ function f() {
 >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments15_ES6.ts, 4, 13))
 
         return () => arguments;
->() => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments15_ES6.ts, 5, 14))
 >arguments : Symbol(arguments)
     }
 }
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols
index 41780bc189a90..453e04d752136 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols
@@ -12,7 +12,6 @@ function f() {
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 
         return () => arguments[0];
->() => arguments[0] : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments16_ES6.ts, 4, 14))
 >arguments : Symbol(arguments)
     }
     var arguments = "world";
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols
index 59a681219826b..b686dd1959243 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols
@@ -5,7 +5,6 @@ function f() {
 
     var { arguments } = { arguments: "hello" };
 >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 2, 9), Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 6, 7))
->{ arguments: "hello" } : Symbol(, Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 2, 23))
 >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 2, 25))
 
     if (Math.random()) {
@@ -14,7 +13,6 @@ function f() {
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 
         return () => arguments[0];
->() => arguments[0] : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 4, 14))
 >arguments : Symbol(arguments)
     }
     var arguments = "world";
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols
index 26262cc6bed9d..4ac60f9b429d5 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols
@@ -5,7 +5,6 @@ function f() {
 
     var { arguments: args } = { arguments };
 >args : Symbol(args, Decl(emitArrowFunctionWhenUsingArguments18_ES6.ts, 2, 9))
->{ arguments } : Symbol(, Decl(emitArrowFunctionWhenUsingArguments18_ES6.ts, 2, 29))
 >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments18_ES6.ts, 2, 31))
 
     if (Math.random()) {
@@ -14,7 +13,6 @@ function f() {
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 
         return () => arguments;
->() => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments18_ES6.ts, 4, 14))
 >arguments : Symbol(arguments)
     }
 }
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.symbols
index 82c1392249840..9e6392daaf18e 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.symbols
@@ -14,7 +14,6 @@ function f() {
 
             var capture = () => arguments;  // Should trigger an '_arguments' capture into function 'h'
 >capture : Symbol(capture, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 5, 15))
->() => arguments : Symbol((Anonymous function), Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 5, 25))
 >arguments : Symbol(arguments)
 
             foo(_arguments);                // Error as this does not resolve to the user defined '_arguments'
diff --git a/tests/baselines/reference/emitArrowFunctionsAsIs.symbols b/tests/baselines/reference/emitArrowFunctionsAsIs.symbols
index ec1fa132a5cb7..73c68bd194d6f 100644
--- a/tests/baselines/reference/emitArrowFunctionsAsIs.symbols
+++ b/tests/baselines/reference/emitArrowFunctionsAsIs.symbols
@@ -1,17 +1,14 @@
 === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionsAsIs.ts ===
 var arrow1 = a => { };
 >arrow1 : Symbol(arrow1, Decl(emitArrowFunctionsAsIs.ts, 0, 3))
->a => { } : Symbol((Anonymous function), Decl(emitArrowFunctionsAsIs.ts, 0, 12))
 >a : Symbol(a, Decl(emitArrowFunctionsAsIs.ts, 0, 12))
 
 var arrow2 = (a) => { };
 >arrow2 : Symbol(arrow2, Decl(emitArrowFunctionsAsIs.ts, 1, 3))
->(a) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionsAsIs.ts, 1, 12))
 >a : Symbol(a, Decl(emitArrowFunctionsAsIs.ts, 1, 14))
 
 var arrow3 = (a, b) => { };
 >arrow3 : Symbol(arrow3, Decl(emitArrowFunctionsAsIs.ts, 3, 3))
->(a, b) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionsAsIs.ts, 3, 12))
 >a : Symbol(a, Decl(emitArrowFunctionsAsIs.ts, 3, 14))
 >b : Symbol(b, Decl(emitArrowFunctionsAsIs.ts, 3, 16))
 
diff --git a/tests/baselines/reference/emitArrowFunctionsAsIsES6.symbols b/tests/baselines/reference/emitArrowFunctionsAsIsES6.symbols
index 86e3e3a96d4ec..73f4df744e86b 100644
--- a/tests/baselines/reference/emitArrowFunctionsAsIsES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionsAsIsES6.symbols
@@ -1,17 +1,14 @@
 === tests/cases/conformance/es6/arrowFunction/emitArrowFunctionsAsIsES6.ts ===
 var arrow1 =  a => { };
 >arrow1 : Symbol(arrow1, Decl(emitArrowFunctionsAsIsES6.ts, 0, 3))
->a => { } : Symbol((Anonymous function), Decl(emitArrowFunctionsAsIsES6.ts, 0, 12))
 >a : Symbol(a, Decl(emitArrowFunctionsAsIsES6.ts, 0, 12))
 
 var arrow2 = (a) => { };
 >arrow2 : Symbol(arrow2, Decl(emitArrowFunctionsAsIsES6.ts, 1, 3))
->(a) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionsAsIsES6.ts, 1, 12))
 >a : Symbol(a, Decl(emitArrowFunctionsAsIsES6.ts, 1, 14))
 
 var arrow3 = (a, b) => { };
 >arrow3 : Symbol(arrow3, Decl(emitArrowFunctionsAsIsES6.ts, 3, 3))
->(a, b) => { } : Symbol((Anonymous function), Decl(emitArrowFunctionsAsIsES6.ts, 3, 12))
 >a : Symbol(a, Decl(emitArrowFunctionsAsIsES6.ts, 3, 14))
 >b : Symbol(b, Decl(emitArrowFunctionsAsIsES6.ts, 3, 16))
 
diff --git a/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.symbols b/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.symbols
index fa83f38432339..13ce54e0641be 100644
--- a/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.symbols
+++ b/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.symbols
@@ -17,7 +17,6 @@ class Foo extends Parent {
 
         var x = () => super.foo();
 >x : Symbol(x, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 8, 11))
->() => super.foo() : Symbol((Anonymous function), Decl(emitClassDeclarationWithSuperMethodCall01.ts, 8, 15))
 >super.foo : Symbol(Parent.foo, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 1, 14))
 >super : Symbol(Parent, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 0, 0))
 >foo : Symbol(Parent.foo, Decl(emitClassDeclarationWithSuperMethodCall01.ts, 1, 14))
diff --git a/tests/baselines/reference/emitDefaultParametersFunctionExpression.symbols b/tests/baselines/reference/emitDefaultParametersFunctionExpression.symbols
index d040321f7f3a8..59c9c2207878e 100644
--- a/tests/baselines/reference/emitDefaultParametersFunctionExpression.symbols
+++ b/tests/baselines/reference/emitDefaultParametersFunctionExpression.symbols
@@ -1,44 +1,37 @@
 === tests/cases/conformance/es6/defaultParameters/emitDefaultParametersFunctionExpression.ts ===
 var lambda1 = (y = "hello") => { }
 >lambda1 : Symbol(lambda1, Decl(emitDefaultParametersFunctionExpression.ts, 0, 3))
->(y = "hello") => { } : Symbol((Anonymous function), Decl(emitDefaultParametersFunctionExpression.ts, 0, 13))
 >y : Symbol(y, Decl(emitDefaultParametersFunctionExpression.ts, 0, 15))
 
 var lambda2 = (x: number, y = "hello") => { }
 >lambda2 : Symbol(lambda2, Decl(emitDefaultParametersFunctionExpression.ts, 1, 3))
->(x: number, y = "hello") => { } : Symbol((Anonymous function), Decl(emitDefaultParametersFunctionExpression.ts, 1, 13))
 >x : Symbol(x, Decl(emitDefaultParametersFunctionExpression.ts, 1, 15))
 >y : Symbol(y, Decl(emitDefaultParametersFunctionExpression.ts, 1, 25))
 
 var lambda3 = (x: number, y = "hello", ...rest) => { }
 >lambda3 : Symbol(lambda3, Decl(emitDefaultParametersFunctionExpression.ts, 2, 3))
->(x: number, y = "hello", ...rest) => { } : Symbol((Anonymous function), Decl(emitDefaultParametersFunctionExpression.ts, 2, 13))
 >x : Symbol(x, Decl(emitDefaultParametersFunctionExpression.ts, 2, 15))
 >y : Symbol(y, Decl(emitDefaultParametersFunctionExpression.ts, 2, 25))
 >rest : Symbol(rest, Decl(emitDefaultParametersFunctionExpression.ts, 2, 38))
 
 var lambda4 = (y = "hello", ...rest) => { }
 >lambda4 : Symbol(lambda4, Decl(emitDefaultParametersFunctionExpression.ts, 3, 3))
->(y = "hello", ...rest) => { } : Symbol((Anonymous function), Decl(emitDefaultParametersFunctionExpression.ts, 3, 13))
 >y : Symbol(y, Decl(emitDefaultParametersFunctionExpression.ts, 3, 15))
 >rest : Symbol(rest, Decl(emitDefaultParametersFunctionExpression.ts, 3, 27))
 
 var x = function (str = "hello", ...rest) { }
 >x : Symbol(x, Decl(emitDefaultParametersFunctionExpression.ts, 5, 3))
->function (str = "hello", ...rest) { } : Symbol((Anonymous function), Decl(emitDefaultParametersFunctionExpression.ts, 5, 7))
 >str : Symbol(str, Decl(emitDefaultParametersFunctionExpression.ts, 5, 18))
 >rest : Symbol(rest, Decl(emitDefaultParametersFunctionExpression.ts, 5, 32))
 
 var y = (function (num = 10, boo = false, ...rest) { })()
 >y : Symbol(y, Decl(emitDefaultParametersFunctionExpression.ts, 6, 3))
->function (num = 10, boo = false, ...rest) { } : Symbol((Anonymous function), Decl(emitDefaultParametersFunctionExpression.ts, 6, 9))
 >num : Symbol(num, Decl(emitDefaultParametersFunctionExpression.ts, 6, 19))
 >boo : Symbol(boo, Decl(emitDefaultParametersFunctionExpression.ts, 6, 28))
 >rest : Symbol(rest, Decl(emitDefaultParametersFunctionExpression.ts, 6, 41))
 
 var z = (function (num: number, boo = false, ...rest) { })(10)
 >z : Symbol(z, Decl(emitDefaultParametersFunctionExpression.ts, 7, 3))
->function (num: number, boo = false, ...rest) { } : Symbol((Anonymous function), Decl(emitDefaultParametersFunctionExpression.ts, 7, 9))
 >num : Symbol(num, Decl(emitDefaultParametersFunctionExpression.ts, 7, 19))
 >boo : Symbol(boo, Decl(emitDefaultParametersFunctionExpression.ts, 7, 31))
 >rest : Symbol(rest, Decl(emitDefaultParametersFunctionExpression.ts, 7, 44))
diff --git a/tests/baselines/reference/emitDefaultParametersFunctionExpressionES6.symbols b/tests/baselines/reference/emitDefaultParametersFunctionExpressionES6.symbols
index 6e1bc97f420d3..36eef9b9a1d06 100644
--- a/tests/baselines/reference/emitDefaultParametersFunctionExpressionES6.symbols
+++ b/tests/baselines/reference/emitDefaultParametersFunctionExpressionES6.symbols
@@ -1,44 +1,37 @@
 === tests/cases/conformance/es6/defaultParameters/emitDefaultParametersFunctionExpressionES6.ts ===
 var lambda1 = (y = "hello") => { }
 >lambda1 : Symbol(lambda1, Decl(emitDefaultParametersFunctionExpressionES6.ts, 0, 3))
->(y = "hello") => { } : Symbol((Anonymous function), Decl(emitDefaultParametersFunctionExpressionES6.ts, 0, 13))
 >y : Symbol(y, Decl(emitDefaultParametersFunctionExpressionES6.ts, 0, 15))
 
 var lambda2 = (x: number, y = "hello") => { }
 >lambda2 : Symbol(lambda2, Decl(emitDefaultParametersFunctionExpressionES6.ts, 1, 3))
->(x: number, y = "hello") => { } : Symbol((Anonymous function), Decl(emitDefaultParametersFunctionExpressionES6.ts, 1, 13))
 >x : Symbol(x, Decl(emitDefaultParametersFunctionExpressionES6.ts, 1, 15))
 >y : Symbol(y, Decl(emitDefaultParametersFunctionExpressionES6.ts, 1, 25))
 
 var lambda3 = (x: number, y = "hello", ...rest) => { }
 >lambda3 : Symbol(lambda3, Decl(emitDefaultParametersFunctionExpressionES6.ts, 2, 3))
->(x: number, y = "hello", ...rest) => { } : Symbol((Anonymous function), Decl(emitDefaultParametersFunctionExpressionES6.ts, 2, 13))
 >x : Symbol(x, Decl(emitDefaultParametersFunctionExpressionES6.ts, 2, 15))
 >y : Symbol(y, Decl(emitDefaultParametersFunctionExpressionES6.ts, 2, 25))
 >rest : Symbol(rest, Decl(emitDefaultParametersFunctionExpressionES6.ts, 2, 38))
 
 var lambda4 = (y = "hello", ...rest) => { }
 >lambda4 : Symbol(lambda4, Decl(emitDefaultParametersFunctionExpressionES6.ts, 3, 3))
->(y = "hello", ...rest) => { } : Symbol((Anonymous function), Decl(emitDefaultParametersFunctionExpressionES6.ts, 3, 13))
 >y : Symbol(y, Decl(emitDefaultParametersFunctionExpressionES6.ts, 3, 15))
 >rest : Symbol(rest, Decl(emitDefaultParametersFunctionExpressionES6.ts, 3, 27))
 
 var x = function (str = "hello", ...rest) { }
 >x : Symbol(x, Decl(emitDefaultParametersFunctionExpressionES6.ts, 5, 3))
->function (str = "hello", ...rest) { } : Symbol((Anonymous function), Decl(emitDefaultParametersFunctionExpressionES6.ts, 5, 7))
 >str : Symbol(str, Decl(emitDefaultParametersFunctionExpressionES6.ts, 5, 18))
 >rest : Symbol(rest, Decl(emitDefaultParametersFunctionExpressionES6.ts, 5, 32))
 
 var y = (function (num = 10, boo = false, ...rest) { })()
 >y : Symbol(y, Decl(emitDefaultParametersFunctionExpressionES6.ts, 6, 3))
->function (num = 10, boo = false, ...rest) { } : Symbol((Anonymous function), Decl(emitDefaultParametersFunctionExpressionES6.ts, 6, 9))
 >num : Symbol(num, Decl(emitDefaultParametersFunctionExpressionES6.ts, 6, 19))
 >boo : Symbol(boo, Decl(emitDefaultParametersFunctionExpressionES6.ts, 6, 28))
 >rest : Symbol(rest, Decl(emitDefaultParametersFunctionExpressionES6.ts, 6, 41))
 
 var z = (function (num: number, boo = false, ...rest) { })(10)
 >z : Symbol(z, Decl(emitDefaultParametersFunctionExpressionES6.ts, 7, 3))
->function (num: number, boo = false, ...rest) { } : Symbol((Anonymous function), Decl(emitDefaultParametersFunctionExpressionES6.ts, 7, 9))
 >num : Symbol(num, Decl(emitDefaultParametersFunctionExpressionES6.ts, 7, 19))
 >boo : Symbol(boo, Decl(emitDefaultParametersFunctionExpressionES6.ts, 7, 31))
 >rest : Symbol(rest, Decl(emitDefaultParametersFunctionExpressionES6.ts, 7, 44))
diff --git a/tests/baselines/reference/emitDefaultParametersFunctionProperty.symbols b/tests/baselines/reference/emitDefaultParametersFunctionProperty.symbols
index 7423c3f4d50d4..f377e8bd69631 100644
--- a/tests/baselines/reference/emitDefaultParametersFunctionProperty.symbols
+++ b/tests/baselines/reference/emitDefaultParametersFunctionProperty.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/defaultParameters/emitDefaultParametersFunctionProperty.ts ===
 var obj2 = {
 >obj2 : Symbol(obj2, Decl(emitDefaultParametersFunctionProperty.ts, 0, 3))
->{    func1(y = 10, ...rest) { },    func2(x = "hello") { },    func3(x: string, z: number, y = "hello") { },    func4(x: string, z: number, y = "hello", ...rest) { },} : Symbol(, Decl(emitDefaultParametersFunctionProperty.ts, 0, 10))
 
     func1(y = 10, ...rest) { },
 >func1 : Symbol(func1, Decl(emitDefaultParametersFunctionProperty.ts, 0, 12))
diff --git a/tests/baselines/reference/emitDefaultParametersFunctionPropertyES6.symbols b/tests/baselines/reference/emitDefaultParametersFunctionPropertyES6.symbols
index 621cb0b702bbf..88bad28bbf89a 100644
--- a/tests/baselines/reference/emitDefaultParametersFunctionPropertyES6.symbols
+++ b/tests/baselines/reference/emitDefaultParametersFunctionPropertyES6.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/defaultParameters/emitDefaultParametersFunctionPropertyES6.ts ===
 var obj2 = {
 >obj2 : Symbol(obj2, Decl(emitDefaultParametersFunctionPropertyES6.ts, 0, 3))
->{    func1(y = 10, ...rest) { },    func2(x = "hello") { },    func3(x: string, z: number, y = "hello") { },    func4(x: string, z: number, y = "hello", ...rest) { },} : Symbol(, Decl(emitDefaultParametersFunctionPropertyES6.ts, 0, 10))
 
     func1(y = 10, ...rest) { },
 >func1 : Symbol(func1, Decl(emitDefaultParametersFunctionPropertyES6.ts, 0, 12))
diff --git a/tests/baselines/reference/emitRestParametersFunctionExpression.symbols b/tests/baselines/reference/emitRestParametersFunctionExpression.symbols
index 1b5a34d7b9d7d..8a42e7b5296e0 100644
--- a/tests/baselines/reference/emitRestParametersFunctionExpression.symbols
+++ b/tests/baselines/reference/emitRestParametersFunctionExpression.symbols
@@ -1,22 +1,18 @@
 === tests/cases/conformance/es6/restParameters/emitRestParametersFunctionExpression.ts ===
 var funcExp = (...rest) => { }
 >funcExp : Symbol(funcExp, Decl(emitRestParametersFunctionExpression.ts, 0, 3))
->(...rest) => { } : Symbol((Anonymous function), Decl(emitRestParametersFunctionExpression.ts, 0, 13))
 >rest : Symbol(rest, Decl(emitRestParametersFunctionExpression.ts, 0, 15))
 
 var funcExp1 = (X: number, ...rest) => { }
 >funcExp1 : Symbol(funcExp1, Decl(emitRestParametersFunctionExpression.ts, 1, 3))
->(X: number, ...rest) => { } : Symbol((Anonymous function), Decl(emitRestParametersFunctionExpression.ts, 1, 14))
 >X : Symbol(X, Decl(emitRestParametersFunctionExpression.ts, 1, 16))
 >rest : Symbol(rest, Decl(emitRestParametersFunctionExpression.ts, 1, 26))
 
 var funcExp2 = function (...rest) { }
 >funcExp2 : Symbol(funcExp2, Decl(emitRestParametersFunctionExpression.ts, 2, 3))
->function (...rest) { } : Symbol((Anonymous function), Decl(emitRestParametersFunctionExpression.ts, 2, 14))
 >rest : Symbol(rest, Decl(emitRestParametersFunctionExpression.ts, 2, 25))
 
 var funcExp3 = (function (...rest) { })()
 >funcExp3 : Symbol(funcExp3, Decl(emitRestParametersFunctionExpression.ts, 3, 3))
->function (...rest) { } : Symbol((Anonymous function), Decl(emitRestParametersFunctionExpression.ts, 3, 16))
 >rest : Symbol(rest, Decl(emitRestParametersFunctionExpression.ts, 3, 26))
 
diff --git a/tests/baselines/reference/emitRestParametersFunctionExpressionES6.symbols b/tests/baselines/reference/emitRestParametersFunctionExpressionES6.symbols
index e9dbcd0f2d35b..cf39ed21a8820 100644
--- a/tests/baselines/reference/emitRestParametersFunctionExpressionES6.symbols
+++ b/tests/baselines/reference/emitRestParametersFunctionExpressionES6.symbols
@@ -1,22 +1,18 @@
 === tests/cases/conformance/es6/restParameters/emitRestParametersFunctionExpressionES6.ts ===
 var funcExp = (...rest) => { }
 >funcExp : Symbol(funcExp, Decl(emitRestParametersFunctionExpressionES6.ts, 0, 3))
->(...rest) => { } : Symbol((Anonymous function), Decl(emitRestParametersFunctionExpressionES6.ts, 0, 13))
 >rest : Symbol(rest, Decl(emitRestParametersFunctionExpressionES6.ts, 0, 15))
 
 var funcExp1 = (X: number, ...rest) => { }
 >funcExp1 : Symbol(funcExp1, Decl(emitRestParametersFunctionExpressionES6.ts, 1, 3))
->(X: number, ...rest) => { } : Symbol((Anonymous function), Decl(emitRestParametersFunctionExpressionES6.ts, 1, 14))
 >X : Symbol(X, Decl(emitRestParametersFunctionExpressionES6.ts, 1, 16))
 >rest : Symbol(rest, Decl(emitRestParametersFunctionExpressionES6.ts, 1, 26))
 
 var funcExp2 = function (...rest) { }
 >funcExp2 : Symbol(funcExp2, Decl(emitRestParametersFunctionExpressionES6.ts, 2, 3))
->function (...rest) { } : Symbol((Anonymous function), Decl(emitRestParametersFunctionExpressionES6.ts, 2, 14))
 >rest : Symbol(rest, Decl(emitRestParametersFunctionExpressionES6.ts, 2, 25))
 
 var funcExp3 = (function (...rest) { })()
 >funcExp3 : Symbol(funcExp3, Decl(emitRestParametersFunctionExpressionES6.ts, 3, 3))
->function (...rest) { } : Symbol((Anonymous function), Decl(emitRestParametersFunctionExpressionES6.ts, 3, 16))
 >rest : Symbol(rest, Decl(emitRestParametersFunctionExpressionES6.ts, 3, 26))
 
diff --git a/tests/baselines/reference/emitRestParametersFunctionProperty.symbols b/tests/baselines/reference/emitRestParametersFunctionProperty.symbols
index 5fbaf746c809f..2a0505831b9f3 100644
--- a/tests/baselines/reference/emitRestParametersFunctionProperty.symbols
+++ b/tests/baselines/reference/emitRestParametersFunctionProperty.symbols
@@ -9,7 +9,6 @@ var obj: {
 
 var obj2 = {
 >obj2 : Symbol(obj2, Decl(emitRestParametersFunctionProperty.ts, 4, 3))
->{    func(...rest) { }} : Symbol(, Decl(emitRestParametersFunctionProperty.ts, 4, 10))
 
     func(...rest) { }
 >func : Symbol(func, Decl(emitRestParametersFunctionProperty.ts, 4, 12))
diff --git a/tests/baselines/reference/emitRestParametersFunctionPropertyES6.symbols b/tests/baselines/reference/emitRestParametersFunctionPropertyES6.symbols
index a24165f70bc42..a6b00757eec93 100644
--- a/tests/baselines/reference/emitRestParametersFunctionPropertyES6.symbols
+++ b/tests/baselines/reference/emitRestParametersFunctionPropertyES6.symbols
@@ -9,7 +9,6 @@ var obj: {
 
 var obj2 = {
 >obj2 : Symbol(obj2, Decl(emitRestParametersFunctionPropertyES6.ts, 4, 3))
->{    func(...rest) { }} : Symbol(, Decl(emitRestParametersFunctionPropertyES6.ts, 4, 10))
 
     func(...rest) { }
 >func : Symbol(func, Decl(emitRestParametersFunctionPropertyES6.ts, 4, 12))
diff --git a/tests/baselines/reference/emptyExpr.symbols b/tests/baselines/reference/emptyExpr.symbols
index 7f48b4c1eeb0d..e699404332f09 100644
--- a/tests/baselines/reference/emptyExpr.symbols
+++ b/tests/baselines/reference/emptyExpr.symbols
@@ -1,4 +1,3 @@
 === tests/cases/compiler/emptyExpr.ts ===
 [{},]
->{} : Symbol(, Decl(emptyExpr.ts, 0, 1))
-
+No type information for this code.
\ No newline at end of file
diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter04.symbols b/tests/baselines/reference/emptyObjectBindingPatternParameter04.symbols
index 641d6338c5138..9922d4cd074d8 100644
--- a/tests/baselines/reference/emptyObjectBindingPatternParameter04.symbols
+++ b/tests/baselines/reference/emptyObjectBindingPatternParameter04.symbols
@@ -3,7 +3,6 @@
 
 function f({} = {a: 1, b: "2", c: true}) {
 >f : Symbol(f, Decl(emptyObjectBindingPatternParameter04.ts, 0, 0))
->{a: 1, b: "2", c: true} : Symbol(, Decl(emptyObjectBindingPatternParameter04.ts, 2, 15))
 >a : Symbol(a, Decl(emptyObjectBindingPatternParameter04.ts, 2, 17))
 >b : Symbol(b, Decl(emptyObjectBindingPatternParameter04.ts, 2, 22))
 >c : Symbol(c, Decl(emptyObjectBindingPatternParameter04.ts, 2, 30))
diff --git a/tests/baselines/reference/enumIndexer.symbols b/tests/baselines/reference/enumIndexer.symbols
index 6a595a4133f37..3f65044c2ec55 100644
--- a/tests/baselines/reference/enumIndexer.symbols
+++ b/tests/baselines/reference/enumIndexer.symbols
@@ -8,9 +8,7 @@ enum MyEnumType {
 }
 var _arr = [{ key: 'foo' }, { key: 'bar' }]
 >_arr : Symbol(_arr, Decl(enumIndexer.ts, 3, 3))
->{ key: 'foo' } : Symbol(, Decl(enumIndexer.ts, 3, 12))
 >key : Symbol(key, Decl(enumIndexer.ts, 3, 13))
->{ key: 'bar' } : Symbol(, Decl(enumIndexer.ts, 3, 27))
 >key : Symbol(key, Decl(enumIndexer.ts, 3, 29))
 
 var enumValue = MyEnumType.foo;
@@ -24,7 +22,6 @@ var x = _arr.map(o => MyEnumType[o.key] === enumValue); // these are not same ty
 >_arr.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
 >_arr : Symbol(_arr, Decl(enumIndexer.ts, 3, 3))
 >map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
->o => MyEnumType[o.key] === enumValue : Symbol((Anonymous function), Decl(enumIndexer.ts, 5, 17))
 >o : Symbol(o, Decl(enumIndexer.ts, 5, 17))
 >MyEnumType : Symbol(MyEnumType, Decl(enumIndexer.ts, 0, 0))
 >o.key : Symbol(key, Decl(enumIndexer.ts, 3, 13))
diff --git a/tests/baselines/reference/es6ClassTest5.symbols b/tests/baselines/reference/es6ClassTest5.symbols
index 1a0b30521fe43..89c6921e1635d 100644
--- a/tests/baselines/reference/es6ClassTest5.symbols
+++ b/tests/baselines/reference/es6ClassTest5.symbols
@@ -8,7 +8,6 @@ class C1T5 {
 >s : Symbol(s, Decl(es6ClassTest5.ts, 1, 20))
 
 	   	(i) => {
->(i) => {	        return i;	    } : Symbol((Anonymous function), Decl(es6ClassTest5.ts, 1, 43))
 >i : Symbol(i, Decl(es6ClassTest5.ts, 2, 6))
 
 	        return i;
diff --git a/tests/baselines/reference/es6ClassTest8.symbols b/tests/baselines/reference/es6ClassTest8.symbols
index e6735a03d8528..b02b80e7017ec 100644
--- a/tests/baselines/reference/es6ClassTest8.symbols
+++ b/tests/baselines/reference/es6ClassTest8.symbols
@@ -10,7 +10,6 @@ class C {
     constructor() {
         var bar:any = (function() {
 >bar : Symbol(bar, Decl(es6ClassTest8.ts, 4, 11))
->function() {            return bar; // 'bar' should be resolvable        } : Symbol((Anonymous function), Decl(es6ClassTest8.ts, 4, 23))
 
             return bar; // 'bar' should be resolvable
 >bar : Symbol(bar, Decl(es6ClassTest8.ts, 4, 11))
diff --git a/tests/baselines/reference/escapedIdentifiers.symbols b/tests/baselines/reference/escapedIdentifiers.symbols
index 01207a584a7d0..6c84b25647f6a 100644
--- a/tests/baselines/reference/escapedIdentifiers.symbols
+++ b/tests/baselines/reference/escapedIdentifiers.symbols
@@ -131,7 +131,6 @@ interface interfaceType\u0032 {
 var interfaceType1Object1 = <interfaceType1>{ bar1: 0 };
 >interfaceType1Object1 : Symbol(interfaceType1Object1, Decl(escapedIdentifiers.ts, 59, 3))
 >interfaceType1 : Symbol(interfaceType1, Decl(escapedIdentifiers.ts, 49, 27))
->{ bar1: 0 } : Symbol(, Decl(escapedIdentifiers.ts, 59, 44))
 >bar1 : Symbol(bar1, Decl(escapedIdentifiers.ts, 59, 45))
 
 interfaceType1Object1.bar1 = 2;
@@ -142,7 +141,6 @@ interfaceType1Object1.bar1 = 2;
 var interfaceType1Object2 = <interfaceType\u0031>{ bar1: 0 };
 >interfaceType1Object2 : Symbol(interfaceType1Object2, Decl(escapedIdentifiers.ts, 61, 3))
 >interfaceType\u0031 : Symbol(interfaceType1, Decl(escapedIdentifiers.ts, 49, 27))
->{ bar1: 0 } : Symbol(, Decl(escapedIdentifiers.ts, 61, 49))
 >bar1 : Symbol(bar1, Decl(escapedIdentifiers.ts, 61, 50))
 
 interfaceType1Object2.bar1 = 2;
@@ -153,7 +151,6 @@ interfaceType1Object2.bar1 = 2;
 var interfaceType2Object1 = <interfaceType2>{ bar2: 0 };
 >interfaceType2Object1 : Symbol(interfaceType2Object1, Decl(escapedIdentifiers.ts, 63, 3))
 >interfaceType2 : Symbol(interfaceType\u0032, Decl(escapedIdentifiers.ts, 54, 1))
->{ bar2: 0 } : Symbol(, Decl(escapedIdentifiers.ts, 63, 44))
 >bar2 : Symbol(bar2, Decl(escapedIdentifiers.ts, 63, 45))
 
 interfaceType2Object1.bar2 = 2;
@@ -164,7 +161,6 @@ interfaceType2Object1.bar2 = 2;
 var interfaceType2Object2 = <interfaceType\u0032>{ bar2: 0 };
 >interfaceType2Object2 : Symbol(interfaceType2Object2, Decl(escapedIdentifiers.ts, 65, 3))
 >interfaceType\u0032 : Symbol(interfaceType\u0032, Decl(escapedIdentifiers.ts, 54, 1))
->{ bar2: 0 } : Symbol(, Decl(escapedIdentifiers.ts, 65, 49))
 >bar2 : Symbol(bar2, Decl(escapedIdentifiers.ts, 65, 50))
 
 interfaceType2Object2.bar2 = 2;
diff --git a/tests/baselines/reference/escapedReservedCompilerNamedIdentifier.symbols b/tests/baselines/reference/escapedReservedCompilerNamedIdentifier.symbols
index 6b4816d2e1adc..b629c5bd8750c 100644
--- a/tests/baselines/reference/escapedReservedCompilerNamedIdentifier.symbols
+++ b/tests/baselines/reference/escapedReservedCompilerNamedIdentifier.symbols
@@ -5,7 +5,6 @@ var __proto__ = 10;
 
 var o = {
 >o : Symbol(o, Decl(escapedReservedCompilerNamedIdentifier.ts, 2, 3))
->{    "__proto__": 0} : Symbol(, Decl(escapedReservedCompilerNamedIdentifier.ts, 2, 7))
 
     "__proto__": 0
 };
@@ -16,7 +15,6 @@ var b = o["__proto__"];
 
 var o1 = {
 >o1 : Symbol(o1, Decl(escapedReservedCompilerNamedIdentifier.ts, 6, 3))
->{    __proto__: 0} : Symbol(, Decl(escapedReservedCompilerNamedIdentifier.ts, 6, 8))
 
     __proto__: 0
 >__proto__ : Symbol(__proto__, Decl(escapedReservedCompilerNamedIdentifier.ts, 6, 10))
@@ -33,7 +31,6 @@ var ___proto__ = 10;
 
 var o2 = {
 >o2 : Symbol(o2, Decl(escapedReservedCompilerNamedIdentifier.ts, 12, 3))
->{    "___proto__": 0} : Symbol(, Decl(escapedReservedCompilerNamedIdentifier.ts, 12, 8))
 
     "___proto__": 0
 };
@@ -44,7 +41,6 @@ var b2 = o2["___proto__"];
 
 var o3 = {
 >o3 : Symbol(o3, Decl(escapedReservedCompilerNamedIdentifier.ts, 16, 3))
->{    ___proto__: 0} : Symbol(, Decl(escapedReservedCompilerNamedIdentifier.ts, 16, 8))
 
     ___proto__: 0
 >___proto__ : Symbol(___proto__, Decl(escapedReservedCompilerNamedIdentifier.ts, 16, 10))
@@ -61,7 +57,6 @@ var _proto__ = 10;
 
 var o4 = {
 >o4 : Symbol(o4, Decl(escapedReservedCompilerNamedIdentifier.ts, 22, 3))
->{    "_proto__": 0} : Symbol(, Decl(escapedReservedCompilerNamedIdentifier.ts, 22, 8))
 
     "_proto__": 0
 };
@@ -72,7 +67,6 @@ var b4 = o4["_proto__"];
 
 var o5 = {
 >o5 : Symbol(o5, Decl(escapedReservedCompilerNamedIdentifier.ts, 26, 3))
->{    _proto__: 0} : Symbol(, Decl(escapedReservedCompilerNamedIdentifier.ts, 26, 8))
 
     _proto__: 0
 >_proto__ : Symbol(_proto__, Decl(escapedReservedCompilerNamedIdentifier.ts, 26, 10))
diff --git a/tests/baselines/reference/everyTypeWithAnnotationAndInitializer.symbols b/tests/baselines/reference/everyTypeWithAnnotationAndInitializer.symbols
index 1d795b1c12da3..489903750f5b3 100644
--- a/tests/baselines/reference/everyTypeWithAnnotationAndInitializer.symbols
+++ b/tests/baselines/reference/everyTypeWithAnnotationAndInitializer.symbols
@@ -101,7 +101,6 @@ var aGenericClass: D<string> = new D<string>();
 var anObjectLiteral: I = { id: 12 };
 >anObjectLiteral : Symbol(anObjectLiteral, Decl(everyTypeWithAnnotationAndInitializer.ts, 36, 3))
 >I : Symbol(I, Decl(everyTypeWithAnnotationAndInitializer.ts, 0, 0))
->{ id: 12 } : Symbol(, Decl(everyTypeWithAnnotationAndInitializer.ts, 36, 24))
 >id : Symbol(id, Decl(everyTypeWithAnnotationAndInitializer.ts, 36, 26))
 
 var anOtherObjectLiteral: { id: number } = new C();
@@ -122,7 +121,6 @@ var anOtherFunction: (x: string) => number = F;
 var aLambda: typeof F = (x) => 2;
 >aLambda : Symbol(aLambda, Decl(everyTypeWithAnnotationAndInitializer.ts, 41, 3))
 >F : Symbol(F, Decl(everyTypeWithAnnotationAndInitializer.ts, 12, 1))
->(x) => 2 : Symbol((Anonymous function), Decl(everyTypeWithAnnotationAndInitializer.ts, 41, 23))
 >x : Symbol(x, Decl(everyTypeWithAnnotationAndInitializer.ts, 41, 25))
 
 var aModule: typeof M = M;
@@ -143,7 +141,6 @@ var aFunctionInModule: typeof M.F2 = (x) => 'this is a string';
 >M.F2 : Symbol(M.F2, Decl(everyTypeWithAnnotationAndInitializer.ts, 19, 5))
 >M : Symbol(M, Decl(everyTypeWithAnnotationAndInitializer.ts, 14, 44))
 >F2 : Symbol(M.F2, Decl(everyTypeWithAnnotationAndInitializer.ts, 19, 5))
->(x) => 'this is a string' : Symbol((Anonymous function), Decl(everyTypeWithAnnotationAndInitializer.ts, 45, 36))
 >x : Symbol(x, Decl(everyTypeWithAnnotationAndInitializer.ts, 45, 38))
 
 
diff --git a/tests/baselines/reference/everyTypeWithInitializer.symbols b/tests/baselines/reference/everyTypeWithInitializer.symbols
index d92e7ef6bc34f..0a22252164ba5 100644
--- a/tests/baselines/reference/everyTypeWithInitializer.symbols
+++ b/tests/baselines/reference/everyTypeWithInitializer.symbols
@@ -92,7 +92,6 @@ var aGenericClass = new D<string>();
 
 var anObjectLiteral = { id: 12 };
 >anObjectLiteral : Symbol(anObjectLiteral, Decl(everyTypeWithInitializer.ts, 36, 3))
->{ id: 12 } : Symbol(, Decl(everyTypeWithInitializer.ts, 36, 21))
 >id : Symbol(id, Decl(everyTypeWithInitializer.ts, 36, 23))
 
 var aFunction = F;
@@ -101,7 +100,6 @@ var aFunction = F;
 
 var aLambda = (x) => 2;
 >aLambda : Symbol(aLambda, Decl(everyTypeWithInitializer.ts, 39, 3))
->(x) => 2 : Symbol((Anonymous function), Decl(everyTypeWithInitializer.ts, 39, 13))
 >x : Symbol(x, Decl(everyTypeWithInitializer.ts, 39, 15))
 
 var aModule = M;
diff --git a/tests/baselines/reference/exportAssignmentMergedInterface.symbols b/tests/baselines/reference/exportAssignmentMergedInterface.symbols
index e25a52c7b8df9..a199ed4e6c510 100644
--- a/tests/baselines/reference/exportAssignmentMergedInterface.symbols
+++ b/tests/baselines/reference/exportAssignmentMergedInterface.symbols
@@ -25,7 +25,6 @@ if(!!x.c){ }
 
 var z = {x: 1, y: 2};
 >z : Symbol(z, Decl(foo_1.ts, 6, 3))
->{x: 1, y: 2} : Symbol(, Decl(foo_1.ts, 6, 7))
 >x : Symbol(x, Decl(foo_1.ts, 6, 9))
 >y : Symbol(y, Decl(foo_1.ts, 6, 14))
 
diff --git a/tests/baselines/reference/exportAssignmentWithoutIdentifier1.symbols b/tests/baselines/reference/exportAssignmentWithoutIdentifier1.symbols
index 033df591411e0..bcbf5eb1f60af 100644
--- a/tests/baselines/reference/exportAssignmentWithoutIdentifier1.symbols
+++ b/tests/baselines/reference/exportAssignmentWithoutIdentifier1.symbols
@@ -8,7 +8,6 @@ Greeter.prototype.greet = function () {
 >Greeter.prototype : Symbol(Function.prototype, Decl(lib.d.ts, 249, 48))
 >Greeter : Symbol(Greeter, Decl(exportAssignmentWithoutIdentifier1.ts, 0, 0))
 >prototype : Symbol(Function.prototype, Decl(lib.d.ts, 249, 48))
->function () {    //...} : Symbol((Anonymous function), Decl(exportAssignmentWithoutIdentifier1.ts, 3, 25))
 
     //...
 }
diff --git a/tests/baselines/reference/exportImportNonInstantiatedModule.symbols b/tests/baselines/reference/exportImportNonInstantiatedModule.symbols
index 6122853da9dbe..6e044368bfb40 100644
--- a/tests/baselines/reference/exportImportNonInstantiatedModule.symbols
+++ b/tests/baselines/reference/exportImportNonInstantiatedModule.symbols
@@ -21,6 +21,5 @@ var x: B.A1.I = { x: 1 };
 >B : Symbol(B, Decl(exportImportNonInstantiatedModule.ts, 2, 1))
 >A1 : Symbol(B.A1, Decl(exportImportNonInstantiatedModule.ts, 4, 10))
 >I : Symbol(A.I, Decl(exportImportNonInstantiatedModule.ts, 0, 10))
->{ x: 1 } : Symbol(, Decl(exportImportNonInstantiatedModule.ts, 9, 15))
 >x : Symbol(x, Decl(exportImportNonInstantiatedModule.ts, 9, 17))
 
diff --git a/tests/baselines/reference/exportImportNonInstantiatedModule2.symbols b/tests/baselines/reference/exportImportNonInstantiatedModule2.symbols
index ab1696680c988..02ccf97b1613d 100644
--- a/tests/baselines/reference/exportImportNonInstantiatedModule2.symbols
+++ b/tests/baselines/reference/exportImportNonInstantiatedModule2.symbols
@@ -8,7 +8,6 @@ export function w(): e.w { // Should be OK
 >w : Symbol(e.w, Decl(exporter.ts, 0, 0))
 
     return {name: 'value' };
->{name: 'value' } : Symbol(, Decl(consumer.ts, 3, 10))
 >name : Symbol(name, Decl(consumer.ts, 3, 12))
 }
 === tests/cases/compiler/w1.ts ===
diff --git a/tests/baselines/reference/exportedVariable1.symbols b/tests/baselines/reference/exportedVariable1.symbols
index d785419c068a1..96c4b0210ba12 100644
--- a/tests/baselines/reference/exportedVariable1.symbols
+++ b/tests/baselines/reference/exportedVariable1.symbols
@@ -1,7 +1,6 @@
 === tests/cases/compiler/exportedVariable1.ts ===
 export var foo = {name: "Bill"};
 >foo : Symbol(foo, Decl(exportedVariable1.ts, 0, 10))
->{name: "Bill"} : Symbol(, Decl(exportedVariable1.ts, 0, 16))
 >name : Symbol(name, Decl(exportedVariable1.ts, 0, 18))
 
 var upper = foo.name.toUpperCase();
diff --git a/tests/baselines/reference/extendingClassFromAliasAndUsageInIndexer.symbols b/tests/baselines/reference/extendingClassFromAliasAndUsageInIndexer.symbols
index 7caacb23e1382..02d57509a5507 100644
--- a/tests/baselines/reference/extendingClassFromAliasAndUsageInIndexer.symbols
+++ b/tests/baselines/reference/extendingClassFromAliasAndUsageInIndexer.symbols
@@ -26,7 +26,6 @@ var moduleMap: { [key: string]: IHasVisualizationModel } = {
 >moduleMap : Symbol(moduleMap, Decl(extendingClassFromAliasAndUsageInIndexer_main.ts, 7, 3))
 >key : Symbol(key, Decl(extendingClassFromAliasAndUsageInIndexer_main.ts, 7, 18))
 >IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(extendingClassFromAliasAndUsageInIndexer_main.ts, 2, 77))
->{    "moduleA": moduleA,    "moduleB": moduleB} : Symbol(, Decl(extendingClassFromAliasAndUsageInIndexer_main.ts, 7, 58))
 
     "moduleA": moduleA,
 >moduleA : Symbol(moduleA, Decl(extendingClassFromAliasAndUsageInIndexer_main.ts, 0, 79))
diff --git a/tests/baselines/reference/fatArrowSelf.symbols b/tests/baselines/reference/fatArrowSelf.symbols
index 1af3f8728ab2b..4008b648ae6e5 100644
--- a/tests/baselines/reference/fatArrowSelf.symbols
+++ b/tests/baselines/reference/fatArrowSelf.symbols
@@ -40,7 +40,6 @@ module Consumer {
 >this : Symbol(EventEmitterConsummer, Decl(fatArrowSelf.ts, 10, 17))
 >emitter : Symbol(emitter, Decl(fatArrowSelf.ts, 12, 21))
 >addListener : Symbol(Events.EventEmitter.addListener, Decl(fatArrowSelf.ts, 4, 31))
->(e) => {                this.changed();            } : Symbol((Anonymous function), Decl(fatArrowSelf.ts, 15, 46))
 >e : Symbol(e, Decl(fatArrowSelf.ts, 15, 48))
 
                 this.changed();
diff --git a/tests/baselines/reference/fatArrowfunctionAsType.symbols b/tests/baselines/reference/fatArrowfunctionAsType.symbols
index a105da83c791f..9764149bade7e 100644
--- a/tests/baselines/reference/fatArrowfunctionAsType.symbols
+++ b/tests/baselines/reference/fatArrowfunctionAsType.symbols
@@ -10,7 +10,6 @@ var c: <T>(x: T) => void = function <T>(x: T) { return 42; }
 >T : Symbol(T, Decl(fatArrowfunctionAsType.ts, 2, 8))
 >x : Symbol(x, Decl(fatArrowfunctionAsType.ts, 2, 11))
 >T : Symbol(T, Decl(fatArrowfunctionAsType.ts, 2, 8))
->function <T>(x: T) { return 42; } : Symbol((Anonymous function), Decl(fatArrowfunctionAsType.ts, 2, 26))
 >T : Symbol(T, Decl(fatArrowfunctionAsType.ts, 2, 37))
 >x : Symbol(x, Decl(fatArrowfunctionAsType.ts, 2, 40))
 >T : Symbol(T, Decl(fatArrowfunctionAsType.ts, 2, 37))
diff --git a/tests/baselines/reference/fatarrowfunctions.symbols b/tests/baselines/reference/fatarrowfunctions.symbols
index 96cbe1ee28114..6ed865b091459 100644
--- a/tests/baselines/reference/fatarrowfunctions.symbols
+++ b/tests/baselines/reference/fatarrowfunctions.symbols
@@ -11,7 +11,6 @@ function foo(x:any) {
 
 foo((x:number,y,z)=>{return x+y+z;});
 >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0))
->(x:number,y,z)=>{return x+y+z;} : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 6, 4))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 6, 5))
 >y : Symbol(y, Decl(fatarrowfunctions.ts, 6, 14))
 >z : Symbol(z, Decl(fatarrowfunctions.ts, 6, 16))
@@ -21,7 +20,6 @@ foo((x:number,y,z)=>{return x+y+z;});
 
 foo((x,y,z)=>{return x+y+z;});
 >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0))
->(x,y,z)=>{return x+y+z;} : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 7, 4))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 7, 5))
 >y : Symbol(y, Decl(fatarrowfunctions.ts, 7, 7))
 >z : Symbol(z, Decl(fatarrowfunctions.ts, 7, 9))
@@ -31,7 +29,6 @@ foo((x,y,z)=>{return x+y+z;});
 
 foo((x,y:number,z)=>{return x+y+z;});
 >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0))
->(x,y:number,z)=>{return x+y+z;} : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 8, 4))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 8, 5))
 >y : Symbol(y, Decl(fatarrowfunctions.ts, 8, 7))
 >z : Symbol(z, Decl(fatarrowfunctions.ts, 8, 16))
@@ -41,7 +38,6 @@ foo((x,y:number,z)=>{return x+y+z;});
 
 foo((x,y:number,z:number)=>{return x+y+z;});
 >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0))
->(x,y:number,z:number)=>{return x+y+z;} : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 9, 4))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 9, 5))
 >y : Symbol(y, Decl(fatarrowfunctions.ts, 9, 7))
 >z : Symbol(z, Decl(fatarrowfunctions.ts, 9, 16))
@@ -51,7 +47,6 @@ foo((x,y:number,z:number)=>{return x+y+z;});
 
 foo((x,y,z:number)=>{return x+y+z;});
 >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0))
->(x,y,z:number)=>{return x+y+z;} : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 10, 4))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 10, 5))
 >y : Symbol(y, Decl(fatarrowfunctions.ts, 10, 7))
 >z : Symbol(z, Decl(fatarrowfunctions.ts, 10, 9))
@@ -61,11 +56,9 @@ foo((x,y,z:number)=>{return x+y+z;});
 
 foo(()=>{return 0;});
 >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0))
->()=>{return 0;} : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 11, 4))
 
 foo((x:number,y,z)=>x+y+z);
 >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0))
->(x:number,y,z)=>x+y+z : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 13, 4))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 13, 5))
 >y : Symbol(y, Decl(fatarrowfunctions.ts, 13, 14))
 >z : Symbol(z, Decl(fatarrowfunctions.ts, 13, 16))
@@ -75,7 +68,6 @@ foo((x:number,y,z)=>x+y+z);
 
 foo((x,y,z)=>x+y+z);
 >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0))
->(x,y,z)=>x+y+z : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 14, 4))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 14, 5))
 >y : Symbol(y, Decl(fatarrowfunctions.ts, 14, 7))
 >z : Symbol(z, Decl(fatarrowfunctions.ts, 14, 9))
@@ -85,7 +77,6 @@ foo((x,y,z)=>x+y+z);
 
 foo((x,y:number,z)=>{return x+y+z;});
 >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0))
->(x,y:number,z)=>{return x+y+z;} : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 15, 4))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 15, 5))
 >y : Symbol(y, Decl(fatarrowfunctions.ts, 15, 7))
 >z : Symbol(z, Decl(fatarrowfunctions.ts, 15, 16))
@@ -95,7 +86,6 @@ foo((x,y:number,z)=>{return x+y+z;});
 
 foo((x,y:number,z:number)=>{return x+y+z;});
 >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0))
->(x,y:number,z:number)=>{return x+y+z;} : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 16, 4))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 16, 5))
 >y : Symbol(y, Decl(fatarrowfunctions.ts, 16, 7))
 >z : Symbol(z, Decl(fatarrowfunctions.ts, 16, 16))
@@ -105,7 +95,6 @@ foo((x,y:number,z:number)=>{return x+y+z;});
 
 foo((x,y,z:number)=>{return x+y+z;});
 >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0))
->(x,y,z:number)=>{return x+y+z;} : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 17, 4))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 17, 5))
 >y : Symbol(y, Decl(fatarrowfunctions.ts, 17, 7))
 >z : Symbol(z, Decl(fatarrowfunctions.ts, 17, 9))
@@ -115,39 +104,33 @@ foo((x,y,z:number)=>{return x+y+z;});
 
 foo(()=>{return 0;});
 >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0))
->()=>{return 0;} : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 18, 4))
 
 
 foo(((x) => x));
 >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0))
->(x) => x : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 21, 5))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 21, 6))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 21, 6))
 
 foo(x => x*x);
 >foo : Symbol(foo, Decl(fatarrowfunctions.ts, 0, 0))
->x => x*x : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 23, 4))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 23, 4))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 23, 4))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 23, 4))
 
 var y = x => x*x;
 >y : Symbol(y, Decl(fatarrowfunctions.ts, 25, 3))
->x => x*x : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 25, 7))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 25, 7))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 25, 7))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 25, 7))
 
 var z = (x:number) => x*x;
 >z : Symbol(z, Decl(fatarrowfunctions.ts, 26, 3))
->(x:number) => x*x : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 26, 7))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 26, 9))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 26, 9))
 >x : Symbol(x, Decl(fatarrowfunctions.ts, 26, 9))
 
 var w = () => 3;
 >w : Symbol(w, Decl(fatarrowfunctions.ts, 28, 3))
->() => 3 : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 28, 7))
 
 function ternaryTest(isWhile:boolean) {
 >ternaryTest : Symbol(ternaryTest, Decl(fatarrowfunctions.ts, 28, 16))
@@ -156,10 +139,8 @@ function ternaryTest(isWhile:boolean) {
                 var f = isWhile ? function (n) { return n > 0; } : function (n) { return n === 0; };
 >f : Symbol(f, Decl(fatarrowfunctions.ts, 32, 19))
 >isWhile : Symbol(isWhile, Decl(fatarrowfunctions.ts, 30, 21))
->function (n) { return n > 0; } : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 32, 33))
 >n : Symbol(n, Decl(fatarrowfunctions.ts, 32, 44))
 >n : Symbol(n, Decl(fatarrowfunctions.ts, 32, 44))
->function (n) { return n === 0; } : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 32, 66))
 >n : Symbol(n, Decl(fatarrowfunctions.ts, 32, 77))
 >n : Symbol(n, Decl(fatarrowfunctions.ts, 32, 77))
 
@@ -173,18 +154,15 @@ declare function setTimeout(expression: any, msec?: number, language?: any): num
 
 var messenger = {
 >messenger : Symbol(messenger, Decl(fatarrowfunctions.ts, 38, 3))
->{    message: "Hello World",    start: function() {        setTimeout(() => { this.message.toString(); }, 3000);    }} : Symbol(, Decl(fatarrowfunctions.ts, 38, 15))
 
     message: "Hello World",
 >message : Symbol(message, Decl(fatarrowfunctions.ts, 38, 17))
 
     start: function() {
 >start : Symbol(start, Decl(fatarrowfunctions.ts, 39, 27))
->function() {        setTimeout(() => { this.message.toString(); }, 3000);    } : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 40, 10))
 
         setTimeout(() => { this.message.toString(); }, 3000);
 >setTimeout : Symbol(setTimeout, Decl(fatarrowfunctions.ts, 34, 1))
->() => { this.message.toString(); } : Symbol((Anonymous function), Decl(fatarrowfunctions.ts, 41, 19))
     }
 };
 
diff --git a/tests/baselines/reference/fatarrowfunctionsInFunctionParameterDefaults.symbols b/tests/baselines/reference/fatarrowfunctionsInFunctionParameterDefaults.symbols
index c7256f8c38ba6..731e8558bab1b 100644
--- a/tests/baselines/reference/fatarrowfunctionsInFunctionParameterDefaults.symbols
+++ b/tests/baselines/reference/fatarrowfunctionsInFunctionParameterDefaults.symbols
@@ -2,7 +2,6 @@
 function fn(x = () => this, y = x()) {
 >fn : Symbol(fn, Decl(fatarrowfunctionsInFunctionParameterDefaults.ts, 0, 0))
 >x : Symbol(x, Decl(fatarrowfunctionsInFunctionParameterDefaults.ts, 0, 12))
->() => this : Symbol((Anonymous function), Decl(fatarrowfunctionsInFunctionParameterDefaults.ts, 0, 15))
 >y : Symbol(y, Decl(fatarrowfunctionsInFunctionParameterDefaults.ts, 0, 27))
 >x : Symbol(x, Decl(fatarrowfunctionsInFunctionParameterDefaults.ts, 0, 12))
 
diff --git a/tests/baselines/reference/fatarrowfunctionsInFunctions.symbols b/tests/baselines/reference/fatarrowfunctionsInFunctions.symbols
index 98d0c1f6d5871..0a86affc21589 100644
--- a/tests/baselines/reference/fatarrowfunctionsInFunctions.symbols
+++ b/tests/baselines/reference/fatarrowfunctionsInFunctions.symbols
@@ -7,21 +7,18 @@ declare function setTimeout(expression: any, msec?: number, language?: any): num
 
 var messenger = {
 >messenger : Symbol(messenger, Decl(fatarrowfunctionsInFunctions.ts, 2, 3))
->{    message: "Hello World",    start: function() {        var _self = this;        setTimeout(function() {            _self.message.toString();         }, 3000);     }} : Symbol(, Decl(fatarrowfunctionsInFunctions.ts, 2, 15))
 
     message: "Hello World",
 >message : Symbol(message, Decl(fatarrowfunctionsInFunctions.ts, 2, 17))
 
     start: function() {
 >start : Symbol(start, Decl(fatarrowfunctionsInFunctions.ts, 3, 27))
->function() {        var _self = this;        setTimeout(function() {            _self.message.toString();         }, 3000);     } : Symbol((Anonymous function), Decl(fatarrowfunctionsInFunctions.ts, 4, 10))
 
         var _self = this;
 >_self : Symbol(_self, Decl(fatarrowfunctionsInFunctions.ts, 5, 11))
 
         setTimeout(function() {
 >setTimeout : Symbol(setTimeout, Decl(fatarrowfunctionsInFunctions.ts, 0, 0))
->function() {            _self.message.toString();         } : Symbol((Anonymous function), Decl(fatarrowfunctionsInFunctions.ts, 6, 19))
 
             _self.message.toString(); 
 >_self : Symbol(_self, Decl(fatarrowfunctionsInFunctions.ts, 5, 11))
diff --git a/tests/baselines/reference/for-of18.symbols b/tests/baselines/reference/for-of18.symbols
index d09e5810d1dfa..066d9534051ef 100644
--- a/tests/baselines/reference/for-of18.symbols
+++ b/tests/baselines/reference/for-of18.symbols
@@ -13,8 +13,6 @@ class StringIterator {
 >next : Symbol(next, Decl(for-of18.ts, 3, 22))
 
         return {
->{            value: "",            done: false        } : Symbol(, Decl(for-of18.ts, 5, 14))
-
             value: "",
 >value : Symbol(value, Decl(for-of18.ts, 5, 16))
 
diff --git a/tests/baselines/reference/for-of19.symbols b/tests/baselines/reference/for-of19.symbols
index b65b147b30452..8c34f6f0d7a4e 100644
--- a/tests/baselines/reference/for-of19.symbols
+++ b/tests/baselines/reference/for-of19.symbols
@@ -17,8 +17,6 @@ class FooIterator {
 >next : Symbol(next, Decl(for-of19.ts, 5, 19))
 
         return {
->{            value: new Foo,            done: false        } : Symbol(, Decl(for-of19.ts, 7, 14))
-
             value: new Foo,
 >value : Symbol(value, Decl(for-of19.ts, 7, 16))
 >Foo : Symbol(Foo, Decl(for-of19.ts, 2, 1))
diff --git a/tests/baselines/reference/for-of20.symbols b/tests/baselines/reference/for-of20.symbols
index 68d6871a4ced0..4e7aaf7e362bf 100644
--- a/tests/baselines/reference/for-of20.symbols
+++ b/tests/baselines/reference/for-of20.symbols
@@ -17,8 +17,6 @@ class FooIterator {
 >next : Symbol(next, Decl(for-of20.ts, 5, 19))
 
         return {
->{            value: new Foo,            done: false        } : Symbol(, Decl(for-of20.ts, 7, 14))
-
             value: new Foo,
 >value : Symbol(value, Decl(for-of20.ts, 7, 16))
 >Foo : Symbol(Foo, Decl(for-of20.ts, 2, 1))
diff --git a/tests/baselines/reference/for-of21.symbols b/tests/baselines/reference/for-of21.symbols
index ee8b99a09b466..70c1132afbd6d 100644
--- a/tests/baselines/reference/for-of21.symbols
+++ b/tests/baselines/reference/for-of21.symbols
@@ -17,8 +17,6 @@ class FooIterator {
 >next : Symbol(next, Decl(for-of21.ts, 5, 19))
 
         return {
->{            value: new Foo,            done: false        } : Symbol(, Decl(for-of21.ts, 7, 14))
-
             value: new Foo,
 >value : Symbol(value, Decl(for-of21.ts, 7, 16))
 >Foo : Symbol(Foo, Decl(for-of21.ts, 2, 1))
diff --git a/tests/baselines/reference/for-of22.symbols b/tests/baselines/reference/for-of22.symbols
index 7fa0fd6da4a55..4650725593796 100644
--- a/tests/baselines/reference/for-of22.symbols
+++ b/tests/baselines/reference/for-of22.symbols
@@ -18,8 +18,6 @@ class FooIterator {
 >next : Symbol(next, Decl(for-of22.ts, 6, 19))
 
         return {
->{            value: new Foo,            done: false        } : Symbol(, Decl(for-of22.ts, 8, 14))
-
             value: new Foo,
 >value : Symbol(value, Decl(for-of22.ts, 8, 16))
 >Foo : Symbol(Foo, Decl(for-of22.ts, 3, 1))
diff --git a/tests/baselines/reference/for-of23.symbols b/tests/baselines/reference/for-of23.symbols
index 2dd7bc1f48626..8401de024d976 100644
--- a/tests/baselines/reference/for-of23.symbols
+++ b/tests/baselines/reference/for-of23.symbols
@@ -17,8 +17,6 @@ class FooIterator {
 >next : Symbol(next, Decl(for-of23.ts, 5, 19))
 
         return {
->{            value: new Foo,            done: false        } : Symbol(, Decl(for-of23.ts, 7, 14))
-
             value: new Foo,
 >value : Symbol(value, Decl(for-of23.ts, 7, 16))
 >Foo : Symbol(Foo, Decl(for-of23.ts, 2, 1))
diff --git a/tests/baselines/reference/for-of41.symbols b/tests/baselines/reference/for-of41.symbols
index d8d2c4df0ae4f..cf8db913919a2 100644
--- a/tests/baselines/reference/for-of41.symbols
+++ b/tests/baselines/reference/for-of41.symbols
@@ -1,10 +1,8 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of41.ts ===
 var array = [{x: [0], y: {p: ""}}]
 >array : Symbol(array, Decl(for-of41.ts, 0, 3))
->{x: [0], y: {p: ""}} : Symbol(, Decl(for-of41.ts, 0, 13))
 >x : Symbol(x, Decl(for-of41.ts, 0, 14))
 >y : Symbol(y, Decl(for-of41.ts, 0, 21))
->{p: ""} : Symbol(, Decl(for-of41.ts, 0, 24))
 >p : Symbol(p, Decl(for-of41.ts, 0, 26))
 
 for (var {x: [a], y: {p}} of array) {
diff --git a/tests/baselines/reference/for-of42.symbols b/tests/baselines/reference/for-of42.symbols
index 04bf7c478a5f4..b310fb1044f99 100644
--- a/tests/baselines/reference/for-of42.symbols
+++ b/tests/baselines/reference/for-of42.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of42.ts ===
 var array = [{ x: "", y: 0 }]
 >array : Symbol(array, Decl(for-of42.ts, 0, 3))
->{ x: "", y: 0 } : Symbol(, Decl(for-of42.ts, 0, 13))
 >x : Symbol(x, Decl(for-of42.ts, 0, 14))
 >y : Symbol(y, Decl(for-of42.ts, 0, 21))
 
diff --git a/tests/baselines/reference/forBreakStatements.symbols b/tests/baselines/reference/forBreakStatements.symbols
index 92514b9c588ac..76db9309a3969 100644
--- a/tests/baselines/reference/forBreakStatements.symbols
+++ b/tests/baselines/reference/forBreakStatements.symbols
@@ -34,7 +34,6 @@ EIGHT:
 for (; ;) {
     var fn = function () { }
 >fn : Symbol(fn, Decl(forBreakStatements.ts, 33, 7))
->function () { } : Symbol((Anonymous function), Decl(forBreakStatements.ts, 33, 12))
 
     break EIGHT;
 }
diff --git a/tests/baselines/reference/forContinueStatements.symbols b/tests/baselines/reference/forContinueStatements.symbols
index 491c9f15ddde2..e24eb2aaa9252 100644
--- a/tests/baselines/reference/forContinueStatements.symbols
+++ b/tests/baselines/reference/forContinueStatements.symbols
@@ -34,7 +34,6 @@ EIGHT:
 for (; ;) {
     var fn = function () { }
 >fn : Symbol(fn, Decl(forContinueStatements.ts, 33, 7))
->function () { } : Symbol((Anonymous function), Decl(forContinueStatements.ts, 33, 12))
 
     continue EIGHT;
 }
diff --git a/tests/baselines/reference/forInBreakStatements.symbols b/tests/baselines/reference/forInBreakStatements.symbols
index 2303631289982..7984edc3fd699 100644
--- a/tests/baselines/reference/forInBreakStatements.symbols
+++ b/tests/baselines/reference/forInBreakStatements.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/statements/breakStatements/forInBreakStatements.ts ===
 for(var x in {}) {
 >x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8))
->{} : Symbol(, Decl(forInBreakStatements.ts, 0, 12))
 
     break;
 }
@@ -9,7 +8,6 @@ for(var x in {}) {
 ONE:
 for(var x in {}) {
 >x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8))
->{} : Symbol(, Decl(forInBreakStatements.ts, 5, 12))
 
     break ONE;
 }
@@ -18,7 +16,6 @@ TWO:
 THREE:
 for(var x in {}) {
 >x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8))
->{} : Symbol(, Decl(forInBreakStatements.ts, 11, 12))
 
     break THREE;
 }
@@ -26,12 +23,10 @@ for(var x in {}) {
 FOUR:
 for(var x in {}) {
 >x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8))
->{} : Symbol(, Decl(forInBreakStatements.ts, 16, 12))
 
     FIVE:
     for(var x in {}) {
 >x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8))
->{} : Symbol(, Decl(forInBreakStatements.ts, 18, 16))
 
         break FOUR;
     }
@@ -39,31 +34,24 @@ for(var x in {}) {
 
 for(var x in {}) {
 >x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8))
->{} : Symbol(, Decl(forInBreakStatements.ts, 23, 12))
 
     SIX:
     for(var x in {}) break SIX;
 >x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8))
->{} : Symbol(, Decl(forInBreakStatements.ts, 25, 16))
 }
 
 SEVEN:
 for (var x in {}) for (var x in {}) for (var x in {}) break SEVEN;
 >x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8))
->{} : Symbol(, Decl(forInBreakStatements.ts, 29, 13))
 >x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8))
->{} : Symbol(, Decl(forInBreakStatements.ts, 29, 31))
 >x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8))
->{} : Symbol(, Decl(forInBreakStatements.ts, 29, 49))
 
 EIGHT:
 for (var x in {}){
 >x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8))
->{} : Symbol(, Decl(forInBreakStatements.ts, 32, 13))
 
     var fn = function () { }
 >fn : Symbol(fn, Decl(forInBreakStatements.ts, 33, 7))
->function () { } : Symbol((Anonymous function), Decl(forInBreakStatements.ts, 33, 12))
 
     break EIGHT;
 }
diff --git a/tests/baselines/reference/forInContinueStatements.symbols b/tests/baselines/reference/forInContinueStatements.symbols
index 8bd70b8dd3afe..88129a50d21ce 100644
--- a/tests/baselines/reference/forInContinueStatements.symbols
+++ b/tests/baselines/reference/forInContinueStatements.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/statements/continueStatements/forInContinueStatements.ts ===
 for(var x in {}) {
 >x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8))
->{} : Symbol(, Decl(forInContinueStatements.ts, 0, 12))
 
     continue;
 }
@@ -9,7 +8,6 @@ for(var x in {}) {
 ONE:
 for(var x in {}) {
 >x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8))
->{} : Symbol(, Decl(forInContinueStatements.ts, 5, 12))
 
     continue ONE;
 }
@@ -18,7 +16,6 @@ TWO:
 THREE:
 for(var x in {}) {
 >x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8))
->{} : Symbol(, Decl(forInContinueStatements.ts, 11, 12))
 
     continue THREE;
 }
@@ -26,12 +23,10 @@ for(var x in {}) {
 FOUR:
 for(var x in {}) {
 >x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8))
->{} : Symbol(, Decl(forInContinueStatements.ts, 16, 12))
 
     FIVE:
     for(var x in {}) {
 >x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8))
->{} : Symbol(, Decl(forInContinueStatements.ts, 18, 16))
 
         continue FOUR;
     }
@@ -39,31 +34,24 @@ for(var x in {}) {
 
 for(var x in {}) {
 >x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8))
->{} : Symbol(, Decl(forInContinueStatements.ts, 23, 12))
 
     SIX:
     for(var x in {}) continue SIX;
 >x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8))
->{} : Symbol(, Decl(forInContinueStatements.ts, 25, 16))
 }
 
 SEVEN:
 for (var x in {}) for (var x in {}) for (var x in {}) continue SEVEN;
 >x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8))
->{} : Symbol(, Decl(forInContinueStatements.ts, 29, 13))
 >x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8))
->{} : Symbol(, Decl(forInContinueStatements.ts, 29, 31))
 >x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8))
->{} : Symbol(, Decl(forInContinueStatements.ts, 29, 49))
 
 EIGHT:
 for (var x in {}){
 >x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8))
->{} : Symbol(, Decl(forInContinueStatements.ts, 32, 13))
 
     var fn = function () { }
 >fn : Symbol(fn, Decl(forInContinueStatements.ts, 33, 7))
->function () { } : Symbol((Anonymous function), Decl(forInContinueStatements.ts, 33, 12))
 
     continue EIGHT;
 }
diff --git a/tests/baselines/reference/forStatements.symbols b/tests/baselines/reference/forStatements.symbols
index 6d12aab096a12..6f7c6d6cdbe3a 100644
--- a/tests/baselines/reference/forStatements.symbols
+++ b/tests/baselines/reference/forStatements.symbols
@@ -101,7 +101,6 @@ for(var aGenericClass: D<string> = new D<string>();;){}
 for(var anObjectLiteral: I = { id: 12 };;){}
 >anObjectLiteral : Symbol(anObjectLiteral, Decl(forStatements.ts, 36, 7))
 >I : Symbol(I, Decl(forStatements.ts, 0, 0))
->{ id: 12 } : Symbol(, Decl(forStatements.ts, 36, 28))
 >id : Symbol(id, Decl(forStatements.ts, 36, 30))
 
 for(var anOtherObjectLiteral: { id: number } = new C();;){}
@@ -122,7 +121,6 @@ for(var anOtherFunction: (x: string) => number = F;;){}
 for(var aLambda: typeof F = (x) => 2;;){}
 >aLambda : Symbol(aLambda, Decl(forStatements.ts, 41, 7))
 >F : Symbol(F, Decl(forStatements.ts, 12, 1))
->(x) => 2 : Symbol((Anonymous function), Decl(forStatements.ts, 41, 27))
 >x : Symbol(x, Decl(forStatements.ts, 41, 29))
 
 for(var aModule: typeof M = M;;){}
@@ -143,6 +141,5 @@ for(var aFunctionInModule: typeof M.F2 = (x) => 'this is a string';;){}
 >M.F2 : Symbol(M.F2, Decl(forStatements.ts, 19, 5))
 >M : Symbol(M, Decl(forStatements.ts, 14, 44))
 >F2 : Symbol(M.F2, Decl(forStatements.ts, 19, 5))
->(x) => 'this is a string' : Symbol((Anonymous function), Decl(forStatements.ts, 45, 40))
 >x : Symbol(x, Decl(forStatements.ts, 45, 42))
 
diff --git a/tests/baselines/reference/forStatementsMultipleValidDecl.symbols b/tests/baselines/reference/forStatementsMultipleValidDecl.symbols
index f8fa1ca146934..6a98fbf133ea1 100644
--- a/tests/baselines/reference/forStatementsMultipleValidDecl.symbols
+++ b/tests/baselines/reference/forStatementsMultipleValidDecl.symbols
@@ -29,21 +29,18 @@ for (var p: Point; ;) { }
 
 for (var p = { x: 1, y: 2 }; ;) { }
 >p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8))
->{ x: 1, y: 2 } : Symbol(, Decl(forStatementsMultipleValidDecl.ts, 13, 12))
 >x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 13, 14))
 >y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 13, 20))
 
 for (var p: Point = { x: 0, y: undefined }; ;) { }
 >p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8))
 >Point : Symbol(Point, Decl(forStatementsMultipleValidDecl.ts, 9, 1))
->{ x: 0, y: undefined } : Symbol(, Decl(forStatementsMultipleValidDecl.ts, 14, 19))
 >x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 14, 21))
 >y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 14, 27))
 >undefined : Symbol(undefined)
 
 for (var p = { x: 1, y: <number>undefined }; ;) { }
 >p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8))
->{ x: 1, y: <number>undefined } : Symbol(, Decl(forStatementsMultipleValidDecl.ts, 15, 12))
 >x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 15, 14))
 >y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 15, 20))
 >undefined : Symbol(undefined)
@@ -52,7 +49,6 @@ for (var p: { x: number; y: number; } = { x: 1, y: 2 }; ;) { }
 >p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8))
 >x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 16, 13))
 >y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 16, 24))
->{ x: 1, y: 2 } : Symbol(, Decl(forStatementsMultipleValidDecl.ts, 16, 39))
 >x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 16, 41))
 >y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 16, 47))
 
@@ -60,7 +56,6 @@ for (var p = <{ x: number; y: number; }>{ x: 0, y: undefined }; ;) { }
 >p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8))
 >x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 17, 15))
 >y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 17, 26))
->{ x: 0, y: undefined } : Symbol(, Decl(forStatementsMultipleValidDecl.ts, 17, 40))
 >x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 17, 41))
 >y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 17, 47))
 >undefined : Symbol(undefined)
@@ -71,12 +66,10 @@ for (var p: typeof p; ;) { }
 
 for (var fn = function (s: string) { return 42; }; ;) { }
 >fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 20, 8), Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8))
->function (s: string) { return 42; } : Symbol((Anonymous function), Decl(forStatementsMultipleValidDecl.ts, 20, 13))
 >s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 20, 24))
 
 for (var fn = (s: string) => 3; ;) { }
 >fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 20, 8), Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8))
->(s: string) => 3 : Symbol((Anonymous function), Decl(forStatementsMultipleValidDecl.ts, 21, 13))
 >s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 21, 15))
 
 for (var fn: (s: string) => number; ;) { }
diff --git a/tests/baselines/reference/funcdecl.symbols b/tests/baselines/reference/funcdecl.symbols
index e9d5c24603269..2538e3a9a0402 100644
--- a/tests/baselines/reference/funcdecl.symbols
+++ b/tests/baselines/reference/funcdecl.symbols
@@ -126,7 +126,6 @@ m2.foo(() =>  {
 >m2.foo : Symbol(m2.foo, Decl(funcdecl.ts, 50, 11))
 >m2 : Symbol(m2, Decl(funcdecl.ts, 48, 29))
 >foo : Symbol(m2.foo, Decl(funcdecl.ts, 50, 11))
->() =>  {    var b = 30;    return b;} : Symbol((Anonymous function), Decl(funcdecl.ts, 56, 7))
 
     var b = 30;
 >b : Symbol(b, Decl(funcdecl.ts, 58, 7))
@@ -151,7 +150,6 @@ declare function overloadAmbient(s: string): string;
 
 var f2 = () => {
 >f2 : Symbol(f2, Decl(funcdecl.ts, 68, 3))
->() => {    return "string";} : Symbol((Anonymous function), Decl(funcdecl.ts, 68, 8))
 
     return "string";
 }
diff --git a/tests/baselines/reference/functionAssignmentError.symbols b/tests/baselines/reference/functionAssignmentError.symbols
index dc1edaab9119b..b0d57ac410233 100644
--- a/tests/baselines/reference/functionAssignmentError.symbols
+++ b/tests/baselines/reference/functionAssignmentError.symbols
@@ -1,9 +1,7 @@
 === tests/cases/compiler/functionAssignmentError.ts ===
 var func = function (){return "ONE";};
 >func : Symbol(func, Decl(functionAssignmentError.ts, 0, 3))
->function (){return "ONE";} : Symbol((Anonymous function), Decl(functionAssignmentError.ts, 0, 10))
 
 func = function (){return "ONE";};
 >func : Symbol(func, Decl(functionAssignmentError.ts, 0, 3))
->function (){return "ONE";} : Symbol((Anonymous function), Decl(functionAssignmentError.ts, 1, 6))
 
diff --git a/tests/baselines/reference/functionConstraintSatisfaction.symbols b/tests/baselines/reference/functionConstraintSatisfaction.symbols
index 8b9695f7f4d9d..eb71bb78e25f2 100644
--- a/tests/baselines/reference/functionConstraintSatisfaction.symbols
+++ b/tests/baselines/reference/functionConstraintSatisfaction.symbols
@@ -44,28 +44,24 @@ var r = foo(new Function());
 var r1 = foo((x) => x);
 >r1 : Symbol(r1, Decl(functionConstraintSatisfaction.ts, 18, 3))
 >foo : Symbol(foo, Decl(functionConstraintSatisfaction.ts, 0, 0))
->(x) => x : Symbol((Anonymous function), Decl(functionConstraintSatisfaction.ts, 18, 13))
 >x : Symbol(x, Decl(functionConstraintSatisfaction.ts, 18, 14))
 >x : Symbol(x, Decl(functionConstraintSatisfaction.ts, 18, 14))
 
 var r2 = foo((x: string[]) => x);
 >r2 : Symbol(r2, Decl(functionConstraintSatisfaction.ts, 19, 3))
 >foo : Symbol(foo, Decl(functionConstraintSatisfaction.ts, 0, 0))
->(x: string[]) => x : Symbol((Anonymous function), Decl(functionConstraintSatisfaction.ts, 19, 13))
 >x : Symbol(x, Decl(functionConstraintSatisfaction.ts, 19, 14))
 >x : Symbol(x, Decl(functionConstraintSatisfaction.ts, 19, 14))
 
 var r3 = foo(function (x) { return x });
 >r3 : Symbol(r3, Decl(functionConstraintSatisfaction.ts, 20, 3))
 >foo : Symbol(foo, Decl(functionConstraintSatisfaction.ts, 0, 0))
->function (x) { return x } : Symbol((Anonymous function), Decl(functionConstraintSatisfaction.ts, 20, 13))
 >x : Symbol(x, Decl(functionConstraintSatisfaction.ts, 20, 23))
 >x : Symbol(x, Decl(functionConstraintSatisfaction.ts, 20, 23))
 
 var r4 = foo(function (x: string[]) { return x });
 >r4 : Symbol(r4, Decl(functionConstraintSatisfaction.ts, 21, 3))
 >foo : Symbol(foo, Decl(functionConstraintSatisfaction.ts, 0, 0))
->function (x: string[]) { return x } : Symbol((Anonymous function), Decl(functionConstraintSatisfaction.ts, 21, 13))
 >x : Symbol(x, Decl(functionConstraintSatisfaction.ts, 21, 23))
 >x : Symbol(x, Decl(functionConstraintSatisfaction.ts, 21, 23))
 
@@ -141,7 +137,6 @@ var c2: { <T>(x: T): T; <T>(x: T, y: T): T };
 var r9 = foo(<U>(x: U) => x);
 >r9 : Symbol(r9, Decl(functionConstraintSatisfaction.ts, 40, 3))
 >foo : Symbol(foo, Decl(functionConstraintSatisfaction.ts, 0, 0))
-><U>(x: U) => x : Symbol((Anonymous function), Decl(functionConstraintSatisfaction.ts, 40, 13))
 >U : Symbol(U, Decl(functionConstraintSatisfaction.ts, 40, 14))
 >x : Symbol(x, Decl(functionConstraintSatisfaction.ts, 40, 17))
 >U : Symbol(U, Decl(functionConstraintSatisfaction.ts, 40, 14))
@@ -150,7 +145,6 @@ var r9 = foo(<U>(x: U) => x);
 var r10 = foo(function <U>(x: U) { return x; });
 >r10 : Symbol(r10, Decl(functionConstraintSatisfaction.ts, 41, 3))
 >foo : Symbol(foo, Decl(functionConstraintSatisfaction.ts, 0, 0))
->function <U>(x: U) { return x; } : Symbol((Anonymous function), Decl(functionConstraintSatisfaction.ts, 41, 14))
 >U : Symbol(U, Decl(functionConstraintSatisfaction.ts, 41, 24))
 >x : Symbol(x, Decl(functionConstraintSatisfaction.ts, 41, 27))
 >U : Symbol(U, Decl(functionConstraintSatisfaction.ts, 41, 24))
@@ -159,7 +153,6 @@ var r10 = foo(function <U>(x: U) { return x; });
 var r11 = foo(<U extends Date>(x: U) => x);
 >r11 : Symbol(r11, Decl(functionConstraintSatisfaction.ts, 42, 3))
 >foo : Symbol(foo, Decl(functionConstraintSatisfaction.ts, 0, 0))
-><U extends Date>(x: U) => x : Symbol((Anonymous function), Decl(functionConstraintSatisfaction.ts, 42, 14))
 >U : Symbol(U, Decl(functionConstraintSatisfaction.ts, 42, 15))
 >Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
 >x : Symbol(x, Decl(functionConstraintSatisfaction.ts, 42, 31))
@@ -169,7 +162,6 @@ var r11 = foo(<U extends Date>(x: U) => x);
 var r12 = foo(<U, V>(x: U, y: V) => x);
 >r12 : Symbol(r12, Decl(functionConstraintSatisfaction.ts, 43, 3))
 >foo : Symbol(foo, Decl(functionConstraintSatisfaction.ts, 0, 0))
-><U, V>(x: U, y: V) => x : Symbol((Anonymous function), Decl(functionConstraintSatisfaction.ts, 43, 14))
 >U : Symbol(U, Decl(functionConstraintSatisfaction.ts, 43, 15))
 >V : Symbol(V, Decl(functionConstraintSatisfaction.ts, 43, 17))
 >x : Symbol(x, Decl(functionConstraintSatisfaction.ts, 43, 21))
diff --git a/tests/baselines/reference/functionConstraintSatisfaction3.symbols b/tests/baselines/reference/functionConstraintSatisfaction3.symbols
index 330d41d611979..74f3a65aa8e3f 100644
--- a/tests/baselines/reference/functionConstraintSatisfaction3.symbols
+++ b/tests/baselines/reference/functionConstraintSatisfaction3.symbols
@@ -39,28 +39,24 @@ var c: { (): string; (x): string };
 var r1 = foo((x) => x);
 >r1 : Symbol(r1, Decl(functionConstraintSatisfaction3.ts, 17, 3))
 >foo : Symbol(foo, Decl(functionConstraintSatisfaction3.ts, 0, 0))
->(x) => x : Symbol((Anonymous function), Decl(functionConstraintSatisfaction3.ts, 17, 13))
 >x : Symbol(x, Decl(functionConstraintSatisfaction3.ts, 17, 14))
 >x : Symbol(x, Decl(functionConstraintSatisfaction3.ts, 17, 14))
 
 var r2 = foo((x: string) => x);
 >r2 : Symbol(r2, Decl(functionConstraintSatisfaction3.ts, 18, 3))
 >foo : Symbol(foo, Decl(functionConstraintSatisfaction3.ts, 0, 0))
->(x: string) => x : Symbol((Anonymous function), Decl(functionConstraintSatisfaction3.ts, 18, 13))
 >x : Symbol(x, Decl(functionConstraintSatisfaction3.ts, 18, 14))
 >x : Symbol(x, Decl(functionConstraintSatisfaction3.ts, 18, 14))
 
 var r3 = foo(function (x) { return x });
 >r3 : Symbol(r3, Decl(functionConstraintSatisfaction3.ts, 19, 3))
 >foo : Symbol(foo, Decl(functionConstraintSatisfaction3.ts, 0, 0))
->function (x) { return x } : Symbol((Anonymous function), Decl(functionConstraintSatisfaction3.ts, 19, 13))
 >x : Symbol(x, Decl(functionConstraintSatisfaction3.ts, 19, 23))
 >x : Symbol(x, Decl(functionConstraintSatisfaction3.ts, 19, 23))
 
 var r4 = foo(function (x: string) { return x });
 >r4 : Symbol(r4, Decl(functionConstraintSatisfaction3.ts, 20, 3))
 >foo : Symbol(foo, Decl(functionConstraintSatisfaction3.ts, 0, 0))
->function (x: string) { return x } : Symbol((Anonymous function), Decl(functionConstraintSatisfaction3.ts, 20, 13))
 >x : Symbol(x, Decl(functionConstraintSatisfaction3.ts, 20, 23))
 >x : Symbol(x, Decl(functionConstraintSatisfaction3.ts, 20, 23))
 
@@ -126,7 +122,6 @@ var c2: { <T>(x: T): T; <T>(x: T, y: T): T };
 var r9 = foo(function <U>(x: U) { return x; });
 >r9 : Symbol(r9, Decl(functionConstraintSatisfaction3.ts, 37, 3))
 >foo : Symbol(foo, Decl(functionConstraintSatisfaction3.ts, 0, 0))
->function <U>(x: U) { return x; } : Symbol((Anonymous function), Decl(functionConstraintSatisfaction3.ts, 37, 13))
 >U : Symbol(U, Decl(functionConstraintSatisfaction3.ts, 37, 23))
 >x : Symbol(x, Decl(functionConstraintSatisfaction3.ts, 37, 26))
 >U : Symbol(U, Decl(functionConstraintSatisfaction3.ts, 37, 23))
@@ -135,7 +130,6 @@ var r9 = foo(function <U>(x: U) { return x; });
 var r10 = foo(<U extends string>(x: U) => x);
 >r10 : Symbol(r10, Decl(functionConstraintSatisfaction3.ts, 38, 3))
 >foo : Symbol(foo, Decl(functionConstraintSatisfaction3.ts, 0, 0))
-><U extends string>(x: U) => x : Symbol((Anonymous function), Decl(functionConstraintSatisfaction3.ts, 38, 14))
 >U : Symbol(U, Decl(functionConstraintSatisfaction3.ts, 38, 15))
 >x : Symbol(x, Decl(functionConstraintSatisfaction3.ts, 38, 33))
 >U : Symbol(U, Decl(functionConstraintSatisfaction3.ts, 38, 15))
diff --git a/tests/baselines/reference/functionExpressionAndLambdaMatchesFunction.symbols b/tests/baselines/reference/functionExpressionAndLambdaMatchesFunction.symbols
index b9ea38442b606..db66aa5618b99 100644
--- a/tests/baselines/reference/functionExpressionAndLambdaMatchesFunction.symbols
+++ b/tests/baselines/reference/functionExpressionAndLambdaMatchesFunction.symbols
@@ -10,12 +10,10 @@ class CDoc {
         }
         doSomething(() => undefined);
 >doSomething : Symbol(doSomething, Decl(functionExpressionAndLambdaMatchesFunction.ts, 1, 23))
->() => undefined : Symbol((Anonymous function), Decl(functionExpressionAndLambdaMatchesFunction.ts, 4, 20))
 >undefined : Symbol(undefined)
 
         doSomething(function () { });
 >doSomething : Symbol(doSomething, Decl(functionExpressionAndLambdaMatchesFunction.ts, 1, 23))
->function () { } : Symbol((Anonymous function), Decl(functionExpressionAndLambdaMatchesFunction.ts, 5, 20))
     }
 }
 
diff --git a/tests/baselines/reference/functionExpressionContextualTyping1.symbols b/tests/baselines/reference/functionExpressionContextualTyping1.symbols
index fb3ee291be6d7..6182e4bb9a8e4 100644
--- a/tests/baselines/reference/functionExpressionContextualTyping1.symbols
+++ b/tests/baselines/reference/functionExpressionContextualTyping1.symbols
@@ -14,7 +14,6 @@ var a0: (n: number, s: string) => number = (num, str) => {
 >a0 : Symbol(a0, Decl(functionExpressionContextualTyping1.ts, 8, 3))
 >n : Symbol(n, Decl(functionExpressionContextualTyping1.ts, 8, 9))
 >s : Symbol(s, Decl(functionExpressionContextualTyping1.ts, 8, 19))
->(num, str) => {    num.toExponential();    return 0;} : Symbol((Anonymous function), Decl(functionExpressionContextualTyping1.ts, 8, 42))
 >num : Symbol(num, Decl(functionExpressionContextualTyping1.ts, 8, 44))
 >str : Symbol(str, Decl(functionExpressionContextualTyping1.ts, 8, 48))
 
@@ -39,7 +38,6 @@ var a1: (c: Class<Number>) => number = (a1) => {
 >c : Symbol(c, Decl(functionExpressionContextualTyping1.ts, 17, 9))
 >Class : Symbol(Class, Decl(functionExpressionContextualTyping1.ts, 11, 1))
 >Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
->(a1) => {    a1.foo();    return 1;} : Symbol((Anonymous function), Decl(functionExpressionContextualTyping1.ts, 17, 38))
 >a1 : Symbol(a1, Decl(functionExpressionContextualTyping1.ts, 17, 40))
 
     a1.foo();
@@ -64,7 +62,6 @@ var b1: ((s: string, w: boolean) => void) | ((s: string, w: boolean) => string);
 
 b1 = (k, h) => { };
 >b1 : Symbol(b1, Decl(functionExpressionContextualTyping1.ts, 27, 3))
->(k, h) => { } : Symbol((Anonymous function), Decl(functionExpressionContextualTyping1.ts, 28, 4))
 >k : Symbol(k, Decl(functionExpressionContextualTyping1.ts, 28, 6))
 >h : Symbol(h, Decl(functionExpressionContextualTyping1.ts, 28, 8))
 
@@ -76,14 +73,12 @@ var b2: typeof a0 | ((n: number, s: string) => string);
 
 b2 = (foo, bar) => { return foo + 1; }
 >b2 : Symbol(b2, Decl(functionExpressionContextualTyping1.ts, 29, 3))
->(foo, bar) => { return foo + 1; } : Symbol((Anonymous function), Decl(functionExpressionContextualTyping1.ts, 30, 4))
 >foo : Symbol(foo, Decl(functionExpressionContextualTyping1.ts, 30, 6))
 >bar : Symbol(bar, Decl(functionExpressionContextualTyping1.ts, 30, 10))
 >foo : Symbol(foo, Decl(functionExpressionContextualTyping1.ts, 30, 6))
 
 b2 = (foo, bar) => { return "hello"; }
 >b2 : Symbol(b2, Decl(functionExpressionContextualTyping1.ts, 29, 3))
->(foo, bar) => { return "hello"; } : Symbol((Anonymous function), Decl(functionExpressionContextualTyping1.ts, 31, 4))
 >foo : Symbol(foo, Decl(functionExpressionContextualTyping1.ts, 31, 6))
 >bar : Symbol(bar, Decl(functionExpressionContextualTyping1.ts, 31, 10))
 
@@ -95,7 +90,6 @@ var b3: (name: string, num: number, boo: boolean) => void;
 
 b3 = (name, number) => { };
 >b3 : Symbol(b3, Decl(functionExpressionContextualTyping1.ts, 32, 3))
->(name, number) => { } : Symbol((Anonymous function), Decl(functionExpressionContextualTyping1.ts, 33, 4))
 >name : Symbol(name, Decl(functionExpressionContextualTyping1.ts, 33, 6))
 >number : Symbol(number, Decl(functionExpressionContextualTyping1.ts, 33, 11))
 
@@ -103,13 +97,11 @@ var b4: (n: E) => string = (number = 1) => { return "hello"; };
 >b4 : Symbol(b4, Decl(functionExpressionContextualTyping1.ts, 35, 3))
 >n : Symbol(n, Decl(functionExpressionContextualTyping1.ts, 35, 9))
 >E : Symbol(E, Decl(functionExpressionContextualTyping1.ts, 0, 0))
->(number = 1) => { return "hello"; } : Symbol((Anonymous function), Decl(functionExpressionContextualTyping1.ts, 35, 26))
 >number : Symbol(number, Decl(functionExpressionContextualTyping1.ts, 35, 28))
 
 var b5: (n: {}) => string = (number = "string") => { return "hello"; };
 >b5 : Symbol(b5, Decl(functionExpressionContextualTyping1.ts, 36, 3))
 >n : Symbol(n, Decl(functionExpressionContextualTyping1.ts, 36, 9))
->(number = "string") => { return "hello"; } : Symbol((Anonymous function), Decl(functionExpressionContextualTyping1.ts, 36, 27))
 >number : Symbol(number, Decl(functionExpressionContextualTyping1.ts, 36, 29))
 
 // A contextual signature S is extracted from a function type T as follows:
@@ -129,13 +121,11 @@ var b7: ((s: string, w: boolean) => void) | ((s: string, w: number) => string);
 
 b6 = (k) => { k.toLowerCase() };
 >b6 : Symbol(b6, Decl(functionExpressionContextualTyping1.ts, 40, 3))
->(k) => { k.toLowerCase() } : Symbol((Anonymous function), Decl(functionExpressionContextualTyping1.ts, 42, 4))
 >k : Symbol(k, Decl(functionExpressionContextualTyping1.ts, 42, 6))
 >k : Symbol(k, Decl(functionExpressionContextualTyping1.ts, 42, 6))
 
 b6 = (i) => {
 >b6 : Symbol(b6, Decl(functionExpressionContextualTyping1.ts, 40, 3))
->(i) => {    i.toExponential();    return i;} : Symbol((Anonymous function), Decl(functionExpressionContextualTyping1.ts, 43, 4))
 >i : Symbol(i, Decl(functionExpressionContextualTyping1.ts, 43, 6))
 
     i.toExponential();
@@ -147,7 +137,6 @@ b6 = (i) => {
 };                   // Per spec, no contextual signature can be extracted in this case. (Otherwise clause)
 b7 = (j, m) => { };  // Per spec, no contextual signature can be extracted in this case. (Otherwise clause)
 >b7 : Symbol(b7, Decl(functionExpressionContextualTyping1.ts, 41, 3))
->(j, m) => { } : Symbol((Anonymous function), Decl(functionExpressionContextualTyping1.ts, 47, 4))
 >j : Symbol(j, Decl(functionExpressionContextualTyping1.ts, 47, 6))
 >m : Symbol(m, Decl(functionExpressionContextualTyping1.ts, 47, 8))
 
@@ -168,7 +157,6 @@ class C<T, U> {
 >j : Symbol(j, Decl(functionExpressionContextualTyping1.ts, 51, 45))
 >k : Symbol(k, Decl(functionExpressionContextualTyping1.ts, 51, 55))
 >U : Symbol(U, Decl(functionExpressionContextualTyping1.ts, 49, 10))
->(j, k) => {            return [j, k];        } : Symbol((Anonymous function), Decl(functionExpressionContextualTyping1.ts, 51, 75))
 >j : Symbol(j, Decl(functionExpressionContextualTyping1.ts, 51, 77))
 >k : Symbol(k, Decl(functionExpressionContextualTyping1.ts, 51, 79))
 
diff --git a/tests/baselines/reference/functionExpressionReturningItself.symbols b/tests/baselines/reference/functionExpressionReturningItself.symbols
index 93005a27e8c5f..ba4d29f275aff 100644
--- a/tests/baselines/reference/functionExpressionReturningItself.symbols
+++ b/tests/baselines/reference/functionExpressionReturningItself.symbols
@@ -1,7 +1,6 @@
 === tests/cases/compiler/functionExpressionReturningItself.ts ===
 var x = function somefn() { return somefn; };
 >x : Symbol(x, Decl(functionExpressionReturningItself.ts, 0, 3))
->function somefn() { return somefn; } : Symbol(somefn, Decl(functionExpressionReturningItself.ts, 0, 7))
 >somefn : Symbol(somefn, Decl(functionExpressionReturningItself.ts, 0, 7))
 >somefn : Symbol(somefn, Decl(functionExpressionReturningItself.ts, 0, 7))
 
diff --git a/tests/baselines/reference/functionExpressionWithResolutionOfTypeNamedArguments01.symbols b/tests/baselines/reference/functionExpressionWithResolutionOfTypeNamedArguments01.symbols
index cd658db87d5bb..d2455fd0106cf 100644
--- a/tests/baselines/reference/functionExpressionWithResolutionOfTypeNamedArguments01.symbols
+++ b/tests/baselines/reference/functionExpressionWithResolutionOfTypeNamedArguments01.symbols
@@ -5,7 +5,6 @@ interface arguments {
 
 var x = function f() {
 >x : Symbol(x, Decl(functionExpressionWithResolutionOfTypeNamedArguments01.ts, 3, 3))
->function f() {    <arguments>arguments;} : Symbol(f, Decl(functionExpressionWithResolutionOfTypeNamedArguments01.ts, 3, 7))
 >f : Symbol(f, Decl(functionExpressionWithResolutionOfTypeNamedArguments01.ts, 3, 7))
 
     <arguments>arguments;
diff --git a/tests/baselines/reference/functionExpressionWithResolutionOfTypeOfSameName01.symbols b/tests/baselines/reference/functionExpressionWithResolutionOfTypeOfSameName01.symbols
index c1f074d5c1c3f..cd2248c601884 100644
--- a/tests/baselines/reference/functionExpressionWithResolutionOfTypeOfSameName01.symbols
+++ b/tests/baselines/reference/functionExpressionWithResolutionOfTypeOfSameName01.symbols
@@ -5,7 +5,6 @@ interface f {
 
 var x = function f() {
 >x : Symbol(x, Decl(functionExpressionWithResolutionOfTypeOfSameName01.ts, 3, 3))
->function f() {    <f>f;} : Symbol(f, Decl(functionExpressionWithResolutionOfTypeOfSameName01.ts, 3, 7))
 >f : Symbol(f, Decl(functionExpressionWithResolutionOfTypeOfSameName01.ts, 3, 7))
 
     <f>f;
diff --git a/tests/baselines/reference/functionExpressionWithResolutionOfTypeOfSameName02.symbols b/tests/baselines/reference/functionExpressionWithResolutionOfTypeOfSameName02.symbols
index 6632b54ee520a..89b46c99b4ea6 100644
--- a/tests/baselines/reference/functionExpressionWithResolutionOfTypeOfSameName02.symbols
+++ b/tests/baselines/reference/functionExpressionWithResolutionOfTypeOfSameName02.symbols
@@ -5,7 +5,6 @@ interface Foo {
 
 var x = function Foo() {
 >x : Symbol(x, Decl(functionExpressionWithResolutionOfTypeOfSameName02.ts, 3, 3))
->function Foo() {    var x: Foo;} : Symbol(Foo, Decl(functionExpressionWithResolutionOfTypeOfSameName02.ts, 3, 7))
 >Foo : Symbol(Foo, Decl(functionExpressionWithResolutionOfTypeOfSameName02.ts, 3, 7))
 
     var x: Foo;
diff --git a/tests/baselines/reference/functionImplementations.symbols b/tests/baselines/reference/functionImplementations.symbols
index 0fab22deaebac..f9205f3765077 100644
--- a/tests/baselines/reference/functionImplementations.symbols
+++ b/tests/baselines/reference/functionImplementations.symbols
@@ -2,12 +2,10 @@
 // FunctionExpression with no return type annotation and no return statement returns void
 var v: void = function () { } ();
 >v : Symbol(v, Decl(functionImplementations.ts, 1, 3))
->function () { } : Symbol((Anonymous function), Decl(functionImplementations.ts, 1, 13))
 
 // FunctionExpression f with no return type annotation and directly references f in its body returns any
 var a: any = function f() {
 >a : Symbol(a, Decl(functionImplementations.ts, 4, 3), Decl(functionImplementations.ts, 7, 3), Decl(functionImplementations.ts, 12, 3), Decl(functionImplementations.ts, 24, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 84, 3))
->function f() {    return f;} : Symbol(f, Decl(functionImplementations.ts, 4, 12))
 >f : Symbol(f, Decl(functionImplementations.ts, 4, 12))
 
     return f;
@@ -16,7 +14,6 @@ var a: any = function f() {
 };
 var a: any = function f() {
 >a : Symbol(a, Decl(functionImplementations.ts, 4, 3), Decl(functionImplementations.ts, 7, 3), Decl(functionImplementations.ts, 12, 3), Decl(functionImplementations.ts, 24, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 84, 3))
->function f() {    return f();} : Symbol(f, Decl(functionImplementations.ts, 7, 12))
 >f : Symbol(f, Decl(functionImplementations.ts, 7, 12))
 
     return f();
@@ -27,7 +24,6 @@ var a: any = function f() {
 // FunctionExpression f with no return type annotation and indirectly references f in its body returns any
 var a: any = function f() {
 >a : Symbol(a, Decl(functionImplementations.ts, 4, 3), Decl(functionImplementations.ts, 7, 3), Decl(functionImplementations.ts, 12, 3), Decl(functionImplementations.ts, 24, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 84, 3))
->function f() {    var x = f;    return x;} : Symbol(f, Decl(functionImplementations.ts, 12, 12))
 >f : Symbol(f, Decl(functionImplementations.ts, 12, 12))
 
     var x = f;
@@ -87,7 +83,6 @@ var n = rec4();
 // FunctionExpression with no return type annotation and returns a number
 var n = function () {
 >n : Symbol(n, Decl(functionImplementations.ts, 34, 3), Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 39, 3), Decl(functionImplementations.ts, 56, 3), Decl(functionImplementations.ts, 61, 3), Decl(functionImplementations.ts, 66, 3))
->function () {    return 3;} : Symbol((Anonymous function), Decl(functionImplementations.ts, 39, 7))
 
     return 3;
 } ();
@@ -98,7 +93,6 @@ var nu = null;
 
 var nu = function () {
 >nu : Symbol(nu, Decl(functionImplementations.ts, 44, 3), Decl(functionImplementations.ts, 45, 3))
->function () {    return null;} : Symbol((Anonymous function), Decl(functionImplementations.ts, 45, 8))
 
     return null;
 } ();
@@ -110,7 +104,6 @@ var un = undefined;
 
 var un = function () {
 >un : Symbol(un, Decl(functionImplementations.ts, 50, 3), Decl(functionImplementations.ts, 51, 3))
->function () {    return undefined;} : Symbol((Anonymous function), Decl(functionImplementations.ts, 51, 8))
 
     return undefined;
 >undefined : Symbol(undefined)
@@ -120,7 +113,6 @@ var un = function () {
 // FunctionExpression with no return type annotation and returns a type parameter type
 var n = function <T>(x: T) {
 >n : Symbol(n, Decl(functionImplementations.ts, 34, 3), Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 39, 3), Decl(functionImplementations.ts, 56, 3), Decl(functionImplementations.ts, 61, 3), Decl(functionImplementations.ts, 66, 3))
->function <T>(x: T) {    return x;} : Symbol((Anonymous function), Decl(functionImplementations.ts, 56, 7))
 >T : Symbol(T, Decl(functionImplementations.ts, 56, 18))
 >x : Symbol(x, Decl(functionImplementations.ts, 56, 21))
 >T : Symbol(T, Decl(functionImplementations.ts, 56, 18))
@@ -133,7 +125,6 @@ var n = function <T>(x: T) {
 // FunctionExpression with no return type annotation and returns a constrained type parameter type
 var n = function <T extends {}>(x: T) {
 >n : Symbol(n, Decl(functionImplementations.ts, 34, 3), Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 39, 3), Decl(functionImplementations.ts, 56, 3), Decl(functionImplementations.ts, 61, 3), Decl(functionImplementations.ts, 66, 3))
->function <T extends {}>(x: T) {    return x;} : Symbol((Anonymous function), Decl(functionImplementations.ts, 61, 7))
 >T : Symbol(T, Decl(functionImplementations.ts, 61, 18))
 >x : Symbol(x, Decl(functionImplementations.ts, 61, 32))
 >T : Symbol(T, Decl(functionImplementations.ts, 61, 18))
@@ -146,7 +137,6 @@ var n = function <T extends {}>(x: T) {
 // FunctionExpression with no return type annotation with multiple return statements with identical types
 var n = function () {
 >n : Symbol(n, Decl(functionImplementations.ts, 34, 3), Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 39, 3), Decl(functionImplementations.ts, 56, 3), Decl(functionImplementations.ts, 61, 3), Decl(functionImplementations.ts, 66, 3))
->function () {    return 3;    return 5;} : Symbol((Anonymous function), Decl(functionImplementations.ts, 66, 7))
 
     return 3;
     return 5;
@@ -172,7 +162,6 @@ var b: Base;
 
 var b = function () {
 >b : Symbol(b, Decl(functionImplementations.ts, 78, 3), Decl(functionImplementations.ts, 79, 3))
->function () {    return new Base(); return new Derived();} : Symbol((Anonymous function), Decl(functionImplementations.ts, 79, 7))
 
     return new Base(); return new Derived();
 >Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4))
@@ -183,7 +172,6 @@ var b = function () {
 // FunctionExpression with no return type annotation with multiple return statements with one a recursive call
 var a = function f() {
 >a : Symbol(a, Decl(functionImplementations.ts, 4, 3), Decl(functionImplementations.ts, 7, 3), Decl(functionImplementations.ts, 12, 3), Decl(functionImplementations.ts, 24, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 84, 3))
->function f() {    return new Base(); return new Derived(); return f(); // ?} : Symbol(f, Decl(functionImplementations.ts, 84, 7))
 >f : Symbol(f, Decl(functionImplementations.ts, 84, 7))
 
     return new Base(); return new Derived(); return f(); // ?
@@ -196,7 +184,6 @@ var a = function f() {
 // FunctionExpression with non -void return type annotation with a single throw statement
 undefined === function (): number {
 >undefined : Symbol(undefined)
->function (): number {    throw undefined;} : Symbol((Anonymous function), Decl(functionImplementations.ts, 89, 13))
 
     throw undefined;
 >undefined : Symbol(undefined)
@@ -231,7 +218,6 @@ function opt1(n = 4) {
 function opt2(n = { x: null, y: undefined }) {
 >opt2 : Symbol(opt2, Decl(functionImplementations.ts, 103, 1))
 >n : Symbol(n, Decl(functionImplementations.ts, 106, 14))
->{ x: null, y: undefined } : Symbol(, Decl(functionImplementations.ts, 106, 17))
 >x : Symbol(x, Decl(functionImplementations.ts, 106, 19))
 >y : Symbol(y, Decl(functionImplementations.ts, 106, 28))
 >undefined : Symbol(undefined)
@@ -286,7 +272,6 @@ class AnotherClass { private x }
 var f7: (x: number) => string | number = x => { // should be (x: number) => number | string
 >f7 : Symbol(f7, Decl(functionImplementations.ts, 130, 3))
 >x : Symbol(x, Decl(functionImplementations.ts, 130, 9))
->x => { // should be (x: number) => number | string    if (x < 0) { return x; }    return x.toString();} : Symbol((Anonymous function), Decl(functionImplementations.ts, 130, 40))
 >x : Symbol(x, Decl(functionImplementations.ts, 130, 40))
 
     if (x < 0) { return x; }
@@ -301,7 +286,6 @@ var f7: (x: number) => string | number = x => { // should be (x: number) => numb
 var f8: (x: number) => any = x => { // should be (x: number) => Base
 >f8 : Symbol(f8, Decl(functionImplementations.ts, 134, 3))
 >x : Symbol(x, Decl(functionImplementations.ts, 134, 9))
->x => { // should be (x: number) => Base    return new Base();    return new Derived2();} : Symbol((Anonymous function), Decl(functionImplementations.ts, 134, 28))
 >x : Symbol(x, Decl(functionImplementations.ts, 134, 28))
 
     return new Base();
@@ -313,7 +297,6 @@ var f8: (x: number) => any = x => { // should be (x: number) => Base
 var f9: (x: number) => any = x => { // should be (x: number) => Base
 >f9 : Symbol(f9, Decl(functionImplementations.ts, 138, 3))
 >x : Symbol(x, Decl(functionImplementations.ts, 138, 9))
->x => { // should be (x: number) => Base    return new Base();    return new Derived();    return new Derived2();} : Symbol((Anonymous function), Decl(functionImplementations.ts, 138, 28))
 >x : Symbol(x, Decl(functionImplementations.ts, 138, 28))
 
     return new Base();
@@ -328,7 +311,6 @@ var f9: (x: number) => any = x => { // should be (x: number) => Base
 var f10: (x: number) => any = x => { // should be (x: number) => Derived | Derived1
 >f10 : Symbol(f10, Decl(functionImplementations.ts, 143, 3))
 >x : Symbol(x, Decl(functionImplementations.ts, 143, 10))
->x => { // should be (x: number) => Derived | Derived1    return new Derived();    return new Derived2();} : Symbol((Anonymous function), Decl(functionImplementations.ts, 143, 29))
 >x : Symbol(x, Decl(functionImplementations.ts, 143, 29))
 
     return new Derived();
@@ -340,7 +322,6 @@ var f10: (x: number) => any = x => { // should be (x: number) => Derived | Deriv
 var f11: (x: number) => any = x => { // should be (x: number) => Base | AnotherClass
 >f11 : Symbol(f11, Decl(functionImplementations.ts, 147, 3))
 >x : Symbol(x, Decl(functionImplementations.ts, 147, 10))
->x => { // should be (x: number) => Base | AnotherClass    return new Base();    return new AnotherClass();} : Symbol((Anonymous function), Decl(functionImplementations.ts, 147, 29))
 >x : Symbol(x, Decl(functionImplementations.ts, 147, 29))
 
     return new Base();
@@ -352,7 +333,6 @@ var f11: (x: number) => any = x => { // should be (x: number) => Base | AnotherC
 var f12: (x: number) => any = x => { // should be (x: number) => Base | AnotherClass
 >f12 : Symbol(f12, Decl(functionImplementations.ts, 151, 3))
 >x : Symbol(x, Decl(functionImplementations.ts, 151, 10))
->x => { // should be (x: number) => Base | AnotherClass    return new Base();    return; // should be ignored    return new AnotherClass();} : Symbol((Anonymous function), Decl(functionImplementations.ts, 151, 29))
 >x : Symbol(x, Decl(functionImplementations.ts, 151, 29))
 
     return new Base();
diff --git a/tests/baselines/reference/functionLiteral.symbols b/tests/baselines/reference/functionLiteral.symbols
index 514a71bca41db..3a8a4cfbad712 100644
--- a/tests/baselines/reference/functionLiteral.symbols
+++ b/tests/baselines/reference/functionLiteral.symbols
@@ -3,7 +3,6 @@
 
 var x = () => 1;
 >x : Symbol(x, Decl(functionLiteral.ts, 2, 3), Decl(functionLiteral.ts, 3, 3))
->() => 1 : Symbol((Anonymous function), Decl(functionLiteral.ts, 2, 7))
 
 var x: {
 >x : Symbol(x, Decl(functionLiteral.ts, 2, 3), Decl(functionLiteral.ts, 3, 3))
@@ -25,7 +24,6 @@ var y2: { <T>(x: T): T; } = <T>(x: T) => x
 >x : Symbol(x, Decl(functionLiteral.ts, 9, 14))
 >T : Symbol(T, Decl(functionLiteral.ts, 9, 11))
 >T : Symbol(T, Decl(functionLiteral.ts, 9, 11))
-><T>(x: T) => x : Symbol((Anonymous function), Decl(functionLiteral.ts, 9, 27))
 >T : Symbol(T, Decl(functionLiteral.ts, 9, 29))
 >x : Symbol(x, Decl(functionLiteral.ts, 9, 32))
 >T : Symbol(T, Decl(functionLiteral.ts, 9, 29))
diff --git a/tests/baselines/reference/functionLiteralForOverloads.symbols b/tests/baselines/reference/functionLiteralForOverloads.symbols
index 952b8d81f6bba..205945b73ea10 100644
--- a/tests/baselines/reference/functionLiteralForOverloads.symbols
+++ b/tests/baselines/reference/functionLiteralForOverloads.symbols
@@ -11,7 +11,6 @@ var f: {
 >x : Symbol(x, Decl(functionLiteralForOverloads.ts, 4, 5))
 
 } = (x) => x;
->(x) => x : Symbol((Anonymous function), Decl(functionLiteralForOverloads.ts, 5, 3))
 >x : Symbol(x, Decl(functionLiteralForOverloads.ts, 5, 5))
 >x : Symbol(x, Decl(functionLiteralForOverloads.ts, 5, 5))
 
@@ -27,7 +26,6 @@ var f2: {
 >x : Symbol(x, Decl(functionLiteralForOverloads.ts, 9, 8))
 
 } = (x) => x;
->(x) => x : Symbol((Anonymous function), Decl(functionLiteralForOverloads.ts, 10, 3))
 >x : Symbol(x, Decl(functionLiteralForOverloads.ts, 10, 5))
 >x : Symbol(x, Decl(functionLiteralForOverloads.ts, 10, 5))
 
@@ -45,7 +43,6 @@ var f3: {
 >T : Symbol(T, Decl(functionLiteralForOverloads.ts, 14, 5))
 
 } = (x) => x;
->(x) => x : Symbol((Anonymous function), Decl(functionLiteralForOverloads.ts, 15, 3))
 >x : Symbol(x, Decl(functionLiteralForOverloads.ts, 15, 5))
 >x : Symbol(x, Decl(functionLiteralForOverloads.ts, 15, 5))
 
@@ -63,7 +60,6 @@ var f4: {
 >T : Symbol(T, Decl(functionLiteralForOverloads.ts, 19, 5))
 
 } = (x) => x;
->(x) => x : Symbol((Anonymous function), Decl(functionLiteralForOverloads.ts, 20, 3))
 >x : Symbol(x, Decl(functionLiteralForOverloads.ts, 20, 5))
 >x : Symbol(x, Decl(functionLiteralForOverloads.ts, 20, 5))
 
diff --git a/tests/baselines/reference/functionOverloads14.symbols b/tests/baselines/reference/functionOverloads14.symbols
index 33b8bc1d70b04..4f4c3e4750b3d 100644
--- a/tests/baselines/reference/functionOverloads14.symbols
+++ b/tests/baselines/reference/functionOverloads14.symbols
@@ -10,6 +10,5 @@ function foo():{a:string;}
 function foo():{a:any;} { return {a:1} }
 >foo : Symbol(foo, Decl(functionOverloads14.ts, 0, 0), Decl(functionOverloads14.ts, 0, 26), Decl(functionOverloads14.ts, 1, 26))
 >a : Symbol(a, Decl(functionOverloads14.ts, 2, 16))
->{a:1} : Symbol(, Decl(functionOverloads14.ts, 2, 32))
 >a : Symbol(a, Decl(functionOverloads14.ts, 2, 34))
 
diff --git a/tests/baselines/reference/functionOverloads24.symbols b/tests/baselines/reference/functionOverloads24.symbols
index bc2f098826ec6..0753e1f832b29 100644
--- a/tests/baselines/reference/functionOverloads24.symbols
+++ b/tests/baselines/reference/functionOverloads24.symbols
@@ -13,5 +13,4 @@ function foo(bar:any):(a)=>void { return function(){} }
 >foo : Symbol(foo, Decl(functionOverloads24.ts, 0, 0), Decl(functionOverloads24.ts, 0, 42), Decl(functionOverloads24.ts, 1, 42))
 >bar : Symbol(bar, Decl(functionOverloads24.ts, 2, 13))
 >a : Symbol(a, Decl(functionOverloads24.ts, 2, 23))
->function(){} : Symbol((Anonymous function), Decl(functionOverloads24.ts, 2, 40))
 
diff --git a/tests/baselines/reference/functionOverloads35.symbols b/tests/baselines/reference/functionOverloads35.symbols
index dfcc9aba0539c..44a65a452f4f7 100644
--- a/tests/baselines/reference/functionOverloads35.symbols
+++ b/tests/baselines/reference/functionOverloads35.symbols
@@ -18,6 +18,5 @@ function foo(bar:{a:any;}):any{ return bar }
 var x = foo({a:1});
 >x : Symbol(x, Decl(functionOverloads35.ts, 3, 3))
 >foo : Symbol(foo, Decl(functionOverloads35.ts, 0, 0), Decl(functionOverloads35.ts, 0, 37), Decl(functionOverloads35.ts, 1, 37))
->{a:1} : Symbol(, Decl(functionOverloads35.ts, 3, 12))
 >a : Symbol(a, Decl(functionOverloads35.ts, 3, 13))
 
diff --git a/tests/baselines/reference/functionOverloads36.symbols b/tests/baselines/reference/functionOverloads36.symbols
index bc2d1a703d30a..fa6df8fafac05 100644
--- a/tests/baselines/reference/functionOverloads36.symbols
+++ b/tests/baselines/reference/functionOverloads36.symbols
@@ -18,6 +18,5 @@ function foo(bar:{a:any;}):any{ return bar }
 var x = foo({a:'foo'});
 >x : Symbol(x, Decl(functionOverloads36.ts, 3, 3))
 >foo : Symbol(foo, Decl(functionOverloads36.ts, 0, 0), Decl(functionOverloads36.ts, 0, 37), Decl(functionOverloads36.ts, 1, 37))
->{a:'foo'} : Symbol(, Decl(functionOverloads36.ts, 3, 12))
 >a : Symbol(a, Decl(functionOverloads36.ts, 3, 13))
 
diff --git a/tests/baselines/reference/functionOverloads38.symbols b/tests/baselines/reference/functionOverloads38.symbols
index 3b2fe84cd6713..460ea75377666 100644
--- a/tests/baselines/reference/functionOverloads38.symbols
+++ b/tests/baselines/reference/functionOverloads38.symbols
@@ -18,6 +18,5 @@ function foo(bar:{a:any;}[]):any{ return bar }
 var x = foo([{a:1}]);
 >x : Symbol(x, Decl(functionOverloads38.ts, 3, 3))
 >foo : Symbol(foo, Decl(functionOverloads38.ts, 0, 0), Decl(functionOverloads38.ts, 0, 39), Decl(functionOverloads38.ts, 1, 40))
->{a:1} : Symbol(, Decl(functionOverloads38.ts, 3, 13))
 >a : Symbol(a, Decl(functionOverloads38.ts, 3, 14))
 
diff --git a/tests/baselines/reference/functionOverloads39.symbols b/tests/baselines/reference/functionOverloads39.symbols
index ed724a2e6cc42..37bb56117d519 100644
--- a/tests/baselines/reference/functionOverloads39.symbols
+++ b/tests/baselines/reference/functionOverloads39.symbols
@@ -18,6 +18,5 @@ function foo(bar:{a:any;}[]):any{ return bar }
 var x = foo([{a:true}]);
 >x : Symbol(x, Decl(functionOverloads39.ts, 3, 3))
 >foo : Symbol(foo, Decl(functionOverloads39.ts, 0, 0), Decl(functionOverloads39.ts, 0, 39), Decl(functionOverloads39.ts, 1, 40))
->{a:true} : Symbol(, Decl(functionOverloads39.ts, 3, 13))
 >a : Symbol(a, Decl(functionOverloads39.ts, 3, 14))
 
diff --git a/tests/baselines/reference/functionOverloads42.symbols b/tests/baselines/reference/functionOverloads42.symbols
index 5ef2d3f868b3e..6cca9a552f240 100644
--- a/tests/baselines/reference/functionOverloads42.symbols
+++ b/tests/baselines/reference/functionOverloads42.symbols
@@ -18,6 +18,5 @@ function foo(bar:{a:any;}[]):any{ return bar }
 var x = foo([{a:'s'}]);
 >x : Symbol(x, Decl(functionOverloads42.ts, 3, 3))
 >foo : Symbol(foo, Decl(functionOverloads42.ts, 0, 0), Decl(functionOverloads42.ts, 0, 39), Decl(functionOverloads42.ts, 1, 36))
->{a:'s'} : Symbol(, Decl(functionOverloads42.ts, 3, 13))
 >a : Symbol(a, Decl(functionOverloads42.ts, 3, 14))
 
diff --git a/tests/baselines/reference/functionWithAnyReturnTypeAndNoReturnExpression.symbols b/tests/baselines/reference/functionWithAnyReturnTypeAndNoReturnExpression.symbols
index 71d20a743e96d..71a678b6c9331 100644
--- a/tests/baselines/reference/functionWithAnyReturnTypeAndNoReturnExpression.symbols
+++ b/tests/baselines/reference/functionWithAnyReturnTypeAndNoReturnExpression.symbols
@@ -5,9 +5,7 @@ function f(): any { }
 
 var f2: () => any = () => { };
 >f2 : Symbol(f2, Decl(functionWithAnyReturnTypeAndNoReturnExpression.ts, 2, 3))
->() => { } : Symbol((Anonymous function), Decl(functionWithAnyReturnTypeAndNoReturnExpression.ts, 2, 19))
 
 var f3 = (): any => { };
 >f3 : Symbol(f3, Decl(functionWithAnyReturnTypeAndNoReturnExpression.ts, 3, 3))
->(): any => { } : Symbol((Anonymous function), Decl(functionWithAnyReturnTypeAndNoReturnExpression.ts, 3, 8))
 
diff --git a/tests/baselines/reference/generatedContextualTyping.symbols b/tests/baselines/reference/generatedContextualTyping.symbols
index 5c3671979d528..287b7be66d091 100644
--- a/tests/baselines/reference/generatedContextualTyping.symbols
+++ b/tests/baselines/reference/generatedContextualTyping.symbols
@@ -31,21 +31,18 @@ var b = new Base(), d1 = new Derived1(), d2 = new Derived2();
 var x1: () => Base[] = () => [d1, d2];
 >x1 : Symbol(x1, Decl(generatedContextualTyping.ts, 5, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 5, 22))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x2: () => Base[] = function() { return [d1, d2] };
 >x2 : Symbol(x2, Decl(generatedContextualTyping.ts, 6, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 6, 22))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x3: () => Base[] = function named() { return [d1, d2] };
 >x3 : Symbol(x3, Decl(generatedContextualTyping.ts, 7, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 7, 22))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 7, 22))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -53,21 +50,18 @@ var x3: () => Base[] = function named() { return [d1, d2] };
 var x4: { (): Base[]; } = () => [d1, d2];
 >x4 : Symbol(x4, Decl(generatedContextualTyping.ts, 8, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 8, 25))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x5: { (): Base[]; } = function() { return [d1, d2] };
 >x5 : Symbol(x5, Decl(generatedContextualTyping.ts, 9, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 9, 25))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x6: { (): Base[]; } = function named() { return [d1, d2] };
 >x6 : Symbol(x6, Decl(generatedContextualTyping.ts, 10, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 10, 25))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 10, 25))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -96,7 +90,6 @@ var x10: {n: Base[]; }  = { n: [d1, d2] };
 >x10 : Symbol(x10, Decl(generatedContextualTyping.ts, 14, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 14, 10))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 14, 25))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 14, 27))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -105,7 +98,6 @@ var x11: (s: Base[]) => any = n => { var n: Base[]; return null; };
 >x11 : Symbol(x11, Decl(generatedContextualTyping.ts, 15, 3))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 15, 10))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 15, 29))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 15, 29), Decl(generatedContextualTyping.ts, 15, 40))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 15, 29), Decl(generatedContextualTyping.ts, 15, 40))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -114,9 +106,7 @@ var x12: Genric<Base> = { func: n => { return [d1, d2]; } };
 >x12 : Symbol(x12, Decl(generatedContextualTyping.ts, 16, 3))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 16, 23))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 16, 25))
->n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 16, 31))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 16, 31))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -125,7 +115,6 @@ class x13 { member: () => Base[] = () => [d1, d2] }
 >x13 : Symbol(x13, Decl(generatedContextualTyping.ts, 16, 60))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 17, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 17, 34))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -133,7 +122,6 @@ class x14 { member: () => Base[] = function() { return [d1, d2] } }
 >x14 : Symbol(x14, Decl(generatedContextualTyping.ts, 17, 51))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 18, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 18, 34))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -141,7 +129,6 @@ class x15 { member: () => Base[] = function named() { return [d1, d2] } }
 >x15 : Symbol(x15, Decl(generatedContextualTyping.ts, 18, 67))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 19, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 19, 34))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 19, 34))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -150,7 +137,6 @@ class x16 { member: { (): Base[]; } = () => [d1, d2] }
 >x16 : Symbol(x16, Decl(generatedContextualTyping.ts, 19, 73))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 20, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 20, 37))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -158,7 +144,6 @@ class x17 { member: { (): Base[]; } = function() { return [d1, d2] } }
 >x17 : Symbol(x17, Decl(generatedContextualTyping.ts, 20, 54))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 21, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 21, 37))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -166,7 +151,6 @@ class x18 { member: { (): Base[]; } = function named() { return [d1, d2] } }
 >x18 : Symbol(x18, Decl(generatedContextualTyping.ts, 21, 70))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 22, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 22, 37))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 22, 37))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -199,7 +183,6 @@ class x22 { member: {n: Base[]; }  = { n: [d1, d2] } }
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 26, 11))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 26, 21))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 26, 36))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 26, 38))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -209,7 +192,6 @@ class x23 { member: (s: Base[]) => any = n => { var n: Base[]; return null; } }
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 27, 11))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 27, 21))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 27, 40))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 27, 40), Decl(generatedContextualTyping.ts, 27, 51))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 27, 40), Decl(generatedContextualTyping.ts, 27, 51))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -219,9 +201,7 @@ class x24 { member: Genric<Base> = { func: n => { return [d1, d2]; } } }
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 28, 11))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 28, 34))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 28, 36))
->n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 28, 42))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 28, 42))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -230,7 +210,6 @@ class x25 { private member: () => Base[] = () => [d1, d2] }
 >x25 : Symbol(x25, Decl(generatedContextualTyping.ts, 28, 72))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 29, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 29, 42))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -238,7 +217,6 @@ class x26 { private member: () => Base[] = function() { return [d1, d2] } }
 >x26 : Symbol(x26, Decl(generatedContextualTyping.ts, 29, 59))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 30, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 30, 42))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -246,7 +224,6 @@ class x27 { private member: () => Base[] = function named() { return [d1, d2] }
 >x27 : Symbol(x27, Decl(generatedContextualTyping.ts, 30, 75))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 31, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 31, 42))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 31, 42))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -255,7 +232,6 @@ class x28 { private member: { (): Base[]; } = () => [d1, d2] }
 >x28 : Symbol(x28, Decl(generatedContextualTyping.ts, 31, 81))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 32, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 32, 45))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -263,7 +239,6 @@ class x29 { private member: { (): Base[]; } = function() { return [d1, d2] } }
 >x29 : Symbol(x29, Decl(generatedContextualTyping.ts, 32, 62))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 33, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 33, 45))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -271,7 +246,6 @@ class x30 { private member: { (): Base[]; } = function named() { return [d1, d2]
 >x30 : Symbol(x30, Decl(generatedContextualTyping.ts, 33, 78))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 34, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 34, 45))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 34, 45))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -304,7 +278,6 @@ class x34 { private member: {n: Base[]; }  = { n: [d1, d2] } }
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 38, 11))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 38, 29))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 38, 44))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 38, 46))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -314,7 +287,6 @@ class x35 { private member: (s: Base[]) => any = n => { var n: Base[]; return nu
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 39, 11))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 39, 29))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 39, 48))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 39, 48), Decl(generatedContextualTyping.ts, 39, 59))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 39, 48), Decl(generatedContextualTyping.ts, 39, 59))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -324,9 +296,7 @@ class x36 { private member: Genric<Base> = { func: n => { return [d1, d2]; } } }
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 40, 11))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 40, 42))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 40, 44))
->n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 40, 50))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 40, 50))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -335,7 +305,6 @@ class x37 { public member: () => Base[] = () => [d1, d2] }
 >x37 : Symbol(x37, Decl(generatedContextualTyping.ts, 40, 80))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 41, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 41, 41))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -343,7 +312,6 @@ class x38 { public member: () => Base[] = function() { return [d1, d2] } }
 >x38 : Symbol(x38, Decl(generatedContextualTyping.ts, 41, 58))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 42, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 42, 41))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -351,7 +319,6 @@ class x39 { public member: () => Base[] = function named() { return [d1, d2] } }
 >x39 : Symbol(x39, Decl(generatedContextualTyping.ts, 42, 74))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 43, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 43, 41))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 43, 41))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -360,7 +327,6 @@ class x40 { public member: { (): Base[]; } = () => [d1, d2] }
 >x40 : Symbol(x40, Decl(generatedContextualTyping.ts, 43, 80))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 44, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 44, 44))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -368,7 +334,6 @@ class x41 { public member: { (): Base[]; } = function() { return [d1, d2] } }
 >x41 : Symbol(x41, Decl(generatedContextualTyping.ts, 44, 61))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 45, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 45, 44))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -376,7 +341,6 @@ class x42 { public member: { (): Base[]; } = function named() { return [d1, d2]
 >x42 : Symbol(x42, Decl(generatedContextualTyping.ts, 45, 77))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 46, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 46, 44))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 46, 44))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -409,7 +373,6 @@ class x46 { public member: {n: Base[]; }  = { n: [d1, d2] } }
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 50, 11))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 50, 28))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 50, 43))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 50, 45))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -419,7 +382,6 @@ class x47 { public member: (s: Base[]) => any = n => { var n: Base[]; return nul
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 51, 11))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 51, 28))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 51, 47))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 51, 47), Decl(generatedContextualTyping.ts, 51, 58))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 51, 47), Decl(generatedContextualTyping.ts, 51, 58))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -429,9 +391,7 @@ class x48 { public member: Genric<Base> = { func: n => { return [d1, d2]; } } }
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 52, 11))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 52, 41))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 52, 43))
->n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 52, 49))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 52, 49))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -440,7 +400,6 @@ class x49 { static member: () => Base[] = () => [d1, d2] }
 >x49 : Symbol(x49, Decl(generatedContextualTyping.ts, 52, 79))
 >member : Symbol(x49.member, Decl(generatedContextualTyping.ts, 53, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 53, 41))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -448,7 +407,6 @@ class x50 { static member: () => Base[] = function() { return [d1, d2] } }
 >x50 : Symbol(x50, Decl(generatedContextualTyping.ts, 53, 58))
 >member : Symbol(x50.member, Decl(generatedContextualTyping.ts, 54, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 54, 41))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -456,7 +414,6 @@ class x51 { static member: () => Base[] = function named() { return [d1, d2] } }
 >x51 : Symbol(x51, Decl(generatedContextualTyping.ts, 54, 74))
 >member : Symbol(x51.member, Decl(generatedContextualTyping.ts, 55, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 55, 41))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 55, 41))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -465,7 +422,6 @@ class x52 { static member: { (): Base[]; } = () => [d1, d2] }
 >x52 : Symbol(x52, Decl(generatedContextualTyping.ts, 55, 80))
 >member : Symbol(x52.member, Decl(generatedContextualTyping.ts, 56, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 56, 44))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -473,7 +429,6 @@ class x53 { static member: { (): Base[]; } = function() { return [d1, d2] } }
 >x53 : Symbol(x53, Decl(generatedContextualTyping.ts, 56, 61))
 >member : Symbol(x53.member, Decl(generatedContextualTyping.ts, 57, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 57, 44))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -481,7 +436,6 @@ class x54 { static member: { (): Base[]; } = function named() { return [d1, d2]
 >x54 : Symbol(x54, Decl(generatedContextualTyping.ts, 57, 77))
 >member : Symbol(x54.member, Decl(generatedContextualTyping.ts, 58, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 58, 44))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 58, 44))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -514,7 +468,6 @@ class x58 { static member: {n: Base[]; }  = { n: [d1, d2] } }
 >member : Symbol(x58.member, Decl(generatedContextualTyping.ts, 62, 11))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 62, 28))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 62, 43))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 62, 45))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -524,7 +477,6 @@ class x59 { static member: (s: Base[]) => any = n => { var n: Base[]; return nul
 >member : Symbol(x59.member, Decl(generatedContextualTyping.ts, 63, 11))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 63, 28))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 63, 47))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 63, 47), Decl(generatedContextualTyping.ts, 63, 58))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 63, 47), Decl(generatedContextualTyping.ts, 63, 58))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -534,9 +486,7 @@ class x60 { static member: Genric<Base> = { func: n => { return [d1, d2]; } } }
 >member : Symbol(x60.member, Decl(generatedContextualTyping.ts, 64, 11))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 64, 41))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 64, 43))
->n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 64, 49))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 64, 49))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -545,7 +495,6 @@ class x61 { private static member: () => Base[] = () => [d1, d2] }
 >x61 : Symbol(x61, Decl(generatedContextualTyping.ts, 64, 79))
 >member : Symbol(x61.member, Decl(generatedContextualTyping.ts, 65, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 65, 49))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -553,7 +502,6 @@ class x62 { private static member: () => Base[] = function() { return [d1, d2] }
 >x62 : Symbol(x62, Decl(generatedContextualTyping.ts, 65, 66))
 >member : Symbol(x62.member, Decl(generatedContextualTyping.ts, 66, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 66, 49))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -561,7 +509,6 @@ class x63 { private static member: () => Base[] = function named() { return [d1,
 >x63 : Symbol(x63, Decl(generatedContextualTyping.ts, 66, 82))
 >member : Symbol(x63.member, Decl(generatedContextualTyping.ts, 67, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 67, 49))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 67, 49))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -570,7 +517,6 @@ class x64 { private static member: { (): Base[]; } = () => [d1, d2] }
 >x64 : Symbol(x64, Decl(generatedContextualTyping.ts, 67, 88))
 >member : Symbol(x64.member, Decl(generatedContextualTyping.ts, 68, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 68, 52))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -578,7 +524,6 @@ class x65 { private static member: { (): Base[]; } = function() { return [d1, d2
 >x65 : Symbol(x65, Decl(generatedContextualTyping.ts, 68, 69))
 >member : Symbol(x65.member, Decl(generatedContextualTyping.ts, 69, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 69, 52))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -586,7 +531,6 @@ class x66 { private static member: { (): Base[]; } = function named() { return [
 >x66 : Symbol(x66, Decl(generatedContextualTyping.ts, 69, 85))
 >member : Symbol(x66.member, Decl(generatedContextualTyping.ts, 70, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 70, 52))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 70, 52))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -619,7 +563,6 @@ class x70 { private static member: {n: Base[]; }  = { n: [d1, d2] } }
 >member : Symbol(x70.member, Decl(generatedContextualTyping.ts, 74, 11))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 74, 36))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 74, 51))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 74, 53))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -629,7 +572,6 @@ class x71 { private static member: (s: Base[]) => any = n => { var n: Base[]; re
 >member : Symbol(x71.member, Decl(generatedContextualTyping.ts, 75, 11))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 75, 36))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 75, 55))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 75, 55), Decl(generatedContextualTyping.ts, 75, 66))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 75, 55), Decl(generatedContextualTyping.ts, 75, 66))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -639,9 +581,7 @@ class x72 { private static member: Genric<Base> = { func: n => { return [d1, d2]
 >member : Symbol(x72.member, Decl(generatedContextualTyping.ts, 76, 11))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 76, 49))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 76, 51))
->n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 76, 57))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 76, 57))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -650,7 +590,6 @@ class x73 { public static member: () => Base[] = () => [d1, d2] }
 >x73 : Symbol(x73, Decl(generatedContextualTyping.ts, 76, 87))
 >member : Symbol(x73.member, Decl(generatedContextualTyping.ts, 77, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 77, 48))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -658,7 +597,6 @@ class x74 { public static member: () => Base[] = function() { return [d1, d2] }
 >x74 : Symbol(x74, Decl(generatedContextualTyping.ts, 77, 65))
 >member : Symbol(x74.member, Decl(generatedContextualTyping.ts, 78, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 78, 48))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -666,7 +604,6 @@ class x75 { public static member: () => Base[] = function named() { return [d1,
 >x75 : Symbol(x75, Decl(generatedContextualTyping.ts, 78, 81))
 >member : Symbol(x75.member, Decl(generatedContextualTyping.ts, 79, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 79, 48))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 79, 48))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -675,7 +612,6 @@ class x76 { public static member: { (): Base[]; } = () => [d1, d2] }
 >x76 : Symbol(x76, Decl(generatedContextualTyping.ts, 79, 87))
 >member : Symbol(x76.member, Decl(generatedContextualTyping.ts, 80, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 80, 51))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -683,7 +619,6 @@ class x77 { public static member: { (): Base[]; } = function() { return [d1, d2]
 >x77 : Symbol(x77, Decl(generatedContextualTyping.ts, 80, 68))
 >member : Symbol(x77.member, Decl(generatedContextualTyping.ts, 81, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 81, 51))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -691,7 +626,6 @@ class x78 { public static member: { (): Base[]; } = function named() { return [d
 >x78 : Symbol(x78, Decl(generatedContextualTyping.ts, 81, 84))
 >member : Symbol(x78.member, Decl(generatedContextualTyping.ts, 82, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 82, 51))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 82, 51))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -724,7 +658,6 @@ class x82 { public static member: {n: Base[]; }  = { n: [d1, d2] } }
 >member : Symbol(x82.member, Decl(generatedContextualTyping.ts, 86, 11))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 86, 35))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 86, 50))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 86, 52))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -734,7 +667,6 @@ class x83 { public static member: (s: Base[]) => any = n => { var n: Base[]; ret
 >member : Symbol(x83.member, Decl(generatedContextualTyping.ts, 87, 11))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 87, 35))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 87, 54))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 87, 54), Decl(generatedContextualTyping.ts, 87, 65))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 87, 54), Decl(generatedContextualTyping.ts, 87, 65))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -744,9 +676,7 @@ class x84 { public static member: Genric<Base> = { func: n => { return [d1, d2];
 >member : Symbol(x84.member, Decl(generatedContextualTyping.ts, 88, 11))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 88, 48))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 88, 50))
->n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 88, 56))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 88, 56))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -755,7 +685,6 @@ class x85 { constructor(parm: () => Base[] = () => [d1, d2]) { } }
 >x85 : Symbol(x85, Decl(generatedContextualTyping.ts, 88, 86))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 89, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 89, 44))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -763,7 +692,6 @@ class x86 { constructor(parm: () => Base[] = function() { return [d1, d2] }) { }
 >x86 : Symbol(x86, Decl(generatedContextualTyping.ts, 89, 66))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 90, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 90, 44))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -771,7 +699,6 @@ class x87 { constructor(parm: () => Base[] = function named() { return [d1, d2]
 >x87 : Symbol(x87, Decl(generatedContextualTyping.ts, 90, 82))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 91, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 91, 44))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 91, 44))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -780,7 +707,6 @@ class x88 { constructor(parm: { (): Base[]; } = () => [d1, d2]) { } }
 >x88 : Symbol(x88, Decl(generatedContextualTyping.ts, 91, 88))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 92, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 92, 47))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -788,7 +714,6 @@ class x89 { constructor(parm: { (): Base[]; } = function() { return [d1, d2] })
 >x89 : Symbol(x89, Decl(generatedContextualTyping.ts, 92, 69))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 93, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 93, 47))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -796,7 +721,6 @@ class x90 { constructor(parm: { (): Base[]; } = function named() { return [d1, d
 >x90 : Symbol(x90, Decl(generatedContextualTyping.ts, 93, 85))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 94, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 94, 47))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 94, 47))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -829,7 +753,6 @@ class x94 { constructor(parm: {n: Base[]; }  = { n: [d1, d2] }) { } }
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 98, 24))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 98, 31))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 98, 46))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 98, 48))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -839,7 +762,6 @@ class x95 { constructor(parm: (s: Base[]) => any = n => { var n: Base[]; return
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 99, 24))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 99, 31))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 99, 50))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 99, 50), Decl(generatedContextualTyping.ts, 99, 61))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 99, 50), Decl(generatedContextualTyping.ts, 99, 61))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -849,9 +771,7 @@ class x96 { constructor(parm: Genric<Base> = { func: n => { return [d1, d2]; } }
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 100, 24))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 100, 44))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 100, 46))
->n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 100, 52))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 100, 52))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -860,7 +780,6 @@ class x97 { constructor(public parm: () => Base[] = () => [d1, d2]) { } }
 >x97 : Symbol(x97, Decl(generatedContextualTyping.ts, 100, 87))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 101, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 101, 51))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -868,7 +787,6 @@ class x98 { constructor(public parm: () => Base[] = function() { return [d1, d2]
 >x98 : Symbol(x98, Decl(generatedContextualTyping.ts, 101, 73))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 102, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 102, 51))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -876,7 +794,6 @@ class x99 { constructor(public parm: () => Base[] = function named() { return [d
 >x99 : Symbol(x99, Decl(generatedContextualTyping.ts, 102, 89))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 103, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 103, 51))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 103, 51))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -885,7 +802,6 @@ class x100 { constructor(public parm: { (): Base[]; } = () => [d1, d2]) { } }
 >x100 : Symbol(x100, Decl(generatedContextualTyping.ts, 103, 95))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 104, 25))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 104, 55))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -893,7 +809,6 @@ class x101 { constructor(public parm: { (): Base[]; } = function() { return [d1,
 >x101 : Symbol(x101, Decl(generatedContextualTyping.ts, 104, 77))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 105, 25))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 105, 55))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -901,7 +816,6 @@ class x102 { constructor(public parm: { (): Base[]; } = function named() { retur
 >x102 : Symbol(x102, Decl(generatedContextualTyping.ts, 105, 93))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 106, 25))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 106, 55))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 106, 55))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -934,7 +848,6 @@ class x106 { constructor(public parm: {n: Base[]; }  = { n: [d1, d2] }) { } }
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 110, 25))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 110, 39))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 110, 54))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 110, 56))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -944,7 +857,6 @@ class x107 { constructor(public parm: (s: Base[]) => any = n => { var n: Base[];
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 111, 25))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 111, 39))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 111, 58))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 111, 58), Decl(generatedContextualTyping.ts, 111, 69))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 111, 58), Decl(generatedContextualTyping.ts, 111, 69))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -954,9 +866,7 @@ class x108 { constructor(public parm: Genric<Base> = { func: n => { return [d1,
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 112, 25))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 112, 52))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 112, 54))
->n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 112, 60))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 112, 60))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -965,7 +875,6 @@ class x109 { constructor(private parm: () => Base[] = () => [d1, d2]) { } }
 >x109 : Symbol(x109, Decl(generatedContextualTyping.ts, 112, 95))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 113, 25))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 113, 53))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -973,7 +882,6 @@ class x110 { constructor(private parm: () => Base[] = function() { return [d1, d
 >x110 : Symbol(x110, Decl(generatedContextualTyping.ts, 113, 75))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 114, 25))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 114, 53))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -981,7 +889,6 @@ class x111 { constructor(private parm: () => Base[] = function named() { return
 >x111 : Symbol(x111, Decl(generatedContextualTyping.ts, 114, 91))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 115, 25))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 115, 53))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 115, 53))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -990,7 +897,6 @@ class x112 { constructor(private parm: { (): Base[]; } = () => [d1, d2]) { } }
 >x112 : Symbol(x112, Decl(generatedContextualTyping.ts, 115, 97))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 116, 25))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 116, 56))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -998,7 +904,6 @@ class x113 { constructor(private parm: { (): Base[]; } = function() { return [d1
 >x113 : Symbol(x113, Decl(generatedContextualTyping.ts, 116, 78))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 117, 25))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 117, 56))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1006,7 +911,6 @@ class x114 { constructor(private parm: { (): Base[]; } = function named() { retu
 >x114 : Symbol(x114, Decl(generatedContextualTyping.ts, 117, 94))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 118, 25))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 118, 56))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 118, 56))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1039,7 +943,6 @@ class x118 { constructor(private parm: {n: Base[]; }  = { n: [d1, d2] }) { } }
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 122, 25))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 122, 40))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 122, 55))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 122, 57))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1049,7 +952,6 @@ class x119 { constructor(private parm: (s: Base[]) => any = n => { var n: Base[]
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 123, 25))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 123, 40))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 123, 59))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 123, 59), Decl(generatedContextualTyping.ts, 123, 70))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 123, 59), Decl(generatedContextualTyping.ts, 123, 70))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -1059,9 +961,7 @@ class x120 { constructor(private parm: Genric<Base> = { func: n => { return [d1,
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 124, 25))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 124, 53))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 124, 55))
->n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 124, 61))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 124, 61))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1070,7 +970,6 @@ function x121(parm: () => Base[] = () => [d1, d2]) { }
 >x121 : Symbol(x121, Decl(generatedContextualTyping.ts, 124, 96))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 125, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 125, 34))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1078,7 +977,6 @@ function x122(parm: () => Base[] = function() { return [d1, d2] }) { }
 >x122 : Symbol(x122, Decl(generatedContextualTyping.ts, 125, 54))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 126, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 126, 34))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1086,7 +984,6 @@ function x123(parm: () => Base[] = function named() { return [d1, d2] }) { }
 >x123 : Symbol(x123, Decl(generatedContextualTyping.ts, 126, 70))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 127, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 127, 34))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 127, 34))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1095,7 +992,6 @@ function x124(parm: { (): Base[]; } = () => [d1, d2]) { }
 >x124 : Symbol(x124, Decl(generatedContextualTyping.ts, 127, 76))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 128, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 128, 37))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1103,7 +999,6 @@ function x125(parm: { (): Base[]; } = function() { return [d1, d2] }) { }
 >x125 : Symbol(x125, Decl(generatedContextualTyping.ts, 128, 57))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 129, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 129, 37))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1111,7 +1006,6 @@ function x126(parm: { (): Base[]; } = function named() { return [d1, d2] }) { }
 >x126 : Symbol(x126, Decl(generatedContextualTyping.ts, 129, 73))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 130, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 130, 37))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 130, 37))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1144,7 +1038,6 @@ function x130(parm: {n: Base[]; }  = { n: [d1, d2] }) { }
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 134, 14))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 134, 21))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 134, 36))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 134, 38))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1154,7 +1047,6 @@ function x131(parm: (s: Base[]) => any = n => { var n: Base[]; return null; }) {
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 135, 14))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 135, 21))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 135, 40))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 135, 40), Decl(generatedContextualTyping.ts, 135, 51))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 135, 40), Decl(generatedContextualTyping.ts, 135, 51))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -1164,9 +1056,7 @@ function x132(parm: Genric<Base> = { func: n => { return [d1, d2]; } }) { }
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 136, 14))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 136, 34))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 136, 36))
->n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 136, 42))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 136, 42))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1174,21 +1064,18 @@ function x132(parm: Genric<Base> = { func: n => { return [d1, d2]; } }) { }
 function x133(): () => Base[] { return () => [d1, d2]; }
 >x133 : Symbol(x133, Decl(generatedContextualTyping.ts, 136, 75))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 137, 38))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 function x134(): () => Base[] { return function() { return [d1, d2] }; }
 >x134 : Symbol(x134, Decl(generatedContextualTyping.ts, 137, 56))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 138, 38))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 function x135(): () => Base[] { return function named() { return [d1, d2] }; }
 >x135 : Symbol(x135, Decl(generatedContextualTyping.ts, 138, 72))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 139, 38))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 139, 38))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1196,21 +1083,18 @@ function x135(): () => Base[] { return function named() { return [d1, d2] }; }
 function x136(): { (): Base[]; } { return () => [d1, d2]; }
 >x136 : Symbol(x136, Decl(generatedContextualTyping.ts, 139, 78))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 140, 41))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 function x137(): { (): Base[]; } { return function() { return [d1, d2] }; }
 >x137 : Symbol(x137, Decl(generatedContextualTyping.ts, 140, 59))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 141, 41))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 function x138(): { (): Base[]; } { return function named() { return [d1, d2] }; }
 >x138 : Symbol(x138, Decl(generatedContextualTyping.ts, 141, 75))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 142, 41))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 142, 41))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1239,7 +1123,6 @@ function x142(): {n: Base[]; }  { return { n: [d1, d2] }; }
 >x142 : Symbol(x142, Decl(generatedContextualTyping.ts, 145, 60))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 146, 18))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 146, 40))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 146, 42))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1248,7 +1131,6 @@ function x143(): (s: Base[]) => any { return n => { var n: Base[]; return null;
 >x143 : Symbol(x143, Decl(generatedContextualTyping.ts, 146, 59))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 147, 18))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 147, 44))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 147, 44), Decl(generatedContextualTyping.ts, 147, 55))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 147, 44), Decl(generatedContextualTyping.ts, 147, 55))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -1257,9 +1139,7 @@ function x144(): Genric<Base> { return { func: n => { return [d1, d2]; } }; }
 >x144 : Symbol(x144, Decl(generatedContextualTyping.ts, 147, 84))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 148, 38))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 148, 40))
->n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 148, 46))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 148, 46))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1267,31 +1147,25 @@ function x144(): Genric<Base> { return { func: n => { return [d1, d2]; } }; }
 function x145(): () => Base[] { return () => [d1, d2]; return () => [d1, d2]; }
 >x145 : Symbol(x145, Decl(generatedContextualTyping.ts, 148, 77))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 149, 38))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 149, 61))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 function x146(): () => Base[] { return function() { return [d1, d2] }; return function() { return [d1, d2] }; }
 >x146 : Symbol(x146, Decl(generatedContextualTyping.ts, 149, 79))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 150, 38))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 150, 77))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 function x147(): () => Base[] { return function named() { return [d1, d2] }; return function named() { return [d1, d2] }; }
 >x147 : Symbol(x147, Decl(generatedContextualTyping.ts, 150, 111))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 151, 38))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 151, 38))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 151, 83))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 151, 83))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1299,31 +1173,25 @@ function x147(): () => Base[] { return function named() { return [d1, d2] }; ret
 function x148(): { (): Base[]; } { return () => [d1, d2]; return () => [d1, d2]; }
 >x148 : Symbol(x148, Decl(generatedContextualTyping.ts, 151, 123))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 152, 41))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 152, 64))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 function x149(): { (): Base[]; } { return function() { return [d1, d2] }; return function() { return [d1, d2] }; }
 >x149 : Symbol(x149, Decl(generatedContextualTyping.ts, 152, 82))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 153, 41))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 153, 80))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 function x150(): { (): Base[]; } { return function named() { return [d1, d2] }; return function named() { return [d1, d2] }; }
 >x150 : Symbol(x150, Decl(generatedContextualTyping.ts, 153, 114))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 154, 41))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 154, 41))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 154, 86))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 154, 86))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1358,11 +1226,9 @@ function x154(): {n: Base[]; }  { return { n: [d1, d2] }; return { n: [d1, d2] }
 >x154 : Symbol(x154, Decl(generatedContextualTyping.ts, 157, 77))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 158, 18))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 158, 40))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 158, 42))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 158, 64))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 158, 66))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1371,11 +1237,9 @@ function x155(): (s: Base[]) => any { return n => { var n: Base[]; return null;
 >x155 : Symbol(x155, Decl(generatedContextualTyping.ts, 158, 83))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 159, 18))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 159, 44))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 44), Decl(generatedContextualTyping.ts, 159, 55))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 44), Decl(generatedContextualTyping.ts, 159, 55))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 159, 89))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 89), Decl(generatedContextualTyping.ts, 159, 100))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 89), Decl(generatedContextualTyping.ts, 159, 100))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -1384,15 +1248,11 @@ function x156(): Genric<Base> { return { func: n => { return [d1, d2]; } }; retu
 >x156 : Symbol(x156, Decl(generatedContextualTyping.ts, 159, 129))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 160, 38))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 160, 40))
->n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 160, 46))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 160, 46))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 160, 82))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 160, 84))
->n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 160, 90))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 160, 90))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1400,24 +1260,18 @@ function x156(): Genric<Base> { return { func: n => { return [d1, d2]; } }; retu
 var x157: () => () => Base[] = () => { return () => [d1, d2]; };
 >x157 : Symbol(x157, Decl(generatedContextualTyping.ts, 161, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => { return () => [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 161, 30))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 161, 45))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x158: () => () => Base[] = () => { return function() { return [d1, d2] }; };
 >x158 : Symbol(x158, Decl(generatedContextualTyping.ts, 162, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => { return function() { return [d1, d2] }; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 162, 30))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 162, 45))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x159: () => () => Base[] = () => { return function named() { return [d1, d2] }; };
 >x159 : Symbol(x159, Decl(generatedContextualTyping.ts, 163, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => { return function named() { return [d1, d2] }; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 163, 30))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 163, 45))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 163, 45))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1425,24 +1279,18 @@ var x159: () => () => Base[] = () => { return function named() { return [d1, d2]
 var x160: () => { (): Base[]; } = () => { return () => [d1, d2]; };
 >x160 : Symbol(x160, Decl(generatedContextualTyping.ts, 164, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => { return () => [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 164, 33))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 164, 48))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x161: () => { (): Base[]; } = () => { return function() { return [d1, d2] }; };
 >x161 : Symbol(x161, Decl(generatedContextualTyping.ts, 165, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => { return function() { return [d1, d2] }; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 165, 33))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 165, 48))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x162: () => { (): Base[]; } = () => { return function named() { return [d1, d2] }; };
 >x162 : Symbol(x162, Decl(generatedContextualTyping.ts, 166, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => { return function named() { return [d1, d2] }; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 166, 33))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 166, 48))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 166, 48))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1450,7 +1298,6 @@ var x162: () => { (): Base[]; } = () => { return function named() { return [d1,
 var x163: () => Base[] = () => { return [d1, d2]; };
 >x163 : Symbol(x163, Decl(generatedContextualTyping.ts, 167, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 167, 24))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1458,7 +1305,6 @@ var x164: () => Array<Base> = () => { return [d1, d2]; };
 >x164 : Symbol(x164, Decl(generatedContextualTyping.ts, 168, 3))
 >Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 168, 29))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1466,7 +1312,6 @@ var x165: () => { [n: number]: Base; } = () => { return [d1, d2]; };
 >x165 : Symbol(x165, Decl(generatedContextualTyping.ts, 169, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 169, 19))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 169, 40))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1474,8 +1319,6 @@ var x166: () => {n: Base[]; }  = () => { return { n: [d1, d2] }; };
 >x166 : Symbol(x166, Decl(generatedContextualTyping.ts, 170, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 170, 17))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => { return { n: [d1, d2] }; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 170, 32))
->{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 170, 47))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 170, 49))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1484,8 +1327,6 @@ var x167: () => (s: Base[]) => any = () => { return n => { var n: Base[]; return
 >x167 : Symbol(x167, Decl(generatedContextualTyping.ts, 171, 3))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 171, 17))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => { return n => { var n: Base[]; return null; }; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 171, 36))
->n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 171, 51))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 171, 51), Decl(generatedContextualTyping.ts, 171, 62))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 171, 51), Decl(generatedContextualTyping.ts, 171, 62))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -1494,10 +1335,7 @@ var x168: () => Genric<Base> = () => { return { func: n => { return [d1, d2]; }
 >x168 : Symbol(x168, Decl(generatedContextualTyping.ts, 172, 3))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => { return { func: n => { return [d1, d2]; } }; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 172, 30))
->{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 172, 45))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 172, 47))
->n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 172, 53))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 172, 53))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1505,24 +1343,18 @@ var x168: () => Genric<Base> = () => { return { func: n => { return [d1, d2]; }
 var x169: () => () => Base[] = function() { return () => [d1, d2]; };
 >x169 : Symbol(x169, Decl(generatedContextualTyping.ts, 173, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return () => [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 173, 30))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 173, 50))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x170: () => () => Base[] = function() { return function() { return [d1, d2] }; };
 >x170 : Symbol(x170, Decl(generatedContextualTyping.ts, 174, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return function() { return [d1, d2] }; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 174, 30))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 174, 50))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x171: () => () => Base[] = function() { return function named() { return [d1, d2] }; };
 >x171 : Symbol(x171, Decl(generatedContextualTyping.ts, 175, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return function named() { return [d1, d2] }; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 175, 30))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 175, 50))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 175, 50))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1530,24 +1362,18 @@ var x171: () => () => Base[] = function() { return function named() { return [d1
 var x172: () => { (): Base[]; } = function() { return () => [d1, d2]; };
 >x172 : Symbol(x172, Decl(generatedContextualTyping.ts, 176, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return () => [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 176, 33))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 176, 53))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x173: () => { (): Base[]; } = function() { return function() { return [d1, d2] }; };
 >x173 : Symbol(x173, Decl(generatedContextualTyping.ts, 177, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return function() { return [d1, d2] }; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 177, 33))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 177, 53))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x174: () => { (): Base[]; } = function() { return function named() { return [d1, d2] }; };
 >x174 : Symbol(x174, Decl(generatedContextualTyping.ts, 178, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return function named() { return [d1, d2] }; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 178, 33))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 178, 53))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 178, 53))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1555,7 +1381,6 @@ var x174: () => { (): Base[]; } = function() { return function named() { return
 var x175: () => Base[] = function() { return [d1, d2]; };
 >x175 : Symbol(x175, Decl(generatedContextualTyping.ts, 179, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 179, 24))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1563,7 +1388,6 @@ var x176: () => Array<Base> = function() { return [d1, d2]; };
 >x176 : Symbol(x176, Decl(generatedContextualTyping.ts, 180, 3))
 >Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 180, 29))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1571,7 +1395,6 @@ var x177: () => { [n: number]: Base; } = function() { return [d1, d2]; };
 >x177 : Symbol(x177, Decl(generatedContextualTyping.ts, 181, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 181, 19))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 181, 40))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1579,8 +1402,6 @@ var x178: () => {n: Base[]; }  = function() { return { n: [d1, d2] }; };
 >x178 : Symbol(x178, Decl(generatedContextualTyping.ts, 182, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 182, 17))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return { n: [d1, d2] }; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 182, 32))
->{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 182, 52))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 182, 54))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1589,8 +1410,6 @@ var x179: () => (s: Base[]) => any = function() { return n => { var n: Base[]; r
 >x179 : Symbol(x179, Decl(generatedContextualTyping.ts, 183, 3))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 183, 17))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return n => { var n: Base[]; return null; }; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 183, 36))
->n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 183, 56))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 183, 56), Decl(generatedContextualTyping.ts, 183, 67))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 183, 56), Decl(generatedContextualTyping.ts, 183, 67))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -1599,10 +1418,7 @@ var x180: () => Genric<Base> = function() { return { func: n => { return [d1, d2
 >x180 : Symbol(x180, Decl(generatedContextualTyping.ts, 184, 3))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return { func: n => { return [d1, d2]; } }; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 184, 30))
->{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 184, 50))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 184, 52))
->n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 184, 58))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 184, 58))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1611,7 +1427,6 @@ module x181 { var t: () => Base[] = () => [d1, d2]; }
 >x181 : Symbol(x181, Decl(generatedContextualTyping.ts, 184, 90))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 185, 17))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 185, 35))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1619,7 +1434,6 @@ module x182 { var t: () => Base[] = function() { return [d1, d2] }; }
 >x182 : Symbol(x182, Decl(generatedContextualTyping.ts, 185, 53))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 186, 17))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 186, 35))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1627,7 +1441,6 @@ module x183 { var t: () => Base[] = function named() { return [d1, d2] }; }
 >x183 : Symbol(x183, Decl(generatedContextualTyping.ts, 186, 69))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 187, 17))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 187, 35))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 187, 35))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1636,7 +1449,6 @@ module x184 { var t: { (): Base[]; } = () => [d1, d2]; }
 >x184 : Symbol(x184, Decl(generatedContextualTyping.ts, 187, 75))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 188, 17))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 188, 38))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1644,7 +1456,6 @@ module x185 { var t: { (): Base[]; } = function() { return [d1, d2] }; }
 >x185 : Symbol(x185, Decl(generatedContextualTyping.ts, 188, 56))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 189, 17))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 189, 38))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1652,7 +1463,6 @@ module x186 { var t: { (): Base[]; } = function named() { return [d1, d2] }; }
 >x186 : Symbol(x186, Decl(generatedContextualTyping.ts, 189, 72))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 190, 17))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 190, 38))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 190, 38))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1685,7 +1495,6 @@ module x190 { var t: {n: Base[]; }  = { n: [d1, d2] }; }
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 194, 17))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 194, 22))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 194, 37))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 194, 39))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1695,7 +1504,6 @@ module x191 { var t: (s: Base[]) => any = n => { var n: Base[]; return null; };
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 195, 17))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 195, 22))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 195, 41))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 195, 41), Decl(generatedContextualTyping.ts, 195, 52))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 195, 41), Decl(generatedContextualTyping.ts, 195, 52))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -1705,9 +1513,7 @@ module x192 { var t: Genric<Base> = { func: n => { return [d1, d2]; } }; }
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 196, 17))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 196, 35))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 196, 37))
->n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 196, 43))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 196, 43))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1716,7 +1522,6 @@ module x193 { export var t: () => Base[] = () => [d1, d2]; }
 >x193 : Symbol(x193, Decl(generatedContextualTyping.ts, 196, 74))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 197, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 197, 42))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1724,7 +1529,6 @@ module x194 { export var t: () => Base[] = function() { return [d1, d2] }; }
 >x194 : Symbol(x194, Decl(generatedContextualTyping.ts, 197, 60))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 198, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 198, 42))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1732,7 +1536,6 @@ module x195 { export var t: () => Base[] = function named() { return [d1, d2] };
 >x195 : Symbol(x195, Decl(generatedContextualTyping.ts, 198, 76))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 199, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 199, 42))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 199, 42))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1741,7 +1544,6 @@ module x196 { export var t: { (): Base[]; } = () => [d1, d2]; }
 >x196 : Symbol(x196, Decl(generatedContextualTyping.ts, 199, 82))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 200, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 200, 45))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1749,7 +1551,6 @@ module x197 { export var t: { (): Base[]; } = function() { return [d1, d2] }; }
 >x197 : Symbol(x197, Decl(generatedContextualTyping.ts, 200, 63))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 201, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 201, 45))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1757,7 +1558,6 @@ module x198 { export var t: { (): Base[]; } = function named() { return [d1, d2]
 >x198 : Symbol(x198, Decl(generatedContextualTyping.ts, 201, 79))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 202, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 202, 45))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 202, 45))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1790,7 +1590,6 @@ module x202 { export var t: {n: Base[]; }  = { n: [d1, d2] }; }
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 206, 24))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 206, 29))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 206, 44))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 206, 46))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1800,7 +1599,6 @@ module x203 { export var t: (s: Base[]) => any = n => { var n: Base[]; return nu
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 207, 24))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 207, 29))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 207, 48))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 207, 48), Decl(generatedContextualTyping.ts, 207, 59))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 207, 48), Decl(generatedContextualTyping.ts, 207, 59))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -1810,9 +1608,7 @@ module x204 { export var t: Genric<Base> = { func: n => { return [d1, d2]; } };
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 208, 24))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 208, 42))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 208, 44))
->n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 208, 50))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 208, 50))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1820,14 +1616,12 @@ module x204 { export var t: Genric<Base> = { func: n => { return [d1, d2]; } };
 var x206 = <() => Base[]>function() { return [d1, d2] };
 >x206 : Symbol(x206, Decl(generatedContextualTyping.ts, 209, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 209, 25))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x207 = <() => Base[]>function named() { return [d1, d2] };
 >x207 : Symbol(x207, Decl(generatedContextualTyping.ts, 210, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 210, 25))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 210, 25))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1835,14 +1629,12 @@ var x207 = <() => Base[]>function named() { return [d1, d2] };
 var x209 = <{ (): Base[]; }>function() { return [d1, d2] };
 >x209 : Symbol(x209, Decl(generatedContextualTyping.ts, 211, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 211, 28))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x210 = <{ (): Base[]; }>function named() { return [d1, d2] };
 >x210 : Symbol(x210, Decl(generatedContextualTyping.ts, 212, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 212, 28))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 212, 28))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1871,7 +1663,6 @@ var x214 = <{n: Base[]; } >{ n: [d1, d2] };
 >x214 : Symbol(x214, Decl(generatedContextualTyping.ts, 216, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 216, 13))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 216, 27))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 216, 28))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1880,9 +1671,7 @@ var x216 = <Genric<Base>>{ func: n => { return [d1, d2]; } };
 >x216 : Symbol(x216, Decl(generatedContextualTyping.ts, 217, 3))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 217, 25))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 217, 26))
->n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 217, 32))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 217, 32))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1891,7 +1680,6 @@ var x217 = (<() => Base[]>undefined) || function() { return [d1, d2] };
 >x217 : Symbol(x217, Decl(generatedContextualTyping.ts, 218, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 218, 39))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1899,7 +1687,6 @@ var x218 = (<() => Base[]>undefined) || function named() { return [d1, d2] };
 >x218 : Symbol(x218, Decl(generatedContextualTyping.ts, 219, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 219, 39))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 219, 39))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1908,7 +1695,6 @@ var x219 = (<{ (): Base[]; }>undefined) || function() { return [d1, d2] };
 >x219 : Symbol(x219, Decl(generatedContextualTyping.ts, 220, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 220, 42))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1916,7 +1702,6 @@ var x220 = (<{ (): Base[]; }>undefined) || function named() { return [d1, d2] };
 >x220 : Symbol(x220, Decl(generatedContextualTyping.ts, 221, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 221, 42))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 221, 42))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1949,7 +1734,6 @@ var x224 = (<{n: Base[]; } >undefined) || { n: [d1, d2] };
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 225, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 225, 41))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 225, 43))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1958,7 +1742,6 @@ var x225: () => Base[]; x225 = () => [d1, d2];
 >x225 : Symbol(x225, Decl(generatedContextualTyping.ts, 226, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x225 : Symbol(x225, Decl(generatedContextualTyping.ts, 226, 3))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 226, 30))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1966,7 +1749,6 @@ var x226: () => Base[]; x226 = function() { return [d1, d2] };
 >x226 : Symbol(x226, Decl(generatedContextualTyping.ts, 227, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x226 : Symbol(x226, Decl(generatedContextualTyping.ts, 227, 3))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 227, 30))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1974,7 +1756,6 @@ var x227: () => Base[]; x227 = function named() { return [d1, d2] };
 >x227 : Symbol(x227, Decl(generatedContextualTyping.ts, 228, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x227 : Symbol(x227, Decl(generatedContextualTyping.ts, 228, 3))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 228, 30))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 228, 30))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1983,7 +1764,6 @@ var x228: { (): Base[]; }; x228 = () => [d1, d2];
 >x228 : Symbol(x228, Decl(generatedContextualTyping.ts, 229, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x228 : Symbol(x228, Decl(generatedContextualTyping.ts, 229, 3))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 229, 33))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1991,7 +1771,6 @@ var x229: { (): Base[]; }; x229 = function() { return [d1, d2] };
 >x229 : Symbol(x229, Decl(generatedContextualTyping.ts, 230, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x229 : Symbol(x229, Decl(generatedContextualTyping.ts, 230, 3))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 230, 33))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -1999,7 +1778,6 @@ var x230: { (): Base[]; }; x230 = function named() { return [d1, d2] };
 >x230 : Symbol(x230, Decl(generatedContextualTyping.ts, 231, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x230 : Symbol(x230, Decl(generatedContextualTyping.ts, 231, 3))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 231, 33))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 231, 33))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2032,7 +1810,6 @@ var x234: {n: Base[]; } ; x234 = { n: [d1, d2] };
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 235, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x234 : Symbol(x234, Decl(generatedContextualTyping.ts, 235, 3))
->{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 235, 32))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 235, 34))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2042,7 +1819,6 @@ var x235: (s: Base[]) => any; x235 = n => { var n: Base[]; return null; };
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 236, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x235 : Symbol(x235, Decl(generatedContextualTyping.ts, 236, 3))
->n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 236, 36))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 236, 36), Decl(generatedContextualTyping.ts, 236, 47))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 236, 36), Decl(generatedContextualTyping.ts, 236, 47))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -2052,9 +1828,7 @@ var x236: Genric<Base>; x236 = { func: n => { return [d1, d2]; } };
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x236 : Symbol(x236, Decl(generatedContextualTyping.ts, 237, 3))
->{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 237, 30))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 237, 32))
->n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 237, 38))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 237, 38))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2063,9 +1837,7 @@ var x237: { n: () => Base[]; } = { n: () => [d1, d2] };
 >x237 : Symbol(x237, Decl(generatedContextualTyping.ts, 238, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 238, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ n: () => [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 238, 32))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 238, 34))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 238, 37))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -2073,9 +1845,7 @@ var x238: { n: () => Base[]; } = { n: function() { return [d1, d2] } };
 >x238 : Symbol(x238, Decl(generatedContextualTyping.ts, 239, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 239, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ n: function() { return [d1, d2] } } : Symbol(, Decl(generatedContextualTyping.ts, 239, 32))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 239, 34))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 239, 37))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -2083,9 +1853,7 @@ var x239: { n: () => Base[]; } = { n: function named() { return [d1, d2] } };
 >x239 : Symbol(x239, Decl(generatedContextualTyping.ts, 240, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 240, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ n: function named() { return [d1, d2] } } : Symbol(, Decl(generatedContextualTyping.ts, 240, 32))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 240, 34))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 240, 37))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 240, 37))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2094,9 +1862,7 @@ var x240: { n: { (): Base[]; }; } = { n: () => [d1, d2] };
 >x240 : Symbol(x240, Decl(generatedContextualTyping.ts, 241, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 241, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ n: () => [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 241, 35))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 241, 37))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 241, 40))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -2104,9 +1870,7 @@ var x241: { n: { (): Base[]; }; } = { n: function() { return [d1, d2] } };
 >x241 : Symbol(x241, Decl(generatedContextualTyping.ts, 242, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 242, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ n: function() { return [d1, d2] } } : Symbol(, Decl(generatedContextualTyping.ts, 242, 35))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 242, 37))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 242, 40))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -2114,9 +1878,7 @@ var x242: { n: { (): Base[]; }; } = { n: function named() { return [d1, d2] } };
 >x242 : Symbol(x242, Decl(generatedContextualTyping.ts, 243, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 243, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ n: function named() { return [d1, d2] } } : Symbol(, Decl(generatedContextualTyping.ts, 243, 35))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 243, 37))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 243, 40))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 243, 40))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2125,7 +1887,6 @@ var x243: { n: Base[]; } = { n: [d1, d2] };
 >x243 : Symbol(x243, Decl(generatedContextualTyping.ts, 244, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 244, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 244, 26))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 244, 28))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2135,7 +1896,6 @@ var x244: { n: Array<Base>; } = { n: [d1, d2] };
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 245, 11))
 >Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 245, 31))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 245, 33))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2145,7 +1905,6 @@ var x245: { n: { [n: number]: Base; }; } = { n: [d1, d2] };
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 246, 11))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 246, 18))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 246, 42))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 246, 44))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2155,9 +1914,7 @@ var x246: { n: {n: Base[]; } ; } = { n: { n: [d1, d2] } };
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 11))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 16))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ n: { n: [d1, d2] } } : Symbol(, Decl(generatedContextualTyping.ts, 247, 34))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 36))
->{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 247, 39))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 41))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2167,9 +1924,7 @@ var x247: { n: (s: Base[]) => any; } = { n: n => { var n: Base[]; return null; }
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 11))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 248, 16))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ n: n => { var n: Base[]; return null; } } : Symbol(, Decl(generatedContextualTyping.ts, 248, 38))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 40))
->n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 248, 43))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 43), Decl(generatedContextualTyping.ts, 248, 54))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 43), Decl(generatedContextualTyping.ts, 248, 54))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -2179,11 +1934,8 @@ var x248: { n: Genric<Base>; } = { n: { func: n => { return [d1, d2]; } } };
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 11))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ n: { func: n => { return [d1, d2]; } } } : Symbol(, Decl(generatedContextualTyping.ts, 249, 32))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 34))
->{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 249, 37))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 249, 39))
->n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 249, 45))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 45))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2191,21 +1943,18 @@ var x248: { n: Genric<Base>; } = { n: { func: n => { return [d1, d2]; } } };
 var x252: { (): Base[]; }[] = [() => [d1, d2]];
 >x252 : Symbol(x252, Decl(generatedContextualTyping.ts, 250, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 250, 31))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x253: { (): Base[]; }[] = [function() { return [d1, d2] }];
 >x253 : Symbol(x253, Decl(generatedContextualTyping.ts, 251, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 251, 31))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x254: { (): Base[]; }[] = [function named() { return [d1, d2] }];
 >x254 : Symbol(x254, Decl(generatedContextualTyping.ts, 252, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 252, 31))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 252, 31))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2234,7 +1983,6 @@ var x258: {n: Base[]; } [] = [{ n: [d1, d2] }];
 >x258 : Symbol(x258, Decl(generatedContextualTyping.ts, 256, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 256, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 256, 30))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 256, 31))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2243,9 +1991,7 @@ var x260: Genric<Base>[] = [{ func: n => { return [d1, d2]; } }];
 >x260 : Symbol(x260, Decl(generatedContextualTyping.ts, 257, 3))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 257, 28))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 257, 29))
->n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 257, 35))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 257, 35))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2253,7 +1999,6 @@ var x260: Genric<Base>[] = [{ func: n => { return [d1, d2]; } }];
 var x261: () => Base[] = function() { return [d1, d2] } || undefined;
 >x261 : Symbol(x261, Decl(generatedContextualTyping.ts, 258, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 258, 24))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 >undefined : Symbol(undefined)
@@ -2261,7 +2006,6 @@ var x261: () => Base[] = function() { return [d1, d2] } || undefined;
 var x262: () => Base[] = function named() { return [d1, d2] } || undefined;
 >x262 : Symbol(x262, Decl(generatedContextualTyping.ts, 259, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 259, 24))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 259, 24))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2270,7 +2014,6 @@ var x262: () => Base[] = function named() { return [d1, d2] } || undefined;
 var x263: { (): Base[]; } = function() { return [d1, d2] } || undefined;
 >x263 : Symbol(x263, Decl(generatedContextualTyping.ts, 260, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 260, 27))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 >undefined : Symbol(undefined)
@@ -2278,7 +2021,6 @@ var x263: { (): Base[]; } = function() { return [d1, d2] } || undefined;
 var x264: { (): Base[]; } = function named() { return [d1, d2] } || undefined;
 >x264 : Symbol(x264, Decl(generatedContextualTyping.ts, 261, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 261, 27))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 261, 27))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2311,7 +2053,6 @@ var x268: {n: Base[]; }  = { n: [d1, d2] } || undefined;
 >x268 : Symbol(x268, Decl(generatedContextualTyping.ts, 265, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 265, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 265, 26))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 265, 28))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2321,7 +2062,6 @@ var x269: () => Base[] = undefined || function() { return [d1, d2] };
 >x269 : Symbol(x269, Decl(generatedContextualTyping.ts, 266, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 266, 37))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -2329,7 +2069,6 @@ var x270: () => Base[] = undefined || function named() { return [d1, d2] };
 >x270 : Symbol(x270, Decl(generatedContextualTyping.ts, 267, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 267, 37))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 267, 37))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2338,7 +2077,6 @@ var x271: { (): Base[]; } = undefined || function() { return [d1, d2] };
 >x271 : Symbol(x271, Decl(generatedContextualTyping.ts, 268, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 268, 40))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -2346,7 +2084,6 @@ var x272: { (): Base[]; } = undefined || function named() { return [d1, d2] };
 >x272 : Symbol(x272, Decl(generatedContextualTyping.ts, 269, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 269, 40))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 269, 40))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2379,7 +2116,6 @@ var x276: {n: Base[]; }  = undefined || { n: [d1, d2] };
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 273, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 273, 39))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 273, 41))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2387,21 +2123,17 @@ var x276: {n: Base[]; }  = undefined || { n: [d1, d2] };
 var x277: () => Base[] = function() { return [d1, d2] } || function() { return [d1, d2] };
 >x277 : Symbol(x277, Decl(generatedContextualTyping.ts, 274, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 274, 24))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 274, 58))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x278: () => Base[] = function named() { return [d1, d2] } || function named() { return [d1, d2] };
 >x278 : Symbol(x278, Decl(generatedContextualTyping.ts, 275, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 275, 24))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 275, 24))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 275, 64))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 275, 64))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2409,21 +2141,17 @@ var x278: () => Base[] = function named() { return [d1, d2] } || function named(
 var x279: { (): Base[]; } = function() { return [d1, d2] } || function() { return [d1, d2] };
 >x279 : Symbol(x279, Decl(generatedContextualTyping.ts, 276, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 276, 27))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 276, 61))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x280: { (): Base[]; } = function named() { return [d1, d2] } || function named() { return [d1, d2] };
 >x280 : Symbol(x280, Decl(generatedContextualTyping.ts, 277, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 277, 27))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 277, 27))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 277, 67))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 277, 67))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2458,11 +2186,9 @@ var x284: {n: Base[]; }  = { n: [d1, d2] } || { n: [d1, d2] };
 >x284 : Symbol(x284, Decl(generatedContextualTyping.ts, 281, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 281, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 281, 26))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 281, 28))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 281, 45))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 281, 47))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2470,31 +2196,25 @@ var x284: {n: Base[]; }  = { n: [d1, d2] } || { n: [d1, d2] };
 var x285: () => Base[] = true ? () => [d1, d2] : () => [d1, d2];
 >x285 : Symbol(x285, Decl(generatedContextualTyping.ts, 282, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 282, 31))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 282, 48))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x286: () => Base[] = true ? function() { return [d1, d2] } : function() { return [d1, d2] };
 >x286 : Symbol(x286, Decl(generatedContextualTyping.ts, 283, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 283, 31))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 283, 64))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x287: () => Base[] = true ? function named() { return [d1, d2] } : function named() { return [d1, d2] };
 >x287 : Symbol(x287, Decl(generatedContextualTyping.ts, 284, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 284, 31))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 284, 31))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 284, 70))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 284, 70))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2502,31 +2222,25 @@ var x287: () => Base[] = true ? function named() { return [d1, d2] } : function
 var x288: { (): Base[]; } = true ? () => [d1, d2] : () => [d1, d2];
 >x288 : Symbol(x288, Decl(generatedContextualTyping.ts, 285, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 285, 34))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 285, 51))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x289: { (): Base[]; } = true ? function() { return [d1, d2] } : function() { return [d1, d2] };
 >x289 : Symbol(x289, Decl(generatedContextualTyping.ts, 286, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 286, 34))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 286, 67))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x290: { (): Base[]; } = true ? function named() { return [d1, d2] } : function named() { return [d1, d2] };
 >x290 : Symbol(x290, Decl(generatedContextualTyping.ts, 287, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 287, 34))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 287, 34))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 287, 73))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 287, 73))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2561,11 +2275,9 @@ var x294: {n: Base[]; }  = true ? { n: [d1, d2] } : { n: [d1, d2] };
 >x294 : Symbol(x294, Decl(generatedContextualTyping.ts, 291, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 291, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 291, 33))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 291, 35))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 291, 51))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 291, 53))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2574,11 +2286,9 @@ var x295: (s: Base[]) => any = true ? n => { var n: Base[]; return null; } : n =
 >x295 : Symbol(x295, Decl(generatedContextualTyping.ts, 292, 3))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 292, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 292, 37))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 37), Decl(generatedContextualTyping.ts, 292, 48))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 37), Decl(generatedContextualTyping.ts, 292, 48))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 292, 76))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 76), Decl(generatedContextualTyping.ts, 292, 87))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 76), Decl(generatedContextualTyping.ts, 292, 87))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -2587,15 +2297,11 @@ var x296: Genric<Base> = true ? { func: n => { return [d1, d2]; } } : { func: n
 >x296 : Symbol(x296, Decl(generatedContextualTyping.ts, 293, 3))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 293, 31))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 293, 33))
->n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 293, 39))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 293, 39))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 293, 69))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 293, 71))
->n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 293, 77))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 293, 77))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2604,7 +2310,6 @@ var x297: () => Base[] = true ? undefined : () => [d1, d2];
 >x297 : Symbol(x297, Decl(generatedContextualTyping.ts, 294, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 294, 43))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -2612,7 +2317,6 @@ var x298: () => Base[] = true ? undefined : function() { return [d1, d2] };
 >x298 : Symbol(x298, Decl(generatedContextualTyping.ts, 295, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 295, 43))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -2620,7 +2324,6 @@ var x299: () => Base[] = true ? undefined : function named() { return [d1, d2] }
 >x299 : Symbol(x299, Decl(generatedContextualTyping.ts, 296, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 296, 43))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 296, 43))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2629,7 +2332,6 @@ var x300: { (): Base[]; } = true ? undefined : () => [d1, d2];
 >x300 : Symbol(x300, Decl(generatedContextualTyping.ts, 297, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 297, 46))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -2637,7 +2339,6 @@ var x301: { (): Base[]; } = true ? undefined : function() { return [d1, d2] };
 >x301 : Symbol(x301, Decl(generatedContextualTyping.ts, 298, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 298, 46))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -2645,7 +2346,6 @@ var x302: { (): Base[]; } = true ? undefined : function named() { return [d1, d2
 >x302 : Symbol(x302, Decl(generatedContextualTyping.ts, 299, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 299, 46))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 299, 46))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2678,7 +2378,6 @@ var x306: {n: Base[]; }  = true ? undefined : { n: [d1, d2] };
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 303, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 303, 45))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 303, 47))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2688,7 +2387,6 @@ var x307: (s: Base[]) => any = true ? undefined : n => { var n: Base[]; return n
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 304, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 304, 49))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 304, 49), Decl(generatedContextualTyping.ts, 304, 60))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 304, 49), Decl(generatedContextualTyping.ts, 304, 60))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -2698,9 +2396,7 @@ var x308: Genric<Base> = true ? undefined : { func: n => { return [d1, d2]; } };
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 305, 43))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 305, 45))
->n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 305, 51))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 305, 51))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2708,7 +2404,6 @@ var x308: Genric<Base> = true ? undefined : { func: n => { return [d1, d2]; } };
 var x309: () => Base[] = true ? () => [d1, d2] : undefined;
 >x309 : Symbol(x309, Decl(generatedContextualTyping.ts, 306, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 306, 31))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 >undefined : Symbol(undefined)
@@ -2716,7 +2411,6 @@ var x309: () => Base[] = true ? () => [d1, d2] : undefined;
 var x310: () => Base[] = true ? function() { return [d1, d2] } : undefined;
 >x310 : Symbol(x310, Decl(generatedContextualTyping.ts, 307, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 307, 31))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 >undefined : Symbol(undefined)
@@ -2724,7 +2418,6 @@ var x310: () => Base[] = true ? function() { return [d1, d2] } : undefined;
 var x311: () => Base[] = true ? function named() { return [d1, d2] } : undefined;
 >x311 : Symbol(x311, Decl(generatedContextualTyping.ts, 308, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 308, 31))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 308, 31))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2733,7 +2426,6 @@ var x311: () => Base[] = true ? function named() { return [d1, d2] } : undefined
 var x312: { (): Base[]; } = true ? () => [d1, d2] : undefined;
 >x312 : Symbol(x312, Decl(generatedContextualTyping.ts, 309, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 309, 34))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 >undefined : Symbol(undefined)
@@ -2741,7 +2433,6 @@ var x312: { (): Base[]; } = true ? () => [d1, d2] : undefined;
 var x313: { (): Base[]; } = true ? function() { return [d1, d2] } : undefined;
 >x313 : Symbol(x313, Decl(generatedContextualTyping.ts, 310, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 310, 34))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 >undefined : Symbol(undefined)
@@ -2749,7 +2440,6 @@ var x313: { (): Base[]; } = true ? function() { return [d1, d2] } : undefined;
 var x314: { (): Base[]; } = true ? function named() { return [d1, d2] } : undefined;
 >x314 : Symbol(x314, Decl(generatedContextualTyping.ts, 311, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 311, 34))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 311, 34))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2782,7 +2472,6 @@ var x318: {n: Base[]; }  = true ? { n: [d1, d2] } : undefined;
 >x318 : Symbol(x318, Decl(generatedContextualTyping.ts, 315, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 315, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 315, 33))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 315, 35))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2792,7 +2481,6 @@ var x319: (s: Base[]) => any = true ? n => { var n: Base[]; return null; } : und
 >x319 : Symbol(x319, Decl(generatedContextualTyping.ts, 316, 3))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 316, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 316, 37))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 316, 37), Decl(generatedContextualTyping.ts, 316, 48))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 316, 37), Decl(generatedContextualTyping.ts, 316, 48))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -2802,9 +2490,7 @@ var x320: Genric<Base> = true ? { func: n => { return [d1, d2]; } } : undefined;
 >x320 : Symbol(x320, Decl(generatedContextualTyping.ts, 317, 3))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 317, 31))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 317, 33))
->n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 317, 39))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 317, 39))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2815,7 +2501,6 @@ function x321(n: () => Base[]) { }; x321(() => [d1, d2]);
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 318, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x321 : Symbol(x321, Decl(generatedContextualTyping.ts, 317, 80))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 318, 41))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -2824,7 +2509,6 @@ function x322(n: () => Base[]) { }; x322(function() { return [d1, d2] });
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 319, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x322 : Symbol(x322, Decl(generatedContextualTyping.ts, 318, 57))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 319, 41))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -2833,7 +2517,6 @@ function x323(n: () => Base[]) { }; x323(function named() { return [d1, d2] });
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 320, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x323 : Symbol(x323, Decl(generatedContextualTyping.ts, 319, 73))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 320, 41))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 320, 41))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2843,7 +2526,6 @@ function x324(n: { (): Base[]; }) { }; x324(() => [d1, d2]);
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 321, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x324 : Symbol(x324, Decl(generatedContextualTyping.ts, 320, 79))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 321, 44))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -2852,7 +2534,6 @@ function x325(n: { (): Base[]; }) { }; x325(function() { return [d1, d2] });
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 322, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x325 : Symbol(x325, Decl(generatedContextualTyping.ts, 321, 60))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 322, 44))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
@@ -2861,7 +2542,6 @@ function x326(n: { (): Base[]; }) { }; x326(function named() { return [d1, d2] }
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 323, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x326 : Symbol(x326, Decl(generatedContextualTyping.ts, 322, 76))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 323, 44))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 323, 44))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2898,7 +2578,6 @@ function x330(n: {n: Base[]; } ) { }; x330({ n: [d1, d2] });
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 327, 18))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x330 : Symbol(x330, Decl(generatedContextualTyping.ts, 326, 61))
->{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 327, 43))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 327, 44))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2909,7 +2588,6 @@ function x331(n: (s: Base[]) => any) { }; x331(n => { var n: Base[]; return null
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 328, 18))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x331 : Symbol(x331, Decl(generatedContextualTyping.ts, 327, 60))
->n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 328, 47))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 328, 47), Decl(generatedContextualTyping.ts, 328, 57))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 328, 47), Decl(generatedContextualTyping.ts, 328, 57))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -2920,84 +2598,69 @@ function x332(n: Genric<Base>) { }; x332({ func: n => { return [d1, d2]; } });
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x332 : Symbol(x332, Decl(generatedContextualTyping.ts, 328, 85))
->{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 329, 41))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 329, 42))
->n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 329, 48))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 329, 48))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x333 = (n: () => Base[]) => n; x333(() => [d1, d2]);
 >x333 : Symbol(x333, Decl(generatedContextualTyping.ts, 330, 3))
->(n: () => Base[]) => n : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 330, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 330, 12))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 330, 12))
 >x333 : Symbol(x333, Decl(generatedContextualTyping.ts, 330, 3))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 330, 40))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x334 = (n: () => Base[]) => n; x334(function() { return [d1, d2] });
 >x334 : Symbol(x334, Decl(generatedContextualTyping.ts, 331, 3))
->(n: () => Base[]) => n : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 331, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 331, 12))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 331, 12))
 >x334 : Symbol(x334, Decl(generatedContextualTyping.ts, 331, 3))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 331, 40))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x335 = (n: () => Base[]) => n; x335(function named() { return [d1, d2] });
 >x335 : Symbol(x335, Decl(generatedContextualTyping.ts, 332, 3))
->(n: () => Base[]) => n : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 332, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 332, 12))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 332, 12))
 >x335 : Symbol(x335, Decl(generatedContextualTyping.ts, 332, 3))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 332, 40))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 332, 40))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x336 = (n: { (): Base[]; }) => n; x336(() => [d1, d2]);
 >x336 : Symbol(x336, Decl(generatedContextualTyping.ts, 333, 3))
->(n: { (): Base[]; }) => n : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 333, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 333, 12))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 333, 12))
 >x336 : Symbol(x336, Decl(generatedContextualTyping.ts, 333, 3))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 333, 43))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x337 = (n: { (): Base[]; }) => n; x337(function() { return [d1, d2] });
 >x337 : Symbol(x337, Decl(generatedContextualTyping.ts, 334, 3))
->(n: { (): Base[]; }) => n : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 334, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 334, 12))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 334, 12))
 >x337 : Symbol(x337, Decl(generatedContextualTyping.ts, 334, 3))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 334, 43))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x338 = (n: { (): Base[]; }) => n; x338(function named() { return [d1, d2] });
 >x338 : Symbol(x338, Decl(generatedContextualTyping.ts, 335, 3))
->(n: { (): Base[]; }) => n : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 335, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 335, 12))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 335, 12))
 >x338 : Symbol(x338, Decl(generatedContextualTyping.ts, 335, 3))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 335, 43))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 335, 43))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x339 = (n: Base[]) => n; x339([d1, d2]);
 >x339 : Symbol(x339, Decl(generatedContextualTyping.ts, 336, 3))
->(n: Base[]) => n : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 336, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 336, 12))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 336, 12))
@@ -3007,7 +2670,6 @@ var x339 = (n: Base[]) => n; x339([d1, d2]);
 
 var x340 = (n: Array<Base>) => n; x340([d1, d2]);
 >x340 : Symbol(x340, Decl(generatedContextualTyping.ts, 337, 3))
->(n: Array<Base>) => n : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 337, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 337, 12))
 >Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -3018,7 +2680,6 @@ var x340 = (n: Array<Base>) => n; x340([d1, d2]);
 
 var x341 = (n: { [n: number]: Base; }) => n; x341([d1, d2]);
 >x341 : Symbol(x341, Decl(generatedContextualTyping.ts, 338, 3))
->(n: { [n: number]: Base; }) => n : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 338, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 338, 12))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 338, 18))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -3029,110 +2690,90 @@ var x341 = (n: { [n: number]: Base; }) => n; x341([d1, d2]);
 
 var x342 = (n: {n: Base[]; } ) => n; x342({ n: [d1, d2] });
 >x342 : Symbol(x342, Decl(generatedContextualTyping.ts, 339, 3))
->(n: {n: Base[]; } ) => n : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 339, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 339, 12))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 339, 16))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 339, 12))
 >x342 : Symbol(x342, Decl(generatedContextualTyping.ts, 339, 3))
->{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 339, 42))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 339, 43))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x343 = (n: (s: Base[]) => any) => n; x343(n => { var n: Base[]; return null; });
 >x343 : Symbol(x343, Decl(generatedContextualTyping.ts, 340, 3))
->(n: (s: Base[]) => any) => n : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 340, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 12))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 340, 16))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 12))
 >x343 : Symbol(x343, Decl(generatedContextualTyping.ts, 340, 3))
->n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 340, 46))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 46), Decl(generatedContextualTyping.ts, 340, 56))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 46), Decl(generatedContextualTyping.ts, 340, 56))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 
 var x344 = (n: Genric<Base>) => n; x344({ func: n => { return [d1, d2]; } });
 >x344 : Symbol(x344, Decl(generatedContextualTyping.ts, 341, 3))
->(n: Genric<Base>) => n : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 341, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 341, 12))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 341, 12))
 >x344 : Symbol(x344, Decl(generatedContextualTyping.ts, 341, 3))
->{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 341, 40))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 341, 41))
->n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 341, 47))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 341, 47))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x345 = function(n: () => Base[]) { }; x345(() => [d1, d2]);
 >x345 : Symbol(x345, Decl(generatedContextualTyping.ts, 342, 3))
->function(n: () => Base[]) { } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 342, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 342, 20))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x345 : Symbol(x345, Decl(generatedContextualTyping.ts, 342, 3))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 342, 47))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x346 = function(n: () => Base[]) { }; x346(function() { return [d1, d2] });
 >x346 : Symbol(x346, Decl(generatedContextualTyping.ts, 343, 3))
->function(n: () => Base[]) { } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 343, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 343, 20))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x346 : Symbol(x346, Decl(generatedContextualTyping.ts, 343, 3))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 343, 47))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x347 = function(n: () => Base[]) { }; x347(function named() { return [d1, d2] });
 >x347 : Symbol(x347, Decl(generatedContextualTyping.ts, 344, 3))
->function(n: () => Base[]) { } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 344, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 344, 20))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x347 : Symbol(x347, Decl(generatedContextualTyping.ts, 344, 3))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 344, 47))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 344, 47))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x348 = function(n: { (): Base[]; }) { }; x348(() => [d1, d2]);
 >x348 : Symbol(x348, Decl(generatedContextualTyping.ts, 345, 3))
->function(n: { (): Base[]; }) { } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 345, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 345, 20))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x348 : Symbol(x348, Decl(generatedContextualTyping.ts, 345, 3))
->() => [d1, d2] : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 345, 50))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x349 = function(n: { (): Base[]; }) { }; x349(function() { return [d1, d2] });
 >x349 : Symbol(x349, Decl(generatedContextualTyping.ts, 346, 3))
->function(n: { (): Base[]; }) { } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 346, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 346, 20))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x349 : Symbol(x349, Decl(generatedContextualTyping.ts, 346, 3))
->function() { return [d1, d2] } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 346, 50))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x350 = function(n: { (): Base[]; }) { }; x350(function named() { return [d1, d2] });
 >x350 : Symbol(x350, Decl(generatedContextualTyping.ts, 347, 3))
->function(n: { (): Base[]; }) { } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 347, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 347, 20))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x350 : Symbol(x350, Decl(generatedContextualTyping.ts, 347, 3))
->function named() { return [d1, d2] } : Symbol(named, Decl(generatedContextualTyping.ts, 347, 50))
 >named : Symbol(named, Decl(generatedContextualTyping.ts, 347, 50))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x351 = function(n: Base[]) { }; x351([d1, d2]);
 >x351 : Symbol(x351, Decl(generatedContextualTyping.ts, 348, 3))
->function(n: Base[]) { } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 348, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 348, 20))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x351 : Symbol(x351, Decl(generatedContextualTyping.ts, 348, 3))
@@ -3141,7 +2782,6 @@ var x351 = function(n: Base[]) { }; x351([d1, d2]);
 
 var x352 = function(n: Array<Base>) { }; x352([d1, d2]);
 >x352 : Symbol(x352, Decl(generatedContextualTyping.ts, 349, 3))
->function(n: Array<Base>) { } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 349, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 349, 20))
 >Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -3151,7 +2791,6 @@ var x352 = function(n: Array<Base>) { }; x352([d1, d2]);
 
 var x353 = function(n: { [n: number]: Base; }) { }; x353([d1, d2]);
 >x353 : Symbol(x353, Decl(generatedContextualTyping.ts, 350, 3))
->function(n: { [n: number]: Base; }) { } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 350, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 350, 20))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 350, 26))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
@@ -3161,38 +2800,31 @@ var x353 = function(n: { [n: number]: Base; }) { }; x353([d1, d2]);
 
 var x354 = function(n: {n: Base[]; } ) { }; x354({ n: [d1, d2] });
 >x354 : Symbol(x354, Decl(generatedContextualTyping.ts, 351, 3))
->function(n: {n: Base[]; } ) { } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 351, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 351, 20))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 351, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x354 : Symbol(x354, Decl(generatedContextualTyping.ts, 351, 3))
->{ n: [d1, d2] } : Symbol(, Decl(generatedContextualTyping.ts, 351, 49))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 351, 50))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
 
 var x355 = function(n: (s: Base[]) => any) { }; x355(n => { var n: Base[]; return null; });
 >x355 : Symbol(x355, Decl(generatedContextualTyping.ts, 352, 3))
->function(n: (s: Base[]) => any) { } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 352, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 352, 20))
 >s : Symbol(s, Decl(generatedContextualTyping.ts, 352, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x355 : Symbol(x355, Decl(generatedContextualTyping.ts, 352, 3))
->n => { var n: Base[]; return null; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 352, 53))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 352, 53), Decl(generatedContextualTyping.ts, 352, 63))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 352, 53), Decl(generatedContextualTyping.ts, 352, 63))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 
 var x356 = function(n: Genric<Base>) { }; x356({ func: n => { return [d1, d2]; } });
 >x356 : Symbol(x356, Decl(generatedContextualTyping.ts, 353, 3))
->function(n: Genric<Base>) { } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 353, 10))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 353, 20))
 >Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x356 : Symbol(x356, Decl(generatedContextualTyping.ts, 353, 3))
->{ func: n => { return [d1, d2]; } } : Symbol(, Decl(generatedContextualTyping.ts, 353, 47))
 >func : Symbol(func, Decl(generatedContextualTyping.ts, 353, 48))
->n => { return [d1, d2]; } : Symbol((Anonymous function), Decl(generatedContextualTyping.ts, 353, 54))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 353, 54))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
diff --git a/tests/baselines/reference/generatorES6_3.symbols b/tests/baselines/reference/generatorES6_3.symbols
index 0f14389a1559e..329c96e6de8ec 100644
--- a/tests/baselines/reference/generatorES6_3.symbols
+++ b/tests/baselines/reference/generatorES6_3.symbols
@@ -1,7 +1,6 @@
 === tests/cases/compiler/generatorES6_3.ts ===
 var v = function*() {
 >v : Symbol(v, Decl(generatorES6_3.ts, 0, 3))
->function*() {    yield 0} : Symbol((Anonymous function), Decl(generatorES6_3.ts, 0, 7))
 
     yield 0
 }
diff --git a/tests/baselines/reference/generatorES6_4.symbols b/tests/baselines/reference/generatorES6_4.symbols
index 4e6bd9bb40068..fc514dad45f1e 100644
--- a/tests/baselines/reference/generatorES6_4.symbols
+++ b/tests/baselines/reference/generatorES6_4.symbols
@@ -1,7 +1,6 @@
 === tests/cases/compiler/generatorES6_4.ts ===
 var v = { 
 >v : Symbol(v, Decl(generatorES6_4.ts, 0, 3))
->{    *foo() {       yield 0   }} : Symbol(, Decl(generatorES6_4.ts, 0, 7))
 
    *foo() {
 >foo : Symbol(foo, Decl(generatorES6_4.ts, 0, 9))
diff --git a/tests/baselines/reference/generatorTypeCheck26.symbols b/tests/baselines/reference/generatorTypeCheck26.symbols
index fd9252086dc3a..08cc7289ef872 100644
--- a/tests/baselines/reference/generatorTypeCheck26.symbols
+++ b/tests/baselines/reference/generatorTypeCheck26.symbols
@@ -5,21 +5,18 @@ function* g(): IterableIterator<(x: string) => number> {
 >x : Symbol(x, Decl(generatorTypeCheck26.ts, 0, 33))
 
     yield x => x.length;
->x => x.length : Symbol((Anonymous function), Decl(generatorTypeCheck26.ts, 1, 9))
 >x : Symbol(x, Decl(generatorTypeCheck26.ts, 1, 9))
 >x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >x : Symbol(x, Decl(generatorTypeCheck26.ts, 1, 9))
 >length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 
     yield *[x => x.length];
->x => x.length : Symbol((Anonymous function), Decl(generatorTypeCheck26.ts, 2, 12))
 >x : Symbol(x, Decl(generatorTypeCheck26.ts, 2, 12))
 >x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >x : Symbol(x, Decl(generatorTypeCheck26.ts, 2, 12))
 >length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 
     return x => x.length;
->x => x.length : Symbol((Anonymous function), Decl(generatorTypeCheck26.ts, 3, 10))
 >x : Symbol(x, Decl(generatorTypeCheck26.ts, 3, 10))
 >x : Symbol(x, Decl(generatorTypeCheck26.ts, 3, 10))
 }
diff --git a/tests/baselines/reference/generatorTypeCheck27.symbols b/tests/baselines/reference/generatorTypeCheck27.symbols
index 2df08fdf91b38..fcee922d1e909 100644
--- a/tests/baselines/reference/generatorTypeCheck27.symbols
+++ b/tests/baselines/reference/generatorTypeCheck27.symbols
@@ -5,10 +5,7 @@ function* g(): IterableIterator<(x: string) => number> {
 >x : Symbol(x, Decl(generatorTypeCheck27.ts, 0, 33))
 
     yield * function* () {
->function* () {        yield x => x.length;    } : Symbol((Anonymous function), Decl(generatorTypeCheck27.ts, 1, 11))
-
         yield x => x.length;
->x => x.length : Symbol((Anonymous function), Decl(generatorTypeCheck27.ts, 2, 13))
 >x : Symbol(x, Decl(generatorTypeCheck27.ts, 2, 13))
 >x : Symbol(x, Decl(generatorTypeCheck27.ts, 2, 13))
 
diff --git a/tests/baselines/reference/generatorTypeCheck28.symbols b/tests/baselines/reference/generatorTypeCheck28.symbols
index 47cdc8aa32e77..27b246515f603 100644
--- a/tests/baselines/reference/generatorTypeCheck28.symbols
+++ b/tests/baselines/reference/generatorTypeCheck28.symbols
@@ -5,15 +5,12 @@ function* g(): IterableIterator<(x: string) => number> {
 >x : Symbol(x, Decl(generatorTypeCheck28.ts, 0, 33))
 
     yield * {
->{        *[Symbol.iterator]() {            yield x => x.length;        }    } : Symbol(, Decl(generatorTypeCheck28.ts, 1, 11))
-
         *[Symbol.iterator]() {
 >Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31))
 >Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11))
 >iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31))
 
             yield x => x.length;
->x => x.length : Symbol((Anonymous function), Decl(generatorTypeCheck28.ts, 3, 17))
 >x : Symbol(x, Decl(generatorTypeCheck28.ts, 3, 17))
 >x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >x : Symbol(x, Decl(generatorTypeCheck28.ts, 3, 17))
diff --git a/tests/baselines/reference/generatorTypeCheck29.symbols b/tests/baselines/reference/generatorTypeCheck29.symbols
index 3ae180d20e681..260137dd1cf3a 100644
--- a/tests/baselines/reference/generatorTypeCheck29.symbols
+++ b/tests/baselines/reference/generatorTypeCheck29.symbols
@@ -6,10 +6,7 @@ function* g2(): Iterator<Iterable<(x: string) => number>> {
 >x : Symbol(x, Decl(generatorTypeCheck29.ts, 0, 35))
 
     yield function* () {
->function* () {        yield x => x.length;    } : Symbol((Anonymous function), Decl(generatorTypeCheck29.ts, 1, 9))
-
         yield x => x.length;
->x => x.length : Symbol((Anonymous function), Decl(generatorTypeCheck29.ts, 2, 13))
 >x : Symbol(x, Decl(generatorTypeCheck29.ts, 2, 13))
 >x : Symbol(x, Decl(generatorTypeCheck29.ts, 2, 13))
 
diff --git a/tests/baselines/reference/generatorTypeCheck30.symbols b/tests/baselines/reference/generatorTypeCheck30.symbols
index 16b8dba03e121..086c65685a8e3 100644
--- a/tests/baselines/reference/generatorTypeCheck30.symbols
+++ b/tests/baselines/reference/generatorTypeCheck30.symbols
@@ -6,10 +6,7 @@ function* g2(): Iterator<Iterable<(x: string) => number>> {
 >x : Symbol(x, Decl(generatorTypeCheck30.ts, 0, 35))
 
     yield function* () {
->function* () {        yield x => x.length;    } : Symbol((Anonymous function), Decl(generatorTypeCheck30.ts, 1, 9))
-
         yield x => x.length;
->x => x.length : Symbol((Anonymous function), Decl(generatorTypeCheck30.ts, 2, 13))
 >x : Symbol(x, Decl(generatorTypeCheck30.ts, 2, 13))
 >x : Symbol(x, Decl(generatorTypeCheck30.ts, 2, 13))
 
diff --git a/tests/baselines/reference/generatorTypeCheck41.symbols b/tests/baselines/reference/generatorTypeCheck41.symbols
index 42290619120b3..9111affa87569 100644
--- a/tests/baselines/reference/generatorTypeCheck41.symbols
+++ b/tests/baselines/reference/generatorTypeCheck41.symbols
@@ -4,7 +4,6 @@ function* g() {
 
     let x = {
 >x : Symbol(x, Decl(generatorTypeCheck41.ts, 1, 7))
->{        [yield 0]: 0    } : Symbol(, Decl(generatorTypeCheck41.ts, 1, 11))
 
         [yield 0]: 0
     }
diff --git a/tests/baselines/reference/generatorTypeCheck42.symbols b/tests/baselines/reference/generatorTypeCheck42.symbols
index eb5a58a1b5cde..a49534fd21112 100644
--- a/tests/baselines/reference/generatorTypeCheck42.symbols
+++ b/tests/baselines/reference/generatorTypeCheck42.symbols
@@ -4,7 +4,6 @@ function* g() {
 
     let x = {
 >x : Symbol(x, Decl(generatorTypeCheck42.ts, 1, 7))
->{        [yield 0]() {        }    } : Symbol(, Decl(generatorTypeCheck42.ts, 1, 11))
 
         [yield 0]() {
 
diff --git a/tests/baselines/reference/generatorTypeCheck43.symbols b/tests/baselines/reference/generatorTypeCheck43.symbols
index 9b119a242c7b2..f5f7b6c359f44 100644
--- a/tests/baselines/reference/generatorTypeCheck43.symbols
+++ b/tests/baselines/reference/generatorTypeCheck43.symbols
@@ -4,7 +4,6 @@ function* g() {
 
     let x = {
 >x : Symbol(x, Decl(generatorTypeCheck43.ts, 1, 7))
->{        *[yield 0]() {        }    } : Symbol(, Decl(generatorTypeCheck43.ts, 1, 11))
 
         *[yield 0]() {
 
diff --git a/tests/baselines/reference/generatorTypeCheck44.symbols b/tests/baselines/reference/generatorTypeCheck44.symbols
index 9c0b41f006774..b6606064c438a 100644
--- a/tests/baselines/reference/generatorTypeCheck44.symbols
+++ b/tests/baselines/reference/generatorTypeCheck44.symbols
@@ -4,7 +4,6 @@ function* g() {
 
     let x = {
 >x : Symbol(x, Decl(generatorTypeCheck44.ts, 1, 7))
->{        get [yield 0]() {            return 0;        }    } : Symbol(, Decl(generatorTypeCheck44.ts, 1, 11))
 
         get [yield 0]() {
             return 0;
diff --git a/tests/baselines/reference/generatorTypeCheck45.symbols b/tests/baselines/reference/generatorTypeCheck45.symbols
index 202ec8a317a27..89c01ff020353 100644
--- a/tests/baselines/reference/generatorTypeCheck45.symbols
+++ b/tests/baselines/reference/generatorTypeCheck45.symbols
@@ -18,13 +18,10 @@ declare function foo<T, U>(x: T, fun: () => Iterator<(x: T) => U>, fun2: (y: U)
 
 foo("", function* () { yield x => x.length }, p => undefined); // T is fixed, should be string
 >foo : Symbol(foo, Decl(generatorTypeCheck45.ts, 0, 0))
->function* () { yield x => x.length } : Symbol((Anonymous function), Decl(generatorTypeCheck45.ts, 2, 7))
->x => x.length : Symbol((Anonymous function), Decl(generatorTypeCheck45.ts, 2, 28))
 >x : Symbol(x, Decl(generatorTypeCheck45.ts, 2, 28))
 >x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >x : Symbol(x, Decl(generatorTypeCheck45.ts, 2, 28))
 >length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
->p => undefined : Symbol((Anonymous function), Decl(generatorTypeCheck45.ts, 2, 45))
 >p : Symbol(p, Decl(generatorTypeCheck45.ts, 2, 45))
 >undefined : Symbol(undefined)
 
diff --git a/tests/baselines/reference/generatorTypeCheck46.symbols b/tests/baselines/reference/generatorTypeCheck46.symbols
index d2d3c708f5483..72d8ebf57a167 100644
--- a/tests/baselines/reference/generatorTypeCheck46.symbols
+++ b/tests/baselines/reference/generatorTypeCheck46.symbols
@@ -18,18 +18,14 @@ declare function foo<T, U>(x: T, fun: () => Iterable<(x: T) => U>, fun2: (y: U)
 
 foo("", function* () {
 >foo : Symbol(foo, Decl(generatorTypeCheck46.ts, 0, 0))
->function* () {    yield* {        *[Symbol.iterator]() {            yield x => x.length        }    }} : Symbol((Anonymous function), Decl(generatorTypeCheck46.ts, 2, 7))
 
     yield* {
->{        *[Symbol.iterator]() {            yield x => x.length        }    } : Symbol(, Decl(generatorTypeCheck46.ts, 3, 10))
-
         *[Symbol.iterator]() {
 >Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31))
 >Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11))
 >iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31))
 
             yield x => x.length
->x => x.length : Symbol((Anonymous function), Decl(generatorTypeCheck46.ts, 5, 17))
 >x : Symbol(x, Decl(generatorTypeCheck46.ts, 5, 17))
 >x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >x : Symbol(x, Decl(generatorTypeCheck46.ts, 5, 17))
@@ -37,7 +33,6 @@ foo("", function* () {
         }
     }
 }, p => undefined); // T is fixed, should be string
->p => undefined : Symbol((Anonymous function), Decl(generatorTypeCheck46.ts, 8, 2))
 >p : Symbol(p, Decl(generatorTypeCheck46.ts, 8, 2))
 >undefined : Symbol(undefined)
 
diff --git a/tests/baselines/reference/genericArray1.symbols b/tests/baselines/reference/genericArray1.symbols
index 11aad48a16a91..b403bd2b72043 100644
--- a/tests/baselines/reference/genericArray1.symbols
+++ b/tests/baselines/reference/genericArray1.symbols
@@ -15,7 +15,6 @@ var lengths = ["a", "b", "c"].map(x => x.length);
 >lengths : Symbol(lengths, Decl(genericArray1.ts, 12, 3))
 >["a", "b", "c"].map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
 >map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
->x => x.length : Symbol((Anonymous function), Decl(genericArray1.ts, 12, 34))
 >x : Symbol(x, Decl(genericArray1.ts, 12, 34))
 >x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >x : Symbol(x, Decl(genericArray1.ts, 12, 34))
diff --git a/tests/baselines/reference/genericBaseClassLiteralProperty2.symbols b/tests/baselines/reference/genericBaseClassLiteralProperty2.symbols
index 18d0aa15d3ebc..5ddccd40e389c 100644
--- a/tests/baselines/reference/genericBaseClassLiteralProperty2.symbols
+++ b/tests/baselines/reference/genericBaseClassLiteralProperty2.symbols
@@ -17,7 +17,6 @@ class BaseCollection2<TItem extends CollectionItem2> {
 >this._itemsByKey : Symbol(_itemsByKey, Decl(genericBaseClassLiteralProperty2.ts, 2, 54))
 >this : Symbol(BaseCollection2, Decl(genericBaseClassLiteralProperty2.ts, 0, 25))
 >_itemsByKey : Symbol(_itemsByKey, Decl(genericBaseClassLiteralProperty2.ts, 2, 54))
->{} : Symbol(, Decl(genericBaseClassLiteralProperty2.ts, 5, 26))
     }
 }
 
diff --git a/tests/baselines/reference/genericCallWithObjectTypeArgs2.symbols b/tests/baselines/reference/genericCallWithObjectTypeArgs2.symbols
index 5d41eef1a3f45..f567499d4c984 100644
--- a/tests/baselines/reference/genericCallWithObjectTypeArgs2.symbols
+++ b/tests/baselines/reference/genericCallWithObjectTypeArgs2.symbols
@@ -45,7 +45,6 @@ function f<T extends Base, U extends Base>(a: { x: T; y: U }) {
 var r = f({ x: new Derived(), y: new Derived2() }); // {}[]
 >r : Symbol(r, Decl(genericCallWithObjectTypeArgs2.ts, 15, 3))
 >f : Symbol(f, Decl(genericCallWithObjectTypeArgs2.ts, 8, 1))
->{ x: new Derived(), y: new Derived2() } : Symbol(, Decl(genericCallWithObjectTypeArgs2.ts, 15, 10))
 >x : Symbol(x, Decl(genericCallWithObjectTypeArgs2.ts, 15, 11))
 >Derived : Symbol(Derived, Decl(genericCallWithObjectTypeArgs2.ts, 2, 1))
 >y : Symbol(y, Decl(genericCallWithObjectTypeArgs2.ts, 15, 29))
@@ -54,7 +53,6 @@ var r = f({ x: new Derived(), y: new Derived2() }); // {}[]
 var r2 = f({ x: new Base(), y: new Derived2() }); // {}[]
 >r2 : Symbol(r2, Decl(genericCallWithObjectTypeArgs2.ts, 16, 3))
 >f : Symbol(f, Decl(genericCallWithObjectTypeArgs2.ts, 8, 1))
->{ x: new Base(), y: new Derived2() } : Symbol(, Decl(genericCallWithObjectTypeArgs2.ts, 16, 11))
 >x : Symbol(x, Decl(genericCallWithObjectTypeArgs2.ts, 16, 12))
 >Base : Symbol(Base, Decl(genericCallWithObjectTypeArgs2.ts, 0, 0))
 >y : Symbol(y, Decl(genericCallWithObjectTypeArgs2.ts, 16, 27))
@@ -74,7 +72,6 @@ function f2<T extends Base, U extends Base>(a: { x: T; y: U }) {
 >U : Symbol(U, Decl(genericCallWithObjectTypeArgs2.ts, 19, 27))
 
     return (x: T) => a.y;
->(x: T) => a.y : Symbol((Anonymous function), Decl(genericCallWithObjectTypeArgs2.ts, 20, 10))
 >x : Symbol(x, Decl(genericCallWithObjectTypeArgs2.ts, 20, 12))
 >T : Symbol(T, Decl(genericCallWithObjectTypeArgs2.ts, 19, 12))
 >a.y : Symbol(y, Decl(genericCallWithObjectTypeArgs2.ts, 19, 54))
@@ -85,7 +82,6 @@ function f2<T extends Base, U extends Base>(a: { x: T; y: U }) {
 var r3 = f2({ x: new Derived(), y: new Derived2() }); // Derived => Derived2
 >r3 : Symbol(r3, Decl(genericCallWithObjectTypeArgs2.ts, 23, 3))
 >f2 : Symbol(f2, Decl(genericCallWithObjectTypeArgs2.ts, 16, 49))
->{ x: new Derived(), y: new Derived2() } : Symbol(, Decl(genericCallWithObjectTypeArgs2.ts, 23, 12))
 >x : Symbol(x, Decl(genericCallWithObjectTypeArgs2.ts, 23, 13))
 >Derived : Symbol(Derived, Decl(genericCallWithObjectTypeArgs2.ts, 2, 1))
 >y : Symbol(y, Decl(genericCallWithObjectTypeArgs2.ts, 23, 31))
diff --git a/tests/baselines/reference/genericCallWithObjectTypeArgsAndConstraints2.symbols b/tests/baselines/reference/genericCallWithObjectTypeArgsAndConstraints2.symbols
index d168eeea133a7..864927a3a8c6f 100644
--- a/tests/baselines/reference/genericCallWithObjectTypeArgsAndConstraints2.symbols
+++ b/tests/baselines/reference/genericCallWithObjectTypeArgsAndConstraints2.symbols
@@ -36,7 +36,6 @@ function f<T extends Base>(x: { foo: T; bar: T }) {
 var r = f({ foo: new Base(), bar: new Derived() });
 >r : Symbol(r, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 14, 3))
 >f : Symbol(f, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 8, 1))
->{ foo: new Base(), bar: new Derived() } : Symbol(, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 14, 10))
 >foo : Symbol(foo, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 14, 11))
 >Base : Symbol(Base, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 0, 0))
 >bar : Symbol(bar, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 14, 28))
@@ -45,7 +44,6 @@ var r = f({ foo: new Base(), bar: new Derived() });
 var r2 = f({ foo: new Derived(), bar: new Derived() });
 >r2 : Symbol(r2, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 15, 3))
 >f : Symbol(f, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 8, 1))
->{ foo: new Derived(), bar: new Derived() } : Symbol(, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 15, 11))
 >foo : Symbol(foo, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 15, 12))
 >Derived : Symbol(Derived, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 5, 1))
 >bar : Symbol(bar, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 15, 32))
@@ -104,7 +102,6 @@ var r4 = f3(new Base(), x => x);
 >r4 : Symbol(r4, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 32, 3))
 >f3 : Symbol(f3, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 26, 15))
 >Base : Symbol(Base, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 0, 0))
->x => x : Symbol((Anonymous function), Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 32, 23))
 >x : Symbol(x, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 32, 23))
 >x : Symbol(x, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 32, 23))
 
@@ -112,7 +109,6 @@ var r5 = f3(new Derived(), x => x);
 >r5 : Symbol(r5, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 33, 3))
 >f3 : Symbol(f3, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 26, 15))
 >Derived : Symbol(Derived, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 5, 1))
->x => x : Symbol((Anonymous function), Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 33, 26))
 >x : Symbol(x, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 33, 26))
 >x : Symbol(x, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 33, 26))
 
@@ -123,7 +119,6 @@ var r6 = f3(null, null); // any
 var r7 = f3(null, x => x); // any
 >r7 : Symbol(r7, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 36, 3))
 >f3 : Symbol(f3, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 26, 15))
->x => x : Symbol((Anonymous function), Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 36, 17))
 >x : Symbol(x, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 36, 17))
 >x : Symbol(x, Decl(genericCallWithObjectTypeArgsAndConstraints2.ts, 36, 17))
 
diff --git a/tests/baselines/reference/genericCallWithOverloadedFunctionTypedArguments.symbols b/tests/baselines/reference/genericCallWithOverloadedFunctionTypedArguments.symbols
index 553c0e1f07e03..1d32c55fd33e4 100644
--- a/tests/baselines/reference/genericCallWithOverloadedFunctionTypedArguments.symbols
+++ b/tests/baselines/reference/genericCallWithOverloadedFunctionTypedArguments.symbols
@@ -32,7 +32,6 @@ module NonGenericParameter {
     var r2 = foo4(<T>(x: T) => x);
 >r2 : Symbol(r2, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 14, 7))
 >foo4 : Symbol(foo4, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 7, 5))
-><T>(x: T) => x : Symbol((Anonymous function), Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 14, 18))
 >T : Symbol(T, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 14, 19))
 >x : Symbol(x, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 14, 22))
 >T : Symbol(T, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 14, 19))
@@ -41,7 +40,6 @@ module NonGenericParameter {
     var r4 = foo4(x => x);    
 >r4 : Symbol(r4, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 15, 7))
 >foo4 : Symbol(foo4, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 7, 5))
->x => x : Symbol((Anonymous function), Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 15, 18))
 >x : Symbol(x, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 15, 18))
 >x : Symbol(x, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 15, 18))
 }
@@ -65,7 +63,6 @@ module GenericParameter {
     var r5 = foo5(x => x); // any => string (+1 overload) [inferences are made for T, but lambda not contextually typed]. T is any
 >r5 : Symbol(r5, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 23, 7))
 >foo5 : Symbol(foo5, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 18, 25))
->x => x : Symbol((Anonymous function), Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 23, 18))
 >x : Symbol(x, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 23, 18))
 >x : Symbol(x, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 23, 18))
 
@@ -101,14 +98,12 @@ module GenericParameter {
     var r8 = foo6(x => x); // any => string (+1 overload) [inferences are made for T, but lambda not contextually typed]. T is any
 >r8 : Symbol(r8, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 31, 7))
 >foo6 : Symbol(foo6, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 25, 21))
->x => x : Symbol((Anonymous function), Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 31, 18))
 >x : Symbol(x, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 31, 18))
 >x : Symbol(x, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 31, 18))
 
     var r9 = foo6(<T>(x: T) => ''); // any => string (+1 overload)
 >r9 : Symbol(r9, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 32, 7))
 >foo6 : Symbol(foo6, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 25, 21))
-><T>(x: T) => '' : Symbol((Anonymous function), Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 32, 18))
 >T : Symbol(T, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 32, 19))
 >x : Symbol(x, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 32, 22))
 >T : Symbol(T, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 32, 19))
@@ -116,7 +111,6 @@ module GenericParameter {
     var r11 = foo6(<T>(x: T, y?: T) => ''); // any => string (+1 overload)
 >r11 : Symbol(r11, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 33, 7))
 >foo6 : Symbol(foo6, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 25, 21))
-><T>(x: T, y?: T) => '' : Symbol((Anonymous function), Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 33, 19))
 >T : Symbol(T, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 33, 20))
 >x : Symbol(x, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 33, 23))
 >T : Symbol(T, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 33, 20))
@@ -143,14 +137,12 @@ module GenericParameter {
     var r12 = foo7(1, (x) => x); // any => string (+1 overload) [inferences are made for T, but lambda not contextually typed]
 >r12 : Symbol(r12, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 39, 7))
 >foo7 : Symbol(foo7, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 33, 43))
->(x) => x : Symbol((Anonymous function), Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 39, 21))
 >x : Symbol(x, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 39, 23))
 >x : Symbol(x, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 39, 23))
 
     var r13 = foo7(1, <T>(x: T) => ''); // any => string (+1 overload) [inferences are made for T, but lambda not contextually typed]
 >r13 : Symbol(r13, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 40, 7))
 >foo7 : Symbol(foo7, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 33, 43))
-><T>(x: T) => '' : Symbol((Anonymous function), Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 40, 21))
 >T : Symbol(T, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 40, 23))
 >x : Symbol(x, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 40, 26))
 >T : Symbol(T, Decl(genericCallWithOverloadedFunctionTypedArguments.ts, 40, 23))
diff --git a/tests/baselines/reference/genericCallbacksAndClassHierarchy.symbols b/tests/baselines/reference/genericCallbacksAndClassHierarchy.symbols
index f4f8f11562655..be46c49a9ca09 100644
--- a/tests/baselines/reference/genericCallbacksAndClassHierarchy.symbols
+++ b/tests/baselines/reference/genericCallbacksAndClassHierarchy.symbols
@@ -47,7 +47,6 @@ module M {
 
             var f = (newValue: A<T>) => { };
 >f : Symbol(f, Decl(genericCallbacksAndClassHierarchy.ts, 13, 15))
->(newValue: A<T>) => { } : Symbol((Anonymous function), Decl(genericCallbacksAndClassHierarchy.ts, 13, 19))
 >newValue : Symbol(newValue, Decl(genericCallbacksAndClassHierarchy.ts, 13, 21))
 >A : Symbol(A, Decl(genericCallbacksAndClassHierarchy.ts, 6, 5))
 >T : Symbol(T, Decl(genericCallbacksAndClassHierarchy.ts, 11, 19))
@@ -72,7 +71,6 @@ module M {
 >v.subscribe : Symbol(I.subscribe, Decl(genericCallbacksAndClassHierarchy.ts, 1, 27))
 >v : Symbol(v, Decl(genericCallbacksAndClassHierarchy.ts, 15, 15))
 >subscribe : Symbol(I.subscribe, Decl(genericCallbacksAndClassHierarchy.ts, 1, 27))
->(newValue: A<T>) => { } : Symbol((Anonymous function), Decl(genericCallbacksAndClassHierarchy.ts, 19, 24))
 >newValue : Symbol(newValue, Decl(genericCallbacksAndClassHierarchy.ts, 19, 25))
 >A : Symbol(A, Decl(genericCallbacksAndClassHierarchy.ts, 6, 5))
 >T : Symbol(T, Decl(genericCallbacksAndClassHierarchy.ts, 11, 19))
diff --git a/tests/baselines/reference/genericContextualTypingSpecialization.symbols b/tests/baselines/reference/genericContextualTypingSpecialization.symbols
index ce17c68901b82..05312d889c986 100644
--- a/tests/baselines/reference/genericContextualTypingSpecialization.symbols
+++ b/tests/baselines/reference/genericContextualTypingSpecialization.symbols
@@ -6,7 +6,6 @@ b.reduce<number>((c, d) => c + d, 0); // should not error on '+'
 >b.reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120))
 >b : Symbol(b, Decl(genericContextualTypingSpecialization.ts, 0, 3))
 >reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120))
->(c, d) => c + d : Symbol((Anonymous function), Decl(genericContextualTypingSpecialization.ts, 1, 17))
 >c : Symbol(c, Decl(genericContextualTypingSpecialization.ts, 1, 18))
 >d : Symbol(d, Decl(genericContextualTypingSpecialization.ts, 1, 20))
 >c : Symbol(c, Decl(genericContextualTypingSpecialization.ts, 1, 18))
diff --git a/tests/baselines/reference/genericFunctionHasFreshTypeArgs.symbols b/tests/baselines/reference/genericFunctionHasFreshTypeArgs.symbols
index a8dc86a423c0f..0baf9eda80fcc 100644
--- a/tests/baselines/reference/genericFunctionHasFreshTypeArgs.symbols
+++ b/tests/baselines/reference/genericFunctionHasFreshTypeArgs.symbols
@@ -8,10 +8,8 @@ function f(p: <T>(x: T) => void) { };
 
 f(x => f(y => x = y));
 >f : Symbol(f, Decl(genericFunctionHasFreshTypeArgs.ts, 0, 0))
->x => f(y => x = y) : Symbol((Anonymous function), Decl(genericFunctionHasFreshTypeArgs.ts, 1, 2))
 >x : Symbol(x, Decl(genericFunctionHasFreshTypeArgs.ts, 1, 2))
 >f : Symbol(f, Decl(genericFunctionHasFreshTypeArgs.ts, 0, 0))
->y => x = y : Symbol((Anonymous function), Decl(genericFunctionHasFreshTypeArgs.ts, 1, 9))
 >y : Symbol(y, Decl(genericFunctionHasFreshTypeArgs.ts, 1, 9))
 >x : Symbol(x, Decl(genericFunctionHasFreshTypeArgs.ts, 1, 2))
 >y : Symbol(y, Decl(genericFunctionHasFreshTypeArgs.ts, 1, 9))
diff --git a/tests/baselines/reference/genericFunctions2.symbols b/tests/baselines/reference/genericFunctions2.symbols
index a49787f9212ab..59068cbd8dda1 100644
--- a/tests/baselines/reference/genericFunctions2.symbols
+++ b/tests/baselines/reference/genericFunctions2.symbols
@@ -18,7 +18,6 @@ var lengths = map(myItems, x => x.length);
 >lengths : Symbol(lengths, Decl(genericFunctions2.ts, 3, 3))
 >map : Symbol(map, Decl(genericFunctions2.ts, 0, 0))
 >myItems : Symbol(myItems, Decl(genericFunctions2.ts, 2, 3))
->x => x.length : Symbol((Anonymous function), Decl(genericFunctions2.ts, 3, 26))
 >x : Symbol(x, Decl(genericFunctions2.ts, 3, 26))
 >x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >x : Symbol(x, Decl(genericFunctions2.ts, 3, 26))
diff --git a/tests/baselines/reference/genericFunctionsWithOptionalParameters3.symbols b/tests/baselines/reference/genericFunctionsWithOptionalParameters3.symbols
index 3ef1d31ac8542..2fe7e295a0d70 100644
--- a/tests/baselines/reference/genericFunctionsWithOptionalParameters3.symbols
+++ b/tests/baselines/reference/genericFunctionsWithOptionalParameters3.symbols
@@ -61,9 +61,7 @@ var r3 = utils.mapReduce(c, (x) => { return 1 }, (y) => { return new Date() });
 >utils : Symbol(utils, Decl(genericFunctionsWithOptionalParameters3.ts, 7, 3))
 >mapReduce : Symbol(Utils.mapReduce, Decl(genericFunctionsWithOptionalParameters3.ts, 4, 75))
 >c : Symbol(c, Decl(genericFunctionsWithOptionalParameters3.ts, 8, 3))
->(x) => { return 1 } : Symbol((Anonymous function), Decl(genericFunctionsWithOptionalParameters3.ts, 9, 27))
 >x : Symbol(x, Decl(genericFunctionsWithOptionalParameters3.ts, 9, 29))
->(y) => { return new Date() } : Symbol((Anonymous function), Decl(genericFunctionsWithOptionalParameters3.ts, 9, 48))
 >y : Symbol(y, Decl(genericFunctionsWithOptionalParameters3.ts, 9, 50))
 >Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
 
@@ -73,20 +71,16 @@ var r4 = utils.mapReduce(c, (x: string) => { return 1 }, (y: number) => { return
 >utils : Symbol(utils, Decl(genericFunctionsWithOptionalParameters3.ts, 7, 3))
 >mapReduce : Symbol(Utils.mapReduce, Decl(genericFunctionsWithOptionalParameters3.ts, 4, 75))
 >c : Symbol(c, Decl(genericFunctionsWithOptionalParameters3.ts, 8, 3))
->(x: string) => { return 1 } : Symbol((Anonymous function), Decl(genericFunctionsWithOptionalParameters3.ts, 10, 27))
 >x : Symbol(x, Decl(genericFunctionsWithOptionalParameters3.ts, 10, 29))
->(y: number) => { return new Date() } : Symbol((Anonymous function), Decl(genericFunctionsWithOptionalParameters3.ts, 10, 56))
 >y : Symbol(y, Decl(genericFunctionsWithOptionalParameters3.ts, 10, 58))
 >Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
 
 var f1 = (x: string) => { return 1 };
 >f1 : Symbol(f1, Decl(genericFunctionsWithOptionalParameters3.ts, 11, 3))
->(x: string) => { return 1 } : Symbol((Anonymous function), Decl(genericFunctionsWithOptionalParameters3.ts, 11, 8))
 >x : Symbol(x, Decl(genericFunctionsWithOptionalParameters3.ts, 11, 10))
 
 var f2 = (y: number) => { return new Date() };
 >f2 : Symbol(f2, Decl(genericFunctionsWithOptionalParameters3.ts, 12, 3))
->(y: number) => { return new Date() } : Symbol((Anonymous function), Decl(genericFunctionsWithOptionalParameters3.ts, 12, 8))
 >y : Symbol(y, Decl(genericFunctionsWithOptionalParameters3.ts, 12, 10))
 >Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
 
diff --git a/tests/baselines/reference/genericInference1.symbols b/tests/baselines/reference/genericInference1.symbols
index 2104ce7ae448b..6980668c6ebc1 100644
--- a/tests/baselines/reference/genericInference1.symbols
+++ b/tests/baselines/reference/genericInference1.symbols
@@ -2,7 +2,6 @@
 ['a', 'b', 'c'].map(x => x.length);
 >['a', 'b', 'c'].map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
 >map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
->x => x.length : Symbol((Anonymous function), Decl(genericInference1.ts, 0, 20))
 >x : Symbol(x, Decl(genericInference1.ts, 0, 20))
 >x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >x : Symbol(x, Decl(genericInference1.ts, 0, 20))
diff --git a/tests/baselines/reference/genericInference2.symbols b/tests/baselines/reference/genericInference2.symbols
index 253020927ef27..83b371005f710 100644
--- a/tests/baselines/reference/genericInference2.symbols
+++ b/tests/baselines/reference/genericInference2.symbols
@@ -33,7 +33,6 @@
     } 
     var o = { 
 >o : Symbol(o, Decl(genericInference2.ts, 10, 7))
->{        name: ko.observable("Bob"),        age: ko.observable(37)     } : Symbol(, Decl(genericInference2.ts, 10, 11))
 
        name: ko.observable("Bob"), 
 >name : Symbol(name, Decl(genericInference2.ts, 10, 13))
diff --git a/tests/baselines/reference/genericInterfaceTypeCall.symbols b/tests/baselines/reference/genericInterfaceTypeCall.symbols
index 6ad334c6ae42e..e28ce8f8d80fe 100644
--- a/tests/baselines/reference/genericInterfaceTypeCall.symbols
+++ b/tests/baselines/reference/genericInterfaceTypeCall.symbols
@@ -36,7 +36,6 @@ test.fail(arg => foo.reject(arg));
 >test.fail : Symbol(bar.fail, Decl(genericInterfaceTypeCall.ts, 5, 18))
 >test : Symbol(test, Decl(genericInterfaceTypeCall.ts, 9, 3))
 >fail : Symbol(bar.fail, Decl(genericInterfaceTypeCall.ts, 5, 18))
->arg => foo.reject(arg) : Symbol((Anonymous function), Decl(genericInterfaceTypeCall.ts, 11, 10))
 >arg : Symbol(arg, Decl(genericInterfaceTypeCall.ts, 11, 10))
 >foo.reject : Symbol(Foo.reject, Decl(genericInterfaceTypeCall.ts, 0, 18))
 >foo : Symbol(foo, Decl(genericInterfaceTypeCall.ts, 3, 3))
@@ -47,7 +46,6 @@ test.fail2(arg => foo.reject(arg)); // Error: Supplied parameters do not match a
 >test.fail2 : Symbol(bar.fail2, Decl(genericInterfaceTypeCall.ts, 6, 40))
 >test : Symbol(test, Decl(genericInterfaceTypeCall.ts, 9, 3))
 >fail2 : Symbol(bar.fail2, Decl(genericInterfaceTypeCall.ts, 6, 40))
->arg => foo.reject(arg) : Symbol((Anonymous function), Decl(genericInterfaceTypeCall.ts, 12, 11))
 >arg : Symbol(arg, Decl(genericInterfaceTypeCall.ts, 12, 11))
 >foo.reject : Symbol(Foo.reject, Decl(genericInterfaceTypeCall.ts, 0, 18))
 >foo : Symbol(foo, Decl(genericInterfaceTypeCall.ts, 3, 3))
diff --git a/tests/baselines/reference/genericMethodOverspecialization.symbols b/tests/baselines/reference/genericMethodOverspecialization.symbols
index 488838a7837b2..651aced0fcdc0 100644
--- a/tests/baselines/reference/genericMethodOverspecialization.symbols
+++ b/tests/baselines/reference/genericMethodOverspecialization.symbols
@@ -30,7 +30,6 @@ var elements = names.map(function (name) {
 >names.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
 >names : Symbol(names, Decl(genericMethodOverspecialization.ts, 0, 3))
 >map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
->function (name) {    return document.getElementById(name);} : Symbol((Anonymous function), Decl(genericMethodOverspecialization.ts, 12, 25))
 >name : Symbol(name, Decl(genericMethodOverspecialization.ts, 12, 35))
 
     return document.getElementById(name);
@@ -47,7 +46,6 @@ var xxx = elements.filter(function (e) {
 >elements.filter : Symbol(Array.filter, Decl(lib.d.ts, 1122, 87))
 >elements : Symbol(elements, Decl(genericMethodOverspecialization.ts, 12, 3))
 >filter : Symbol(Array.filter, Decl(lib.d.ts, 1122, 87))
->function (e) {    return !e.isDisabled;} : Symbol((Anonymous function), Decl(genericMethodOverspecialization.ts, 17, 26))
 >e : Symbol(e, Decl(genericMethodOverspecialization.ts, 17, 36))
 
     return !e.isDisabled;
@@ -62,7 +60,6 @@ var widths:number[] = elements.map(function (e) { // should not error
 >elements.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
 >elements : Symbol(elements, Decl(genericMethodOverspecialization.ts, 12, 3))
 >map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
->function (e) { // should not error    return e.clientWidth;} : Symbol((Anonymous function), Decl(genericMethodOverspecialization.ts, 21, 35))
 >e : Symbol(e, Decl(genericMethodOverspecialization.ts, 21, 45))
 
     return e.clientWidth;
diff --git a/tests/baselines/reference/genericObjectLitReturnType.symbols b/tests/baselines/reference/genericObjectLitReturnType.symbols
index 982a2474b17e5..f3253bdf81036 100644
--- a/tests/baselines/reference/genericObjectLitReturnType.symbols
+++ b/tests/baselines/reference/genericObjectLitReturnType.symbols
@@ -7,7 +7,6 @@ class X<T>
 >f : Symbol(f, Decl(genericObjectLitReturnType.ts, 1, 1))
 >t : Symbol(t, Decl(genericObjectLitReturnType.ts, 2, 6))
 >T : Symbol(T, Decl(genericObjectLitReturnType.ts, 0, 8))
->{ a: t } : Symbol(, Decl(genericObjectLitReturnType.ts, 2, 20))
 >a : Symbol(a, Decl(genericObjectLitReturnType.ts, 2, 22))
 >t : Symbol(t, Decl(genericObjectLitReturnType.ts, 2, 6))
 }
diff --git a/tests/baselines/reference/genericParameterAssignability1.symbols b/tests/baselines/reference/genericParameterAssignability1.symbols
index 7973fdaf8dc22..766190aecabfb 100644
--- a/tests/baselines/reference/genericParameterAssignability1.symbols
+++ b/tests/baselines/reference/genericParameterAssignability1.symbols
@@ -8,7 +8,6 @@ function f<T>(x: T): T { return null; }
 
 var r = <T>(x: T) => x;
 >r : Symbol(r, Decl(genericParameterAssignability1.ts, 1, 3))
-><T>(x: T) => x : Symbol((Anonymous function), Decl(genericParameterAssignability1.ts, 1, 7))
 >T : Symbol(T, Decl(genericParameterAssignability1.ts, 1, 9))
 >x : Symbol(x, Decl(genericParameterAssignability1.ts, 1, 12))
 >T : Symbol(T, Decl(genericParameterAssignability1.ts, 1, 9))
diff --git a/tests/baselines/reference/genericTypeAliases.symbols b/tests/baselines/reference/genericTypeAliases.symbols
index 3d907a02c6d67..1a1d0e514870e 100644
--- a/tests/baselines/reference/genericTypeAliases.symbols
+++ b/tests/baselines/reference/genericTypeAliases.symbols
@@ -13,18 +13,15 @@ type Tree<T> = T | { left: Tree<T>, right: Tree<T> };
 var tree: Tree<number> = {
 >tree : Symbol(tree, Decl(genericTypeAliases.ts, 2, 3))
 >Tree : Symbol(Tree, Decl(genericTypeAliases.ts, 0, 0))
->{    left: {        left: 0,        right: {            left: 1,            right: 2        },    },    right: 3} : Symbol(, Decl(genericTypeAliases.ts, 2, 24))
 
     left: {
 >left : Symbol(left, Decl(genericTypeAliases.ts, 2, 26))
->{        left: 0,        right: {            left: 1,            right: 2        },    } : Symbol(, Decl(genericTypeAliases.ts, 3, 9))
 
         left: 0,
 >left : Symbol(left, Decl(genericTypeAliases.ts, 3, 11))
 
         right: {
 >right : Symbol(right, Decl(genericTypeAliases.ts, 4, 16))
->{            left: 1,            right: 2        } : Symbol(, Decl(genericTypeAliases.ts, 5, 14))
 
             left: 1,
 >left : Symbol(left, Decl(genericTypeAliases.ts, 5, 16))
@@ -54,7 +51,6 @@ ls = "eager";
 
 ls = () => "lazy";
 >ls : Symbol(ls, Decl(genericTypeAliases.ts, 15, 3))
->() => "lazy" : Symbol((Anonymous function), Decl(genericTypeAliases.ts, 17, 4))
 
 type Foo<T> = T | { x: Foo<T> };
 >Foo : Symbol(Foo, Decl(genericTypeAliases.ts, 17, 18))
@@ -94,14 +90,11 @@ x = "string";
 
 x = { x: "hello" };
 >x : Symbol(x, Decl(genericTypeAliases.ts, 23, 3))
->{ x: "hello" } : Symbol(, Decl(genericTypeAliases.ts, 29, 3))
 >x : Symbol(x, Decl(genericTypeAliases.ts, 29, 5))
 
 x = { x: { x: "world" } };
 >x : Symbol(x, Decl(genericTypeAliases.ts, 23, 3))
->{ x: { x: "world" } } : Symbol(, Decl(genericTypeAliases.ts, 30, 3))
 >x : Symbol(x, Decl(genericTypeAliases.ts, 30, 5))
->{ x: "world" } : Symbol(, Decl(genericTypeAliases.ts, 30, 8))
 >x : Symbol(x, Decl(genericTypeAliases.ts, 30, 10))
 
 var z: Foo<number>;
@@ -113,14 +106,11 @@ z = 42;
 
 z = { x: 42 };
 >z : Symbol(z, Decl(genericTypeAliases.ts, 32, 3))
->{ x: 42 } : Symbol(, Decl(genericTypeAliases.ts, 34, 3))
 >x : Symbol(x, Decl(genericTypeAliases.ts, 34, 5))
 
 z = { x: { x: 42 } };
 >z : Symbol(z, Decl(genericTypeAliases.ts, 32, 3))
->{ x: { x: 42 } } : Symbol(, Decl(genericTypeAliases.ts, 35, 3))
 >x : Symbol(x, Decl(genericTypeAliases.ts, 35, 5))
->{ x: 42 } : Symbol(, Decl(genericTypeAliases.ts, 35, 8))
 >x : Symbol(x, Decl(genericTypeAliases.ts, 35, 10))
 
 type Strange<T> = string;  // Type parameter not used
diff --git a/tests/baselines/reference/genericTypeAssertions3.symbols b/tests/baselines/reference/genericTypeAssertions3.symbols
index 52487927757f8..4d19f1562005d 100644
--- a/tests/baselines/reference/genericTypeAssertions3.symbols
+++ b/tests/baselines/reference/genericTypeAssertions3.symbols
@@ -5,7 +5,6 @@ var r = < <T>(x: T) => T > ((x) => { return null; }); // bug was 'could not find
 >x : Symbol(x, Decl(genericTypeAssertions3.ts, 0, 14))
 >T : Symbol(T, Decl(genericTypeAssertions3.ts, 0, 11))
 >T : Symbol(T, Decl(genericTypeAssertions3.ts, 0, 11))
->(x) => { return null; } : Symbol((Anonymous function), Decl(genericTypeAssertions3.ts, 0, 28))
 >x : Symbol(x, Decl(genericTypeAssertions3.ts, 0, 29))
 
 var s = < <T>(x: T) => T > ((x: any) => { return null; }); // no error
@@ -14,6 +13,5 @@ var s = < <T>(x: T) => T > ((x: any) => { return null; }); // no error
 >x : Symbol(x, Decl(genericTypeAssertions3.ts, 1, 14))
 >T : Symbol(T, Decl(genericTypeAssertions3.ts, 1, 11))
 >T : Symbol(T, Decl(genericTypeAssertions3.ts, 1, 11))
->(x: any) => { return null; } : Symbol((Anonymous function), Decl(genericTypeAssertions3.ts, 1, 28))
 >x : Symbol(x, Decl(genericTypeAssertions3.ts, 1, 29))
 
diff --git a/tests/baselines/reference/genericTypeParameterEquivalence2.symbols b/tests/baselines/reference/genericTypeParameterEquivalence2.symbols
index 3db85b7427bb0..056b4ce96ab73 100644
--- a/tests/baselines/reference/genericTypeParameterEquivalence2.symbols
+++ b/tests/baselines/reference/genericTypeParameterEquivalence2.symbols
@@ -18,7 +18,6 @@ function compose<A, B, C>(f: (b: B) => C, g: (a:A) => B): (a:A) => C {
 >C : Symbol(C, Decl(genericTypeParameterEquivalence2.ts, 1, 22))
 
     return function (a:A) : C {
->function (a:A) : C {        return f(g.apply(null, a));    } : Symbol((Anonymous function), Decl(genericTypeParameterEquivalence2.ts, 2, 10))
 >a : Symbol(a, Decl(genericTypeParameterEquivalence2.ts, 2, 21))
 >A : Symbol(A, Decl(genericTypeParameterEquivalence2.ts, 1, 17))
 >C : Symbol(C, Decl(genericTypeParameterEquivalence2.ts, 1, 22))
@@ -77,7 +76,6 @@ function filter<A>(f: (a: A) => boolean, ar: A[]): A[] {
     forEach(ar, (el) => {
 >forEach : Symbol(forEach, Decl(genericTypeParameterEquivalence2.ts, 5, 1))
 >ar : Symbol(ar, Decl(genericTypeParameterEquivalence2.ts, 15, 40))
->(el) => {        if (f(el)) {            ret.push(el);        }    } : Symbol((Anonymous function), Decl(genericTypeParameterEquivalence2.ts, 17, 15))
 >el : Symbol(el, Decl(genericTypeParameterEquivalence2.ts, 17, 17))
 
         if (f(el)) {
@@ -128,12 +126,10 @@ function curry1<A, B, C>(f: (a: A, b: B) => C): (ax: A) => (bx: B) => C {
 >C : Symbol(C, Decl(genericTypeParameterEquivalence2.ts, 32, 21))
 
     return function (ay: A) {
->function (ay: A) {        return function (by: B) {            return f(ay, by);        };    } : Symbol((Anonymous function), Decl(genericTypeParameterEquivalence2.ts, 33, 10))
 >ay : Symbol(ay, Decl(genericTypeParameterEquivalence2.ts, 33, 21))
 >A : Symbol(A, Decl(genericTypeParameterEquivalence2.ts, 32, 16))
 
         return function (by: B) {
->function (by: B) {            return f(ay, by);        } : Symbol((Anonymous function), Decl(genericTypeParameterEquivalence2.ts, 34, 14))
 >by : Symbol(by, Decl(genericTypeParameterEquivalence2.ts, 34, 25))
 >B : Symbol(B, Decl(genericTypeParameterEquivalence2.ts, 32, 18))
 
diff --git a/tests/baselines/reference/genericWithIndexerOfTypeParameterType1.symbols b/tests/baselines/reference/genericWithIndexerOfTypeParameterType1.symbols
index 8976290deb913..26918e9ebfb33 100644
--- a/tests/baselines/reference/genericWithIndexerOfTypeParameterType1.symbols
+++ b/tests/baselines/reference/genericWithIndexerOfTypeParameterType1.symbols
@@ -7,7 +7,6 @@ class LazyArray<T> {
 >objects : Symbol(objects, Decl(genericWithIndexerOfTypeParameterType1.ts, 0, 20))
 >objectId : Symbol(objectId, Decl(genericWithIndexerOfTypeParameterType1.ts, 1, 26))
 >T : Symbol(T, Decl(genericWithIndexerOfTypeParameterType1.ts, 0, 16))
->{} : Symbol(, Decl(genericWithIndexerOfTypeParameterType1.ts, 1, 50))
 
     array() {
 >array : Symbol(array, Decl(genericWithIndexerOfTypeParameterType1.ts, 1, 53))
diff --git a/tests/baselines/reference/genericsAndHigherOrderFunctions.symbols b/tests/baselines/reference/genericsAndHigherOrderFunctions.symbols
index d29b3078b2894..a9f324278d687 100644
--- a/tests/baselines/reference/genericsAndHigherOrderFunctions.symbols
+++ b/tests/baselines/reference/genericsAndHigherOrderFunctions.symbols
@@ -23,7 +23,6 @@ var combine: <T, S>(f: (_: T) => S) =>
 >S : Symbol(S, Decl(genericsAndHigherOrderFunctions.ts, 2, 16))
 
     = <T, S>(f: (_: T) => S) =>
-><T, S>(f: (_: T) => S) =>        <U>(g: (_: U) => T) =>            (x: U) => f(g(x)) : Symbol((Anonymous function), Decl(genericsAndHigherOrderFunctions.ts, 6, 5))
 >T : Symbol(T, Decl(genericsAndHigherOrderFunctions.ts, 6, 7))
 >S : Symbol(S, Decl(genericsAndHigherOrderFunctions.ts, 6, 9))
 >f : Symbol(f, Decl(genericsAndHigherOrderFunctions.ts, 6, 13))
@@ -32,7 +31,6 @@ var combine: <T, S>(f: (_: T) => S) =>
 >S : Symbol(S, Decl(genericsAndHigherOrderFunctions.ts, 6, 9))
 
         <U>(g: (_: U) => T) =>
-><U>(g: (_: U) => T) =>            (x: U) => f(g(x)) : Symbol((Anonymous function), Decl(genericsAndHigherOrderFunctions.ts, 6, 31))
 >U : Symbol(U, Decl(genericsAndHigherOrderFunctions.ts, 7, 9))
 >g : Symbol(g, Decl(genericsAndHigherOrderFunctions.ts, 7, 12))
 >_ : Symbol(_, Decl(genericsAndHigherOrderFunctions.ts, 7, 16))
@@ -40,7 +38,6 @@ var combine: <T, S>(f: (_: T) => S) =>
 >T : Symbol(T, Decl(genericsAndHigherOrderFunctions.ts, 6, 7))
 
             (x: U) => f(g(x))
->(x: U) => f(g(x)) : Symbol((Anonymous function), Decl(genericsAndHigherOrderFunctions.ts, 7, 30))
 >x : Symbol(x, Decl(genericsAndHigherOrderFunctions.ts, 8, 13))
 >U : Symbol(U, Decl(genericsAndHigherOrderFunctions.ts, 7, 9))
 >f : Symbol(f, Decl(genericsAndHigherOrderFunctions.ts, 6, 13))
@@ -82,7 +79,6 @@ var foo: <K, N>(g: (x: K) => N) =>
 >R : Symbol(R, Decl(genericsAndHigherOrderFunctions.ts, 12, 5))
 
     = <K, N>(g: (x: K) => N) =>
-><K, N>(g: (x: K) => N) =>        (h: <M>(_: (_: K) => (_: M) => M) => (_: M) => M) =>            <R>(f: (_: N) => (_: R) => R) => h(combine(f)(g)) : Symbol((Anonymous function), Decl(genericsAndHigherOrderFunctions.ts, 14, 5))
 >K : Symbol(K, Decl(genericsAndHigherOrderFunctions.ts, 14, 7))
 >N : Symbol(N, Decl(genericsAndHigherOrderFunctions.ts, 14, 9))
 >g : Symbol(g, Decl(genericsAndHigherOrderFunctions.ts, 14, 13))
@@ -91,7 +87,6 @@ var foo: <K, N>(g: (x: K) => N) =>
 >N : Symbol(N, Decl(genericsAndHigherOrderFunctions.ts, 14, 9))
 
         (h: <M>(_: (_: K) => (_: M) => M) => (_: M) => M) =>
->(h: <M>(_: (_: K) => (_: M) => M) => (_: M) => M) =>            <R>(f: (_: N) => (_: R) => R) => h(combine(f)(g)) : Symbol((Anonymous function), Decl(genericsAndHigherOrderFunctions.ts, 14, 31))
 >h : Symbol(h, Decl(genericsAndHigherOrderFunctions.ts, 15, 9))
 >M : Symbol(M, Decl(genericsAndHigherOrderFunctions.ts, 15, 13))
 >_ : Symbol(_, Decl(genericsAndHigherOrderFunctions.ts, 15, 16))
@@ -105,7 +100,6 @@ var foo: <K, N>(g: (x: K) => N) =>
 >M : Symbol(M, Decl(genericsAndHigherOrderFunctions.ts, 15, 13))
 
             <R>(f: (_: N) => (_: R) => R) => h(combine(f)(g))
-><R>(f: (_: N) => (_: R) => R) => h(combine(f)(g)) : Symbol((Anonymous function), Decl(genericsAndHigherOrderFunctions.ts, 15, 60))
 >R : Symbol(R, Decl(genericsAndHigherOrderFunctions.ts, 16, 13))
 >f : Symbol(f, Decl(genericsAndHigherOrderFunctions.ts, 16, 16))
 >_ : Symbol(_, Decl(genericsAndHigherOrderFunctions.ts, 16, 20))
diff --git a/tests/baselines/reference/getterSetterNonAccessor.symbols b/tests/baselines/reference/getterSetterNonAccessor.symbols
index 14916e0a348c4..10ffc55480c74 100644
--- a/tests/baselines/reference/getterSetterNonAccessor.symbols
+++ b/tests/baselines/reference/getterSetterNonAccessor.symbols
@@ -10,9 +10,7 @@ Object.defineProperty({}, "0", <PropertyDescriptor>({
 >Object.defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.d.ts, 160, 60))
 >Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
 >defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.d.ts, 160, 60))
->{} : Symbol(, Decl(getterSetterNonAccessor.ts, 3, 22))
 >PropertyDescriptor : Symbol(PropertyDescriptor, Decl(lib.d.ts, 79, 66))
->{          get: getFunc,          set: setFunc,          configurable: true      } : Symbol(, Decl(getterSetterNonAccessor.ts, 3, 52))
 
           get: getFunc,
 >get : Symbol(get, Decl(getterSetterNonAccessor.ts, 3, 53))
diff --git a/tests/baselines/reference/globalThisCapture.symbols b/tests/baselines/reference/globalThisCapture.symbols
index 8c3ff7e31299c..bfb7bf147c0a4 100644
--- a/tests/baselines/reference/globalThisCapture.symbols
+++ b/tests/baselines/reference/globalThisCapture.symbols
@@ -1,7 +1,6 @@
 === tests/cases/compiler/globalThisCapture.ts ===
 // Add a lambda to ensure global 'this' capture is triggered
 (()=>this.window);
->()=>this.window : Symbol((Anonymous function), Decl(globalThisCapture.ts, 1, 1))
 
 var parts = [];
 >parts : Symbol(parts, Decl(globalThisCapture.ts, 3, 3))
diff --git a/tests/baselines/reference/heterogeneousArrayLiterals.symbols b/tests/baselines/reference/heterogeneousArrayLiterals.symbols
index d7700318a8204..c7a73d5641445 100644
--- a/tests/baselines/reference/heterogeneousArrayLiterals.symbols
+++ b/tests/baselines/reference/heterogeneousArrayLiterals.symbols
@@ -12,11 +12,9 @@ var c = [1, '', null]; // {}[]
 
 var d = [{}, 1]; // {}[]
 >d : Symbol(d, Decl(heterogeneousArrayLiterals.ts, 5, 3))
->{} : Symbol(, Decl(heterogeneousArrayLiterals.ts, 5, 9))
 
 var e = [{}, Object]; // {}[]
 >e : Symbol(e, Decl(heterogeneousArrayLiterals.ts, 6, 3))
->{} : Symbol(, Decl(heterogeneousArrayLiterals.ts, 6, 9))
 >Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
 
 var f = [[], [1]]; // number[][]
@@ -27,45 +25,30 @@ var g = [[1], ['']]; // {}[]
 
 var h = [{ foo: 1, bar: '' }, { foo: 2 }]; // {foo: number}[]
 >h : Symbol(h, Decl(heterogeneousArrayLiterals.ts, 11, 3))
->{ foo: 1, bar: '' } : Symbol(, Decl(heterogeneousArrayLiterals.ts, 11, 9))
 >foo : Symbol(foo, Decl(heterogeneousArrayLiterals.ts, 11, 10))
 >bar : Symbol(bar, Decl(heterogeneousArrayLiterals.ts, 11, 18))
->{ foo: 2 } : Symbol(, Decl(heterogeneousArrayLiterals.ts, 11, 29))
 >foo : Symbol(foo, Decl(heterogeneousArrayLiterals.ts, 11, 31))
 
 var i = [{ foo: 1, bar: '' }, { foo: '' }]; // {}[]
 >i : Symbol(i, Decl(heterogeneousArrayLiterals.ts, 12, 3))
->{ foo: 1, bar: '' } : Symbol(, Decl(heterogeneousArrayLiterals.ts, 12, 9))
 >foo : Symbol(foo, Decl(heterogeneousArrayLiterals.ts, 12, 10))
 >bar : Symbol(bar, Decl(heterogeneousArrayLiterals.ts, 12, 18))
->{ foo: '' } : Symbol(, Decl(heterogeneousArrayLiterals.ts, 12, 29))
 >foo : Symbol(foo, Decl(heterogeneousArrayLiterals.ts, 12, 31))
 
 var j = [() => 1, () => '']; // {}[]
 >j : Symbol(j, Decl(heterogeneousArrayLiterals.ts, 14, 3))
->() => 1 : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 14, 9))
->() => '' : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 14, 17))
 
 var k = [() => 1, () => 1]; // { (): number }[]
 >k : Symbol(k, Decl(heterogeneousArrayLiterals.ts, 15, 3))
->() => 1 : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 15, 9))
->() => 1 : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 15, 17))
 
 var l = [() => 1, () => null]; // { (): any }[]
 >l : Symbol(l, Decl(heterogeneousArrayLiterals.ts, 16, 3))
->() => 1 : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 16, 9))
->() => null : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 16, 17))
 
 var m = [() => 1, () => '', () => null]; // { (): any }[]
 >m : Symbol(m, Decl(heterogeneousArrayLiterals.ts, 17, 3))
->() => 1 : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 17, 9))
->() => '' : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 17, 17))
->() => null : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 17, 27))
 
 var n = [[() => 1], [() => '']]; // {}[]
 >n : Symbol(n, Decl(heterogeneousArrayLiterals.ts, 18, 3))
->() => 1 : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 18, 10))
->() => '' : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 18, 21))
 
 class Base { foo: string; }
 >Base : Symbol(Base, Decl(heterogeneousArrayLiterals.ts, 18, 32))
@@ -98,58 +81,43 @@ module Derived {
 
     var h = [{ foo: base, basear: derived }, { foo: base }]; // {foo: Base}[]
 >h : Symbol(h, Decl(heterogeneousArrayLiterals.ts, 28, 7))
->{ foo: base, basear: derived } : Symbol(, Decl(heterogeneousArrayLiterals.ts, 28, 13))
 >foo : Symbol(foo, Decl(heterogeneousArrayLiterals.ts, 28, 14))
 >base : Symbol(base, Decl(heterogeneousArrayLiterals.ts, 23, 3))
 >basear : Symbol(basear, Decl(heterogeneousArrayLiterals.ts, 28, 25))
 >derived : Symbol(derived, Decl(heterogeneousArrayLiterals.ts, 24, 3))
->{ foo: base } : Symbol(, Decl(heterogeneousArrayLiterals.ts, 28, 44))
 >foo : Symbol(foo, Decl(heterogeneousArrayLiterals.ts, 28, 46))
 >base : Symbol(base, Decl(heterogeneousArrayLiterals.ts, 23, 3))
 
     var i = [{ foo: base, basear: derived }, { foo: derived }]; // {foo: Derived}[]
 >i : Symbol(i, Decl(heterogeneousArrayLiterals.ts, 29, 7))
->{ foo: base, basear: derived } : Symbol(, Decl(heterogeneousArrayLiterals.ts, 29, 13))
 >foo : Symbol(foo, Decl(heterogeneousArrayLiterals.ts, 29, 14))
 >base : Symbol(base, Decl(heterogeneousArrayLiterals.ts, 23, 3))
 >basear : Symbol(basear, Decl(heterogeneousArrayLiterals.ts, 29, 25))
 >derived : Symbol(derived, Decl(heterogeneousArrayLiterals.ts, 24, 3))
->{ foo: derived } : Symbol(, Decl(heterogeneousArrayLiterals.ts, 29, 44))
 >foo : Symbol(foo, Decl(heterogeneousArrayLiterals.ts, 29, 46))
 >derived : Symbol(derived, Decl(heterogeneousArrayLiterals.ts, 24, 3))
 
     var j = [() => base, () => derived]; // { {}: Base }
 >j : Symbol(j, Decl(heterogeneousArrayLiterals.ts, 31, 7))
->() => base : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 31, 13))
 >base : Symbol(base, Decl(heterogeneousArrayLiterals.ts, 23, 3))
->() => derived : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 31, 24))
 >derived : Symbol(derived, Decl(heterogeneousArrayLiterals.ts, 24, 3))
 
     var k = [() => base, () => 1]; // {}[]~
 >k : Symbol(k, Decl(heterogeneousArrayLiterals.ts, 32, 7))
->() => base : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 32, 13))
 >base : Symbol(base, Decl(heterogeneousArrayLiterals.ts, 23, 3))
->() => 1 : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 32, 24))
 
     var l = [() => base, () => null]; // { (): any }[]
 >l : Symbol(l, Decl(heterogeneousArrayLiterals.ts, 33, 7))
->() => base : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 33, 13))
 >base : Symbol(base, Decl(heterogeneousArrayLiterals.ts, 23, 3))
->() => null : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 33, 24))
 
     var m = [() => base, () => derived, () => null]; // { (): any }[]
 >m : Symbol(m, Decl(heterogeneousArrayLiterals.ts, 34, 7))
->() => base : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 34, 13))
 >base : Symbol(base, Decl(heterogeneousArrayLiterals.ts, 23, 3))
->() => derived : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 34, 24))
 >derived : Symbol(derived, Decl(heterogeneousArrayLiterals.ts, 24, 3))
->() => null : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 34, 39))
 
     var n = [[() => base], [() => derived]]; // { (): Base }[]
 >n : Symbol(n, Decl(heterogeneousArrayLiterals.ts, 35, 7))
->() => base : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 35, 14))
 >base : Symbol(base, Decl(heterogeneousArrayLiterals.ts, 23, 3))
->() => derived : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 35, 28))
 >derived : Symbol(derived, Decl(heterogeneousArrayLiterals.ts, 24, 3))
 
     var o = [derived, derived2]; // {}[]
@@ -165,9 +133,7 @@ module Derived {
 
     var q = [[() => derived2], [() => derived]]; // {}[]
 >q : Symbol(q, Decl(heterogeneousArrayLiterals.ts, 38, 7))
->() => derived2 : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 38, 14))
 >derived2 : Symbol(derived2, Decl(heterogeneousArrayLiterals.ts, 25, 3))
->() => derived : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 38, 32))
 >derived : Symbol(derived, Decl(heterogeneousArrayLiterals.ts, 24, 3))
 }
 
@@ -192,9 +158,7 @@ module WithContextualType {
     var d: { (): Base }[] = [() => derived, () => derived2];
 >d : Symbol(d, Decl(heterogeneousArrayLiterals.ts, 46, 7))
 >Base : Symbol(Base, Decl(heterogeneousArrayLiterals.ts, 18, 32))
->() => derived : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 46, 29))
 >derived : Symbol(derived, Decl(heterogeneousArrayLiterals.ts, 24, 3))
->() => derived2 : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 46, 43))
 >derived2 : Symbol(derived2, Decl(heterogeneousArrayLiterals.ts, 25, 3))
 }
 
@@ -227,18 +191,13 @@ function foo<T, U>(t: T, u: U) {
 
     var e = [() => t, () => u]; // {}[]
 >e : Symbol(e, Decl(heterogeneousArrayLiterals.ts, 54, 7))
->() => t : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 54, 13))
 >t : Symbol(t, Decl(heterogeneousArrayLiterals.ts, 49, 19))
->() => u : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 54, 21))
 >u : Symbol(u, Decl(heterogeneousArrayLiterals.ts, 49, 24))
 
     var f = [() => t, () => u, () => null]; // { (): any }[]
 >f : Symbol(f, Decl(heterogeneousArrayLiterals.ts, 55, 7))
->() => t : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 55, 13))
 >t : Symbol(t, Decl(heterogeneousArrayLiterals.ts, 49, 19))
->() => u : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 55, 21))
 >u : Symbol(u, Decl(heterogeneousArrayLiterals.ts, 49, 24))
->() => null : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 55, 30))
 }
 
 function foo2<T extends Base, U extends Derived>(t: T, u: U) {
@@ -272,18 +231,13 @@ function foo2<T extends Base, U extends Derived>(t: T, u: U) {
 
     var e = [() => t, () => u]; // {}[]
 >e : Symbol(e, Decl(heterogeneousArrayLiterals.ts, 63, 7))
->() => t : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 63, 13))
 >t : Symbol(t, Decl(heterogeneousArrayLiterals.ts, 58, 49))
->() => u : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 63, 21))
 >u : Symbol(u, Decl(heterogeneousArrayLiterals.ts, 58, 54))
 
     var f = [() => t, () => u, () => null]; // { (): any }[]
 >f : Symbol(f, Decl(heterogeneousArrayLiterals.ts, 64, 7))
->() => t : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 64, 13))
 >t : Symbol(t, Decl(heterogeneousArrayLiterals.ts, 58, 49))
->() => u : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 64, 21))
 >u : Symbol(u, Decl(heterogeneousArrayLiterals.ts, 58, 54))
->() => null : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 64, 30))
 
     var g = [t, base]; // Base[]
 >g : Symbol(g, Decl(heterogeneousArrayLiterals.ts, 66, 7))
@@ -337,18 +291,13 @@ function foo3<T extends Derived, U extends Derived>(t: T, u: U) {
 
     var e = [() => t, () => u]; // {}[]
 >e : Symbol(e, Decl(heterogeneousArrayLiterals.ts, 77, 7))
->() => t : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 77, 13))
 >t : Symbol(t, Decl(heterogeneousArrayLiterals.ts, 72, 52))
->() => u : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 77, 21))
 >u : Symbol(u, Decl(heterogeneousArrayLiterals.ts, 72, 57))
 
     var f = [() => t, () => u, () => null]; // { (): any }[]
 >f : Symbol(f, Decl(heterogeneousArrayLiterals.ts, 78, 7))
->() => t : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 78, 13))
 >t : Symbol(t, Decl(heterogeneousArrayLiterals.ts, 72, 52))
->() => u : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 78, 21))
 >u : Symbol(u, Decl(heterogeneousArrayLiterals.ts, 72, 57))
->() => null : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 78, 30))
 
     var g = [t, base]; // Base[]
 >g : Symbol(g, Decl(heterogeneousArrayLiterals.ts, 80, 7))
@@ -402,18 +351,13 @@ function foo4<T extends Base, U extends Base>(t: T, u: U) {
 
     var e = [() => t, () => u]; // {}[]
 >e : Symbol(e, Decl(heterogeneousArrayLiterals.ts, 91, 7))
->() => t : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 91, 13))
 >t : Symbol(t, Decl(heterogeneousArrayLiterals.ts, 86, 46))
->() => u : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 91, 21))
 >u : Symbol(u, Decl(heterogeneousArrayLiterals.ts, 86, 51))
 
     var f = [() => t, () => u, () => null]; // { (): any }[]
 >f : Symbol(f, Decl(heterogeneousArrayLiterals.ts, 92, 7))
->() => t : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 92, 13))
 >t : Symbol(t, Decl(heterogeneousArrayLiterals.ts, 86, 46))
->() => u : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 92, 21))
 >u : Symbol(u, Decl(heterogeneousArrayLiterals.ts, 86, 51))
->() => null : Symbol((Anonymous function), Decl(heterogeneousArrayLiterals.ts, 92, 30))
 
     var g = [t, base]; // Base[]
 >g : Symbol(g, Decl(heterogeneousArrayLiterals.ts, 94, 7))
diff --git a/tests/baselines/reference/ifDoWhileStatements.symbols b/tests/baselines/reference/ifDoWhileStatements.symbols
index 49774ec6233a1..36a990010efe4 100644
--- a/tests/baselines/reference/ifDoWhileStatements.symbols
+++ b/tests/baselines/reference/ifDoWhileStatements.symbols
@@ -133,37 +133,24 @@ while ([1, 2]) { }
 do { }while([1, 2])
 
 if ({}) { }
->{} : Symbol(, Decl(ifDoWhileStatements.ts, 75, 4))
-
 while ({}) { }
->{} : Symbol(, Decl(ifDoWhileStatements.ts, 76, 7))
-
 do { }while({})
->{} : Symbol(, Decl(ifDoWhileStatements.ts, 77, 12))
 
 if ({ x: 1, y: 'a' }) { }
->{ x: 1, y: 'a' } : Symbol(, Decl(ifDoWhileStatements.ts, 79, 4))
 >x : Symbol(x, Decl(ifDoWhileStatements.ts, 79, 5))
 >y : Symbol(y, Decl(ifDoWhileStatements.ts, 79, 11))
 
 while ({ x: 1, y: 'a' }) { }
->{ x: 1, y: 'a' } : Symbol(, Decl(ifDoWhileStatements.ts, 80, 7))
 >x : Symbol(x, Decl(ifDoWhileStatements.ts, 80, 8))
 >y : Symbol(y, Decl(ifDoWhileStatements.ts, 80, 14))
 
 do { }while({ x: 1, y: 'a' })
->{ x: 1, y: 'a' } : Symbol(, Decl(ifDoWhileStatements.ts, 81, 12))
 >x : Symbol(x, Decl(ifDoWhileStatements.ts, 81, 13))
 >y : Symbol(y, Decl(ifDoWhileStatements.ts, 81, 19))
 
 if (() => 43) { }
->() => 43 : Symbol((Anonymous function), Decl(ifDoWhileStatements.ts, 83, 4))
-
 while (() => 43) { }
->() => 43 : Symbol((Anonymous function), Decl(ifDoWhileStatements.ts, 84, 7))
-
 do { }while(() => 43)
->() => 43 : Symbol((Anonymous function), Decl(ifDoWhileStatements.ts, 85, 12))
 
 if (new C()) { }
 >C : Symbol(C, Decl(ifDoWhileStatements.ts, 2, 1))
@@ -298,7 +285,6 @@ do { }while(i)
 
 var j = {};
 >j : Symbol(j, Decl(ifDoWhileStatements.ts, 141, 3))
->{} : Symbol(, Decl(ifDoWhileStatements.ts, 141, 7))
 
 if (j) { }
 >j : Symbol(j, Decl(ifDoWhileStatements.ts, 141, 3))
@@ -311,7 +297,6 @@ do { }while(j)
 
 var k = { x: 1, y: 'a' };
 >k : Symbol(k, Decl(ifDoWhileStatements.ts, 146, 3))
->{ x: 1, y: 'a' } : Symbol(, Decl(ifDoWhileStatements.ts, 146, 7))
 >x : Symbol(x, Decl(ifDoWhileStatements.ts, 146, 9))
 >y : Symbol(y, Decl(ifDoWhileStatements.ts, 146, 15))
 
diff --git a/tests/baselines/reference/implicitAnyAnyReturningFunction.symbols b/tests/baselines/reference/implicitAnyAnyReturningFunction.symbols
index c163a2e166845..73e91853255bf 100644
--- a/tests/baselines/reference/implicitAnyAnyReturningFunction.symbols
+++ b/tests/baselines/reference/implicitAnyAnyReturningFunction.symbols
@@ -10,7 +10,6 @@ function B() {
 
     var someLocal: any = {};
 >someLocal : Symbol(someLocal, Decl(implicitAnyAnyReturningFunction.ts, 5, 7))
->{} : Symbol(, Decl(implicitAnyAnyReturningFunction.ts, 5, 24))
 
     return someLocal;
 >someLocal : Symbol(someLocal, Decl(implicitAnyAnyReturningFunction.ts, 5, 7))
@@ -30,7 +29,6 @@ class C {
 
         var someLocal: any = {};
 >someLocal : Symbol(someLocal, Decl(implicitAnyAnyReturningFunction.ts, 15, 11))
->{} : Symbol(, Decl(implicitAnyAnyReturningFunction.ts, 15, 28))
 
         return someLocal;
 >someLocal : Symbol(someLocal, Decl(implicitAnyAnyReturningFunction.ts, 15, 11))
diff --git a/tests/baselines/reference/importAliasIdentifiers.symbols b/tests/baselines/reference/importAliasIdentifiers.symbols
index d4cf2bd7a87ed..3b2ba0ea46abf 100644
--- a/tests/baselines/reference/importAliasIdentifiers.symbols
+++ b/tests/baselines/reference/importAliasIdentifiers.symbols
@@ -50,7 +50,6 @@ module clodule {
     var Point: Point = { x: 0, y: 0 };
 >Point : Symbol(Point, Decl(importAliasIdentifiers.ts, 16, 16), Decl(importAliasIdentifiers.ts, 20, 7))
 >Point : Symbol(Point, Decl(importAliasIdentifiers.ts, 16, 16))
->{ x: 0, y: 0 } : Symbol(, Decl(importAliasIdentifiers.ts, 20, 22))
 >x : Symbol(x, Decl(importAliasIdentifiers.ts, 20, 24))
 >y : Symbol(y, Decl(importAliasIdentifiers.ts, 20, 30))
 }
@@ -79,7 +78,6 @@ function fundule() {
 >fundule : Symbol(fundule, Decl(importAliasIdentifiers.ts, 27, 33), Decl(importAliasIdentifiers.ts, 32, 1))
 
     return { x: 0, y: 0 };
->{ x: 0, y: 0 } : Symbol(, Decl(importAliasIdentifiers.ts, 31, 10))
 >x : Symbol(x, Decl(importAliasIdentifiers.ts, 31, 12))
 >y : Symbol(y, Decl(importAliasIdentifiers.ts, 31, 18))
 }
@@ -97,7 +95,6 @@ module fundule {
     var Point: Point = { x: 0, y: 0 };
 >Point : Symbol(Point, Decl(importAliasIdentifiers.ts, 34, 16), Decl(importAliasIdentifiers.ts, 38, 7))
 >Point : Symbol(Point, Decl(importAliasIdentifiers.ts, 34, 16))
->{ x: 0, y: 0 } : Symbol(, Decl(importAliasIdentifiers.ts, 38, 22))
 >x : Symbol(x, Decl(importAliasIdentifiers.ts, 38, 24))
 >y : Symbol(y, Decl(importAliasIdentifiers.ts, 38, 30))
 }
diff --git a/tests/baselines/reference/importInTypePosition.symbols b/tests/baselines/reference/importInTypePosition.symbols
index a91e28bac8ec0..08f55093c5037 100644
--- a/tests/baselines/reference/importInTypePosition.symbols
+++ b/tests/baselines/reference/importInTypePosition.symbols
@@ -41,7 +41,6 @@ module C {
 
     var p = { x: 0, y: 0 };
 >p : Symbol(p, Decl(importInTypePosition.ts, 17, 7), Decl(importInTypePosition.ts, 18, 7))
->{ x: 0, y: 0 } : Symbol(, Decl(importInTypePosition.ts, 18, 11))
 >x : Symbol(x, Decl(importInTypePosition.ts, 18, 13))
 >y : Symbol(y, Decl(importInTypePosition.ts, 18, 19))
 }
diff --git a/tests/baselines/reference/importStatements.symbols b/tests/baselines/reference/importStatements.symbols
index 62d5a16f5e5ba..b160dcf2888b8 100644
--- a/tests/baselines/reference/importStatements.symbols
+++ b/tests/baselines/reference/importStatements.symbols
@@ -43,7 +43,6 @@ module C {
 
     var p = {x:0, y:0 };
 >p : Symbol(p, Decl(importStatements.ts, 17, 7), Decl(importStatements.ts, 18, 7))
->{x:0, y:0 } : Symbol(, Decl(importStatements.ts, 18, 11))
 >x : Symbol(x, Decl(importStatements.ts, 18, 13))
 >y : Symbol(y, Decl(importStatements.ts, 18, 17))
 }
diff --git a/tests/baselines/reference/inOperatorWithFunction.symbols b/tests/baselines/reference/inOperatorWithFunction.symbols
index bf30bd3460933..1e915ba107d80 100644
--- a/tests/baselines/reference/inOperatorWithFunction.symbols
+++ b/tests/baselines/reference/inOperatorWithFunction.symbols
@@ -1,11 +1,9 @@
 === tests/cases/compiler/inOperatorWithFunction.ts ===
 var fn = function (val: boolean) { return val; }
 >fn : Symbol(fn, Decl(inOperatorWithFunction.ts, 0, 3))
->function (val: boolean) { return val; } : Symbol((Anonymous function), Decl(inOperatorWithFunction.ts, 0, 8))
 >val : Symbol(val, Decl(inOperatorWithFunction.ts, 0, 19))
 >val : Symbol(val, Decl(inOperatorWithFunction.ts, 0, 19))
 
 fn("a" in { "a": true });
 >fn : Symbol(fn, Decl(inOperatorWithFunction.ts, 0, 3))
->{ "a": true } : Symbol(, Decl(inOperatorWithFunction.ts, 1, 9))
 
diff --git a/tests/baselines/reference/inOperatorWithValidOperands.symbols b/tests/baselines/reference/inOperatorWithValidOperands.symbols
index 2752ed91d3a81..07e0bd4f6de1b 100644
--- a/tests/baselines/reference/inOperatorWithValidOperands.symbols
+++ b/tests/baselines/reference/inOperatorWithValidOperands.symbols
@@ -46,7 +46,6 @@ var rb1 = x in b1;
 var rb2 = x in {};
 >rb2 : Symbol(rb2, Decl(inOperatorWithValidOperands.ts, 18, 3))
 >x : Symbol(x, Decl(inOperatorWithValidOperands.ts, 0, 3))
->{} : Symbol(, Decl(inOperatorWithValidOperands.ts, 18, 14))
 
 function foo<T>(t: T) {
 >foo : Symbol(foo, Decl(inOperatorWithValidOperands.ts, 18, 18))
diff --git a/tests/baselines/reference/incrementOperatorWithAnyOtherType.symbols b/tests/baselines/reference/incrementOperatorWithAnyOtherType.symbols
index 2d855ec719883..d0af700ea8e81 100644
--- a/tests/baselines/reference/incrementOperatorWithAnyOtherType.symbols
+++ b/tests/baselines/reference/incrementOperatorWithAnyOtherType.symbols
@@ -12,7 +12,6 @@ var ANY2: any[] = ["", ""];
 
 var obj = {x:1,y:null};
 >obj : Symbol(obj, Decl(incrementOperatorWithAnyOtherType.ts, 5, 3))
->{x:1,y:null} : Symbol(, Decl(incrementOperatorWithAnyOtherType.ts, 5, 9))
 >x : Symbol(x, Decl(incrementOperatorWithAnyOtherType.ts, 5, 11))
 >y : Symbol(y, Decl(incrementOperatorWithAnyOtherType.ts, 5, 15))
 
diff --git a/tests/baselines/reference/indexSignaturesInferentialTyping.symbols b/tests/baselines/reference/indexSignaturesInferentialTyping.symbols
index 336a9a2f2a273..a34aa7a5cd186 100644
--- a/tests/baselines/reference/indexSignaturesInferentialTyping.symbols
+++ b/tests/baselines/reference/indexSignaturesInferentialTyping.symbols
@@ -20,24 +20,20 @@ function bar<T>(items: { [index: string]: T }): T { return undefined; }
 var x1 = foo({ 0: 0, 1: 1 });       // type should be number
 >x1 : Symbol(x1, Decl(indexSignaturesInferentialTyping.ts, 3, 3))
 >foo : Symbol(foo, Decl(indexSignaturesInferentialTyping.ts, 0, 0))
->{ 0: 0, 1: 1 } : Symbol(, Decl(indexSignaturesInferentialTyping.ts, 3, 13))
 
 var x2 = foo({ zero: 0, one: 1 });
 >x2 : Symbol(x2, Decl(indexSignaturesInferentialTyping.ts, 4, 3))
 >foo : Symbol(foo, Decl(indexSignaturesInferentialTyping.ts, 0, 0))
->{ zero: 0, one: 1 } : Symbol(, Decl(indexSignaturesInferentialTyping.ts, 4, 13))
 >zero : Symbol(zero, Decl(indexSignaturesInferentialTyping.ts, 4, 14))
 >one : Symbol(one, Decl(indexSignaturesInferentialTyping.ts, 4, 23))
 
 var x3 = bar({ 0: 0, 1: 1 });
 >x3 : Symbol(x3, Decl(indexSignaturesInferentialTyping.ts, 5, 3))
 >bar : Symbol(bar, Decl(indexSignaturesInferentialTyping.ts, 0, 71))
->{ 0: 0, 1: 1 } : Symbol(, Decl(indexSignaturesInferentialTyping.ts, 5, 13))
 
 var x4 = bar({ zero: 0, one: 1 });  // type should be number
 >x4 : Symbol(x4, Decl(indexSignaturesInferentialTyping.ts, 6, 3))
 >bar : Symbol(bar, Decl(indexSignaturesInferentialTyping.ts, 0, 71))
->{ zero: 0, one: 1 } : Symbol(, Decl(indexSignaturesInferentialTyping.ts, 6, 13))
 >zero : Symbol(zero, Decl(indexSignaturesInferentialTyping.ts, 6, 14))
 >one : Symbol(one, Decl(indexSignaturesInferentialTyping.ts, 6, 23))
 
diff --git a/tests/baselines/reference/indexer.symbols b/tests/baselines/reference/indexer.symbols
index 1abcc566bf1da..409bd8092d674 100644
--- a/tests/baselines/reference/indexer.symbols
+++ b/tests/baselines/reference/indexer.symbols
@@ -17,10 +17,7 @@ interface JQuery {
 var jq:JQuery={ 0: { id : "a" }, 1: { id : "b" } };
 >jq : Symbol(jq, Decl(indexer.ts, 8, 3))
 >JQuery : Symbol(JQuery, Decl(indexer.ts, 2, 1))
->{ 0: { id : "a" }, 1: { id : "b" } } : Symbol(, Decl(indexer.ts, 8, 14))
->{ id : "a" } : Symbol(, Decl(indexer.ts, 8, 18))
 >id : Symbol(id, Decl(indexer.ts, 8, 20))
->{ id : "b" } : Symbol(, Decl(indexer.ts, 8, 35))
 >id : Symbol(id, Decl(indexer.ts, 8, 37))
 
 jq[0].id;
diff --git a/tests/baselines/reference/indexer2.symbols b/tests/baselines/reference/indexer2.symbols
index 5533a3f298aee..c23debb925c90 100644
--- a/tests/baselines/reference/indexer2.symbols
+++ b/tests/baselines/reference/indexer2.symbols
@@ -16,5 +16,4 @@ interface IDirectChildrenMap {
 var directChildrenMap = <IDirectChildrenMap>{}; 
 >directChildrenMap : Symbol(directChildrenMap, Decl(indexer2.ts, 5, 3))
 >IDirectChildrenMap : Symbol(IDirectChildrenMap, Decl(indexer2.ts, 0, 32))
->{} : Symbol(, Decl(indexer2.ts, 5, 44))
 
diff --git a/tests/baselines/reference/indexer3.symbols b/tests/baselines/reference/indexer3.symbols
index 283e7d2dc6204..1de91806faadd 100644
--- a/tests/baselines/reference/indexer3.symbols
+++ b/tests/baselines/reference/indexer3.symbols
@@ -3,7 +3,6 @@ var dateMap: { [x: string]: Date; } = {}
 >dateMap : Symbol(dateMap, Decl(indexer3.ts, 0, 3))
 >x : Symbol(x, Decl(indexer3.ts, 0, 16))
 >Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->{} : Symbol(, Decl(indexer3.ts, 0, 37))
 
 var r: Date = dateMap["hello"] // result type includes indexer using BCT
 >r : Symbol(r, Decl(indexer3.ts, 1, 3))
diff --git a/tests/baselines/reference/indexerA.symbols b/tests/baselines/reference/indexerA.symbols
index 7bbdabd7df34a..d549c3359d9c5 100644
--- a/tests/baselines/reference/indexerA.symbols
+++ b/tests/baselines/reference/indexerA.symbols
@@ -17,10 +17,7 @@ class JQuery {
 var jq:JQuery={ 0: { id : "a" }, 1: { id : "b" } };
 >jq : Symbol(jq, Decl(indexerA.ts, 8, 3))
 >JQuery : Symbol(JQuery, Decl(indexerA.ts, 2, 1))
->{ 0: { id : "a" }, 1: { id : "b" } } : Symbol(, Decl(indexerA.ts, 8, 14))
->{ id : "a" } : Symbol(, Decl(indexerA.ts, 8, 18))
 >id : Symbol(id, Decl(indexerA.ts, 8, 20))
->{ id : "b" } : Symbol(, Decl(indexerA.ts, 8, 35))
 >id : Symbol(id, Decl(indexerA.ts, 8, 37))
 
 jq[0].id;
diff --git a/tests/baselines/reference/inferSecondaryParameter.symbols b/tests/baselines/reference/inferSecondaryParameter.symbols
index 5de50ab71b8cf..c2527ed14b34a 100644
--- a/tests/baselines/reference/inferSecondaryParameter.symbols
+++ b/tests/baselines/reference/inferSecondaryParameter.symbols
@@ -11,9 +11,7 @@ interface Ib { m(test: string, fn: Function); }
 var b: Ib = { m: function (test: string, fn: Function) { } };
 >b : Symbol(b, Decl(inferSecondaryParameter.ts, 4, 3))
 >Ib : Symbol(Ib, Decl(inferSecondaryParameter.ts, 0, 0))
->{ m: function (test: string, fn: Function) { } } : Symbol(, Decl(inferSecondaryParameter.ts, 4, 11))
 >m : Symbol(m, Decl(inferSecondaryParameter.ts, 4, 13))
->function (test: string, fn: Function) { } : Symbol((Anonymous function), Decl(inferSecondaryParameter.ts, 4, 16))
 >test : Symbol(test, Decl(inferSecondaryParameter.ts, 4, 27))
 >fn : Symbol(fn, Decl(inferSecondaryParameter.ts, 4, 40))
 >Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
@@ -22,7 +20,6 @@ b.m("test", function (bug) {
 >b.m : Symbol(Ib.m, Decl(inferSecondaryParameter.ts, 2, 14))
 >b : Symbol(b, Decl(inferSecondaryParameter.ts, 4, 3))
 >m : Symbol(Ib.m, Decl(inferSecondaryParameter.ts, 2, 14))
->function (bug) {    var a: number = bug;} : Symbol((Anonymous function), Decl(inferSecondaryParameter.ts, 6, 11))
 >bug : Symbol(bug, Decl(inferSecondaryParameter.ts, 6, 22))
 
     var a: number = bug;
diff --git a/tests/baselines/reference/inferenceFromParameterlessLambda.symbols b/tests/baselines/reference/inferenceFromParameterlessLambda.symbols
index be5a18e37ffa0..6170a4d1149db 100644
--- a/tests/baselines/reference/inferenceFromParameterlessLambda.symbols
+++ b/tests/baselines/reference/inferenceFromParameterlessLambda.symbols
@@ -27,10 +27,8 @@ interface Take<T> {
 // Infer string from second argument because it isn't context sensitive
 foo(n => n.length, () => 'hi');
 >foo : Symbol(foo, Decl(inferenceFromParameterlessLambda.ts, 0, 0))
->n => n.length : Symbol((Anonymous function), Decl(inferenceFromParameterlessLambda.ts, 8, 4))
 >n : Symbol(n, Decl(inferenceFromParameterlessLambda.ts, 8, 4))
 >n.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >n : Symbol(n, Decl(inferenceFromParameterlessLambda.ts, 8, 4))
 >length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
->() => 'hi' : Symbol((Anonymous function), Decl(inferenceFromParameterlessLambda.ts, 8, 18))
 
diff --git a/tests/baselines/reference/inferentialTypingObjectLiteralMethod1.symbols b/tests/baselines/reference/inferentialTypingObjectLiteralMethod1.symbols
index 78bcd905864c8..3fee48fc837d2 100644
--- a/tests/baselines/reference/inferentialTypingObjectLiteralMethod1.symbols
+++ b/tests/baselines/reference/inferentialTypingObjectLiteralMethod1.symbols
@@ -28,13 +28,11 @@ declare function foo<T, U>(x: T, y: Int<T, U>, z: Int<U, T>): T;
 
 foo("", { method(p1) { return p1.length } }, { method(p2) { return undefined } });
 >foo : Symbol(foo, Decl(inferentialTypingObjectLiteralMethod1.ts, 2, 1))
->{ method(p1) { return p1.length } } : Symbol(, Decl(inferentialTypingObjectLiteralMethod1.ts, 4, 7))
 >method : Symbol(method, Decl(inferentialTypingObjectLiteralMethod1.ts, 4, 9))
 >p1 : Symbol(p1, Decl(inferentialTypingObjectLiteralMethod1.ts, 4, 17))
 >p1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >p1 : Symbol(p1, Decl(inferentialTypingObjectLiteralMethod1.ts, 4, 17))
 >length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
->{ method(p2) { return undefined } } : Symbol(, Decl(inferentialTypingObjectLiteralMethod1.ts, 4, 44))
 >method : Symbol(method, Decl(inferentialTypingObjectLiteralMethod1.ts, 4, 46))
 >p2 : Symbol(p2, Decl(inferentialTypingObjectLiteralMethod1.ts, 4, 54))
 >undefined : Symbol(undefined)
diff --git a/tests/baselines/reference/inferentialTypingObjectLiteralMethod2.symbols b/tests/baselines/reference/inferentialTypingObjectLiteralMethod2.symbols
index 5fe57e21763eb..fc8d39858b654 100644
--- a/tests/baselines/reference/inferentialTypingObjectLiteralMethod2.symbols
+++ b/tests/baselines/reference/inferentialTypingObjectLiteralMethod2.symbols
@@ -28,13 +28,11 @@ declare function foo<T, U>(x: T, y: Int<T, U>, z: Int<U, T>): T;
 
 foo("", { method(p1) { return p1.length } }, { method(p2) { return undefined } });
 >foo : Symbol(foo, Decl(inferentialTypingObjectLiteralMethod2.ts, 2, 1))
->{ method(p1) { return p1.length } } : Symbol(, Decl(inferentialTypingObjectLiteralMethod2.ts, 4, 7))
 >method : Symbol(method, Decl(inferentialTypingObjectLiteralMethod2.ts, 4, 9))
 >p1 : Symbol(p1, Decl(inferentialTypingObjectLiteralMethod2.ts, 4, 17))
 >p1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >p1 : Symbol(p1, Decl(inferentialTypingObjectLiteralMethod2.ts, 4, 17))
 >length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
->{ method(p2) { return undefined } } : Symbol(, Decl(inferentialTypingObjectLiteralMethod2.ts, 4, 44))
 >method : Symbol(method, Decl(inferentialTypingObjectLiteralMethod2.ts, 4, 46))
 >p2 : Symbol(p2, Decl(inferentialTypingObjectLiteralMethod2.ts, 4, 54))
 >undefined : Symbol(undefined)
diff --git a/tests/baselines/reference/inferentialTypingWithFunctionTypeNested.symbols b/tests/baselines/reference/inferentialTypingWithFunctionTypeNested.symbols
index 7830e7d2c85cd..ae72021b31bdd 100644
--- a/tests/baselines/reference/inferentialTypingWithFunctionTypeNested.symbols
+++ b/tests/baselines/reference/inferentialTypingWithFunctionTypeNested.symbols
@@ -22,8 +22,6 @@ declare function identity<V>(y: V): V;
 var s = map("", () => { return { x: identity }; });
 >s : Symbol(s, Decl(inferentialTypingWithFunctionTypeNested.ts, 3, 3))
 >map : Symbol(map, Decl(inferentialTypingWithFunctionTypeNested.ts, 0, 0))
->() => { return { x: identity }; } : Symbol((Anonymous function), Decl(inferentialTypingWithFunctionTypeNested.ts, 3, 15))
->{ x: identity } : Symbol(, Decl(inferentialTypingWithFunctionTypeNested.ts, 3, 30))
 >x : Symbol(x, Decl(inferentialTypingWithFunctionTypeNested.ts, 3, 32))
 >identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeNested.ts, 0, 65))
 
diff --git a/tests/baselines/reference/inferentialTypingWithFunctionTypeSyntacticScenarios.symbols b/tests/baselines/reference/inferentialTypingWithFunctionTypeSyntacticScenarios.symbols
index a340910a6d997..a9571bc8a388d 100644
--- a/tests/baselines/reference/inferentialTypingWithFunctionTypeSyntacticScenarios.symbols
+++ b/tests/baselines/reference/inferentialTypingWithFunctionTypeSyntacticScenarios.symbols
@@ -24,7 +24,6 @@ var s: string;
 // dotted name
 var dottedIdentity = { x: identity };
 >dottedIdentity : Symbol(dottedIdentity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 5, 3))
->{ x: identity } : Symbol(, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 5, 20))
 >x : Symbol(x, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 5, 22))
 >identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 59))
 
@@ -46,7 +45,6 @@ s = map("", dottedIdentity['x']);
 s = map("", (() => identity)());
 >s : Symbol(s, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 2, 3))
 >map : Symbol(map, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 0))
->() => identity : Symbol((Anonymous function), Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 12, 13))
 >identity : Symbol(identity, Decl(inferentialTypingWithFunctionTypeSyntacticScenarios.ts, 0, 59))
 
 // construct
diff --git a/tests/baselines/reference/inheritedFunctionAssignmentCompatibility.symbols b/tests/baselines/reference/inheritedFunctionAssignmentCompatibility.symbols
index b1ba49febc470..a76a4aad7fa0c 100644
--- a/tests/baselines/reference/inheritedFunctionAssignmentCompatibility.symbols
+++ b/tests/baselines/reference/inheritedFunctionAssignmentCompatibility.symbols
@@ -10,13 +10,11 @@ function fn(cb: IResultCallback) { }
 
 fn((a, b) => true);
 >fn : Symbol(fn, Decl(inheritedFunctionAssignmentCompatibility.ts, 0, 46))
->(a, b) => true : Symbol((Anonymous function), Decl(inheritedFunctionAssignmentCompatibility.ts, 4, 3))
 >a : Symbol(a, Decl(inheritedFunctionAssignmentCompatibility.ts, 4, 4))
 >b : Symbol(b, Decl(inheritedFunctionAssignmentCompatibility.ts, 4, 6))
 
 fn(function (a, b) { return true; })
 >fn : Symbol(fn, Decl(inheritedFunctionAssignmentCompatibility.ts, 0, 46))
->function (a, b) { return true; } : Symbol((Anonymous function), Decl(inheritedFunctionAssignmentCompatibility.ts, 5, 3))
 >a : Symbol(a, Decl(inheritedFunctionAssignmentCompatibility.ts, 5, 13))
 >b : Symbol(b, Decl(inheritedFunctionAssignmentCompatibility.ts, 5, 15))
 
diff --git a/tests/baselines/reference/initializePropertiesWithRenamedLet.symbols b/tests/baselines/reference/initializePropertiesWithRenamedLet.symbols
index 4e2250a794bc3..203508ddf9815 100644
--- a/tests/baselines/reference/initializePropertiesWithRenamedLet.symbols
+++ b/tests/baselines/reference/initializePropertiesWithRenamedLet.symbols
@@ -9,13 +9,11 @@ if (true) {
 
     var obj1 = { x0: x0 };
 >obj1 : Symbol(obj1, Decl(initializePropertiesWithRenamedLet.ts, 4, 7))
->{ x0: x0 } : Symbol(, Decl(initializePropertiesWithRenamedLet.ts, 4, 14))
 >x0 : Symbol(x0, Decl(initializePropertiesWithRenamedLet.ts, 4, 16))
 >x0 : Symbol(x0, Decl(initializePropertiesWithRenamedLet.ts, 3, 7))
 
     var obj2 = { x0 };
 >obj2 : Symbol(obj2, Decl(initializePropertiesWithRenamedLet.ts, 5, 7))
->{ x0 } : Symbol(, Decl(initializePropertiesWithRenamedLet.ts, 5, 14))
 >x0 : Symbol(x0, Decl(initializePropertiesWithRenamedLet.ts, 5, 16))
 }
 
@@ -27,27 +25,21 @@ var x, y, z;
 if (true) {
     let { x: x } = { x: 0 };
 >x : Symbol(x, Decl(initializePropertiesWithRenamedLet.ts, 10, 9))
->{ x: 0 } : Symbol(, Decl(initializePropertiesWithRenamedLet.ts, 10, 18))
 >x : Symbol(x, Decl(initializePropertiesWithRenamedLet.ts, 10, 20))
 
     let { y } = { y: 0 };
 >y : Symbol(y, Decl(initializePropertiesWithRenamedLet.ts, 11, 9))
->{ y: 0 } : Symbol(, Decl(initializePropertiesWithRenamedLet.ts, 11, 15))
 >y : Symbol(y, Decl(initializePropertiesWithRenamedLet.ts, 11, 17))
 
     let z;
 >z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 12, 7))
 
     ({ z: z } = { z: 0 });
->{ z: z } : Symbol(, Decl(initializePropertiesWithRenamedLet.ts, 13, 5))
 >z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 13, 6))
 >z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 12, 7))
->{ z: 0 } : Symbol(, Decl(initializePropertiesWithRenamedLet.ts, 13, 15))
 >z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 13, 17))
 
     ({ z } = { z: 0 });
->{ z } : Symbol(, Decl(initializePropertiesWithRenamedLet.ts, 14, 5))
 >z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 14, 6))
->{ z: 0 } : Symbol(, Decl(initializePropertiesWithRenamedLet.ts, 14, 12))
 >z : Symbol(z, Decl(initializePropertiesWithRenamedLet.ts, 14, 14))
 }
diff --git a/tests/baselines/reference/innerBoundLambdaEmit.symbols b/tests/baselines/reference/innerBoundLambdaEmit.symbols
index c4a64a54aa60c..689aa7d075b9e 100644
--- a/tests/baselines/reference/innerBoundLambdaEmit.symbols
+++ b/tests/baselines/reference/innerBoundLambdaEmit.symbols
@@ -7,7 +7,6 @@ module M {
     }
     var bar = () => { };
 >bar : Symbol(bar, Decl(innerBoundLambdaEmit.ts, 3, 7))
->() => { } : Symbol((Anonymous function), Decl(innerBoundLambdaEmit.ts, 3, 13))
 }
 interface Array<T> {
 >Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(innerBoundLambdaEmit.ts, 4, 1))
diff --git a/tests/baselines/reference/instantiatedModule.symbols b/tests/baselines/reference/instantiatedModule.symbols
index 3779bbdb48d5f..42e0edcd2217f 100644
--- a/tests/baselines/reference/instantiatedModule.symbols
+++ b/tests/baselines/reference/instantiatedModule.symbols
@@ -66,7 +66,6 @@ module M2 {
 >Point : Symbol(Point, Decl(instantiatedModule.ts, 20, 11))
 
             return { x: 0, y: 0 };
->{ x: 0, y: 0 } : Symbol(, Decl(instantiatedModule.ts, 25, 18))
 >x : Symbol(x, Decl(instantiatedModule.ts, 25, 20))
 >y : Symbol(y, Decl(instantiatedModule.ts, 25, 26))
         }
diff --git a/tests/baselines/reference/interface0.symbols b/tests/baselines/reference/interface0.symbols
index 2bc7f73edf955..25e12370916df 100644
--- a/tests/baselines/reference/interface0.symbols
+++ b/tests/baselines/reference/interface0.symbols
@@ -11,6 +11,5 @@ interface Generic<T> {
 var y: Generic<number> = { x: 3 };
 >y : Symbol(y, Decl(interface0.ts, 4, 3))
 >Generic : Symbol(Generic, Decl(interface0.ts, 0, 0))
->{ x: 3 } : Symbol(, Decl(interface0.ts, 4, 24))
 >x : Symbol(x, Decl(interface0.ts, 4, 26))
 
diff --git a/tests/baselines/reference/interfaceContextualType.symbols b/tests/baselines/reference/interfaceContextualType.symbols
index 10506cbc4c983..3483188043184 100644
--- a/tests/baselines/reference/interfaceContextualType.symbols
+++ b/tests/baselines/reference/interfaceContextualType.symbols
@@ -30,13 +30,11 @@ class Bug {
 >this.values : Symbol(values, Decl(interfaceContextualType.ts, 8, 11))
 >this : Symbol(Bug, Decl(interfaceContextualType.ts, 6, 1))
 >values : Symbol(values, Decl(interfaceContextualType.ts, 8, 11))
->{} : Symbol(, Decl(interfaceContextualType.ts, 11, 21))
 
         this.values['comments'] = { italic: true };
 >this.values : Symbol(values, Decl(interfaceContextualType.ts, 8, 11))
 >this : Symbol(Bug, Decl(interfaceContextualType.ts, 6, 1))
 >values : Symbol(values, Decl(interfaceContextualType.ts, 8, 11))
->{ italic: true } : Symbol(, Decl(interfaceContextualType.ts, 12, 33))
 >italic : Symbol(italic, Decl(interfaceContextualType.ts, 12, 35))
     }
     shouldBeOK() {
@@ -46,11 +44,9 @@ class Bug {
 >this.values : Symbol(values, Decl(interfaceContextualType.ts, 8, 11))
 >this : Symbol(Bug, Decl(interfaceContextualType.ts, 6, 1))
 >values : Symbol(values, Decl(interfaceContextualType.ts, 8, 11))
->{            comments: { italic: true }        } : Symbol(, Decl(interfaceContextualType.ts, 15, 21))
 
             comments: { italic: true }
 >comments : Symbol(comments, Decl(interfaceContextualType.ts, 15, 23))
->{ italic: true } : Symbol(, Decl(interfaceContextualType.ts, 16, 21))
 >italic : Symbol(italic, Decl(interfaceContextualType.ts, 16, 23))
 
         };
diff --git a/tests/baselines/reference/interfaceWithPropertyOfEveryType.symbols b/tests/baselines/reference/interfaceWithPropertyOfEveryType.symbols
index 465824cbb179a..46c8e92261ff8 100644
--- a/tests/baselines/reference/interfaceWithPropertyOfEveryType.symbols
+++ b/tests/baselines/reference/interfaceWithPropertyOfEveryType.symbols
@@ -79,7 +79,6 @@ interface Foo {
 var a: Foo = {
 >a : Symbol(a, Decl(interfaceWithPropertyOfEveryType.ts, 25, 3))
 >Foo : Symbol(Foo, Decl(interfaceWithPropertyOfEveryType.ts, 5, 12))
->{    a: 1,    b: '',    c: true,    d: {},    e: null ,    f: [1],    g: {},    h: (x: number) => 1,    i: <T>(x: T) => x,    j: <Foo>null,    k: new C(),    l: f1,    m: M,    n: {},    o: E.A} : Symbol(, Decl(interfaceWithPropertyOfEveryType.ts, 25, 12))
 
     a: 1,
 >a : Symbol(a, Decl(interfaceWithPropertyOfEveryType.ts, 25, 14))
@@ -92,7 +91,6 @@ var a: Foo = {
 
     d: {},
 >d : Symbol(d, Decl(interfaceWithPropertyOfEveryType.ts, 28, 12))
->{} : Symbol(, Decl(interfaceWithPropertyOfEveryType.ts, 29, 6))
 
     e: null ,
 >e : Symbol(e, Decl(interfaceWithPropertyOfEveryType.ts, 29, 10))
@@ -102,16 +100,13 @@ var a: Foo = {
 
     g: {},
 >g : Symbol(g, Decl(interfaceWithPropertyOfEveryType.ts, 31, 11))
->{} : Symbol(, Decl(interfaceWithPropertyOfEveryType.ts, 32, 6))
 
     h: (x: number) => 1,
 >h : Symbol(h, Decl(interfaceWithPropertyOfEveryType.ts, 32, 10))
->(x: number) => 1 : Symbol((Anonymous function), Decl(interfaceWithPropertyOfEveryType.ts, 33, 6))
 >x : Symbol(x, Decl(interfaceWithPropertyOfEveryType.ts, 33, 8))
 
     i: <T>(x: T) => x,
 >i : Symbol(i, Decl(interfaceWithPropertyOfEveryType.ts, 33, 24))
-><T>(x: T) => x : Symbol((Anonymous function), Decl(interfaceWithPropertyOfEveryType.ts, 34, 6))
 >T : Symbol(T, Decl(interfaceWithPropertyOfEveryType.ts, 34, 8))
 >x : Symbol(x, Decl(interfaceWithPropertyOfEveryType.ts, 34, 11))
 >T : Symbol(T, Decl(interfaceWithPropertyOfEveryType.ts, 34, 8))
@@ -135,7 +130,6 @@ var a: Foo = {
 
     n: {},
 >n : Symbol(n, Decl(interfaceWithPropertyOfEveryType.ts, 38, 9))
->{} : Symbol(, Decl(interfaceWithPropertyOfEveryType.ts, 39, 6))
 
     o: E.A
 >o : Symbol(o, Decl(interfaceWithPropertyOfEveryType.ts, 39, 10))
diff --git a/tests/baselines/reference/invalidUndefinedValues.symbols b/tests/baselines/reference/invalidUndefinedValues.symbols
index 02b1487e9804f..5a9b81fde3104 100644
--- a/tests/baselines/reference/invalidUndefinedValues.symbols
+++ b/tests/baselines/reference/invalidUndefinedValues.symbols
@@ -60,7 +60,6 @@ x = M;
 
 x = { f() { } }
 >x : Symbol(x, Decl(invalidUndefinedValues.ts, 0, 3))
->{ f() { } } : Symbol(, Decl(invalidUndefinedValues.ts, 21, 3))
 >f : Symbol(f, Decl(invalidUndefinedValues.ts, 21, 5))
 
 function f<T>(a: T) {
diff --git a/tests/baselines/reference/ipromise2.symbols b/tests/baselines/reference/ipromise2.symbols
index 901c9fbf7088a..be936f4512a27 100644
--- a/tests/baselines/reference/ipromise2.symbols
+++ b/tests/baselines/reference/ipromise2.symbols
@@ -107,7 +107,6 @@ var p2 = p.then(function (s) {
 >p.then : Symbol(Windows.Foundation.IPromise.then, Decl(ipromise2.ts, 1, 34), Decl(ipromise2.ts, 2, 159), Decl(ipromise2.ts, 3, 149), Decl(ipromise2.ts, 4, 149))
 >p : Symbol(p, Decl(ipromise2.ts, 11, 3))
 >then : Symbol(Windows.Foundation.IPromise.then, Decl(ipromise2.ts, 1, 34), Decl(ipromise2.ts, 2, 159), Decl(ipromise2.ts, 3, 149), Decl(ipromise2.ts, 4, 149))
->function (s) {    return 34;} : Symbol((Anonymous function), Decl(ipromise2.ts, 13, 16))
 >s : Symbol(s, Decl(ipromise2.ts, 13, 26))
 
     return 34;
diff --git a/tests/baselines/reference/ipromise3.symbols b/tests/baselines/reference/ipromise3.symbols
index aef8bd48f3907..3605a94fc88d3 100644
--- a/tests/baselines/reference/ipromise3.symbols
+++ b/tests/baselines/reference/ipromise3.symbols
@@ -88,7 +88,6 @@ var p2: IPromise3<string> = p1.then(function (x) {
 >p1.then : Symbol(IPromise3.then, Decl(ipromise3.ts, 0, 24), Decl(ipromise3.ts, 1, 139), Decl(ipromise3.ts, 2, 128), Decl(ipromise3.ts, 3, 128))
 >p1 : Symbol(p1, Decl(ipromise3.ts, 7, 3))
 >then : Symbol(IPromise3.then, Decl(ipromise3.ts, 0, 24), Decl(ipromise3.ts, 1, 139), Decl(ipromise3.ts, 2, 128), Decl(ipromise3.ts, 3, 128))
->function (x) {    return x;} : Symbol((Anonymous function), Decl(ipromise3.ts, 8, 36))
 >x : Symbol(x, Decl(ipromise3.ts, 8, 46))
 
     return x;
diff --git a/tests/baselines/reference/ipromise4.symbols b/tests/baselines/reference/ipromise4.symbols
index f90a0e50a0fb6..65ae5f90cfe92 100644
--- a/tests/baselines/reference/ipromise4.symbols
+++ b/tests/baselines/reference/ipromise4.symbols
@@ -102,7 +102,6 @@ p.then(function (x) { } ); // should not error
 >p.then : Symbol(Windows.Foundation.IPromise.then, Decl(ipromise4.ts, 1, 34), Decl(ipromise4.ts, 2, 159), Decl(ipromise4.ts, 3, 149), Decl(ipromise4.ts, 4, 149))
 >p : Symbol(p, Decl(ipromise4.ts, 10, 3))
 >then : Symbol(Windows.Foundation.IPromise.then, Decl(ipromise4.ts, 1, 34), Decl(ipromise4.ts, 2, 159), Decl(ipromise4.ts, 3, 149), Decl(ipromise4.ts, 4, 149))
->function (x) { } : Symbol((Anonymous function), Decl(ipromise4.ts, 12, 7))
 >x : Symbol(x, Decl(ipromise4.ts, 12, 17))
 
 p.then(function (x) { return "hello"; } ).then(function (x) { return x } ); // should not error
@@ -110,10 +109,8 @@ p.then(function (x) { return "hello"; } ).then(function (x) { return x } ); // s
 >p.then : Symbol(Windows.Foundation.IPromise.then, Decl(ipromise4.ts, 1, 34), Decl(ipromise4.ts, 2, 159), Decl(ipromise4.ts, 3, 149), Decl(ipromise4.ts, 4, 149))
 >p : Symbol(p, Decl(ipromise4.ts, 10, 3))
 >then : Symbol(Windows.Foundation.IPromise.then, Decl(ipromise4.ts, 1, 34), Decl(ipromise4.ts, 2, 159), Decl(ipromise4.ts, 3, 149), Decl(ipromise4.ts, 4, 149))
->function (x) { return "hello"; } : Symbol((Anonymous function), Decl(ipromise4.ts, 13, 7))
 >x : Symbol(x, Decl(ipromise4.ts, 13, 17))
 >then : Symbol(Windows.Foundation.IPromise.then, Decl(ipromise4.ts, 1, 34), Decl(ipromise4.ts, 2, 159), Decl(ipromise4.ts, 3, 149), Decl(ipromise4.ts, 4, 149))
->function (x) { return x } : Symbol((Anonymous function), Decl(ipromise4.ts, 13, 47))
 >x : Symbol(x, Decl(ipromise4.ts, 13, 57))
 >x : Symbol(x, Decl(ipromise4.ts, 13, 57))
  
diff --git a/tests/baselines/reference/iterableArrayPattern1.symbols b/tests/baselines/reference/iterableArrayPattern1.symbols
index a6a944f109e88..3920dc1cef466 100644
--- a/tests/baselines/reference/iterableArrayPattern1.symbols
+++ b/tests/baselines/reference/iterableArrayPattern1.symbols
@@ -11,8 +11,6 @@ class SymbolIterator {
 >next : Symbol(next, Decl(iterableArrayPattern1.ts, 1, 22))
 
         return {
->{            value: Symbol(),            done: false        } : Symbol(, Decl(iterableArrayPattern1.ts, 3, 14))
-
             value: Symbol(),
 >value : Symbol(value, Decl(iterableArrayPattern1.ts, 3, 16))
 >Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11))
diff --git a/tests/baselines/reference/iterableArrayPattern11.symbols b/tests/baselines/reference/iterableArrayPattern11.symbols
index 99a6f0885c1ae..06e38c57af41d 100644
--- a/tests/baselines/reference/iterableArrayPattern11.symbols
+++ b/tests/baselines/reference/iterableArrayPattern11.symbols
@@ -25,8 +25,6 @@ class FooIterator {
 >next : Symbol(next, Decl(iterableArrayPattern11.ts, 4, 19))
 
         return {
->{            value: new Foo,            done: false        } : Symbol(, Decl(iterableArrayPattern11.ts, 6, 14))
-
             value: new Foo,
 >value : Symbol(value, Decl(iterableArrayPattern11.ts, 6, 16))
 >Foo : Symbol(Foo, Decl(iterableArrayPattern11.ts, 2, 15))
diff --git a/tests/baselines/reference/iterableArrayPattern12.symbols b/tests/baselines/reference/iterableArrayPattern12.symbols
index d35d83efd0471..e16fe5255e4fd 100644
--- a/tests/baselines/reference/iterableArrayPattern12.symbols
+++ b/tests/baselines/reference/iterableArrayPattern12.symbols
@@ -25,8 +25,6 @@ class FooIterator {
 >next : Symbol(next, Decl(iterableArrayPattern12.ts, 4, 19))
 
         return {
->{            value: new Foo,            done: false        } : Symbol(, Decl(iterableArrayPattern12.ts, 6, 14))
-
             value: new Foo,
 >value : Symbol(value, Decl(iterableArrayPattern12.ts, 6, 16))
 >Foo : Symbol(Foo, Decl(iterableArrayPattern12.ts, 2, 15))
diff --git a/tests/baselines/reference/iterableArrayPattern13.symbols b/tests/baselines/reference/iterableArrayPattern13.symbols
index bddeb62fdf3a5..b870919782926 100644
--- a/tests/baselines/reference/iterableArrayPattern13.symbols
+++ b/tests/baselines/reference/iterableArrayPattern13.symbols
@@ -24,8 +24,6 @@ class FooIterator {
 >next : Symbol(next, Decl(iterableArrayPattern13.ts, 4, 19))
 
         return {
->{            value: new Foo,            done: false        } : Symbol(, Decl(iterableArrayPattern13.ts, 6, 14))
-
             value: new Foo,
 >value : Symbol(value, Decl(iterableArrayPattern13.ts, 6, 16))
 >Foo : Symbol(Foo, Decl(iterableArrayPattern13.ts, 2, 15))
diff --git a/tests/baselines/reference/iterableArrayPattern2.symbols b/tests/baselines/reference/iterableArrayPattern2.symbols
index 832c0719e627b..17ac6a1feacef 100644
--- a/tests/baselines/reference/iterableArrayPattern2.symbols
+++ b/tests/baselines/reference/iterableArrayPattern2.symbols
@@ -11,8 +11,6 @@ class SymbolIterator {
 >next : Symbol(next, Decl(iterableArrayPattern2.ts, 1, 22))
 
         return {
->{            value: Symbol(),            done: false        } : Symbol(, Decl(iterableArrayPattern2.ts, 3, 14))
-
             value: Symbol(),
 >value : Symbol(value, Decl(iterableArrayPattern2.ts, 3, 16))
 >Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11))
diff --git a/tests/baselines/reference/iterableArrayPattern3.symbols b/tests/baselines/reference/iterableArrayPattern3.symbols
index 1ea5556fccd48..468866ca32404 100644
--- a/tests/baselines/reference/iterableArrayPattern3.symbols
+++ b/tests/baselines/reference/iterableArrayPattern3.symbols
@@ -26,8 +26,6 @@ class FooIterator {
 >next : Symbol(next, Decl(iterableArrayPattern3.ts, 4, 19))
 
         return {
->{            value: new Foo,            done: false        } : Symbol(, Decl(iterableArrayPattern3.ts, 6, 14))
-
             value: new Foo,
 >value : Symbol(value, Decl(iterableArrayPattern3.ts, 6, 16))
 >Foo : Symbol(Foo, Decl(iterableArrayPattern3.ts, 2, 15))
diff --git a/tests/baselines/reference/iterableArrayPattern4.symbols b/tests/baselines/reference/iterableArrayPattern4.symbols
index a0f4b6ce0b590..10225e183e6cb 100644
--- a/tests/baselines/reference/iterableArrayPattern4.symbols
+++ b/tests/baselines/reference/iterableArrayPattern4.symbols
@@ -26,8 +26,6 @@ class FooIterator {
 >next : Symbol(next, Decl(iterableArrayPattern4.ts, 4, 19))
 
         return {
->{            value: new Foo,            done: false        } : Symbol(, Decl(iterableArrayPattern4.ts, 6, 14))
-
             value: new Foo,
 >value : Symbol(value, Decl(iterableArrayPattern4.ts, 6, 16))
 >Foo : Symbol(Foo, Decl(iterableArrayPattern4.ts, 2, 15))
diff --git a/tests/baselines/reference/iterableArrayPattern9.symbols b/tests/baselines/reference/iterableArrayPattern9.symbols
index e487b6db88414..86c46812688fa 100644
--- a/tests/baselines/reference/iterableArrayPattern9.symbols
+++ b/tests/baselines/reference/iterableArrayPattern9.symbols
@@ -21,8 +21,6 @@ class FooIterator {
 >next : Symbol(next, Decl(iterableArrayPattern9.ts, 3, 19))
 
         return {
->{            value: new Foo,            done: false        } : Symbol(, Decl(iterableArrayPattern9.ts, 5, 14))
-
             value: new Foo,
 >value : Symbol(value, Decl(iterableArrayPattern9.ts, 5, 16))
 >Foo : Symbol(Foo, Decl(iterableArrayPattern9.ts, 1, 15))
diff --git a/tests/baselines/reference/iterableContextualTyping1.symbols b/tests/baselines/reference/iterableContextualTyping1.symbols
index a969f0fbcd7a8..ae99a4b52554e 100644
--- a/tests/baselines/reference/iterableContextualTyping1.symbols
+++ b/tests/baselines/reference/iterableContextualTyping1.symbols
@@ -3,7 +3,6 @@ var iter: Iterable<(x: string) => number> = [s => s.length];
 >iter : Symbol(iter, Decl(iterableContextualTyping1.ts, 0, 3))
 >Iterable : Symbol(Iterable, Decl(lib.d.ts, 1681, 1))
 >x : Symbol(x, Decl(iterableContextualTyping1.ts, 0, 20))
->s => s.length : Symbol((Anonymous function), Decl(iterableContextualTyping1.ts, 0, 45))
 >s : Symbol(s, Decl(iterableContextualTyping1.ts, 0, 45))
 >s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >s : Symbol(s, Decl(iterableContextualTyping1.ts, 0, 45))
diff --git a/tests/baselines/reference/iteratorSpreadInArray.symbols b/tests/baselines/reference/iteratorSpreadInArray.symbols
index 4738ff6e59864..c4a2459e26276 100644
--- a/tests/baselines/reference/iteratorSpreadInArray.symbols
+++ b/tests/baselines/reference/iteratorSpreadInArray.symbols
@@ -10,8 +10,6 @@ class SymbolIterator {
 >next : Symbol(next, Decl(iteratorSpreadInArray.ts, 2, 22))
 
         return {
->{            value: Symbol(),            done: false        } : Symbol(, Decl(iteratorSpreadInArray.ts, 4, 14))
-
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInArray.ts, 4, 16))
 >Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11))
diff --git a/tests/baselines/reference/iteratorSpreadInArray2.symbols b/tests/baselines/reference/iteratorSpreadInArray2.symbols
index 579597171fd08..cdc7bb3e2bcb6 100644
--- a/tests/baselines/reference/iteratorSpreadInArray2.symbols
+++ b/tests/baselines/reference/iteratorSpreadInArray2.symbols
@@ -11,8 +11,6 @@ class SymbolIterator {
 >next : Symbol(next, Decl(iteratorSpreadInArray2.ts, 2, 22))
 
         return {
->{            value: Symbol(),            done: false        } : Symbol(, Decl(iteratorSpreadInArray2.ts, 4, 14))
-
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInArray2.ts, 4, 16))
 >Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11))
@@ -40,8 +38,6 @@ class NumberIterator {
 >next : Symbol(next, Decl(iteratorSpreadInArray2.ts, 15, 22))
 
         return {
->{            value: 0,            done: false        } : Symbol(, Decl(iteratorSpreadInArray2.ts, 17, 14))
-
             value: 0,
 >value : Symbol(value, Decl(iteratorSpreadInArray2.ts, 17, 16))
 
diff --git a/tests/baselines/reference/iteratorSpreadInArray3.symbols b/tests/baselines/reference/iteratorSpreadInArray3.symbols
index 342671ca07204..e4d1b508bb5d4 100644
--- a/tests/baselines/reference/iteratorSpreadInArray3.symbols
+++ b/tests/baselines/reference/iteratorSpreadInArray3.symbols
@@ -10,8 +10,6 @@ class SymbolIterator {
 >next : Symbol(next, Decl(iteratorSpreadInArray3.ts, 2, 22))
 
         return {
->{            value: Symbol(),            done: false        } : Symbol(, Decl(iteratorSpreadInArray3.ts, 4, 14))
-
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInArray3.ts, 4, 16))
 >Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11))
diff --git a/tests/baselines/reference/iteratorSpreadInArray4.symbols b/tests/baselines/reference/iteratorSpreadInArray4.symbols
index 0f0a608fd6b5b..bd6760dd0aa21 100644
--- a/tests/baselines/reference/iteratorSpreadInArray4.symbols
+++ b/tests/baselines/reference/iteratorSpreadInArray4.symbols
@@ -10,8 +10,6 @@ class SymbolIterator {
 >next : Symbol(next, Decl(iteratorSpreadInArray4.ts, 2, 22))
 
         return {
->{            value: Symbol(),            done: false        } : Symbol(, Decl(iteratorSpreadInArray4.ts, 4, 14))
-
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInArray4.ts, 4, 16))
 >Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11))
diff --git a/tests/baselines/reference/iteratorSpreadInArray7.symbols b/tests/baselines/reference/iteratorSpreadInArray7.symbols
index e6987a8b738ac..d0bc97907526d 100644
--- a/tests/baselines/reference/iteratorSpreadInArray7.symbols
+++ b/tests/baselines/reference/iteratorSpreadInArray7.symbols
@@ -15,8 +15,6 @@ class SymbolIterator {
 >next : Symbol(next, Decl(iteratorSpreadInArray7.ts, 3, 22))
 
         return {
->{            value: Symbol(),            done: false        } : Symbol(, Decl(iteratorSpreadInArray7.ts, 5, 14))
-
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInArray7.ts, 5, 16))
 >Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11))
diff --git a/tests/baselines/reference/iteratorSpreadInCall11.symbols b/tests/baselines/reference/iteratorSpreadInCall11.symbols
index c6b3d6c0a3215..a7e5d7b8919f8 100644
--- a/tests/baselines/reference/iteratorSpreadInCall11.symbols
+++ b/tests/baselines/reference/iteratorSpreadInCall11.symbols
@@ -17,8 +17,6 @@ class SymbolIterator {
 >next : Symbol(next, Decl(iteratorSpreadInCall11.ts, 4, 22))
 
         return {
->{            value: Symbol(),            done: false        } : Symbol(, Decl(iteratorSpreadInCall11.ts, 6, 14))
-
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInCall11.ts, 6, 16))
 >Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11))
diff --git a/tests/baselines/reference/iteratorSpreadInCall12.symbols b/tests/baselines/reference/iteratorSpreadInCall12.symbols
index df9a9a0d16aaf..67b9e9e500daf 100644
--- a/tests/baselines/reference/iteratorSpreadInCall12.symbols
+++ b/tests/baselines/reference/iteratorSpreadInCall12.symbols
@@ -20,8 +20,6 @@ class SymbolIterator {
 >next : Symbol(next, Decl(iteratorSpreadInCall12.ts, 6, 22))
 
         return {
->{            value: Symbol(),            done: false        } : Symbol(, Decl(iteratorSpreadInCall12.ts, 8, 14))
-
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInCall12.ts, 8, 16))
 >Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11))
@@ -49,8 +47,6 @@ class StringIterator {
 >next : Symbol(next, Decl(iteratorSpreadInCall12.ts, 19, 22))
 
         return {
->{            value: "",            done: false        } : Symbol(, Decl(iteratorSpreadInCall12.ts, 21, 14))
-
             value: "",
 >value : Symbol(value, Decl(iteratorSpreadInCall12.ts, 21, 16))
 
diff --git a/tests/baselines/reference/iteratorSpreadInCall3.symbols b/tests/baselines/reference/iteratorSpreadInCall3.symbols
index 8d59ad37c2133..0c3c11c84f470 100644
--- a/tests/baselines/reference/iteratorSpreadInCall3.symbols
+++ b/tests/baselines/reference/iteratorSpreadInCall3.symbols
@@ -14,8 +14,6 @@ class SymbolIterator {
 >next : Symbol(next, Decl(iteratorSpreadInCall3.ts, 3, 22))
 
         return {
->{            value: Symbol(),            done: false        } : Symbol(, Decl(iteratorSpreadInCall3.ts, 5, 14))
-
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInCall3.ts, 5, 16))
 >Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11))
diff --git a/tests/baselines/reference/iteratorSpreadInCall5.symbols b/tests/baselines/reference/iteratorSpreadInCall5.symbols
index 7d7e3a063abce..03faf4b593ea8 100644
--- a/tests/baselines/reference/iteratorSpreadInCall5.symbols
+++ b/tests/baselines/reference/iteratorSpreadInCall5.symbols
@@ -15,8 +15,6 @@ class SymbolIterator {
 >next : Symbol(next, Decl(iteratorSpreadInCall5.ts, 3, 22))
 
         return {
->{            value: Symbol(),            done: false        } : Symbol(, Decl(iteratorSpreadInCall5.ts, 5, 14))
-
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInCall5.ts, 5, 16))
 >Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11))
@@ -44,8 +42,6 @@ class StringIterator {
 >next : Symbol(next, Decl(iteratorSpreadInCall5.ts, 16, 22))
 
         return {
->{            value: "",            done: false        } : Symbol(, Decl(iteratorSpreadInCall5.ts, 18, 14))
-
             value: "",
 >value : Symbol(value, Decl(iteratorSpreadInCall5.ts, 18, 16))
 
diff --git a/tests/baselines/reference/jsxReactTestSuite.symbols b/tests/baselines/reference/jsxReactTestSuite.symbols
index beaa08fee69fe..9e382742f0d4b 100644
--- a/tests/baselines/reference/jsxReactTestSuite.symbols
+++ b/tests/baselines/reference/jsxReactTestSuite.symbols
@@ -186,7 +186,6 @@ var x =
 >Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11))
 >x : Symbol(unknown)
 >z : Symbol(z, Decl(jsxReactTestSuite.tsx, 11, 11))
->{ y: 2 } : Symbol(, Decl(jsxReactTestSuite.tsx, 113, 25))
 >y : Symbol(y, Decl(jsxReactTestSuite.tsx, 113, 27))
 >z : Symbol(z, Decl(jsxReactTestSuite.tsx, 11, 11))
 >z : Symbol(unknown)
diff --git a/tests/baselines/reference/keywordField.symbols b/tests/baselines/reference/keywordField.symbols
index a7f7554d10f27..7ea3438d9852d 100644
--- a/tests/baselines/reference/keywordField.symbols
+++ b/tests/baselines/reference/keywordField.symbols
@@ -1,14 +1,12 @@
 === tests/cases/compiler/keywordField.ts ===
 var obj:any = {};
 >obj : Symbol(obj, Decl(keywordField.ts, 0, 3))
->{} : Symbol(, Decl(keywordField.ts, 0, 13))
 
 obj.if = 1;
 >obj : Symbol(obj, Decl(keywordField.ts, 0, 3))
 
 var a = { if: "test" }
 >a : Symbol(a, Decl(keywordField.ts, 4, 3))
->{ if: "test" } : Symbol(, Decl(keywordField.ts, 4, 7))
 >if : Symbol(if, Decl(keywordField.ts, 4, 9))
 
 var n = a.if
diff --git a/tests/baselines/reference/lambdaASIEmit.symbols b/tests/baselines/reference/lambdaASIEmit.symbols
index 8b430026ae25e..d33cc16817a3c 100644
--- a/tests/baselines/reference/lambdaASIEmit.symbols
+++ b/tests/baselines/reference/lambdaASIEmit.symbols
@@ -8,7 +8,6 @@ function Foo(x: any)
  
 Foo(() =>
 >Foo : Symbol(Foo, Decl(lambdaASIEmit.ts, 0, 0))
->() =>    // do something    127 : Symbol((Anonymous function), Decl(lambdaASIEmit.ts, 5, 4))
 
     // do something
     127);
diff --git a/tests/baselines/reference/lambdaExpression.symbols b/tests/baselines/reference/lambdaExpression.symbols
index 825baf446b9d8..48bda5ce07fb0 100644
--- a/tests/baselines/reference/lambdaExpression.symbols
+++ b/tests/baselines/reference/lambdaExpression.symbols
@@ -1,13 +1,9 @@
 === tests/cases/compiler/lambdaExpression.ts ===
 () => 0; // Needs to be wrapped in parens to be a valid expression (not declaration)
->() => 0 : Symbol((Anonymous function), Decl(lambdaExpression.ts, 0, 0))
-
 var y = 0;
 >y : Symbol(y, Decl(lambdaExpression.ts, 1, 3))
 
 (()=>0);
->()=>0 : Symbol((Anonymous function), Decl(lambdaExpression.ts, 2, 1))
-
 var x = 0;
 >x : Symbol(x, Decl(lambdaExpression.ts, 3, 3))
 
diff --git a/tests/baselines/reference/letDeclarations-es5.symbols b/tests/baselines/reference/letDeclarations-es5.symbols
index 8fd8c951146ab..ac2daaaac8933 100644
--- a/tests/baselines/reference/letDeclarations-es5.symbols
+++ b/tests/baselines/reference/letDeclarations-es5.symbols
@@ -25,7 +25,6 @@ let l9 = 0, l10 :string = "", l11 = null;
 
 for(let l11 in {}) { }
 >l11 : Symbol(l11, Decl(letDeclarations-es5.ts, 9, 7))
->{} : Symbol(, Decl(letDeclarations-es5.ts, 9, 14))
 
 for(let l12 = 0; l12 < 9; l12++) { }
 >l12 : Symbol(l12, Decl(letDeclarations-es5.ts, 11, 7))
diff --git a/tests/baselines/reference/letDeclarations.symbols b/tests/baselines/reference/letDeclarations.symbols
index 39fea572581fa..dbbaac211ac73 100644
--- a/tests/baselines/reference/letDeclarations.symbols
+++ b/tests/baselines/reference/letDeclarations.symbols
@@ -25,7 +25,6 @@ let l9 = 0, l10 :string = "", l11 = null;
 
 for(let l11 in {}) { }
 >l11 : Symbol(l11, Decl(letDeclarations.ts, 9, 7))
->{} : Symbol(, Decl(letDeclarations.ts, 9, 14))
 
 for(let l12 = 0; l12 < 9; l12++) { }
 >l12 : Symbol(l12, Decl(letDeclarations.ts, 11, 7))
diff --git a/tests/baselines/reference/letInNonStrictMode.symbols b/tests/baselines/reference/letInNonStrictMode.symbols
index 51621148aae61..2b854a8c03fb5 100644
--- a/tests/baselines/reference/letInNonStrictMode.symbols
+++ b/tests/baselines/reference/letInNonStrictMode.symbols
@@ -4,6 +4,5 @@ let [x] = [1];
 
 let {a: y} = {a: 1};
 >y : Symbol(y, Decl(letInNonStrictMode.ts, 1, 5))
->{a: 1} : Symbol(, Decl(letInNonStrictMode.ts, 1, 12))
 >a : Symbol(a, Decl(letInNonStrictMode.ts, 1, 14))
 
diff --git a/tests/baselines/reference/localTypes1.symbols b/tests/baselines/reference/localTypes1.symbols
index 3dbbb020d5aac..53d4191ae6197 100644
--- a/tests/baselines/reference/localTypes1.symbols
+++ b/tests/baselines/reference/localTypes1.symbols
@@ -191,7 +191,6 @@ function f5() {
 
     var z1 = function () {
 >z1 : Symbol(z1, Decl(localTypes1.ts, 69, 7))
->function () {        enum E {            A, B, C        }        class C {            x: E;        }        return new C();    } : Symbol((Anonymous function), Decl(localTypes1.ts, 69, 12))
 
         enum E {
 >E : Symbol(E, Decl(localTypes1.ts, 69, 26))
@@ -213,7 +212,6 @@ function f5() {
     }
     var z2 = () => {
 >z2 : Symbol(z2, Decl(localTypes1.ts, 78, 7))
->() => {        enum E {            A, B, C        }        class C {            x: E;        }        return new C();    } : Symbol((Anonymous function), Decl(localTypes1.ts, 78, 12))
 
         enum E {
 >E : Symbol(E, Decl(localTypes1.ts, 78, 20))
diff --git a/tests/baselines/reference/localTypes5.symbols b/tests/baselines/reference/localTypes5.symbols
index d9300c73d4254..4ffe53b3e5303 100644
--- a/tests/baselines/reference/localTypes5.symbols
+++ b/tests/baselines/reference/localTypes5.symbols
@@ -12,7 +12,6 @@ function foo<A>() {
 >C : Symbol(C, Decl(localTypes5.ts, 2, 12))
 
             return (function <D>() {
->function <D>() {                class Y<E> {                }                return new Y<string>();            } : Symbol((Anonymous function), Decl(localTypes5.ts, 3, 20))
 >D : Symbol(D, Decl(localTypes5.ts, 3, 30))
 
                 class Y<E> {
diff --git a/tests/baselines/reference/logicalNotOperatorWithBooleanType.symbols b/tests/baselines/reference/logicalNotOperatorWithBooleanType.symbols
index 63068f8e301ed..b42b9d7922ecd 100644
--- a/tests/baselines/reference/logicalNotOperatorWithBooleanType.symbols
+++ b/tests/baselines/reference/logicalNotOperatorWithBooleanType.symbols
@@ -37,7 +37,6 @@ var ResultIsBoolean2 = !true;
 
 var ResultIsBoolean3 = !{ x: true, y: false };
 >ResultIsBoolean3 : Symbol(ResultIsBoolean3, Decl(logicalNotOperatorWithBooleanType.ts, 20, 3))
->{ x: true, y: false } : Symbol(, Decl(logicalNotOperatorWithBooleanType.ts, 20, 24))
 >x : Symbol(x, Decl(logicalNotOperatorWithBooleanType.ts, 20, 25))
 >y : Symbol(y, Decl(logicalNotOperatorWithBooleanType.ts, 20, 34))
 
diff --git a/tests/baselines/reference/logicalNotOperatorWithNumberType.symbols b/tests/baselines/reference/logicalNotOperatorWithNumberType.symbols
index 195041dffcf00..4f277a8db54c5 100644
--- a/tests/baselines/reference/logicalNotOperatorWithNumberType.symbols
+++ b/tests/baselines/reference/logicalNotOperatorWithNumberType.symbols
@@ -44,16 +44,13 @@ var ResultIsBoolean3 = !1;
 
 var ResultIsBoolean4 = !{ x: 1, y: 2};
 >ResultIsBoolean4 : Symbol(ResultIsBoolean4, Decl(logicalNotOperatorWithNumberType.ts, 22, 3))
->{ x: 1, y: 2} : Symbol(, Decl(logicalNotOperatorWithNumberType.ts, 22, 24))
 >x : Symbol(x, Decl(logicalNotOperatorWithNumberType.ts, 22, 25))
 >y : Symbol(y, Decl(logicalNotOperatorWithNumberType.ts, 22, 31))
 
 var ResultIsBoolean5 = !{ x: 1, y: (n: number) => { return n; } };
 >ResultIsBoolean5 : Symbol(ResultIsBoolean5, Decl(logicalNotOperatorWithNumberType.ts, 23, 3))
->{ x: 1, y: (n: number) => { return n; } } : Symbol(, Decl(logicalNotOperatorWithNumberType.ts, 23, 24))
 >x : Symbol(x, Decl(logicalNotOperatorWithNumberType.ts, 23, 25))
 >y : Symbol(y, Decl(logicalNotOperatorWithNumberType.ts, 23, 31))
->(n: number) => { return n; } : Symbol((Anonymous function), Decl(logicalNotOperatorWithNumberType.ts, 23, 34))
 >n : Symbol(n, Decl(logicalNotOperatorWithNumberType.ts, 23, 36))
 >n : Symbol(n, Decl(logicalNotOperatorWithNumberType.ts, 23, 36))
 
diff --git a/tests/baselines/reference/logicalNotOperatorWithStringType.symbols b/tests/baselines/reference/logicalNotOperatorWithStringType.symbols
index cade80cbd70a5..ff266361321b5 100644
--- a/tests/baselines/reference/logicalNotOperatorWithStringType.symbols
+++ b/tests/baselines/reference/logicalNotOperatorWithStringType.symbols
@@ -44,16 +44,13 @@ var ResultIsBoolean3 = !"";
 
 var ResultIsBoolean4 = !{ x: "", y: "" };
 >ResultIsBoolean4 : Symbol(ResultIsBoolean4, Decl(logicalNotOperatorWithStringType.ts, 22, 3))
->{ x: "", y: "" } : Symbol(, Decl(logicalNotOperatorWithStringType.ts, 22, 24))
 >x : Symbol(x, Decl(logicalNotOperatorWithStringType.ts, 22, 25))
 >y : Symbol(y, Decl(logicalNotOperatorWithStringType.ts, 22, 32))
 
 var ResultIsBoolean5 = !{ x: "", y: (s: string) => { return s; } };
 >ResultIsBoolean5 : Symbol(ResultIsBoolean5, Decl(logicalNotOperatorWithStringType.ts, 23, 3))
->{ x: "", y: (s: string) => { return s; } } : Symbol(, Decl(logicalNotOperatorWithStringType.ts, 23, 24))
 >x : Symbol(x, Decl(logicalNotOperatorWithStringType.ts, 23, 25))
 >y : Symbol(y, Decl(logicalNotOperatorWithStringType.ts, 23, 32))
->(s: string) => { return s; } : Symbol((Anonymous function), Decl(logicalNotOperatorWithStringType.ts, 23, 35))
 >s : Symbol(s, Decl(logicalNotOperatorWithStringType.ts, 23, 37))
 >s : Symbol(s, Decl(logicalNotOperatorWithStringType.ts, 23, 37))
 
diff --git a/tests/baselines/reference/logicalOrExpressionIsContextuallyTyped.symbols b/tests/baselines/reference/logicalOrExpressionIsContextuallyTyped.symbols
index ce7c8c646a955..90fc4ac163ce5 100644
--- a/tests/baselines/reference/logicalOrExpressionIsContextuallyTyped.symbols
+++ b/tests/baselines/reference/logicalOrExpressionIsContextuallyTyped.symbols
@@ -7,10 +7,8 @@
 var r: { a: string } = { a: '', b: 123 } || { a: '', b: true };
 >r : Symbol(r, Decl(logicalOrExpressionIsContextuallyTyped.ts, 5, 3))
 >a : Symbol(a, Decl(logicalOrExpressionIsContextuallyTyped.ts, 5, 8))
->{ a: '', b: 123 } : Symbol(, Decl(logicalOrExpressionIsContextuallyTyped.ts, 5, 22))
 >a : Symbol(a, Decl(logicalOrExpressionIsContextuallyTyped.ts, 5, 24))
 >b : Symbol(b, Decl(logicalOrExpressionIsContextuallyTyped.ts, 5, 31))
->{ a: '', b: true } : Symbol(, Decl(logicalOrExpressionIsContextuallyTyped.ts, 5, 43))
 >a : Symbol(a, Decl(logicalOrExpressionIsContextuallyTyped.ts, 5, 45))
 >b : Symbol(b, Decl(logicalOrExpressionIsContextuallyTyped.ts, 5, 52))
 
diff --git a/tests/baselines/reference/logicalOrExpressionIsNotContextuallyTyped.symbols b/tests/baselines/reference/logicalOrExpressionIsNotContextuallyTyped.symbols
index f3db9ebde61d9..6cfbf7ea6b675 100644
--- a/tests/baselines/reference/logicalOrExpressionIsNotContextuallyTyped.symbols
+++ b/tests/baselines/reference/logicalOrExpressionIsNotContextuallyTyped.symbols
@@ -13,7 +13,6 @@ var a: (a: string) => string;
 var r = a || ((a) => a.toLowerCase());
 >r : Symbol(r, Decl(logicalOrExpressionIsNotContextuallyTyped.ts, 9, 3))
 >a : Symbol(a, Decl(logicalOrExpressionIsNotContextuallyTyped.ts, 6, 3))
->(a) => a.toLowerCase() : Symbol((Anonymous function), Decl(logicalOrExpressionIsNotContextuallyTyped.ts, 9, 14))
 >a : Symbol(a, Decl(logicalOrExpressionIsNotContextuallyTyped.ts, 9, 15))
 >a.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51))
 >a : Symbol(a, Decl(logicalOrExpressionIsNotContextuallyTyped.ts, 9, 15))
diff --git a/tests/baselines/reference/logicalOrOperatorWithTypeParameters.symbols b/tests/baselines/reference/logicalOrOperatorWithTypeParameters.symbols
index f1c69700e45d7..05b33a2b185e9 100644
--- a/tests/baselines/reference/logicalOrOperatorWithTypeParameters.symbols
+++ b/tests/baselines/reference/logicalOrOperatorWithTypeParameters.symbols
@@ -98,7 +98,6 @@ function fn3<T extends { a: string; b: string }, U extends { a: string; b: numbe
     var r3 = t || { a: '' };
 >r3 : Symbol(r3, Decl(logicalOrOperatorWithTypeParameters.ts, 20, 7))
 >t : Symbol(t, Decl(logicalOrOperatorWithTypeParameters.ts, 17, 85))
->{ a: '' } : Symbol(, Decl(logicalOrOperatorWithTypeParameters.ts, 20, 17))
 >a : Symbol(a, Decl(logicalOrOperatorWithTypeParameters.ts, 20, 19))
 
     var r4: { a: string } = t || u;
diff --git a/tests/baselines/reference/m7Bugs.symbols b/tests/baselines/reference/m7Bugs.symbols
index d05ad7eb9f653..be6d798a8a532 100644
--- a/tests/baselines/reference/m7Bugs.symbols
+++ b/tests/baselines/reference/m7Bugs.symbols
@@ -11,7 +11,6 @@ var s: ISomething = <ISomething>({ });
 >s : Symbol(s, Decl(m7Bugs.ts, 5, 3))
 >ISomething : Symbol(ISomething, Decl(m7Bugs.ts, 0, 0))
 >ISomething : Symbol(ISomething, Decl(m7Bugs.ts, 0, 0))
->{ } : Symbol(, Decl(m7Bugs.ts, 5, 33))
 
 
 // scenario 2
@@ -27,7 +26,6 @@ var x: B = <B>{ };
 >x : Symbol(x, Decl(m7Bugs.ts, 13, 3))
 >B : Symbol(B, Decl(m7Bugs.ts, 9, 26))
 >B : Symbol(B, Decl(m7Bugs.ts, 9, 26))
->{ } : Symbol(, Decl(m7Bugs.ts, 13, 14))
 
 class C1 {
 >C1 : Symbol(C1, Decl(m7Bugs.ts, 13, 18))
@@ -55,6 +53,5 @@ var y3: C1 = <C1> {};
 >y3 : Symbol(y3, Decl(m7Bugs.ts, 23, 3))
 >C1 : Symbol(C1, Decl(m7Bugs.ts, 13, 18))
 >C1 : Symbol(C1, Decl(m7Bugs.ts, 13, 18))
->{} : Symbol(, Decl(m7Bugs.ts, 23, 17))
 
 
diff --git a/tests/baselines/reference/mergedDeclarations1.symbols b/tests/baselines/reference/mergedDeclarations1.symbols
index 0e6e9165eec12..733b9c4ee3250 100644
--- a/tests/baselines/reference/mergedDeclarations1.symbols
+++ b/tests/baselines/reference/mergedDeclarations1.symbols
@@ -15,7 +15,6 @@ function point(x: number, y: number): Point {
 >Point : Symbol(Point, Decl(mergedDeclarations1.ts, 0, 0))
 
     return { x: x, y: y };
->{ x: x, y: y } : Symbol(, Decl(mergedDeclarations1.ts, 5, 10))
 >x : Symbol(x, Decl(mergedDeclarations1.ts, 5, 12))
 >x : Symbol(x, Decl(mergedDeclarations1.ts, 4, 15))
 >y : Symbol(y, Decl(mergedDeclarations1.ts, 5, 18))
diff --git a/tests/baselines/reference/methodContainingLocalFunction.symbols b/tests/baselines/reference/methodContainingLocalFunction.symbols
index 7ef55a7684e04..e449d68562f89 100644
--- a/tests/baselines/reference/methodContainingLocalFunction.symbols
+++ b/tests/baselines/reference/methodContainingLocalFunction.symbols
@@ -70,7 +70,6 @@ class C {
 
         var funcExpr = <U>(u?: U) => { };
 >funcExpr : Symbol(funcExpr, Decl(methodContainingLocalFunction.ts, 28, 11))
-><U>(u?: U) => { } : Symbol((Anonymous function), Decl(methodContainingLocalFunction.ts, 28, 22))
 >U : Symbol(U, Decl(methodContainingLocalFunction.ts, 28, 24))
 >u : Symbol(u, Decl(methodContainingLocalFunction.ts, 28, 27))
 >U : Symbol(U, Decl(methodContainingLocalFunction.ts, 28, 24))
@@ -107,7 +106,6 @@ enum E {
 
     A = (() => {
 >A : Symbol(E.A, Decl(methodContainingLocalFunction.ts, 42, 8))
->() => {        function localFunction() { }        var x: { (): void; };        x = localFunction;        return 0;    } : Symbol((Anonymous function), Decl(methodContainingLocalFunction.ts, 43, 9))
 
         function localFunction() { }
 >localFunction : Symbol(localFunction, Decl(methodContainingLocalFunction.ts, 43, 16))
diff --git a/tests/baselines/reference/missingSelf.symbols b/tests/baselines/reference/missingSelf.symbols
index 271d45147fb96..b4b5bd0b905b2 100644
--- a/tests/baselines/reference/missingSelf.symbols
+++ b/tests/baselines/reference/missingSelf.symbols
@@ -17,7 +17,6 @@ class CalcButton2
 {
     public b() { () => this.onClick(); }
 >b : Symbol(b, Decl(missingSelf.ts, 7, 1))
->() => this.onClick() : Symbol((Anonymous function), Decl(missingSelf.ts, 8, 16))
 >this.onClick : Symbol(onClick, Decl(missingSelf.ts, 8, 40))
 >this : Symbol(CalcButton2, Decl(missingSelf.ts, 4, 1))
 >onClick : Symbol(onClick, Decl(missingSelf.ts, 8, 40))
diff --git a/tests/baselines/reference/modFunctionCrash.symbols b/tests/baselines/reference/modFunctionCrash.symbols
index 739ee6001cd6e..b1063a40cd502 100644
--- a/tests/baselines/reference/modFunctionCrash.symbols
+++ b/tests/baselines/reference/modFunctionCrash.symbols
@@ -12,5 +12,4 @@ Q.f(function() {this;});
 >Q.f : Symbol(Q.f, Decl(modFunctionCrash.ts, 0, 18))
 >Q : Symbol(Q, Decl(modFunctionCrash.ts, 0, 0))
 >f : Symbol(Q.f, Decl(modFunctionCrash.ts, 0, 18))
->function() {this;} : Symbol((Anonymous function), Decl(modFunctionCrash.ts, 5, 4))
 
diff --git a/tests/baselines/reference/moduleWithStatementsOfEveryKind.symbols b/tests/baselines/reference/moduleWithStatementsOfEveryKind.symbols
index 9c4bc0ca9a836..d121e6b5367cc 100644
--- a/tests/baselines/reference/moduleWithStatementsOfEveryKind.symbols
+++ b/tests/baselines/reference/moduleWithStatementsOfEveryKind.symbols
@@ -58,7 +58,6 @@ module A {
 
     var fn = (s: string) => {
 >fn : Symbol(fn, Decl(moduleWithStatementsOfEveryKind.ts, 19, 7))
->(s: string) => {        return 'hello ' + s;    } : Symbol((Anonymous function), Decl(moduleWithStatementsOfEveryKind.ts, 19, 12))
 >s : Symbol(s, Decl(moduleWithStatementsOfEveryKind.ts, 19, 14))
 
         return 'hello ' + s;
@@ -66,7 +65,6 @@ module A {
     }
     var ol = { s: 'hello', id: 2, isvalid: true };
 >ol : Symbol(ol, Decl(moduleWithStatementsOfEveryKind.ts, 22, 7))
->{ s: 'hello', id: 2, isvalid: true } : Symbol(, Decl(moduleWithStatementsOfEveryKind.ts, 22, 12))
 >s : Symbol(s, Decl(moduleWithStatementsOfEveryKind.ts, 22, 14))
 >id : Symbol(id, Decl(moduleWithStatementsOfEveryKind.ts, 22, 26))
 >isvalid : Symbol(isvalid, Decl(moduleWithStatementsOfEveryKind.ts, 22, 33))
@@ -138,7 +136,6 @@ module Y {
 
     export var fn = (s: string) => {
 >fn : Symbol(fn, Decl(moduleWithStatementsOfEveryKind.ts, 48, 14))
->(s: string) => {        return 'hello ' + s;    } : Symbol((Anonymous function), Decl(moduleWithStatementsOfEveryKind.ts, 48, 19))
 >s : Symbol(s, Decl(moduleWithStatementsOfEveryKind.ts, 48, 21))
 
         return 'hello ' + s;
@@ -146,7 +143,6 @@ module Y {
     }
     export var ol = { s: 'hello', id: 2, isvalid: true };
 >ol : Symbol(ol, Decl(moduleWithStatementsOfEveryKind.ts, 51, 14))
->{ s: 'hello', id: 2, isvalid: true } : Symbol(, Decl(moduleWithStatementsOfEveryKind.ts, 51, 19))
 >s : Symbol(s, Decl(moduleWithStatementsOfEveryKind.ts, 51, 21))
 >id : Symbol(id, Decl(moduleWithStatementsOfEveryKind.ts, 51, 33))
 >isvalid : Symbol(isvalid, Decl(moduleWithStatementsOfEveryKind.ts, 51, 40))
diff --git a/tests/baselines/reference/multiCallOverloads.symbols b/tests/baselines/reference/multiCallOverloads.symbols
index 7805792d1de82..26b414b463f58 100644
--- a/tests/baselines/reference/multiCallOverloads.symbols
+++ b/tests/baselines/reference/multiCallOverloads.symbols
@@ -14,13 +14,11 @@ function load(f: ICallback) {}
 var f1: ICallback = function(z?) {}
 >f1 : Symbol(f1, Decl(multiCallOverloads.ts, 6, 3))
 >ICallback : Symbol(ICallback, Decl(multiCallOverloads.ts, 0, 0))
->function(z?) {} : Symbol((Anonymous function), Decl(multiCallOverloads.ts, 6, 19))
 >z : Symbol(z, Decl(multiCallOverloads.ts, 6, 29))
 
 var f2: ICallback = function(z?) {}
 >f2 : Symbol(f2, Decl(multiCallOverloads.ts, 7, 3))
 >ICallback : Symbol(ICallback, Decl(multiCallOverloads.ts, 0, 0))
->function(z?) {} : Symbol((Anonymous function), Decl(multiCallOverloads.ts, 7, 19))
 >z : Symbol(z, Decl(multiCallOverloads.ts, 7, 29))
 
 load(f1) // ok
@@ -33,10 +31,8 @@ load(f2) // ok
 
 load(function() {}) // this shouldn’t be an error
 >load : Symbol(load, Decl(multiCallOverloads.ts, 2, 1))
->function() {} : Symbol((Anonymous function), Decl(multiCallOverloads.ts, 10, 5))
 
 load(function(z?) {}) // this shouldn't be an error
 >load : Symbol(load, Decl(multiCallOverloads.ts, 2, 1))
->function(z?) {} : Symbol((Anonymous function), Decl(multiCallOverloads.ts, 11, 5))
 >z : Symbol(z, Decl(multiCallOverloads.ts, 11, 14))
 
diff --git a/tests/baselines/reference/multiImportExport.symbols b/tests/baselines/reference/multiImportExport.symbols
index c9390eef963d3..6601571aabc65 100644
--- a/tests/baselines/reference/multiImportExport.symbols
+++ b/tests/baselines/reference/multiImportExport.symbols
@@ -20,7 +20,6 @@ import Adder = require('Math/Adder');
 
 var Math = {
 >Math : Symbol(Math, Decl(Math.ts, 2, 3))
->{    Adder:Adder} : Symbol(, Decl(Math.ts, 2, 10))
 
     Adder:Adder
 >Adder : Symbol(Adder, Decl(Math.ts, 2, 12))
diff --git a/tests/baselines/reference/nameCollisionsInPropertyAssignments.symbols b/tests/baselines/reference/nameCollisionsInPropertyAssignments.symbols
index 53744c9888f95..2e40d0f8bc51a 100644
--- a/tests/baselines/reference/nameCollisionsInPropertyAssignments.symbols
+++ b/tests/baselines/reference/nameCollisionsInPropertyAssignments.symbols
@@ -4,7 +4,6 @@ var x = 1
 
 var y = { x() { x++; } }; 
 >y : Symbol(y, Decl(nameCollisionsInPropertyAssignments.ts, 1, 3))
->{ x() { x++; } } : Symbol(, Decl(nameCollisionsInPropertyAssignments.ts, 1, 7))
 >x : Symbol(x, Decl(nameCollisionsInPropertyAssignments.ts, 1, 9))
 >x : Symbol(x, Decl(nameCollisionsInPropertyAssignments.ts, 0, 3))
 
diff --git a/tests/baselines/reference/namedFunctionExpressionAssignedToClassProperty.symbols b/tests/baselines/reference/namedFunctionExpressionAssignedToClassProperty.symbols
index d3a6f2ee01fce..707bc64571f43 100644
--- a/tests/baselines/reference/namedFunctionExpressionAssignedToClassProperty.symbols
+++ b/tests/baselines/reference/namedFunctionExpressionAssignedToClassProperty.symbols
@@ -4,7 +4,6 @@ class Foo{
 
        a = function bar(){
 >a : Symbol(a, Decl(namedFunctionExpressionAssignedToClassProperty.ts, 0, 10))
->function bar(){       } : Symbol(bar, Decl(namedFunctionExpressionAssignedToClassProperty.ts, 2, 10))
 >bar : Symbol(bar, Decl(namedFunctionExpressionAssignedToClassProperty.ts, 2, 10))
 
        }; // this shouldn't crash the compiler...
diff --git a/tests/baselines/reference/namedFunctionExpressionCall.symbols b/tests/baselines/reference/namedFunctionExpressionCall.symbols
index 6932f4c73c412..c4ee0d3db4be7 100644
--- a/tests/baselines/reference/namedFunctionExpressionCall.symbols
+++ b/tests/baselines/reference/namedFunctionExpressionCall.symbols
@@ -1,7 +1,6 @@
 === tests/cases/compiler/namedFunctionExpressionCall.ts ===
 var recurser = function foo() {
 >recurser : Symbol(recurser, Decl(namedFunctionExpressionCall.ts, 0, 3))
->function foo() {    // using the local name    foo();    // using the globally visible name    recurser();} : Symbol(foo, Decl(namedFunctionExpressionCall.ts, 0, 14))
 >foo : Symbol(foo, Decl(namedFunctionExpressionCall.ts, 0, 14))
 
     // using the local name
@@ -16,7 +15,6 @@ var recurser = function foo() {
 
 
 (function bar() {
->function bar() {    bar();} : Symbol(bar, Decl(namedFunctionExpressionCall.ts, 9, 1))
 >bar : Symbol(bar, Decl(namedFunctionExpressionCall.ts, 9, 1))
 
     bar();
diff --git a/tests/baselines/reference/namedFunctionExpressionInModule.symbols b/tests/baselines/reference/namedFunctionExpressionInModule.symbols
index 2041fe9c6f978..703cce7bf1428 100644
--- a/tests/baselines/reference/namedFunctionExpressionInModule.symbols
+++ b/tests/baselines/reference/namedFunctionExpressionInModule.symbols
@@ -4,7 +4,6 @@ module Variables{
 
     var x = function bar(a, b, c) {
 >x : Symbol(x, Decl(namedFunctionExpressionInModule.ts, 1, 7))
->function bar(a, b, c) {    } : Symbol(bar, Decl(namedFunctionExpressionInModule.ts, 1, 11))
 >bar : Symbol(bar, Decl(namedFunctionExpressionInModule.ts, 1, 11))
 >a : Symbol(a, Decl(namedFunctionExpressionInModule.ts, 1, 25))
 >b : Symbol(b, Decl(namedFunctionExpressionInModule.ts, 1, 27))
diff --git a/tests/baselines/reference/negateOperatorWithAnyOtherType.symbols b/tests/baselines/reference/negateOperatorWithAnyOtherType.symbols
index 5569a6c6a8647..891fc363dbdcb 100644
--- a/tests/baselines/reference/negateOperatorWithAnyOtherType.symbols
+++ b/tests/baselines/reference/negateOperatorWithAnyOtherType.symbols
@@ -15,10 +15,8 @@ var obj: () => {}
 
 var obj1 = { x: "", y: () => { }};
 >obj1 : Symbol(obj1, Decl(negateOperatorWithAnyOtherType.ts, 6, 3))
->{ x: "", y: () => { }} : Symbol(, Decl(negateOperatorWithAnyOtherType.ts, 6, 10))
 >x : Symbol(x, Decl(negateOperatorWithAnyOtherType.ts, 6, 12))
 >y : Symbol(y, Decl(negateOperatorWithAnyOtherType.ts, 6, 19))
->() => { } : Symbol((Anonymous function), Decl(negateOperatorWithAnyOtherType.ts, 6, 22))
 
 function foo(): any {
 >foo : Symbol(foo, Decl(negateOperatorWithAnyOtherType.ts, 6, 34))
diff --git a/tests/baselines/reference/negateOperatorWithBooleanType.symbols b/tests/baselines/reference/negateOperatorWithBooleanType.symbols
index 8199536077a52..55b35026b979c 100644
--- a/tests/baselines/reference/negateOperatorWithBooleanType.symbols
+++ b/tests/baselines/reference/negateOperatorWithBooleanType.symbols
@@ -37,7 +37,6 @@ var ResultIsNumber2 = -true;
 
 var ResultIsNumber3 = -{ x: true, y: false };
 >ResultIsNumber3 : Symbol(ResultIsNumber3, Decl(negateOperatorWithBooleanType.ts, 20, 3))
->{ x: true, y: false } : Symbol(, Decl(negateOperatorWithBooleanType.ts, 20, 23))
 >x : Symbol(x, Decl(negateOperatorWithBooleanType.ts, 20, 24))
 >y : Symbol(y, Decl(negateOperatorWithBooleanType.ts, 20, 33))
 
diff --git a/tests/baselines/reference/negateOperatorWithNumberType.symbols b/tests/baselines/reference/negateOperatorWithNumberType.symbols
index 08dd36a0a755a..1f75d922b09fe 100644
--- a/tests/baselines/reference/negateOperatorWithNumberType.symbols
+++ b/tests/baselines/reference/negateOperatorWithNumberType.symbols
@@ -44,16 +44,13 @@ var ResultIsNumber3 = -1;
 
 var ResultIsNumber4 = -{ x: 1, y: 2};
 >ResultIsNumber4 : Symbol(ResultIsNumber4, Decl(negateOperatorWithNumberType.ts, 22, 3))
->{ x: 1, y: 2} : Symbol(, Decl(negateOperatorWithNumberType.ts, 22, 23))
 >x : Symbol(x, Decl(negateOperatorWithNumberType.ts, 22, 24))
 >y : Symbol(y, Decl(negateOperatorWithNumberType.ts, 22, 30))
 
 var ResultIsNumber5 = -{ x: 1, y: (n: number) => { return n; } };
 >ResultIsNumber5 : Symbol(ResultIsNumber5, Decl(negateOperatorWithNumberType.ts, 23, 3))
->{ x: 1, y: (n: number) => { return n; } } : Symbol(, Decl(negateOperatorWithNumberType.ts, 23, 23))
 >x : Symbol(x, Decl(negateOperatorWithNumberType.ts, 23, 24))
 >y : Symbol(y, Decl(negateOperatorWithNumberType.ts, 23, 30))
->(n: number) => { return n; } : Symbol((Anonymous function), Decl(negateOperatorWithNumberType.ts, 23, 33))
 >n : Symbol(n, Decl(negateOperatorWithNumberType.ts, 23, 35))
 >n : Symbol(n, Decl(negateOperatorWithNumberType.ts, 23, 35))
 
diff --git a/tests/baselines/reference/negateOperatorWithStringType.symbols b/tests/baselines/reference/negateOperatorWithStringType.symbols
index e5122fed567de..00a90bdf743a6 100644
--- a/tests/baselines/reference/negateOperatorWithStringType.symbols
+++ b/tests/baselines/reference/negateOperatorWithStringType.symbols
@@ -44,16 +44,13 @@ var ResultIsNumber3 = -"";
 
 var ResultIsNumber4 = -{ x: "", y: "" };
 >ResultIsNumber4 : Symbol(ResultIsNumber4, Decl(negateOperatorWithStringType.ts, 22, 3))
->{ x: "", y: "" } : Symbol(, Decl(negateOperatorWithStringType.ts, 22, 23))
 >x : Symbol(x, Decl(negateOperatorWithStringType.ts, 22, 24))
 >y : Symbol(y, Decl(negateOperatorWithStringType.ts, 22, 31))
 
 var ResultIsNumber5 = -{ x: "", y: (s: string) => { return s; } };
 >ResultIsNumber5 : Symbol(ResultIsNumber5, Decl(negateOperatorWithStringType.ts, 23, 3))
->{ x: "", y: (s: string) => { return s; } } : Symbol(, Decl(negateOperatorWithStringType.ts, 23, 23))
 >x : Symbol(x, Decl(negateOperatorWithStringType.ts, 23, 24))
 >y : Symbol(y, Decl(negateOperatorWithStringType.ts, 23, 31))
->(s: string) => { return s; } : Symbol((Anonymous function), Decl(negateOperatorWithStringType.ts, 23, 34))
 >s : Symbol(s, Decl(negateOperatorWithStringType.ts, 23, 36))
 >s : Symbol(s, Decl(negateOperatorWithStringType.ts, 23, 36))
 
diff --git a/tests/baselines/reference/nestedModules.symbols b/tests/baselines/reference/nestedModules.symbols
index 10bf8f4ba025f..7ff4efd30f6de 100644
--- a/tests/baselines/reference/nestedModules.symbols
+++ b/tests/baselines/reference/nestedModules.symbols
@@ -25,7 +25,6 @@ module A {
 >Point : Symbol(Point, Decl(nestedModules.ts, 9, 11))
 >C : Symbol(C, Decl(nestedModules.ts, 0, 11))
 >Point : Symbol(C.Point, Decl(nestedModules.ts, 0, 14))
->{ x: 0, y: 0 } : Symbol(, Decl(nestedModules.ts, 9, 28))
 >x : Symbol(x, Decl(nestedModules.ts, 9, 30))
 >y : Symbol(y, Decl(nestedModules.ts, 9, 36))
     }
diff --git a/tests/baselines/reference/nestedRecursiveLambda.symbols b/tests/baselines/reference/nestedRecursiveLambda.symbols
index 9da6b3951244c..b91c1d84ebbee 100644
--- a/tests/baselines/reference/nestedRecursiveLambda.symbols
+++ b/tests/baselines/reference/nestedRecursiveLambda.symbols
@@ -4,31 +4,23 @@ function f(a:any) {
 >a : Symbol(a, Decl(nestedRecursiveLambda.ts, 0, 11))
 
 void (r =>(r => r));
->r =>(r => r) : Symbol((Anonymous function), Decl(nestedRecursiveLambda.ts, 1, 6))
 >r : Symbol(r, Decl(nestedRecursiveLambda.ts, 1, 6))
->r => r : Symbol((Anonymous function), Decl(nestedRecursiveLambda.ts, 1, 11))
 >r : Symbol(r, Decl(nestedRecursiveLambda.ts, 1, 11))
 >r : Symbol(r, Decl(nestedRecursiveLambda.ts, 1, 11))
 }
 f((r =>(r => r)));
 >f : Symbol(f, Decl(nestedRecursiveLambda.ts, 0, 0))
->r =>(r => r) : Symbol((Anonymous function), Decl(nestedRecursiveLambda.ts, 3, 3))
 >r : Symbol(r, Decl(nestedRecursiveLambda.ts, 3, 3))
->r => r : Symbol((Anonymous function), Decl(nestedRecursiveLambda.ts, 3, 8))
 >r : Symbol(r, Decl(nestedRecursiveLambda.ts, 3, 8))
 >r : Symbol(r, Decl(nestedRecursiveLambda.ts, 3, 8))
 
 void(r =>(r => r));
->r =>(r => r) : Symbol((Anonymous function), Decl(nestedRecursiveLambda.ts, 4, 5))
 >r : Symbol(r, Decl(nestedRecursiveLambda.ts, 4, 5))
->r => r : Symbol((Anonymous function), Decl(nestedRecursiveLambda.ts, 4, 10))
 >r : Symbol(r, Decl(nestedRecursiveLambda.ts, 4, 10))
 >r : Symbol(r, Decl(nestedRecursiveLambda.ts, 4, 10))
 
 [(r =>(r => r))]
->r =>(r => r) : Symbol((Anonymous function), Decl(nestedRecursiveLambda.ts, 5, 2))
 >r : Symbol(r, Decl(nestedRecursiveLambda.ts, 5, 2))
->r => r : Symbol((Anonymous function), Decl(nestedRecursiveLambda.ts, 5, 7))
 >r : Symbol(r, Decl(nestedRecursiveLambda.ts, 5, 7))
 >r : Symbol(r, Decl(nestedRecursiveLambda.ts, 5, 7))
 
diff --git a/tests/baselines/reference/nestedSelf.symbols b/tests/baselines/reference/nestedSelf.symbols
index 9a16cc273b44f..08f41f155d670 100644
--- a/tests/baselines/reference/nestedSelf.symbols
+++ b/tests/baselines/reference/nestedSelf.symbols
@@ -12,7 +12,6 @@ module M {
 >foo : Symbol(foo, Decl(nestedSelf.ts, 2, 17))
 >[1,2,3].map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
 >map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
->(x) => { return this.n * x; } : Symbol((Anonymous function), Decl(nestedSelf.ts, 3, 30))
 >x : Symbol(x, Decl(nestedSelf.ts, 3, 31))
 >this.n : Symbol(n, Decl(nestedSelf.ts, 1, 17))
 >this : Symbol(C, Decl(nestedSelf.ts, 0, 10))
diff --git a/tests/baselines/reference/noCollisionThisExpressionAndClassInGlobal.symbols b/tests/baselines/reference/noCollisionThisExpressionAndClassInGlobal.symbols
index 4d6487e57ab32..e288a42fae0f6 100644
--- a/tests/baselines/reference/noCollisionThisExpressionAndClassInGlobal.symbols
+++ b/tests/baselines/reference/noCollisionThisExpressionAndClassInGlobal.symbols
@@ -4,6 +4,5 @@ class _this {
 }
 var f = () => _this;
 >f : Symbol(f, Decl(noCollisionThisExpressionAndClassInGlobal.ts, 2, 3))
->() => _this : Symbol((Anonymous function), Decl(noCollisionThisExpressionAndClassInGlobal.ts, 2, 7))
 >_this : Symbol(_this, Decl(noCollisionThisExpressionAndClassInGlobal.ts, 0, 0))
 
diff --git a/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInConstructor.symbols b/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInConstructor.symbols
index 35b71804444c1..298e6f9acc16d 100644
--- a/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInConstructor.symbols
+++ b/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInConstructor.symbols
@@ -5,13 +5,10 @@ class class1 {
     constructor() {
         var x2 = {
 >x2 : Symbol(x2, Decl(noCollisionThisExpressionAndLocalVarInConstructor.ts, 2, 11))
->{            doStuff: (callback) => () => {                var _this = 2;                return callback(_this);            }        } : Symbol(, Decl(noCollisionThisExpressionAndLocalVarInConstructor.ts, 2, 16))
 
             doStuff: (callback) => () => {
 >doStuff : Symbol(doStuff, Decl(noCollisionThisExpressionAndLocalVarInConstructor.ts, 2, 18))
->(callback) => () => {                var _this = 2;                return callback(_this);            } : Symbol((Anonymous function), Decl(noCollisionThisExpressionAndLocalVarInConstructor.ts, 3, 20))
 >callback : Symbol(callback, Decl(noCollisionThisExpressionAndLocalVarInConstructor.ts, 3, 22))
->() => {                var _this = 2;                return callback(_this);            } : Symbol((Anonymous function), Decl(noCollisionThisExpressionAndLocalVarInConstructor.ts, 3, 34))
 
                 var _this = 2;
 >_this : Symbol(_this, Decl(noCollisionThisExpressionAndLocalVarInConstructor.ts, 4, 19))
@@ -33,13 +30,10 @@ class class2 {
 
         var x2 = {
 >x2 : Symbol(x2, Decl(noCollisionThisExpressionAndLocalVarInConstructor.ts, 14, 11))
->{            doStuff: (callback) => () => {                return callback(_this);            }        } : Symbol(, Decl(noCollisionThisExpressionAndLocalVarInConstructor.ts, 14, 16))
 
             doStuff: (callback) => () => {
 >doStuff : Symbol(doStuff, Decl(noCollisionThisExpressionAndLocalVarInConstructor.ts, 14, 18))
->(callback) => () => {                return callback(_this);            } : Symbol((Anonymous function), Decl(noCollisionThisExpressionAndLocalVarInConstructor.ts, 15, 20))
 >callback : Symbol(callback, Decl(noCollisionThisExpressionAndLocalVarInConstructor.ts, 15, 22))
->() => {                return callback(_this);            } : Symbol((Anonymous function), Decl(noCollisionThisExpressionAndLocalVarInConstructor.ts, 15, 34))
 
                 return callback(_this);
 >callback : Symbol(callback, Decl(noCollisionThisExpressionAndLocalVarInConstructor.ts, 15, 22))
diff --git a/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInFunction.symbols b/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInFunction.symbols
index 7bfab7051d941..09c99810fea75 100644
--- a/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInFunction.symbols
+++ b/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInFunction.symbols
@@ -13,7 +13,6 @@ function x() {
 >_this : Symbol(_this, Decl(noCollisionThisExpressionAndLocalVarInFunction.ts, 4, 7))
 
     x => { console.log(_this); };
->x => { console.log(_this); } : Symbol((Anonymous function), Decl(noCollisionThisExpressionAndLocalVarInFunction.ts, 4, 18))
 >x : Symbol(x, Decl(noCollisionThisExpressionAndLocalVarInFunction.ts, 4, 18))
 >console.log : Symbol(log, Decl(noCollisionThisExpressionAndLocalVarInFunction.ts, 0, 14))
 >console : Symbol(console, Decl(noCollisionThisExpressionAndLocalVarInFunction.ts, 0, 3))
diff --git a/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInLambda.symbols b/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInLambda.symbols
index e5e9e75ca09e7..45115b278ad28 100644
--- a/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInLambda.symbols
+++ b/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInLambda.symbols
@@ -5,13 +5,10 @@ declare function alert(message?: any): void;
 
 var x = {
 >x : Symbol(x, Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 1, 3))
->{    doStuff: (callback) => () => {        var _this = 2;        return callback(_this);    }} : Symbol(, Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 1, 7))
 
     doStuff: (callback) => () => {
 >doStuff : Symbol(doStuff, Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 1, 9))
->(callback) => () => {        var _this = 2;        return callback(_this);    } : Symbol((Anonymous function), Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 2, 12))
 >callback : Symbol(callback, Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 2, 14))
->() => {        var _this = 2;        return callback(_this);    } : Symbol((Anonymous function), Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 2, 26))
 
         var _this = 2;
 >_this : Symbol(_this, Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 3, 11))
@@ -26,7 +23,6 @@ alert(x.doStuff(x => alert(x)));
 >x.doStuff : Symbol(doStuff, Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 1, 9))
 >x : Symbol(x, Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 1, 3))
 >doStuff : Symbol(doStuff, Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 1, 9))
->x => alert(x) : Symbol((Anonymous function), Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 7, 16))
 >x : Symbol(x, Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 7, 16))
 >alert : Symbol(alert, Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 0, 0))
 >x : Symbol(x, Decl(noCollisionThisExpressionAndLocalVarInLambda.ts, 7, 16))
diff --git a/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInMethod.symbols b/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInMethod.symbols
index 597efeef6225f..72e0d20a9b2de 100644
--- a/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInMethod.symbols
+++ b/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInMethod.symbols
@@ -9,13 +9,9 @@ class a {
 >method1 : Symbol(method1, Decl(noCollisionThisExpressionAndLocalVarInMethod.ts, 1, 9))
 
         return {
->{            doStuff: (callback) => () => {                var _this = 2;                return callback(_this);            }        } : Symbol(, Decl(noCollisionThisExpressionAndLocalVarInMethod.ts, 3, 14))
-
             doStuff: (callback) => () => {
 >doStuff : Symbol(doStuff, Decl(noCollisionThisExpressionAndLocalVarInMethod.ts, 3, 16))
->(callback) => () => {                var _this = 2;                return callback(_this);            } : Symbol((Anonymous function), Decl(noCollisionThisExpressionAndLocalVarInMethod.ts, 4, 20))
 >callback : Symbol(callback, Decl(noCollisionThisExpressionAndLocalVarInMethod.ts, 4, 22))
->() => {                var _this = 2;                return callback(_this);            } : Symbol((Anonymous function), Decl(noCollisionThisExpressionAndLocalVarInMethod.ts, 4, 34))
 
                 var _this = 2;
 >_this : Symbol(_this, Decl(noCollisionThisExpressionAndLocalVarInMethod.ts, 5, 19))
@@ -33,13 +29,9 @@ class a {
 >_this : Symbol(_this, Decl(noCollisionThisExpressionAndLocalVarInMethod.ts, 11, 11))
 
         return {
->{            doStuff: (callback) => () => {                return callback(_this);            }        } : Symbol(, Decl(noCollisionThisExpressionAndLocalVarInMethod.ts, 12, 14))
-
             doStuff: (callback) => () => {
 >doStuff : Symbol(doStuff, Decl(noCollisionThisExpressionAndLocalVarInMethod.ts, 12, 16))
->(callback) => () => {                return callback(_this);            } : Symbol((Anonymous function), Decl(noCollisionThisExpressionAndLocalVarInMethod.ts, 13, 20))
 >callback : Symbol(callback, Decl(noCollisionThisExpressionAndLocalVarInMethod.ts, 13, 22))
->() => {                return callback(_this);            } : Symbol((Anonymous function), Decl(noCollisionThisExpressionAndLocalVarInMethod.ts, 13, 34))
 
                 return callback(_this);
 >callback : Symbol(callback, Decl(noCollisionThisExpressionAndLocalVarInMethod.ts, 13, 22))
diff --git a/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInProperty.symbols b/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInProperty.symbols
index f9883dfcd2a7c..0dc4cf1d84eb5 100644
--- a/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInProperty.symbols
+++ b/tests/baselines/reference/noCollisionThisExpressionAndLocalVarInProperty.symbols
@@ -4,13 +4,10 @@ class class1 {
 
     public prop1 = {
 >prop1 : Symbol(prop1, Decl(noCollisionThisExpressionAndLocalVarInProperty.ts, 0, 14))
->{        doStuff: (callback) => () => {            var _this = 2;            return callback(_this);        }    } : Symbol(, Decl(noCollisionThisExpressionAndLocalVarInProperty.ts, 1, 18))
 
         doStuff: (callback) => () => {
 >doStuff : Symbol(doStuff, Decl(noCollisionThisExpressionAndLocalVarInProperty.ts, 1, 20))
->(callback) => () => {            var _this = 2;            return callback(_this);        } : Symbol((Anonymous function), Decl(noCollisionThisExpressionAndLocalVarInProperty.ts, 2, 16))
 >callback : Symbol(callback, Decl(noCollisionThisExpressionAndLocalVarInProperty.ts, 2, 18))
->() => {            var _this = 2;            return callback(_this);        } : Symbol((Anonymous function), Decl(noCollisionThisExpressionAndLocalVarInProperty.ts, 2, 30))
 
             var _this = 2;
 >_this : Symbol(_this, Decl(noCollisionThisExpressionAndLocalVarInProperty.ts, 3, 15))
@@ -31,13 +28,10 @@ class class2 {
     }
     public prop1 = {
 >prop1 : Symbol(prop1, Decl(noCollisionThisExpressionAndLocalVarInProperty.ts, 12, 5))
->{        doStuff: (callback) => () => {            return callback(10);        }    } : Symbol(, Decl(noCollisionThisExpressionAndLocalVarInProperty.ts, 13, 18))
 
         doStuff: (callback) => () => {
 >doStuff : Symbol(doStuff, Decl(noCollisionThisExpressionAndLocalVarInProperty.ts, 13, 20))
->(callback) => () => {            return callback(10);        } : Symbol((Anonymous function), Decl(noCollisionThisExpressionAndLocalVarInProperty.ts, 14, 16))
 >callback : Symbol(callback, Decl(noCollisionThisExpressionAndLocalVarInProperty.ts, 14, 18))
->() => {            return callback(10);        } : Symbol((Anonymous function), Decl(noCollisionThisExpressionAndLocalVarInProperty.ts, 14, 30))
 
             return callback(10);
 >callback : Symbol(callback, Decl(noCollisionThisExpressionAndLocalVarInProperty.ts, 14, 18))
diff --git a/tests/baselines/reference/noCollisionThisExpressionAndVarInGlobal.symbols b/tests/baselines/reference/noCollisionThisExpressionAndVarInGlobal.symbols
index 76db83884244e..c3746cbcb8f41 100644
--- a/tests/baselines/reference/noCollisionThisExpressionAndVarInGlobal.symbols
+++ b/tests/baselines/reference/noCollisionThisExpressionAndVarInGlobal.symbols
@@ -4,6 +4,5 @@ var _this = 1;
 
 var f = () => _this;
 >f : Symbol(f, Decl(noCollisionThisExpressionAndVarInGlobal.ts, 1, 3))
->() => _this : Symbol((Anonymous function), Decl(noCollisionThisExpressionAndVarInGlobal.ts, 1, 7))
 >_this : Symbol(_this, Decl(noCollisionThisExpressionAndVarInGlobal.ts, 0, 3))
 
diff --git a/tests/baselines/reference/noCollisionThisExpressionInFunctionAndVarInGlobal.symbols b/tests/baselines/reference/noCollisionThisExpressionInFunctionAndVarInGlobal.symbols
index d3fdbc9194f16..b2f2adbbbb609 100644
--- a/tests/baselines/reference/noCollisionThisExpressionInFunctionAndVarInGlobal.symbols
+++ b/tests/baselines/reference/noCollisionThisExpressionInFunctionAndVarInGlobal.symbols
@@ -13,7 +13,6 @@ function x() {
 >x : Symbol(x, Decl(noCollisionThisExpressionInFunctionAndVarInGlobal.ts, 3, 14))
 
     x => { console.log(this); };
->x => { console.log(this); } : Symbol((Anonymous function), Decl(noCollisionThisExpressionInFunctionAndVarInGlobal.ts, 4, 14))
 >x : Symbol(x, Decl(noCollisionThisExpressionInFunctionAndVarInGlobal.ts, 4, 14))
 >console.log : Symbol(log, Decl(noCollisionThisExpressionInFunctionAndVarInGlobal.ts, 0, 14))
 >console : Symbol(console, Decl(noCollisionThisExpressionInFunctionAndVarInGlobal.ts, 0, 3))
diff --git a/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.symbols b/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.symbols
index 11cc6c0d23341..8e9a331a2058f 100644
--- a/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.symbols
+++ b/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.symbols
@@ -3,7 +3,6 @@
 var x: (a: any) => void = function <T>(x: T) {
 >x : Symbol(x, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 1, 3))
 >a : Symbol(a, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 1, 8))
->function <T>(x: T) {    return null;} : Symbol((Anonymous function), Decl(noImplicitAnyFunctionExpressionAssignment.ts, 1, 25))
 >T : Symbol(T, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 1, 36))
 >x : Symbol(x, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 1, 39))
 >T : Symbol(T, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 1, 36))
@@ -14,7 +13,6 @@ var x: (a: any) => void = function <T>(x: T) {
 var x2: (a: any) => void = function f<T>(x: T) {
 >x2 : Symbol(x2, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 5, 3))
 >a : Symbol(a, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 5, 9))
->function f<T>(x: T) {    return null;} : Symbol(f, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 5, 26))
 >f : Symbol(f, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 5, 26))
 >T : Symbol(T, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 5, 38))
 >x : Symbol(x, Decl(noImplicitAnyFunctionExpressionAssignment.ts, 5, 41))
diff --git a/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.symbols b/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.symbols
index 1c838b01eae3f..4bddb6a1f71b0 100644
--- a/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.symbols
+++ b/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.symbols
@@ -7,7 +7,6 @@ regexMatchList.forEach(match => ''.replace(match, ''));
 >regexMatchList.forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
 >regexMatchList : Symbol(regexMatchList, Decl(noImplicitAnyInContextuallyTypesFunctionParamter.ts, 1, 3))
 >forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
->match => ''.replace(match, '') : Symbol((Anonymous function), Decl(noImplicitAnyInContextuallyTypesFunctionParamter.ts, 2, 23))
 >match : Symbol(match, Decl(noImplicitAnyInContextuallyTypesFunctionParamter.ts, 2, 23))
 >''.replace : Symbol(String.replace, Decl(lib.d.ts, 329, 44), Decl(lib.d.ts, 336, 63), Decl(lib.d.ts, 343, 102), Decl(lib.d.ts, 350, 63))
 >replace : Symbol(String.replace, Decl(lib.d.ts, 329, 44), Decl(lib.d.ts, 336, 63), Decl(lib.d.ts, 343, 102), Decl(lib.d.ts, 350, 63))
diff --git a/tests/baselines/reference/noImplicitAnyIndexingSuppressed.symbols b/tests/baselines/reference/noImplicitAnyIndexingSuppressed.symbols
index 496c45de3c274..7c8f57795b40e 100644
--- a/tests/baselines/reference/noImplicitAnyIndexingSuppressed.symbols
+++ b/tests/baselines/reference/noImplicitAnyIndexingSuppressed.symbols
@@ -35,19 +35,16 @@ var strRepresentation4 = MyEmusEnum["emu"];
 // Should be okay, as we suppress implicit 'any' property access checks
 var x = {}["hi"];
 >x : Symbol(x, Decl(noImplicitAnyIndexingSuppressed.ts, 19, 3))
->{} : Symbol(, Decl(noImplicitAnyIndexingSuppressed.ts, 19, 7))
 
 // Should be okay, as we suppress implicit 'any' property access checks
 var y = {}[10];
 >y : Symbol(y, Decl(noImplicitAnyIndexingSuppressed.ts, 22, 3))
->{} : Symbol(, Decl(noImplicitAnyIndexingSuppressed.ts, 22, 7))
 
 var hi: any = "hi";
 >hi : Symbol(hi, Decl(noImplicitAnyIndexingSuppressed.ts, 24, 3))
 
 var emptyObj = {};
 >emptyObj : Symbol(emptyObj, Decl(noImplicitAnyIndexingSuppressed.ts, 26, 3))
->{} : Symbol(, Decl(noImplicitAnyIndexingSuppressed.ts, 26, 14))
 
 // Should be okay, as we suppress implicit 'any' property access checks
 var z1 = emptyObj[hi];
@@ -72,7 +69,6 @@ interface MyMap<T> {
 var m: MyMap<number> = {
 >m : Symbol(m, Decl(noImplicitAnyIndexingSuppressed.ts, 36, 3))
 >MyMap : Symbol(MyMap, Decl(noImplicitAnyIndexingSuppressed.ts, 30, 29))
->{    "0": 0,    "1": 1,    "2": 2,    "Okay that's enough for today.": NaN} : Symbol(, Decl(noImplicitAnyIndexingSuppressed.ts, 36, 22))
 
     "0": 0,
     "1": 1,
diff --git a/tests/baselines/reference/nonInstantiatedModule.symbols b/tests/baselines/reference/nonInstantiatedModule.symbols
index 484d2b07aadb4..0d67b0318f8e4 100644
--- a/tests/baselines/reference/nonInstantiatedModule.symbols
+++ b/tests/baselines/reference/nonInstantiatedModule.symbols
@@ -49,7 +49,6 @@ module M2 {
 >Point : Symbol(Point, Decl(nonInstantiatedModule.ts, 15, 11), Decl(nonInstantiatedModule.ts, 20, 5))
 
             return { x: 0, y: 0 };
->{ x: 0, y: 0 } : Symbol(, Decl(nonInstantiatedModule.ts, 18, 18))
 >x : Symbol(x, Decl(nonInstantiatedModule.ts, 18, 20))
 >y : Symbol(y, Decl(nonInstantiatedModule.ts, 18, 26))
         }
diff --git a/tests/baselines/reference/nonIterableRestElement1.symbols b/tests/baselines/reference/nonIterableRestElement1.symbols
index 5d9b670e41250..352d0c87da45b 100644
--- a/tests/baselines/reference/nonIterableRestElement1.symbols
+++ b/tests/baselines/reference/nonIterableRestElement1.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/destructuring/nonIterableRestElement1.ts ===
 var c = {};
 >c : Symbol(c, Decl(nonIterableRestElement1.ts, 0, 3))
->{} : Symbol(, Decl(nonIterableRestElement1.ts, 0, 7))
 
 [...c] = ["", 0];
 >c : Symbol(c, Decl(nonIterableRestElement1.ts, 0, 3))
diff --git a/tests/baselines/reference/nonIterableRestElement2.symbols b/tests/baselines/reference/nonIterableRestElement2.symbols
index 0ad74b8dd46f6..766524a408ba2 100644
--- a/tests/baselines/reference/nonIterableRestElement2.symbols
+++ b/tests/baselines/reference/nonIterableRestElement2.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/destructuring/nonIterableRestElement2.ts ===
 var c = {};
 >c : Symbol(c, Decl(nonIterableRestElement2.ts, 0, 3))
->{} : Symbol(, Decl(nonIterableRestElement2.ts, 0, 7))
 
 [...c] = ["", 0];
 >c : Symbol(c, Decl(nonIterableRestElement2.ts, 0, 3))
diff --git a/tests/baselines/reference/null.symbols b/tests/baselines/reference/null.symbols
index 97bc53358e1fd..148cd1586b275 100644
--- a/tests/baselines/reference/null.symbols
+++ b/tests/baselines/reference/null.symbols
@@ -37,7 +37,6 @@ interface I {
 var w:I={x:null,y:3};
 >w : Symbol(w, Decl(null.ts, 17, 3))
 >I : Symbol(I, Decl(null.ts, 12, 1))
->{x:null,y:3} : Symbol(, Decl(null.ts, 17, 8))
 >x : Symbol(x, Decl(null.ts, 17, 9))
 >y : Symbol(y, Decl(null.ts, 17, 16))
 
diff --git a/tests/baselines/reference/nullIsSubtypeOfEverythingButUndefined.symbols b/tests/baselines/reference/nullIsSubtypeOfEverythingButUndefined.symbols
index 6e789f7c581b5..7f81995c9be07 100644
--- a/tests/baselines/reference/nullIsSubtypeOfEverythingButUndefined.symbols
+++ b/tests/baselines/reference/nullIsSubtypeOfEverythingButUndefined.symbols
@@ -53,25 +53,20 @@ var r5 = true ? null : /1/;
 
 var r6 = true ? { foo: 1 } : null;
 >r6 : Symbol(r6, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 24, 3), Decl(nullIsSubtypeOfEverythingButUndefined.ts, 25, 3))
->{ foo: 1 } : Symbol(, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 24, 15))
 >foo : Symbol(foo, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 24, 17))
 
 var r6 = true ? null : { foo: 1 };
 >r6 : Symbol(r6, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 24, 3), Decl(nullIsSubtypeOfEverythingButUndefined.ts, 25, 3))
->{ foo: 1 } : Symbol(, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 25, 22))
 >foo : Symbol(foo, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 25, 24))
 
 var r7 = true ? () => { } : null;
 >r7 : Symbol(r7, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 27, 3), Decl(nullIsSubtypeOfEverythingButUndefined.ts, 28, 3))
->() => { } : Symbol((Anonymous function), Decl(nullIsSubtypeOfEverythingButUndefined.ts, 27, 15))
 
 var r7 = true ? null : () => { };
 >r7 : Symbol(r7, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 27, 3), Decl(nullIsSubtypeOfEverythingButUndefined.ts, 28, 3))
->() => { } : Symbol((Anonymous function), Decl(nullIsSubtypeOfEverythingButUndefined.ts, 28, 22))
 
 var r8 = true ? <T>(x: T) => { return x } : null;
 >r8 : Symbol(r8, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 30, 3))
-><T>(x: T) => { return x } : Symbol((Anonymous function), Decl(nullIsSubtypeOfEverythingButUndefined.ts, 30, 15))
 >T : Symbol(T, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 30, 17))
 >x : Symbol(x, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 30, 20))
 >T : Symbol(T, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 30, 17))
@@ -79,7 +74,6 @@ var r8 = true ? <T>(x: T) => { return x } : null;
 
 var r8b = true ? null : <T>(x: T) => { return x }; // type parameters not identical across declarations
 >r8b : Symbol(r8b, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 31, 3))
-><T>(x: T) => { return x } : Symbol((Anonymous function), Decl(nullIsSubtypeOfEverythingButUndefined.ts, 31, 23))
 >T : Symbol(T, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 31, 25))
 >x : Symbol(x, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 31, 28))
 >T : Symbol(T, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 31, 25))
@@ -247,9 +241,7 @@ var r19 = true ? null : new Object();
 
 var r20 = true ? {} : null;
 >r20 : Symbol(r20, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 88, 3), Decl(nullIsSubtypeOfEverythingButUndefined.ts, 89, 3))
->{} : Symbol(, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 88, 16))
 
 var r20 = true ? null : {};
 >r20 : Symbol(r20, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 88, 3), Decl(nullIsSubtypeOfEverythingButUndefined.ts, 89, 3))
->{} : Symbol(, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 89, 23))
 
diff --git a/tests/baselines/reference/numericIndexerConstraint4.symbols b/tests/baselines/reference/numericIndexerConstraint4.symbols
index 2b8aba476406d..63d976ea1b1aa 100644
--- a/tests/baselines/reference/numericIndexerConstraint4.symbols
+++ b/tests/baselines/reference/numericIndexerConstraint4.symbols
@@ -22,7 +22,6 @@ var x: {
 >A : Symbol(A, Decl(numericIndexerConstraint4.ts, 0, 0))
 
 } = { data: new B() }
->{ data: new B() } : Symbol(, Decl(numericIndexerConstraint4.ts, 10, 3))
 >data : Symbol(data, Decl(numericIndexerConstraint4.ts, 10, 5))
 >B : Symbol(B, Decl(numericIndexerConstraint4.ts, 2, 1))
 
diff --git a/tests/baselines/reference/numericIndexingResults.symbols b/tests/baselines/reference/numericIndexingResults.symbols
index 6fb0d250b3b34..16a6e9386da45 100644
--- a/tests/baselines/reference/numericIndexingResults.symbols
+++ b/tests/baselines/reference/numericIndexingResults.symbols
@@ -124,7 +124,6 @@ var r6 = a[3];
 var b: { [x: number]: string } = { 1: '', "2": '' }
 >b : Symbol(b, Decl(numericIndexingResults.ts, 41, 3))
 >x : Symbol(x, Decl(numericIndexingResults.ts, 41, 10))
->{ 1: '', "2": '' } : Symbol(, Decl(numericIndexingResults.ts, 41, 32))
 
 var r1a = b['1'];
 >r1a : Symbol(r1a, Decl(numericIndexingResults.ts, 42, 3))
@@ -153,7 +152,6 @@ var r6 = b[3];
 var b2: { [x: number]: string; 1: string; "2": string; } = { 1: '', "2": '' }
 >b2 : Symbol(b2, Decl(numericIndexingResults.ts, 49, 3))
 >x : Symbol(x, Decl(numericIndexingResults.ts, 49, 11))
->{ 1: '', "2": '' } : Symbol(, Decl(numericIndexingResults.ts, 49, 58))
 
 var r1b = b2['1'];
 >r1b : Symbol(r1b, Decl(numericIndexingResults.ts, 50, 3))
diff --git a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers05.symbols b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers05.symbols
index 66353d703ed58..5ac9bb815f8f9 100644
--- a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers05.symbols
+++ b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers05.symbols
@@ -2,6 +2,5 @@
 
 var { as } = { as: 1 }
 >as : Symbol(as, Decl(objectBindingPatternKeywordIdentifiers05.ts, 1, 5))
->{ as: 1 } : Symbol(, Decl(objectBindingPatternKeywordIdentifiers05.ts, 1, 12))
 >as : Symbol(as, Decl(objectBindingPatternKeywordIdentifiers05.ts, 1, 14))
 
diff --git a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers06.symbols b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers06.symbols
index bba1ada64929d..7cee5f3009b12 100644
--- a/tests/baselines/reference/objectBindingPatternKeywordIdentifiers06.symbols
+++ b/tests/baselines/reference/objectBindingPatternKeywordIdentifiers06.symbols
@@ -2,6 +2,5 @@
 
 var { as: as } = { as: 1 }
 >as : Symbol(as, Decl(objectBindingPatternKeywordIdentifiers06.ts, 1, 5))
->{ as: 1 } : Symbol(, Decl(objectBindingPatternKeywordIdentifiers06.ts, 1, 16))
 >as : Symbol(as, Decl(objectBindingPatternKeywordIdentifiers06.ts, 1, 18))
 
diff --git a/tests/baselines/reference/objectIndexer.symbols b/tests/baselines/reference/objectIndexer.symbols
index b7a8c3746ac38..33885a40e2771 100644
--- a/tests/baselines/reference/objectIndexer.symbols
+++ b/tests/baselines/reference/objectIndexer.symbols
@@ -26,7 +26,6 @@ class Emitter {
 >this.listeners : Symbol(listeners, Decl(objectIndexer.ts, 8, 15))
 >this : Symbol(Emitter, Decl(objectIndexer.ts, 6, 1))
 >listeners : Symbol(listeners, Decl(objectIndexer.ts, 8, 15))
->{} : Symbol(, Decl(objectIndexer.ts, 11, 24))
     }
 }
 
diff --git a/tests/baselines/reference/objectLitGetterSetter.symbols b/tests/baselines/reference/objectLitGetterSetter.symbols
index 45cd43aa2f5e9..512e459c8c060 100644
--- a/tests/baselines/reference/objectLitGetterSetter.symbols
+++ b/tests/baselines/reference/objectLitGetterSetter.symbols
@@ -1,7 +1,6 @@
 === tests/cases/compiler/objectLitGetterSetter.ts ===
             var obj = {};
 >obj : Symbol(obj, Decl(objectLitGetterSetter.ts, 0, 15))
->{} : Symbol(, Decl(objectLitGetterSetter.ts, 0, 21))
 
             Object.defineProperty(obj, "accProperty", <PropertyDescriptor>({
 >Object.defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.d.ts, 160, 60))
@@ -9,11 +8,9 @@
 >defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.d.ts, 160, 60))
 >obj : Symbol(obj, Decl(objectLitGetterSetter.ts, 0, 15))
 >PropertyDescriptor : Symbol(PropertyDescriptor, Decl(lib.d.ts, 79, 66))
->{                get: function () {                    eval("public = 1;");                    return 11;                },                set: function (v) {                }            } : Symbol(, Decl(objectLitGetterSetter.ts, 1, 75))
 
                 get: function () {
 >get : Symbol(get, Decl(objectLitGetterSetter.ts, 1, 76))
->function () {                    eval("public = 1;");                    return 11;                } : Symbol((Anonymous function), Decl(objectLitGetterSetter.ts, 2, 20))
 
                     eval("public = 1;");
 >eval : Symbol(eval, Decl(lib.d.ts, 22, 29))
@@ -22,7 +19,6 @@
                 },
                 set: function (v) {
 >set : Symbol(set, Decl(objectLitGetterSetter.ts, 5, 18))
->function (v) {                } : Symbol((Anonymous function), Decl(objectLitGetterSetter.ts, 6, 20))
 >v : Symbol(v, Decl(objectLitGetterSetter.ts, 6, 31))
                 }
             }))
diff --git a/tests/baselines/reference/objectLiteral1.symbols b/tests/baselines/reference/objectLiteral1.symbols
index b5225b95a5818..76acb6623bc8b 100644
--- a/tests/baselines/reference/objectLiteral1.symbols
+++ b/tests/baselines/reference/objectLiteral1.symbols
@@ -1,7 +1,6 @@
 === tests/cases/compiler/objectLiteral1.ts ===
 var v30 = {a:1, b:2};
 >v30 : Symbol(v30, Decl(objectLiteral1.ts, 0, 3))
->{a:1, b:2} : Symbol(, Decl(objectLiteral1.ts, 0, 9))
 >a : Symbol(a, Decl(objectLiteral1.ts, 0, 11))
 >b : Symbol(b, Decl(objectLiteral1.ts, 0, 15))
 
diff --git a/tests/baselines/reference/objectLiteral2.symbols b/tests/baselines/reference/objectLiteral2.symbols
index 5f85e605df19f..6e953fa2c1223 100644
--- a/tests/baselines/reference/objectLiteral2.symbols
+++ b/tests/baselines/reference/objectLiteral2.symbols
@@ -1,7 +1,6 @@
 === tests/cases/compiler/objectLiteral2.ts ===
 var v30 = {a:1, b:2}, v31;
 >v30 : Symbol(v30, Decl(objectLiteral2.ts, 0, 3))
->{a:1, b:2} : Symbol(, Decl(objectLiteral2.ts, 0, 9))
 >a : Symbol(a, Decl(objectLiteral2.ts, 0, 11))
 >b : Symbol(b, Decl(objectLiteral2.ts, 0, 15))
 >v31 : Symbol(v31, Decl(objectLiteral2.ts, 0, 21))
diff --git a/tests/baselines/reference/objectLiteralArraySpecialization.symbols b/tests/baselines/reference/objectLiteralArraySpecialization.symbols
index 5dd4114bcc11d..4cc1188dcc451 100644
--- a/tests/baselines/reference/objectLiteralArraySpecialization.symbols
+++ b/tests/baselines/reference/objectLiteralArraySpecialization.symbols
@@ -27,10 +27,8 @@ interface MyArrayWrapper<T> {
 var thing = create([ { name: "bob", id: 24 }, { name: "doug", id: 32 } ]); // should not error
 >thing : Symbol(thing, Decl(objectLiteralArraySpecialization.ts, 5, 3))
 >create : Symbol(create, Decl(objectLiteralArraySpecialization.ts, 0, 0))
->{ name: "bob", id: 24 } : Symbol(, Decl(objectLiteralArraySpecialization.ts, 5, 20))
 >name : Symbol(name, Decl(objectLiteralArraySpecialization.ts, 5, 22))
 >id : Symbol(id, Decl(objectLiteralArraySpecialization.ts, 5, 35))
->{ name: "doug", id: 32 } : Symbol(, Decl(objectLiteralArraySpecialization.ts, 5, 45))
 >name : Symbol(name, Decl(objectLiteralArraySpecialization.ts, 5, 47))
 >id : Symbol(id, Decl(objectLiteralArraySpecialization.ts, 5, 61))
 
@@ -38,7 +36,6 @@ thing.doSomething((x, y) => x.name === "bob"); // should not error
 >thing.doSomething : Symbol(MyArrayWrapper.doSomething, Decl(objectLiteralArraySpecialization.ts, 2, 33))
 >thing : Symbol(thing, Decl(objectLiteralArraySpecialization.ts, 5, 3))
 >doSomething : Symbol(MyArrayWrapper.doSomething, Decl(objectLiteralArraySpecialization.ts, 2, 33))
->(x, y) => x.name === "bob" : Symbol((Anonymous function), Decl(objectLiteralArraySpecialization.ts, 6, 18))
 >x : Symbol(x, Decl(objectLiteralArraySpecialization.ts, 6, 19))
 >y : Symbol(y, Decl(objectLiteralArraySpecialization.ts, 6, 21))
 >x.name : Symbol(name, Decl(objectLiteralArraySpecialization.ts, 5, 22))
diff --git a/tests/baselines/reference/objectLiteralContextualTyping.symbols b/tests/baselines/reference/objectLiteralContextualTyping.symbols
index 1d777a55aadbe..23a468eac3f66 100644
--- a/tests/baselines/reference/objectLiteralContextualTyping.symbols
+++ b/tests/baselines/reference/objectLiteralContextualTyping.symbols
@@ -26,7 +26,6 @@ declare function foo(item: any): number;
 var x = foo({ name: "Sprocket" });
 >x : Symbol(x, Decl(objectLiteralContextualTyping.ts, 13, 3), Decl(objectLiteralContextualTyping.ts, 14, 3))
 >foo : Symbol(foo, Decl(objectLiteralContextualTyping.ts, 8, 1), Decl(objectLiteralContextualTyping.ts, 10, 41))
->{ name: "Sprocket" } : Symbol(, Decl(objectLiteralContextualTyping.ts, 13, 12))
 >name : Symbol(name, Decl(objectLiteralContextualTyping.ts, 13, 13))
 
 var x: string;
@@ -35,7 +34,6 @@ var x: string;
 var y = foo({ name: "Sprocket", description: "Bumpy wheel" });
 >y : Symbol(y, Decl(objectLiteralContextualTyping.ts, 16, 3), Decl(objectLiteralContextualTyping.ts, 17, 3))
 >foo : Symbol(foo, Decl(objectLiteralContextualTyping.ts, 8, 1), Decl(objectLiteralContextualTyping.ts, 10, 41))
->{ name: "Sprocket", description: "Bumpy wheel" } : Symbol(, Decl(objectLiteralContextualTyping.ts, 16, 12))
 >name : Symbol(name, Decl(objectLiteralContextualTyping.ts, 16, 13))
 >description : Symbol(description, Decl(objectLiteralContextualTyping.ts, 16, 31))
 
@@ -45,7 +43,6 @@ var y: string;
 var z = foo({ name: "Sprocket", description: false });
 >z : Symbol(z, Decl(objectLiteralContextualTyping.ts, 19, 3), Decl(objectLiteralContextualTyping.ts, 20, 3))
 >foo : Symbol(foo, Decl(objectLiteralContextualTyping.ts, 8, 1), Decl(objectLiteralContextualTyping.ts, 10, 41))
->{ name: "Sprocket", description: false } : Symbol(, Decl(objectLiteralContextualTyping.ts, 19, 12))
 >name : Symbol(name, Decl(objectLiteralContextualTyping.ts, 19, 13))
 >description : Symbol(description, Decl(objectLiteralContextualTyping.ts, 19, 31))
 
@@ -55,7 +52,6 @@ var z: number;
 var w = foo({ a: 10 });
 >w : Symbol(w, Decl(objectLiteralContextualTyping.ts, 22, 3), Decl(objectLiteralContextualTyping.ts, 23, 3))
 >foo : Symbol(foo, Decl(objectLiteralContextualTyping.ts, 8, 1), Decl(objectLiteralContextualTyping.ts, 10, 41))
->{ a: 10 } : Symbol(, Decl(objectLiteralContextualTyping.ts, 22, 12))
 >a : Symbol(a, Decl(objectLiteralContextualTyping.ts, 22, 13))
 
 var w: number;
@@ -72,7 +68,6 @@ declare function bar<T>(param: { x?: T }): T;
 var b = bar({});
 >b : Symbol(b, Decl(objectLiteralContextualTyping.ts, 27, 3), Decl(objectLiteralContextualTyping.ts, 28, 3))
 >bar : Symbol(bar, Decl(objectLiteralContextualTyping.ts, 23, 14))
->{} : Symbol(, Decl(objectLiteralContextualTyping.ts, 27, 12))
 
 var b: {};
 >b : Symbol(b, Decl(objectLiteralContextualTyping.ts, 27, 3), Decl(objectLiteralContextualTyping.ts, 28, 3))
diff --git a/tests/baselines/reference/objectLiteralIndexerNoImplicitAny.symbols b/tests/baselines/reference/objectLiteralIndexerNoImplicitAny.symbols
index 7f50cae48cb16..2a5545f22642d 100644
--- a/tests/baselines/reference/objectLiteralIndexerNoImplicitAny.symbols
+++ b/tests/baselines/reference/objectLiteralIndexerNoImplicitAny.symbols
@@ -9,7 +9,6 @@ interface I {
 var x: I = {
 >x : Symbol(x, Decl(objectLiteralIndexerNoImplicitAny.ts, 4, 3))
 >I : Symbol(I, Decl(objectLiteralIndexerNoImplicitAny.ts, 0, 0))
->{    p: null} : Symbol(, Decl(objectLiteralIndexerNoImplicitAny.ts, 4, 10))
 
     p: null
 >p : Symbol(p, Decl(objectLiteralIndexerNoImplicitAny.ts, 4, 12))
diff --git a/tests/baselines/reference/objectLiteralIndexers.symbols b/tests/baselines/reference/objectLiteralIndexers.symbols
index f081b86fe4287..424e95be0faa1 100644
--- a/tests/baselines/reference/objectLiteralIndexers.symbols
+++ b/tests/baselines/reference/objectLiteralIndexers.symbols
@@ -31,21 +31,18 @@ var o1: { [s: string]: A;[n: number]: B; } = { x: a, 0: b }; // string indexer i
 >A : Symbol(A, Decl(objectLiteralIndexers.ts, 0, 0))
 >n : Symbol(n, Decl(objectLiteralIndexers.ts, 12, 26))
 >B : Symbol(B, Decl(objectLiteralIndexers.ts, 2, 1))
->{ x: a, 0: b } : Symbol(, Decl(objectLiteralIndexers.ts, 12, 44))
 >x : Symbol(x, Decl(objectLiteralIndexers.ts, 12, 46))
 >a : Symbol(a, Decl(objectLiteralIndexers.ts, 8, 3))
 >b : Symbol(b, Decl(objectLiteralIndexers.ts, 9, 3))
 
 o1 = { x: b, 0: c }; // both indexers are any
 >o1 : Symbol(o1, Decl(objectLiteralIndexers.ts, 12, 3))
->{ x: b, 0: c } : Symbol(, Decl(objectLiteralIndexers.ts, 13, 4))
 >x : Symbol(x, Decl(objectLiteralIndexers.ts, 13, 6))
 >b : Symbol(b, Decl(objectLiteralIndexers.ts, 9, 3))
 >c : Symbol(c, Decl(objectLiteralIndexers.ts, 10, 3))
 
 o1 = { x: c, 0: b }; // string indexer is any, number indexer is B
 >o1 : Symbol(o1, Decl(objectLiteralIndexers.ts, 12, 3))
->{ x: c, 0: b } : Symbol(, Decl(objectLiteralIndexers.ts, 14, 4))
 >x : Symbol(x, Decl(objectLiteralIndexers.ts, 14, 6))
 >c : Symbol(c, Decl(objectLiteralIndexers.ts, 10, 3))
 >b : Symbol(b, Decl(objectLiteralIndexers.ts, 9, 3))
diff --git a/tests/baselines/reference/objectLiteralShorthandProperties.symbols b/tests/baselines/reference/objectLiteralShorthandProperties.symbols
index 93533fa480c2e..e75b1d70a1162 100644
--- a/tests/baselines/reference/objectLiteralShorthandProperties.symbols
+++ b/tests/baselines/reference/objectLiteralShorthandProperties.symbols
@@ -6,7 +6,6 @@ var a, b, c;
 
 var x1 = {
 >x1 : Symbol(x1, Decl(objectLiteralShorthandProperties.ts, 2, 3))
->{    a} : Symbol(, Decl(objectLiteralShorthandProperties.ts, 2, 8))
 
     a
 >a : Symbol(a, Decl(objectLiteralShorthandProperties.ts, 2, 10))
@@ -15,7 +14,6 @@ var x1 = {
 
 var x2 = {
 >x2 : Symbol(x2, Decl(objectLiteralShorthandProperties.ts, 6, 3))
->{    a,} : Symbol(, Decl(objectLiteralShorthandProperties.ts, 6, 8))
 
     a,
 >a : Symbol(a, Decl(objectLiteralShorthandProperties.ts, 6, 10))
@@ -23,7 +21,6 @@ var x2 = {
 
 var x3 = {
 >x3 : Symbol(x3, Decl(objectLiteralShorthandProperties.ts, 10, 3))
->{    a: 0,    b,    c,    d() { },    x3,    parent: x3} : Symbol(, Decl(objectLiteralShorthandProperties.ts, 10, 8))
 
     a: 0,
 >a : Symbol(a, Decl(objectLiteralShorthandProperties.ts, 10, 10))
diff --git a/tests/baselines/reference/objectLiteralShorthandPropertiesAssignment.symbols b/tests/baselines/reference/objectLiteralShorthandPropertiesAssignment.symbols
index 91da6b180adc1..6afb48aac498b 100644
--- a/tests/baselines/reference/objectLiteralShorthandPropertiesAssignment.symbols
+++ b/tests/baselines/reference/objectLiteralShorthandPropertiesAssignment.symbols
@@ -9,7 +9,6 @@ var person: { name: string; id: number } = { name, id };
 >person : Symbol(person, Decl(objectLiteralShorthandPropertiesAssignment.ts, 3, 3))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesAssignment.ts, 3, 13))
 >id : Symbol(id, Decl(objectLiteralShorthandPropertiesAssignment.ts, 3, 27))
->{ name, id } : Symbol(, Decl(objectLiteralShorthandPropertiesAssignment.ts, 3, 42))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesAssignment.ts, 3, 44))
 >id : Symbol(id, Decl(objectLiteralShorthandPropertiesAssignment.ts, 3, 50))
 
@@ -22,7 +21,6 @@ function bar(name: string, id: number) { return { name, id }; }
 >bar : Symbol(bar, Decl(objectLiteralShorthandPropertiesAssignment.ts, 4, 46))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesAssignment.ts, 5, 13))
 >id : Symbol(id, Decl(objectLiteralShorthandPropertiesAssignment.ts, 5, 26))
->{ name, id } : Symbol(, Decl(objectLiteralShorthandPropertiesAssignment.ts, 5, 47))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesAssignment.ts, 5, 49))
 >id : Symbol(id, Decl(objectLiteralShorthandPropertiesAssignment.ts, 5, 55))
 
@@ -30,7 +28,6 @@ function bar1(name: string, id: number) { return { name }; }
 >bar1 : Symbol(bar1, Decl(objectLiteralShorthandPropertiesAssignment.ts, 5, 63))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesAssignment.ts, 6, 14))
 >id : Symbol(id, Decl(objectLiteralShorthandPropertiesAssignment.ts, 6, 27))
->{ name } : Symbol(, Decl(objectLiteralShorthandPropertiesAssignment.ts, 6, 48))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesAssignment.ts, 6, 50))
 
 function baz(name: string, id: number): { name: string; id: number } { return { name, id }; }
@@ -39,7 +36,6 @@ function baz(name: string, id: number): { name: string; id: number } { return {
 >id : Symbol(id, Decl(objectLiteralShorthandPropertiesAssignment.ts, 7, 26))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesAssignment.ts, 7, 41))
 >id : Symbol(id, Decl(objectLiteralShorthandPropertiesAssignment.ts, 7, 55))
->{ name, id } : Symbol(, Decl(objectLiteralShorthandPropertiesAssignment.ts, 7, 77))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesAssignment.ts, 7, 79))
 >id : Symbol(id, Decl(objectLiteralShorthandPropertiesAssignment.ts, 7, 85))
 
diff --git a/tests/baselines/reference/objectLiteralShorthandPropertiesAssignmentES6.symbols b/tests/baselines/reference/objectLiteralShorthandPropertiesAssignmentES6.symbols
index ec48a232e0be5..e444d177a798e 100644
--- a/tests/baselines/reference/objectLiteralShorthandPropertiesAssignmentES6.symbols
+++ b/tests/baselines/reference/objectLiteralShorthandPropertiesAssignmentES6.symbols
@@ -9,7 +9,6 @@ var person: { name: string; id: number } = { name, id };
 >person : Symbol(person, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 3, 3))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 3, 13))
 >id : Symbol(id, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 3, 27))
->{ name, id } : Symbol(, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 3, 42))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 3, 44))
 >id : Symbol(id, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 3, 50))
 
@@ -22,7 +21,6 @@ function bar(name: string, id: number) { return { name, id }; }
 >bar : Symbol(bar, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 4, 46))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 5, 13))
 >id : Symbol(id, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 5, 26))
->{ name, id } : Symbol(, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 5, 47))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 5, 49))
 >id : Symbol(id, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 5, 55))
 
@@ -30,7 +28,6 @@ function bar1(name: string, id: number) { return { name }; }
 >bar1 : Symbol(bar1, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 5, 63))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 6, 14))
 >id : Symbol(id, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 6, 27))
->{ name } : Symbol(, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 6, 48))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 6, 50))
 
 function baz(name: string, id: number): { name: string; id: number } { return { name, id }; }
@@ -39,7 +36,6 @@ function baz(name: string, id: number): { name: string; id: number } { return {
 >id : Symbol(id, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 7, 26))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 7, 41))
 >id : Symbol(id, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 7, 55))
->{ name, id } : Symbol(, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 7, 77))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 7, 79))
 >id : Symbol(id, Decl(objectLiteralShorthandPropertiesAssignmentES6.ts, 7, 85))
 
diff --git a/tests/baselines/reference/objectLiteralShorthandPropertiesES6.symbols b/tests/baselines/reference/objectLiteralShorthandPropertiesES6.symbols
index 5e2466b78130e..2f9b50168c118 100644
--- a/tests/baselines/reference/objectLiteralShorthandPropertiesES6.symbols
+++ b/tests/baselines/reference/objectLiteralShorthandPropertiesES6.symbols
@@ -6,7 +6,6 @@ var a, b, c;
 
 var x1 = {
 >x1 : Symbol(x1, Decl(objectLiteralShorthandPropertiesES6.ts, 2, 3))
->{    a} : Symbol(, Decl(objectLiteralShorthandPropertiesES6.ts, 2, 8))
 
     a
 >a : Symbol(a, Decl(objectLiteralShorthandPropertiesES6.ts, 2, 10))
@@ -15,7 +14,6 @@ var x1 = {
 
 var x2 = {
 >x2 : Symbol(x2, Decl(objectLiteralShorthandPropertiesES6.ts, 6, 3))
->{    a,} : Symbol(, Decl(objectLiteralShorthandPropertiesES6.ts, 6, 8))
 
     a,
 >a : Symbol(a, Decl(objectLiteralShorthandPropertiesES6.ts, 6, 10))
@@ -23,7 +21,6 @@ var x2 = {
 
 var x3 = {
 >x3 : Symbol(x3, Decl(objectLiteralShorthandPropertiesES6.ts, 10, 3))
->{    a: 0,    b,    c,    d() { },    x3,    parent: x3} : Symbol(, Decl(objectLiteralShorthandPropertiesES6.ts, 10, 8))
 
     a: 0,
 >a : Symbol(a, Decl(objectLiteralShorthandPropertiesES6.ts, 10, 10))
diff --git a/tests/baselines/reference/objectLiteralShorthandPropertiesFunctionArgument.symbols b/tests/baselines/reference/objectLiteralShorthandPropertiesFunctionArgument.symbols
index 0f76c44d9696c..ba8b0eeb6a92a 100644
--- a/tests/baselines/reference/objectLiteralShorthandPropertiesFunctionArgument.symbols
+++ b/tests/baselines/reference/objectLiteralShorthandPropertiesFunctionArgument.symbols
@@ -7,7 +7,6 @@ var name: string = "my name";
 
 var person = { name, id };
 >person : Symbol(person, Decl(objectLiteralShorthandPropertiesFunctionArgument.ts, 3, 3))
->{ name, id } : Symbol(, Decl(objectLiteralShorthandPropertiesFunctionArgument.ts, 3, 12))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesFunctionArgument.ts, 3, 14))
 >id : Symbol(id, Decl(objectLiteralShorthandPropertiesFunctionArgument.ts, 3, 20))
 
@@ -24,7 +23,6 @@ foo(person);
 
 var obj = { name: name, id: id };
 >obj : Symbol(obj, Decl(objectLiteralShorthandPropertiesFunctionArgument.ts, 9, 3))
->{ name: name, id: id } : Symbol(, Decl(objectLiteralShorthandPropertiesFunctionArgument.ts, 9, 9))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesFunctionArgument.ts, 9, 11))
 >name : Symbol(name, Decl(objectLiteralShorthandPropertiesFunctionArgument.ts, 1, 3))
 >id : Symbol(id, Decl(objectLiteralShorthandPropertiesFunctionArgument.ts, 9, 23))
diff --git a/tests/baselines/reference/objectLiteralShorthandPropertiesWithModule.symbols b/tests/baselines/reference/objectLiteralShorthandPropertiesWithModule.symbols
index 2cdb9d6fbd4c3..681036e2aef82 100644
--- a/tests/baselines/reference/objectLiteralShorthandPropertiesWithModule.symbols
+++ b/tests/baselines/reference/objectLiteralShorthandPropertiesWithModule.symbols
@@ -17,7 +17,6 @@ module m {
 
     var y = {
 >y : Symbol(y, Decl(objectLiteralShorthandPropertiesWithModule.ts, 8, 7))
->{        a: x,        x    } : Symbol(, Decl(objectLiteralShorthandPropertiesWithModule.ts, 8, 11))
 
         a: x,
 >a : Symbol(a, Decl(objectLiteralShorthandPropertiesWithModule.ts, 8, 13))
diff --git a/tests/baselines/reference/objectLiteralShorthandPropertiesWithModuleES6.symbols b/tests/baselines/reference/objectLiteralShorthandPropertiesWithModuleES6.symbols
index 0964222da3ab2..bcb69cc9a976c 100644
--- a/tests/baselines/reference/objectLiteralShorthandPropertiesWithModuleES6.symbols
+++ b/tests/baselines/reference/objectLiteralShorthandPropertiesWithModuleES6.symbols
@@ -16,7 +16,6 @@ module m {
 
     var y = {
 >y : Symbol(y, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 7, 7))
->{        a: x,        x    } : Symbol(, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 7, 11))
 
         a: x,
 >a : Symbol(a, Decl(objectLiteralShorthandPropertiesWithModuleES6.ts, 7, 13))
diff --git a/tests/baselines/reference/objectLiteralWidened.symbols b/tests/baselines/reference/objectLiteralWidened.symbols
index 57fdb291c2e42..0bf077cd9d8a1 100644
--- a/tests/baselines/reference/objectLiteralWidened.symbols
+++ b/tests/baselines/reference/objectLiteralWidened.symbols
@@ -3,7 +3,6 @@
 
 var x = {
 >x : Symbol(x, Decl(objectLiteralWidened.ts, 2, 3))
->{    foo: null,    bar: undefined} : Symbol(, Decl(objectLiteralWidened.ts, 2, 7))
 
     foo: null,
 >foo : Symbol(foo, Decl(objectLiteralWidened.ts, 2, 9))
@@ -15,14 +14,12 @@ var x = {
 
 var y = {
 >y : Symbol(y, Decl(objectLiteralWidened.ts, 7, 3))
->{    foo: null,    bar: {        baz: null,        boo: undefined    }} : Symbol(, Decl(objectLiteralWidened.ts, 7, 7))
 
     foo: null,
 >foo : Symbol(foo, Decl(objectLiteralWidened.ts, 7, 9))
 
     bar: {
 >bar : Symbol(bar, Decl(objectLiteralWidened.ts, 8, 14))
->{        baz: null,        boo: undefined    } : Symbol(, Decl(objectLiteralWidened.ts, 9, 8))
 
         baz: null,
 >baz : Symbol(baz, Decl(objectLiteralWidened.ts, 9, 10))
diff --git a/tests/baselines/reference/objectTypeHidingMembersOfObject.symbols b/tests/baselines/reference/objectTypeHidingMembersOfObject.symbols
index 8601706f37162..5c88d538fdbea 100644
--- a/tests/baselines/reference/objectTypeHidingMembersOfObject.symbols
+++ b/tests/baselines/reference/objectTypeHidingMembersOfObject.symbols
@@ -37,11 +37,9 @@ var r2: void = i.valueOf();
 
 var a = {
 >a : Symbol(a, Decl(objectTypeHidingMembersOfObject.ts, 16, 3))
->{    valueOf: () => { }} : Symbol(, Decl(objectTypeHidingMembersOfObject.ts, 16, 7))
 
     valueOf: () => { }
 >valueOf : Symbol(valueOf, Decl(objectTypeHidingMembersOfObject.ts, 16, 9))
->() => { } : Symbol((Anonymous function), Decl(objectTypeHidingMembersOfObject.ts, 17, 12))
 }
 
 var r3: void = a.valueOf();
diff --git a/tests/baselines/reference/objectTypePropertyAccess.symbols b/tests/baselines/reference/objectTypePropertyAccess.symbols
index a42b6cdae7a86..519bf58926096 100644
--- a/tests/baselines/reference/objectTypePropertyAccess.symbols
+++ b/tests/baselines/reference/objectTypePropertyAccess.symbols
@@ -67,7 +67,6 @@ var r7 = i['bar'];
 
 var a = {
 >a : Symbol(a, Decl(objectTypePropertyAccess.ts, 20, 3))
->{    foo: ''} : Symbol(, Decl(objectTypePropertyAccess.ts, 20, 7))
 
     foo: ''
 >foo : Symbol(foo, Decl(objectTypePropertyAccess.ts, 20, 9))
diff --git a/tests/baselines/reference/objectTypeWithNumericProperty.symbols b/tests/baselines/reference/objectTypeWithNumericProperty.symbols
index 3d51c55f4b0d5..20e54fe1c646c 100644
--- a/tests/baselines/reference/objectTypeWithNumericProperty.symbols
+++ b/tests/baselines/reference/objectTypeWithNumericProperty.symbols
@@ -92,7 +92,6 @@ var r4 = a['1.1'];
 
 var b = {
 >b : Symbol(b, Decl(objectTypeWithNumericProperty.ts, 34, 3))
->{    1: 1,    1.1: ""} : Symbol(, Decl(objectTypeWithNumericProperty.ts, 34, 7))
 
     1: 1,
     1.1: ""
diff --git a/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.symbols b/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.symbols
index 9e35d6be0d3e4..c95105a86269a 100644
--- a/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.symbols
+++ b/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.symbols
@@ -320,7 +320,6 @@ var r13 = i[-01]
 
 var b = {
 >b : Symbol(b, Decl(objectTypeWithStringNamedNumericProperty.ts, 97, 3))
->{    "0.1": <void>null,    ".1": new Object(),    "1": 1,    "1.": "",    "1..": true,    "1.0": new Date(),    "-1.0": /123/,    "-1": Date} : Symbol(, Decl(objectTypeWithStringNamedNumericProperty.ts, 97, 7))
 
     "0.1": <void>null,
     ".1": new Object(),
diff --git a/tests/baselines/reference/objectTypeWithStringNamedPropertyOfIllegalCharacters.symbols b/tests/baselines/reference/objectTypeWithStringNamedPropertyOfIllegalCharacters.symbols
index 8ebeece4c0586..aa76e7e92c8ac 100644
--- a/tests/baselines/reference/objectTypeWithStringNamedPropertyOfIllegalCharacters.symbols
+++ b/tests/baselines/reference/objectTypeWithStringNamedPropertyOfIllegalCharacters.symbols
@@ -96,7 +96,6 @@ var r4 = a["~!@#$%^&*()_+{}|:'<>?\/.,`"];
 
 var b = {
 >b : Symbol(b, Decl(objectTypeWithStringNamedPropertyOfIllegalCharacters.ts, 41, 3))
->{    "   ": 1,    "a   b": "",    "~!@#$%^&*()_+{}|:'<>?\/.,`": 1,} : Symbol(, Decl(objectTypeWithStringNamedPropertyOfIllegalCharacters.ts, 41, 7))
 
     "   ": 1,
     "a   b": "",
diff --git a/tests/baselines/reference/objectTypesIdentity.symbols b/tests/baselines/reference/objectTypesIdentity.symbols
index caf824cc19185..a39b47acf5564 100644
--- a/tests/baselines/reference/objectTypesIdentity.symbols
+++ b/tests/baselines/reference/objectTypesIdentity.symbols
@@ -37,7 +37,6 @@ var a: { foo: string; }
 
 var b = { foo: '' };
 >b : Symbol(b, Decl(objectTypesIdentity.ts, 19, 3))
->{ foo: '' } : Symbol(, Decl(objectTypesIdentity.ts, 19, 7))
 >foo : Symbol(foo, Decl(objectTypesIdentity.ts, 19, 9))
 
 function foo1(x: A);
diff --git a/tests/baselines/reference/objectTypesIdentity2.symbols b/tests/baselines/reference/objectTypesIdentity2.symbols
index 164c767c1fa7c..e78def5ca0031 100644
--- a/tests/baselines/reference/objectTypesIdentity2.symbols
+++ b/tests/baselines/reference/objectTypesIdentity2.symbols
@@ -43,7 +43,6 @@ enum E { A }
 
 var b = { foo: E.A };
 >b : Symbol(b, Decl(objectTypesIdentity2.ts, 20, 3))
->{ foo: E.A } : Symbol(, Decl(objectTypesIdentity2.ts, 20, 7))
 >foo : Symbol(foo, Decl(objectTypesIdentity2.ts, 20, 9))
 >E.A : Symbol(E.A, Decl(objectTypesIdentity2.ts, 19, 8))
 >E : Symbol(E, Decl(objectTypesIdentity2.ts, 18, 23))
diff --git a/tests/baselines/reference/objectTypesIdentityWithCallSignatures.symbols b/tests/baselines/reference/objectTypesIdentityWithCallSignatures.symbols
index 443e960089cfc..e1131a019c01f 100644
--- a/tests/baselines/reference/objectTypesIdentityWithCallSignatures.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithCallSignatures.symbols
@@ -54,7 +54,6 @@ var a: { foo(x: string): string }
 
 var b = { foo(x: string) { return ''; } };
 >b : Symbol(b, Decl(objectTypesIdentityWithCallSignatures.ts, 23, 3))
->{ foo(x: string) { return ''; } } : Symbol(, Decl(objectTypesIdentityWithCallSignatures.ts, 23, 7))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithCallSignatures.ts, 23, 9))
 >x : Symbol(x, Decl(objectTypesIdentityWithCallSignatures.ts, 23, 14))
 
diff --git a/tests/baselines/reference/objectTypesIdentityWithCallSignatures2.symbols b/tests/baselines/reference/objectTypesIdentityWithCallSignatures2.symbols
index e82608f41f7e0..85c138a8c34b2 100644
--- a/tests/baselines/reference/objectTypesIdentityWithCallSignatures2.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithCallSignatures2.symbols
@@ -55,7 +55,6 @@ var a: { foo(x: Date): string }
 
 var b = { foo(x: RegExp) { return ''; } };
 >b : Symbol(b, Decl(objectTypesIdentityWithCallSignatures2.ts, 23, 3))
->{ foo(x: RegExp) { return ''; } } : Symbol(, Decl(objectTypesIdentityWithCallSignatures2.ts, 23, 7))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithCallSignatures2.ts, 23, 9))
 >x : Symbol(x, Decl(objectTypesIdentityWithCallSignatures2.ts, 23, 14))
 >RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
diff --git a/tests/baselines/reference/objectTypesIdentityWithCallSignaturesDifferingParamCounts.symbols b/tests/baselines/reference/objectTypesIdentityWithCallSignaturesDifferingParamCounts.symbols
index 87b15a995bd90..9341ba35c42f5 100644
--- a/tests/baselines/reference/objectTypesIdentityWithCallSignaturesDifferingParamCounts.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithCallSignaturesDifferingParamCounts.symbols
@@ -58,7 +58,6 @@ var a: { foo(x: string, y: string): string }
 
 var b = { foo(x: string) { return ''; } };
 >b : Symbol(b, Decl(objectTypesIdentityWithCallSignaturesDifferingParamCounts.ts, 23, 3))
->{ foo(x: string) { return ''; } } : Symbol(, Decl(objectTypesIdentityWithCallSignaturesDifferingParamCounts.ts, 23, 7))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithCallSignaturesDifferingParamCounts.ts, 23, 9))
 >x : Symbol(x, Decl(objectTypesIdentityWithCallSignaturesDifferingParamCounts.ts, 23, 14))
 
diff --git a/tests/baselines/reference/objectTypesIdentityWithCallSignaturesWithOverloads.symbols b/tests/baselines/reference/objectTypesIdentityWithCallSignaturesWithOverloads.symbols
index 929ff6cbf190b..6575c6787fd0f 100644
--- a/tests/baselines/reference/objectTypesIdentityWithCallSignaturesWithOverloads.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithCallSignaturesWithOverloads.symbols
@@ -101,7 +101,6 @@ var a: {
 
 var b = {
 >b : Symbol(b, Decl(objectTypesIdentityWithCallSignaturesWithOverloads.ts, 37, 3))
->{    foo(x: any) { return <any>''; }} : Symbol(, Decl(objectTypesIdentityWithCallSignaturesWithOverloads.ts, 37, 7))
 
     foo(x: any) { return <any>''; }
 >foo : Symbol(foo, Decl(objectTypesIdentityWithCallSignaturesWithOverloads.ts, 37, 9))
diff --git a/tests/baselines/reference/objectTypesIdentityWithConstructSignatures2.symbols b/tests/baselines/reference/objectTypesIdentityWithConstructSignatures2.symbols
index ed2275e54f25f..0d37d7fc97bc6 100644
--- a/tests/baselines/reference/objectTypesIdentityWithConstructSignatures2.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithConstructSignatures2.symbols
@@ -41,7 +41,6 @@ var a: { new(x: Date): string }
 
 var b = { new(x: RegExp) { return ''; } }; // not a construct signature, function called new
 >b : Symbol(b, Decl(objectTypesIdentityWithConstructSignatures2.ts, 19, 3))
->{ new(x: RegExp) { return ''; } } : Symbol(, Decl(objectTypesIdentityWithConstructSignatures2.ts, 19, 7))
 >new : Symbol(new, Decl(objectTypesIdentityWithConstructSignatures2.ts, 19, 9))
 >x : Symbol(x, Decl(objectTypesIdentityWithConstructSignatures2.ts, 19, 14))
 >RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
diff --git a/tests/baselines/reference/objectTypesIdentityWithConstructSignaturesDifferingParamCounts.symbols b/tests/baselines/reference/objectTypesIdentityWithConstructSignaturesDifferingParamCounts.symbols
index f7ee7c9f8bce3..0563fe7a2fcb5 100644
--- a/tests/baselines/reference/objectTypesIdentityWithConstructSignaturesDifferingParamCounts.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithConstructSignaturesDifferingParamCounts.symbols
@@ -44,7 +44,6 @@ var a: { new(x: string, y: string): string }
 
 var b = { new(x: string) { return ''; } }; // not a construct signature, function called new
 >b : Symbol(b, Decl(objectTypesIdentityWithConstructSignaturesDifferingParamCounts.ts, 19, 3))
->{ new(x: string) { return ''; } } : Symbol(, Decl(objectTypesIdentityWithConstructSignaturesDifferingParamCounts.ts, 19, 7))
 >new : Symbol(new, Decl(objectTypesIdentityWithConstructSignaturesDifferingParamCounts.ts, 19, 9))
 >x : Symbol(x, Decl(objectTypesIdentityWithConstructSignaturesDifferingParamCounts.ts, 19, 14))
 
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignatures.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignatures.symbols
index b51c7dc314162..8fdebdcccbe8d 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignatures.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignatures.symbols
@@ -66,7 +66,6 @@ var a: { foo<T>(x: T): T }
 
 var b = { foo<T>(x: T) { return x; } };
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericCallSignatures.ts, 23, 3))
->{ foo<T>(x: T) { return x; } } : Symbol(, Decl(objectTypesIdentityWithGenericCallSignatures.ts, 23, 7))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignatures.ts, 23, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignatures.ts, 23, 14))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignatures.ts, 23, 17))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignatures2.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignatures2.symbols
index c84d379ee88b4..2ca97948a9986 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignatures2.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignatures2.symbols
@@ -84,7 +84,6 @@ var a: { foo<T, U>(x: T, y: U): T }
 
 var b = { foo<T, U>(x: T, y: U) { return x; } };
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericCallSignatures2.ts, 23, 3))
->{ foo<T, U>(x: T, y: U) { return x; } } : Symbol(, Decl(objectTypesIdentityWithGenericCallSignatures2.ts, 23, 7))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignatures2.ts, 23, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignatures2.ts, 23, 14))
 >U : Symbol(U, Decl(objectTypesIdentityWithGenericCallSignatures2.ts, 23, 16))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.symbols
index 68825d911beb4..3b681c55c13ee 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.symbols
@@ -68,7 +68,6 @@ var a: { foo<T extends Array<string>>(x: T): string }
 
 var b = { foo<T extends RegExp>(x: T) { return ''; } };
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 25, 3))
->{ foo<T extends RegExp>(x: T) { return ''; } } : Symbol(, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 25, 7))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 25, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 25, 14))
 >RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.symbols
index 23c658ec58876..a9210b20f3274 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.symbols
@@ -65,7 +65,6 @@ var a: { foo<T>(x: T): T }
 
 var b = { foo<T>(x: T) { return null; } };
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.ts, 25, 3))
->{ foo<T>(x: T) { return null; } } : Symbol(, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.ts, 25, 7))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.ts, 25, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.ts, 25, 14))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.ts, 25, 17))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.symbols
index 5b0dbdbb4d80f..e1c4e12037056 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.symbols
@@ -71,7 +71,6 @@ var a: { foo<T extends Date>(x: T): T }
 
 var b = { foo<T extends Date>(x: T) { return null; } };
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 25, 3))
->{ foo<T extends Date>(x: T) { return null; } } : Symbol(, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 25, 7))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 25, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 25, 14))
 >Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.symbols
index f60ab98ad2a4f..9b801aa2c6ffd 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.symbols
@@ -79,7 +79,6 @@ var a: { foo<Z, A, B, C, D>(x: Z): Z }
 
 var b = { foo<A, B, C, D, E, F>(x: A) { return x; } };
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 23, 3))
->{ foo<A, B, C, D, E, F>(x: A) { return x; } } : Symbol(, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 23, 7))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 23, 9))
 >A : Symbol(A, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 23, 14))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 23, 16))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterNames.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterNames.symbols
index 8c588064beb2e..94e6aaf01391a 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterNames.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterNames.symbols
@@ -66,7 +66,6 @@ var a: { foo<Z>(x: Z): Z }
 
 var b = { foo<A>(x: A) { return x; } };
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterNames.ts, 23, 3))
->{ foo<A>(x: A) { return x; } } : Symbol(, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterNames.ts, 23, 7))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterNames.ts, 23, 9))
 >A : Symbol(A, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterNames.ts, 23, 14))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterNames.ts, 23, 17))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesOptionalParams.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesOptionalParams.symbols
index 67754f9d0e791..0bb008d82be28 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesOptionalParams.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesOptionalParams.symbols
@@ -80,7 +80,6 @@ var a: { foo<T>(x: T, y?: T): T }
 
 var b = { foo<T>(x: T, y?: T) { return x; } };
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericCallSignaturesOptionalParams.ts, 25, 3))
->{ foo<T>(x: T, y?: T) { return x; } } : Symbol(, Decl(objectTypesIdentityWithGenericCallSignaturesOptionalParams.ts, 25, 7))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesOptionalParams.ts, 25, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesOptionalParams.ts, 25, 14))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesOptionalParams.ts, 25, 17))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesOptionalParams2.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesOptionalParams2.symbols
index d4ea50d59cfa6..8878d73f5766c 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesOptionalParams2.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesOptionalParams2.symbols
@@ -86,7 +86,6 @@ var a: { foo<T, U>(x: T, y?: U): T }
 
 var b = { foo<T, U>(x: T, y?: U) { return x; } };
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericCallSignaturesOptionalParams2.ts, 25, 3))
->{ foo<T, U>(x: T, y?: U) { return x; } } : Symbol(, Decl(objectTypesIdentityWithGenericCallSignaturesOptionalParams2.ts, 25, 7))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesOptionalParams2.ts, 25, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesOptionalParams2.ts, 25, 14))
 >U : Symbol(U, Decl(objectTypesIdentityWithGenericCallSignaturesOptionalParams2.ts, 25, 16))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesOptionalParams3.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesOptionalParams3.symbols
index ef9fac7efab7f..b1cfab012bf90 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesOptionalParams3.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesOptionalParams3.symbols
@@ -86,7 +86,6 @@ var a: { foo<T, U>(x: T, y?: U): T }
 
 var b = { foo<T, U>(x: T, y: U) { return x; } };
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericCallSignaturesOptionalParams3.ts, 25, 3))
->{ foo<T, U>(x: T, y: U) { return x; } } : Symbol(, Decl(objectTypesIdentityWithGenericCallSignaturesOptionalParams3.ts, 25, 7))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesOptionalParams3.ts, 25, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesOptionalParams3.ts, 25, 14))
 >U : Symbol(U, Decl(objectTypesIdentityWithGenericCallSignaturesOptionalParams3.ts, 25, 16))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.symbols
index 940279561cc8d..6f53dcf17b2d1 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.symbols
@@ -52,7 +52,6 @@ var a: { new<T extends Array<string>>(x: T): string }
 
 var b = { new<T extends RegExp>(x: T) { return ''; } }; // not a construct signature, function called new
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 21, 3))
->{ new<T extends RegExp>(x: T) { return ''; } } : Symbol(, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 21, 7))
 >new : Symbol(new, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 21, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 21, 14))
 >RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.symbols
index aea6ba96cc9c9..703ee5d3cc498 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.symbols
@@ -50,7 +50,6 @@ var a: { new<T>(x: T): T }
 
 var b = { new<T>(x: T): T { return null; } }; // not a construct signature, function called new
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.ts, 21, 3))
->{ new<T>(x: T): T { return null; } } : Symbol(, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.ts, 21, 7))
 >new : Symbol(new, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.ts, 21, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.ts, 21, 14))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.ts, 21, 17))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.symbols
index ceaf14b16e780..faa0995c2ddd9 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.symbols
@@ -55,7 +55,6 @@ var a: { new<T extends Date>(x: T): T }
 
 var b = { new<T extends Date>(x: T) { return null; } }; // not a construct signature, function called new
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 21, 3))
->{ new<T extends Date>(x: T) { return null; } } : Symbol(, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 21, 7))
 >new : Symbol(new, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 21, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 21, 14))
 >Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.symbols
index 905ec0c6987b4..d7797a833c92f 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.symbols
@@ -69,7 +69,6 @@ var a: { new <Z, A, B, CC, D>(x: Z): C<Z, A, B>; }
 
 var b = { new<A, B, C, D, E, F>(x: A) { return x; } };
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 19, 3))
->{ new<A, B, C, D, E, F>(x: A) { return x; } } : Symbol(, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 19, 7))
 >new : Symbol(new, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 19, 9))
 >A : Symbol(A, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 19, 14))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 19, 16))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterNames.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterNames.symbols
index 154e486c8d874..6e31b7fcc41a4 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterNames.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterNames.symbols
@@ -51,7 +51,6 @@ var a: { new<Z>(x: Z): B<Z> }
 
 var b = { new<A>(x: A) { return new C<A>(x); } };
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterNames.ts, 19, 3))
->{ new<A>(x: A) { return new C<A>(x); } } : Symbol(, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterNames.ts, 19, 7))
 >new : Symbol(new, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterNames.ts, 19, 9))
 >A : Symbol(A, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterNames.ts, 19, 14))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterNames.ts, 19, 17))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesOptionalParams.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesOptionalParams.symbols
index 179d6bb9f3f9d..c42a6ae4341dd 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesOptionalParams.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesOptionalParams.symbols
@@ -63,7 +63,6 @@ var a: { new<T>(x: T, y?: T): B<T> }
 
 var b = { new<T>(x: T, y?: T) { return new C<T>(x, y); } }; // not a construct signature, function called new
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericConstructSignaturesOptionalParams.ts, 21, 3))
->{ new<T>(x: T, y?: T) { return new C<T>(x, y); } } : Symbol(, Decl(objectTypesIdentityWithGenericConstructSignaturesOptionalParams.ts, 21, 7))
 >new : Symbol(new, Decl(objectTypesIdentityWithGenericConstructSignaturesOptionalParams.ts, 21, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesOptionalParams.ts, 21, 14))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesOptionalParams.ts, 21, 17))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesOptionalParams2.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesOptionalParams2.symbols
index 380afd8e5d364..44bc153cd8f93 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesOptionalParams2.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesOptionalParams2.symbols
@@ -71,7 +71,6 @@ var a: { new<T, U>(x: T, y?: U): B<T,U> }
 
 var b = { new<T, U>(x: T, y?: U) { return new C<T, U>(x, y); } }; // not a construct signature, function called new
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericConstructSignaturesOptionalParams2.ts, 21, 3))
->{ new<T, U>(x: T, y?: U) { return new C<T, U>(x, y); } } : Symbol(, Decl(objectTypesIdentityWithGenericConstructSignaturesOptionalParams2.ts, 21, 7))
 >new : Symbol(new, Decl(objectTypesIdentityWithGenericConstructSignaturesOptionalParams2.ts, 21, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesOptionalParams2.ts, 21, 14))
 >U : Symbol(U, Decl(objectTypesIdentityWithGenericConstructSignaturesOptionalParams2.ts, 21, 16))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesOptionalParams3.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesOptionalParams3.symbols
index b189f26abc9e8..3eb24d1b40092 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesOptionalParams3.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesOptionalParams3.symbols
@@ -71,7 +71,6 @@ var a: { new <T, U>(x: T, y?: U): B<T, U> };
 
 var b = { new<T, U>(x: T, y: U) { return new C<T, U>(x, y); } }; // not a construct signature, function called new
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericConstructSignaturesOptionalParams3.ts, 21, 3))
->{ new<T, U>(x: T, y: U) { return new C<T, U>(x, y); } } : Symbol(, Decl(objectTypesIdentityWithGenericConstructSignaturesOptionalParams3.ts, 21, 7))
 >new : Symbol(new, Decl(objectTypesIdentityWithGenericConstructSignaturesOptionalParams3.ts, 21, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesOptionalParams3.ts, 21, 14))
 >U : Symbol(U, Decl(objectTypesIdentityWithGenericConstructSignaturesOptionalParams3.ts, 21, 16))
diff --git a/tests/baselines/reference/objectTypesIdentityWithNumericIndexers1.symbols b/tests/baselines/reference/objectTypesIdentityWithNumericIndexers1.symbols
index 20a6365f481af..4a2eb1ab2a1e0 100644
--- a/tests/baselines/reference/objectTypesIdentityWithNumericIndexers1.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithNumericIndexers1.symbols
@@ -50,7 +50,6 @@ var a: {
 var b: { [x: number]: string; } = { foo: '' };
 >b : Symbol(b, Decl(objectTypesIdentityWithNumericIndexers1.ts, 27, 3))
 >x : Symbol(x, Decl(objectTypesIdentityWithNumericIndexers1.ts, 27, 10))
->{ foo: '' } : Symbol(, Decl(objectTypesIdentityWithNumericIndexers1.ts, 27, 33))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithNumericIndexers1.ts, 27, 35))
 
 function foo1(x: A);
diff --git a/tests/baselines/reference/objectTypesIdentityWithNumericIndexers2.symbols b/tests/baselines/reference/objectTypesIdentityWithNumericIndexers2.symbols
index 15445868f58c6..375fff858fb43 100644
--- a/tests/baselines/reference/objectTypesIdentityWithNumericIndexers2.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithNumericIndexers2.symbols
@@ -64,7 +64,6 @@ var b: { [x: number]: Derived; } = { foo: <Derived>null };
 >b : Symbol(b, Decl(objectTypesIdentityWithNumericIndexers2.ts, 30, 3))
 >x : Symbol(x, Decl(objectTypesIdentityWithNumericIndexers2.ts, 30, 10))
 >Derived : Symbol(Derived, Decl(objectTypesIdentityWithNumericIndexers2.ts, 2, 27))
->{ foo: <Derived>null } : Symbol(, Decl(objectTypesIdentityWithNumericIndexers2.ts, 30, 34))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithNumericIndexers2.ts, 30, 36))
 >Derived : Symbol(Derived, Decl(objectTypesIdentityWithNumericIndexers2.ts, 2, 27))
 
diff --git a/tests/baselines/reference/objectTypesIdentityWithNumericIndexers3.symbols b/tests/baselines/reference/objectTypesIdentityWithNumericIndexers3.symbols
index bc7fffbc0bdfc..c0bc1b5cf6050 100644
--- a/tests/baselines/reference/objectTypesIdentityWithNumericIndexers3.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithNumericIndexers3.symbols
@@ -50,7 +50,6 @@ var a: {
 var b: { [x: number]: string; } = { foo: '' };
 >b : Symbol(b, Decl(objectTypesIdentityWithNumericIndexers3.ts, 27, 3))
 >x : Symbol(x, Decl(objectTypesIdentityWithNumericIndexers3.ts, 27, 10))
->{ foo: '' } : Symbol(, Decl(objectTypesIdentityWithNumericIndexers3.ts, 27, 33))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithNumericIndexers3.ts, 27, 35))
 
 function foo1(x: A);
diff --git a/tests/baselines/reference/objectTypesIdentityWithOptionality.symbols b/tests/baselines/reference/objectTypesIdentityWithOptionality.symbols
index 0807d0e543387..595295418f592 100644
--- a/tests/baselines/reference/objectTypesIdentityWithOptionality.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithOptionality.symbols
@@ -37,7 +37,6 @@ var a: { foo?: string; }
 
 var b = { foo: '' };
 >b : Symbol(b, Decl(objectTypesIdentityWithOptionality.ts, 19, 3))
->{ foo: '' } : Symbol(, Decl(objectTypesIdentityWithOptionality.ts, 19, 7))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithOptionality.ts, 19, 9))
 
 function foo2(x: I);
diff --git a/tests/baselines/reference/objectTypesIdentityWithPrivates.symbols b/tests/baselines/reference/objectTypesIdentityWithPrivates.symbols
index 84ac619930ff7..d7680f7fb91d1 100644
--- a/tests/baselines/reference/objectTypesIdentityWithPrivates.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithPrivates.symbols
@@ -47,7 +47,6 @@ var a: { foo: string; }
 
 var b = { foo: '' };
 >b : Symbol(b, Decl(objectTypesIdentityWithPrivates.ts, 25, 3))
->{ foo: '' } : Symbol(, Decl(objectTypesIdentityWithPrivates.ts, 25, 7))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithPrivates.ts, 25, 9))
 
 function foo1(x: A);
diff --git a/tests/baselines/reference/objectTypesIdentityWithPublics.symbols b/tests/baselines/reference/objectTypesIdentityWithPublics.symbols
index 5a84e0c96cd53..ebfb52e3d2e4a 100644
--- a/tests/baselines/reference/objectTypesIdentityWithPublics.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithPublics.symbols
@@ -37,7 +37,6 @@ var a: { foo: string; }
 
 var b = { foo: '' };
 >b : Symbol(b, Decl(objectTypesIdentityWithPublics.ts, 19, 3))
->{ foo: '' } : Symbol(, Decl(objectTypesIdentityWithPublics.ts, 19, 7))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithPublics.ts, 19, 9))
 
 function foo1(x: A);
diff --git a/tests/baselines/reference/objectTypesIdentityWithStringIndexers.symbols b/tests/baselines/reference/objectTypesIdentityWithStringIndexers.symbols
index a882ca0d63b53..5a51f1bb0a6e4 100644
--- a/tests/baselines/reference/objectTypesIdentityWithStringIndexers.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithStringIndexers.symbols
@@ -50,7 +50,6 @@ var a: {
 var b: { [x: string]: string; } = { foo: '' };
 >b : Symbol(b, Decl(objectTypesIdentityWithStringIndexers.ts, 27, 3))
 >x : Symbol(x, Decl(objectTypesIdentityWithStringIndexers.ts, 27, 10))
->{ foo: '' } : Symbol(, Decl(objectTypesIdentityWithStringIndexers.ts, 27, 33))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithStringIndexers.ts, 27, 35))
 
 function foo1(x: A);
diff --git a/tests/baselines/reference/objectTypesIdentityWithStringIndexers2.symbols b/tests/baselines/reference/objectTypesIdentityWithStringIndexers2.symbols
index ea9a327c8caa5..2df0bf01b1d7e 100644
--- a/tests/baselines/reference/objectTypesIdentityWithStringIndexers2.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithStringIndexers2.symbols
@@ -64,7 +64,6 @@ var b: { [x: string]: Derived; } = { foo: <Derived>null };
 >b : Symbol(b, Decl(objectTypesIdentityWithStringIndexers2.ts, 30, 3))
 >x : Symbol(x, Decl(objectTypesIdentityWithStringIndexers2.ts, 30, 10))
 >Derived : Symbol(Derived, Decl(objectTypesIdentityWithStringIndexers2.ts, 2, 27))
->{ foo: <Derived>null } : Symbol(, Decl(objectTypesIdentityWithStringIndexers2.ts, 30, 34))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithStringIndexers2.ts, 30, 36))
 >Derived : Symbol(Derived, Decl(objectTypesIdentityWithStringIndexers2.ts, 2, 27))
 
diff --git a/tests/baselines/reference/octalIntegerLiteral.symbols b/tests/baselines/reference/octalIntegerLiteral.symbols
index 6b26823a49ad6..6a4839839aab3 100644
--- a/tests/baselines/reference/octalIntegerLiteral.symbols
+++ b/tests/baselines/reference/octalIntegerLiteral.symbols
@@ -13,7 +13,6 @@ var oct4 = 0o7777777777777777777777777777777777777777777777777777777777777777777
 
 var obj1 = {
 >obj1 : Symbol(obj1, Decl(octalIntegerLiteral.ts, 5, 3))
->{    0o45436: "Hello",    a: 0o45436,     b: oct1,    oct1,    0o7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777: true} : Symbol(, Decl(octalIntegerLiteral.ts, 5, 10))
 
     0o45436: "Hello",
     a: 0o45436, 
@@ -31,7 +30,6 @@ var obj1 = {
 
 var obj2 = {
 >obj2 : Symbol(obj2, Decl(octalIntegerLiteral.ts, 13, 3))
->{    0O45436: "hi",    a: 0O45436,     b: oct2,    oct2,    0o7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777: false,} : Symbol(, Decl(octalIntegerLiteral.ts, 13, 10))
 
     0O45436: "hi",
     a: 0O45436, 
diff --git a/tests/baselines/reference/octalIntegerLiteralES6.symbols b/tests/baselines/reference/octalIntegerLiteralES6.symbols
index f3fd168f7555f..ff3f54936cd79 100644
--- a/tests/baselines/reference/octalIntegerLiteralES6.symbols
+++ b/tests/baselines/reference/octalIntegerLiteralES6.symbols
@@ -13,7 +13,6 @@ var oct4 = 0o7777777777777777777777777777777777777777777777777777777777777777777
 
 var obj1 = {
 >obj1 : Symbol(obj1, Decl(octalIntegerLiteralES6.ts, 5, 3))
->{    0o45436: "Hello",    a: 0o45436,     b: oct1,    oct1,    0o7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777: true} : Symbol(, Decl(octalIntegerLiteralES6.ts, 5, 10))
 
     0o45436: "Hello",
     a: 0o45436, 
@@ -31,7 +30,6 @@ var obj1 = {
 
 var obj2 = {
 >obj2 : Symbol(obj2, Decl(octalIntegerLiteralES6.ts, 13, 3))
->{    0O45436: "hi",    a: 0O45436,     b: oct2,    oct2,    0o7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777: false,} : Symbol(, Decl(octalIntegerLiteralES6.ts, 13, 10))
 
     0O45436: "hi",
     a: 0O45436, 
diff --git a/tests/baselines/reference/optionalAccessorsInInterface1.symbols b/tests/baselines/reference/optionalAccessorsInInterface1.symbols
index 519716e5c0f25..6c9c8ab142951 100644
--- a/tests/baselines/reference/optionalAccessorsInInterface1.symbols
+++ b/tests/baselines/reference/optionalAccessorsInInterface1.symbols
@@ -19,10 +19,7 @@ declare function defineMyProperty(o: any, p: string, attributes: MyPropertyDescr
 
 defineMyProperty({}, "name", { get: function () { return 5; } });
 >defineMyProperty : Symbol(defineMyProperty, Decl(optionalAccessorsInInterface1.ts, 3, 1))
->{} : Symbol(, Decl(optionalAccessorsInInterface1.ts, 6, 17))
->{ get: function () { return 5; } } : Symbol(, Decl(optionalAccessorsInInterface1.ts, 6, 28))
 >get : Symbol(get, Decl(optionalAccessorsInInterface1.ts, 6, 30))
->function () { return 5; } : Symbol((Anonymous function), Decl(optionalAccessorsInInterface1.ts, 6, 35))
 
 interface MyPropertyDescriptor2 {
 >MyPropertyDescriptor2 : Symbol(MyPropertyDescriptor2, Decl(optionalAccessorsInInterface1.ts, 6, 65))
@@ -44,8 +41,5 @@ declare function defineMyProperty2(o: any, p: string, attributes: MyPropertyDesc
 
 defineMyProperty2({}, "name", { get: function () { return 5; } });
 >defineMyProperty2 : Symbol(defineMyProperty2, Decl(optionalAccessorsInInterface1.ts, 11, 1))
->{} : Symbol(, Decl(optionalAccessorsInInterface1.ts, 14, 18))
->{ get: function () { return 5; } } : Symbol(, Decl(optionalAccessorsInInterface1.ts, 14, 29))
 >get : Symbol(get, Decl(optionalAccessorsInInterface1.ts, 14, 31))
->function () { return 5; } : Symbol((Anonymous function), Decl(optionalAccessorsInInterface1.ts, 14, 36))
 
diff --git a/tests/baselines/reference/overloadBindingAcrossDeclarationBoundaries.symbols b/tests/baselines/reference/overloadBindingAcrossDeclarationBoundaries.symbols
index 80086cb10d98b..65f64fa891552 100644
--- a/tests/baselines/reference/overloadBindingAcrossDeclarationBoundaries.symbols
+++ b/tests/baselines/reference/overloadBindingAcrossDeclarationBoundaries.symbols
@@ -104,15 +104,12 @@ var a1 = a.a({});
 >a.a : Symbol(A.a, Decl(overloadBindingAcrossDeclarationBoundaries.ts, 12, 13), Decl(overloadBindingAcrossDeclarationBoundaries.ts, 13, 21), Decl(overloadBindingAcrossDeclarationBoundaries.ts, 20, 13), Decl(overloadBindingAcrossDeclarationBoundaries.ts, 21, 21))
 >a : Symbol(a, Decl(overloadBindingAcrossDeclarationBoundaries.ts, 29, 3))
 >a : Symbol(A.a, Decl(overloadBindingAcrossDeclarationBoundaries.ts, 12, 13), Decl(overloadBindingAcrossDeclarationBoundaries.ts, 13, 21), Decl(overloadBindingAcrossDeclarationBoundaries.ts, 20, 13), Decl(overloadBindingAcrossDeclarationBoundaries.ts, 21, 21))
->{} : Symbol(, Decl(overloadBindingAcrossDeclarationBoundaries.ts, 31, 13))
 
 var a1 = a({});
 >a1 : Symbol(a1, Decl(overloadBindingAcrossDeclarationBoundaries.ts, 31, 3), Decl(overloadBindingAcrossDeclarationBoundaries.ts, 32, 3), Decl(overloadBindingAcrossDeclarationBoundaries.ts, 33, 3))
 >a : Symbol(a, Decl(overloadBindingAcrossDeclarationBoundaries.ts, 29, 3))
->{} : Symbol(, Decl(overloadBindingAcrossDeclarationBoundaries.ts, 32, 11))
 
 var a1 = new a({});
 >a1 : Symbol(a1, Decl(overloadBindingAcrossDeclarationBoundaries.ts, 31, 3), Decl(overloadBindingAcrossDeclarationBoundaries.ts, 32, 3), Decl(overloadBindingAcrossDeclarationBoundaries.ts, 33, 3))
 >a : Symbol(a, Decl(overloadBindingAcrossDeclarationBoundaries.ts, 29, 3))
->{} : Symbol(, Decl(overloadBindingAcrossDeclarationBoundaries.ts, 33, 15))
 
diff --git a/tests/baselines/reference/overloadBindingAcrossDeclarationBoundaries2.symbols b/tests/baselines/reference/overloadBindingAcrossDeclarationBoundaries2.symbols
index f556d5c35fcbd..534475bcc30ed 100644
--- a/tests/baselines/reference/overloadBindingAcrossDeclarationBoundaries2.symbols
+++ b/tests/baselines/reference/overloadBindingAcrossDeclarationBoundaries2.symbols
@@ -107,15 +107,12 @@ var a1 = a.a({});
 >a.a : Symbol(A.a, Decl(overloadBindingAcrossDeclarationBoundaries_file0.ts, 13, 13), Decl(overloadBindingAcrossDeclarationBoundaries_file0.ts, 14, 21), Decl(overloadBindingAcrossDeclarationBoundaries_file1.ts, 0, 13), Decl(overloadBindingAcrossDeclarationBoundaries_file1.ts, 1, 21))
 >a : Symbol(a, Decl(overloadBindingAcrossDeclarationBoundaries_file1.ts, 9, 3))
 >a : Symbol(A.a, Decl(overloadBindingAcrossDeclarationBoundaries_file0.ts, 13, 13), Decl(overloadBindingAcrossDeclarationBoundaries_file0.ts, 14, 21), Decl(overloadBindingAcrossDeclarationBoundaries_file1.ts, 0, 13), Decl(overloadBindingAcrossDeclarationBoundaries_file1.ts, 1, 21))
->{} : Symbol(, Decl(overloadBindingAcrossDeclarationBoundaries_file1.ts, 11, 13))
 
 var a1 = a({});
 >a1 : Symbol(a1, Decl(overloadBindingAcrossDeclarationBoundaries_file1.ts, 11, 3), Decl(overloadBindingAcrossDeclarationBoundaries_file1.ts, 12, 3), Decl(overloadBindingAcrossDeclarationBoundaries_file1.ts, 13, 3))
 >a : Symbol(a, Decl(overloadBindingAcrossDeclarationBoundaries_file1.ts, 9, 3))
->{} : Symbol(, Decl(overloadBindingAcrossDeclarationBoundaries_file1.ts, 12, 11))
 
 var a1 = new a({});
 >a1 : Symbol(a1, Decl(overloadBindingAcrossDeclarationBoundaries_file1.ts, 11, 3), Decl(overloadBindingAcrossDeclarationBoundaries_file1.ts, 12, 3), Decl(overloadBindingAcrossDeclarationBoundaries_file1.ts, 13, 3))
 >a : Symbol(a, Decl(overloadBindingAcrossDeclarationBoundaries_file1.ts, 9, 3))
->{} : Symbol(, Decl(overloadBindingAcrossDeclarationBoundaries_file1.ts, 13, 15))
 
diff --git a/tests/baselines/reference/overloadResolutionOverNonCTLambdas.symbols b/tests/baselines/reference/overloadResolutionOverNonCTLambdas.symbols
index 87262f14f91a2..815f977d60508 100644
--- a/tests/baselines/reference/overloadResolutionOverNonCTLambdas.symbols
+++ b/tests/baselines/reference/overloadResolutionOverNonCTLambdas.symbols
@@ -17,7 +17,6 @@ module Bugs {
 >message.replace : Symbol(String.replace, Decl(lib.d.ts, 329, 44), Decl(lib.d.ts, 336, 63), Decl(lib.d.ts, 343, 102), Decl(lib.d.ts, 350, 63))
 >message : Symbol(message, Decl(overloadResolutionOverNonCTLambdas.ts, 5, 16))
 >replace : Symbol(String.replace, Decl(lib.d.ts, 329, 44), Decl(lib.d.ts, 336, 63), Decl(lib.d.ts, 343, 102), Decl(lib.d.ts, 350, 63))
->function(match, ...rest) {      var index= rest[0];      return typeof args[index] !== 'undefined'        ? args[index]        : match;    } : Symbol((Anonymous function), Decl(overloadResolutionOverNonCTLambdas.ts, 6, 45))
 >match : Symbol(match, Decl(overloadResolutionOverNonCTLambdas.ts, 6, 55))
 >rest : Symbol(rest, Decl(overloadResolutionOverNonCTLambdas.ts, 6, 61))
 
@@ -59,7 +58,6 @@ bug3(fprime);
 
 bug3(function(x:string):string { return x; });
 >bug3 : Symbol(bug3, Decl(overloadResolutionOverNonCTLambdas.ts, 14, 1))
->function(x:string):string { return x; } : Symbol((Anonymous function), Decl(overloadResolutionOverNonCTLambdas.ts, 22, 5))
 >x : Symbol(x, Decl(overloadResolutionOverNonCTLambdas.ts, 22, 14))
 >x : Symbol(x, Decl(overloadResolutionOverNonCTLambdas.ts, 22, 14))
 
diff --git a/tests/baselines/reference/overloadResolutionOverNonCTObjectLit.symbols b/tests/baselines/reference/overloadResolutionOverNonCTObjectLit.symbols
index c8d3cb015ad04..850f188a58b47 100644
--- a/tests/baselines/reference/overloadResolutionOverNonCTObjectLit.symbols
+++ b/tests/baselines/reference/overloadResolutionOverNonCTObjectLit.symbols
@@ -42,7 +42,6 @@ module Bugs {
 >tokens.push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
 >tokens : Symbol(tokens, Decl(overloadResolutionOverNonCTObjectLit.ts, 16, 35))
 >push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
->{ startIndex: 1, type: '', bracket: 3 } : Symbol(, Decl(overloadResolutionOverNonCTObjectLit.ts, 17, 44))
 >startIndex : Symbol(startIndex, Decl(overloadResolutionOverNonCTObjectLit.ts, 17, 45))
 >type : Symbol(type, Decl(overloadResolutionOverNonCTObjectLit.ts, 17, 60))
 >bracket : Symbol(bracket, Decl(overloadResolutionOverNonCTObjectLit.ts, 17, 70))
@@ -52,7 +51,6 @@ module Bugs {
 >tokens : Symbol(tokens, Decl(overloadResolutionOverNonCTObjectLit.ts, 16, 35))
 >push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
 >IToken : Symbol(IToken, Decl(overloadResolutionOverNonCTObjectLit.ts, 0, 13))
->{ startIndex: 1, type: '', bracket: 3, state: null, length: 10 } : Symbol(, Decl(overloadResolutionOverNonCTObjectLit.ts, 18, 53))
 >startIndex : Symbol(startIndex, Decl(overloadResolutionOverNonCTObjectLit.ts, 18, 54))
 >type : Symbol(type, Decl(overloadResolutionOverNonCTObjectLit.ts, 18, 69))
 >bracket : Symbol(bracket, Decl(overloadResolutionOverNonCTObjectLit.ts, 18, 79))
diff --git a/tests/baselines/reference/overloadWithCallbacksWithDifferingOptionalityOnArgs.symbols b/tests/baselines/reference/overloadWithCallbacksWithDifferingOptionalityOnArgs.symbols
index cc5898efa6489..0ae3e488fac6f 100644
--- a/tests/baselines/reference/overloadWithCallbacksWithDifferingOptionalityOnArgs.symbols
+++ b/tests/baselines/reference/overloadWithCallbacksWithDifferingOptionalityOnArgs.symbols
@@ -16,10 +16,8 @@ function x2(callback: (x: any) => number) { }
 
 x2(() => 1);
 >x2 : Symbol(x2, Decl(overloadWithCallbacksWithDifferingOptionalityOnArgs.ts, 0, 0), Decl(overloadWithCallbacksWithDifferingOptionalityOnArgs.ts, 0, 46), Decl(overloadWithCallbacksWithDifferingOptionalityOnArgs.ts, 1, 45))
->() => 1 : Symbol((Anonymous function), Decl(overloadWithCallbacksWithDifferingOptionalityOnArgs.ts, 3, 3))
 
 x2((x) => 1 );
 >x2 : Symbol(x2, Decl(overloadWithCallbacksWithDifferingOptionalityOnArgs.ts, 0, 0), Decl(overloadWithCallbacksWithDifferingOptionalityOnArgs.ts, 0, 46), Decl(overloadWithCallbacksWithDifferingOptionalityOnArgs.ts, 1, 45))
->(x) => 1 : Symbol((Anonymous function), Decl(overloadWithCallbacksWithDifferingOptionalityOnArgs.ts, 4, 3))
 >x : Symbol(x, Decl(overloadWithCallbacksWithDifferingOptionalityOnArgs.ts, 4, 4))
 
diff --git a/tests/baselines/reference/parametersWithNoAnnotationAreAny.symbols b/tests/baselines/reference/parametersWithNoAnnotationAreAny.symbols
index 3ea8c263bde37..9771d7f05ca8a 100644
--- a/tests/baselines/reference/parametersWithNoAnnotationAreAny.symbols
+++ b/tests/baselines/reference/parametersWithNoAnnotationAreAny.symbols
@@ -6,20 +6,17 @@ function foo(x) { return x; }
 
 var f = function foo(x) { return x; }
 >f : Symbol(f, Decl(parametersWithNoAnnotationAreAny.ts, 1, 3))
->function foo(x) { return x; } : Symbol(foo, Decl(parametersWithNoAnnotationAreAny.ts, 1, 7))
 >foo : Symbol(foo, Decl(parametersWithNoAnnotationAreAny.ts, 1, 7))
 >x : Symbol(x, Decl(parametersWithNoAnnotationAreAny.ts, 1, 21))
 >x : Symbol(x, Decl(parametersWithNoAnnotationAreAny.ts, 1, 21))
 
 var f2 = (x) => x;
 >f2 : Symbol(f2, Decl(parametersWithNoAnnotationAreAny.ts, 2, 3))
->(x) => x : Symbol((Anonymous function), Decl(parametersWithNoAnnotationAreAny.ts, 2, 8))
 >x : Symbol(x, Decl(parametersWithNoAnnotationAreAny.ts, 2, 10))
 >x : Symbol(x, Decl(parametersWithNoAnnotationAreAny.ts, 2, 10))
 
 var f3 = <T>(x) => x;
 >f3 : Symbol(f3, Decl(parametersWithNoAnnotationAreAny.ts, 3, 3))
-><T>(x) => x : Symbol((Anonymous function), Decl(parametersWithNoAnnotationAreAny.ts, 3, 8))
 >T : Symbol(T, Decl(parametersWithNoAnnotationAreAny.ts, 3, 10))
 >x : Symbol(x, Decl(parametersWithNoAnnotationAreAny.ts, 3, 13))
 >x : Symbol(x, Decl(parametersWithNoAnnotationAreAny.ts, 3, 13))
@@ -59,7 +56,6 @@ var a: {
 
 var b = {
 >b : Symbol(b, Decl(parametersWithNoAnnotationAreAny.ts, 20, 3))
->{    foo(x) {        return x;    },    a: function foo(x) {        return x;    },    b: (x) => x} : Symbol(, Decl(parametersWithNoAnnotationAreAny.ts, 20, 7))
 
     foo(x) {
 >foo : Symbol(foo, Decl(parametersWithNoAnnotationAreAny.ts, 20, 9))
@@ -71,7 +67,6 @@ var b = {
     },
     a: function foo(x) {
 >a : Symbol(a, Decl(parametersWithNoAnnotationAreAny.ts, 23, 6))
->function foo(x) {        return x;    } : Symbol(foo, Decl(parametersWithNoAnnotationAreAny.ts, 24, 6))
 >foo : Symbol(foo, Decl(parametersWithNoAnnotationAreAny.ts, 24, 6))
 >x : Symbol(x, Decl(parametersWithNoAnnotationAreAny.ts, 24, 20))
 
@@ -81,7 +76,6 @@ var b = {
     },
     b: (x) => x
 >b : Symbol(b, Decl(parametersWithNoAnnotationAreAny.ts, 26, 6))
->(x) => x : Symbol((Anonymous function), Decl(parametersWithNoAnnotationAreAny.ts, 27, 6))
 >x : Symbol(x, Decl(parametersWithNoAnnotationAreAny.ts, 27, 8))
 >x : Symbol(x, Decl(parametersWithNoAnnotationAreAny.ts, 27, 8))
 }
diff --git a/tests/baselines/reference/parenthesizedContexualTyping1.symbols b/tests/baselines/reference/parenthesizedContexualTyping1.symbols
index 9639ffd20f955..698e26734addf 100644
--- a/tests/baselines/reference/parenthesizedContexualTyping1.symbols
+++ b/tests/baselines/reference/parenthesizedContexualTyping1.symbols
@@ -45,68 +45,56 @@ function fun<T>(g: (x: T) => T, x: T): T {
 var a = fun(x => x, 10);
 >a : Symbol(a, Decl(parenthesizedContexualTyping1.ts, 7, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping1.ts, 0, 0), Decl(parenthesizedContexualTyping1.ts, 1, 41), Decl(parenthesizedContexualTyping1.ts, 2, 57))
->x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 7, 12))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 7, 12))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 7, 12))
 
 var b = fun((x => x), 10);
 >b : Symbol(b, Decl(parenthesizedContexualTyping1.ts, 8, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping1.ts, 0, 0), Decl(parenthesizedContexualTyping1.ts, 1, 41), Decl(parenthesizedContexualTyping1.ts, 2, 57))
->x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 8, 13))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 8, 13))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 8, 13))
 
 var c = fun(((x => x)), 10);
 >c : Symbol(c, Decl(parenthesizedContexualTyping1.ts, 9, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping1.ts, 0, 0), Decl(parenthesizedContexualTyping1.ts, 1, 41), Decl(parenthesizedContexualTyping1.ts, 2, 57))
->x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 9, 14))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 9, 14))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 9, 14))
 
 var d = fun((((x => x))), 10);
 >d : Symbol(d, Decl(parenthesizedContexualTyping1.ts, 10, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping1.ts, 0, 0), Decl(parenthesizedContexualTyping1.ts, 1, 41), Decl(parenthesizedContexualTyping1.ts, 2, 57))
->x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 10, 15))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 10, 15))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 10, 15))
 
 var e = fun(x => x, x => x, 10);
 >e : Symbol(e, Decl(parenthesizedContexualTyping1.ts, 12, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping1.ts, 0, 0), Decl(parenthesizedContexualTyping1.ts, 1, 41), Decl(parenthesizedContexualTyping1.ts, 2, 57))
->x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 12, 12))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 12, 12))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 12, 12))
->x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 12, 19))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 12, 19))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 12, 19))
 
 var f = fun((x => x), (x => x), 10);
 >f : Symbol(f, Decl(parenthesizedContexualTyping1.ts, 13, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping1.ts, 0, 0), Decl(parenthesizedContexualTyping1.ts, 1, 41), Decl(parenthesizedContexualTyping1.ts, 2, 57))
->x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 13, 13))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 13, 13))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 13, 13))
->x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 13, 23))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 13, 23))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 13, 23))
 
 var g = fun(((x => x)), ((x => x)), 10);
 >g : Symbol(g, Decl(parenthesizedContexualTyping1.ts, 14, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping1.ts, 0, 0), Decl(parenthesizedContexualTyping1.ts, 1, 41), Decl(parenthesizedContexualTyping1.ts, 2, 57))
->x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 14, 14))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 14, 14))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 14, 14))
->x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 14, 26))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 14, 26))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 14, 26))
 
 var h = fun((((x => x))), ((x => x)), 10);
 >h : Symbol(h, Decl(parenthesizedContexualTyping1.ts, 15, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping1.ts, 0, 0), Decl(parenthesizedContexualTyping1.ts, 1, 41), Decl(parenthesizedContexualTyping1.ts, 2, 57))
->x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 15, 15))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 15, 15))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 15, 15))
->x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 15, 28))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 15, 28))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 15, 28))
 
@@ -117,10 +105,8 @@ var i = fun((Math.random() < 0.5 ? x => x : x => undefined), 10);
 >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 >Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 18, 34))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 18, 34))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 18, 34))
->x => undefined : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 18, 43))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 18, 43))
 >undefined : Symbol(undefined)
 
@@ -130,10 +116,8 @@ var j = fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), 10);
 >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 >Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 19, 36))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 19, 36))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 19, 36))
->x => undefined : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 19, 47))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 19, 47))
 >undefined : Symbol(undefined)
 
@@ -143,13 +127,10 @@ var k = fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), x => x, 10);
 >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 >Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 20, 36))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 20, 36))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 20, 36))
->x => undefined : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 20, 47))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 20, 47))
 >undefined : Symbol(undefined)
->x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 20, 64))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 20, 64))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 20, 64))
 
@@ -159,27 +140,22 @@ var l = fun(((Math.random() < 0.5 ? ((x => x)) : ((x => undefined)))), ((x => x)
 >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 >Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 21, 38))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 21, 38))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 21, 38))
->x => undefined : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 21, 51))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 21, 51))
 >undefined : Symbol(undefined)
->x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 21, 73))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 21, 73))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 21, 73))
 
 var lambda1: (x: number) => number = x => x;
 >lambda1 : Symbol(lambda1, Decl(parenthesizedContexualTyping1.ts, 23, 3))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 23, 14))
->x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 23, 36))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 23, 36))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 23, 36))
 
 var lambda2: (x: number) => number = (x => x);
 >lambda2 : Symbol(lambda2, Decl(parenthesizedContexualTyping1.ts, 24, 3))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 24, 14))
->x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 24, 38))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 24, 38))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 24, 38))
 
@@ -193,14 +169,11 @@ type ObjType = { x: (p: number) => string; y: (p: string) => number };
 var obj1: ObjType = { x: x => (x, undefined), y: y => (y, undefined) };
 >obj1 : Symbol(obj1, Decl(parenthesizedContexualTyping1.ts, 27, 3))
 >ObjType : Symbol(ObjType, Decl(parenthesizedContexualTyping1.ts, 24, 46))
->{ x: x => (x, undefined), y: y => (y, undefined) } : Symbol(, Decl(parenthesizedContexualTyping1.ts, 27, 19))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 27, 21))
->x => (x, undefined) : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 27, 24))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 27, 24))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 27, 24))
 >undefined : Symbol(undefined)
 >y : Symbol(y, Decl(parenthesizedContexualTyping1.ts, 27, 45))
->y => (y, undefined) : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 27, 48))
 >y : Symbol(y, Decl(parenthesizedContexualTyping1.ts, 27, 48))
 >y : Symbol(y, Decl(parenthesizedContexualTyping1.ts, 27, 48))
 >undefined : Symbol(undefined)
@@ -208,14 +181,11 @@ var obj1: ObjType = { x: x => (x, undefined), y: y => (y, undefined) };
 var obj2: ObjType = ({ x: x => (x, undefined), y: y => (y, undefined) });
 >obj2 : Symbol(obj2, Decl(parenthesizedContexualTyping1.ts, 28, 3))
 >ObjType : Symbol(ObjType, Decl(parenthesizedContexualTyping1.ts, 24, 46))
->{ x: x => (x, undefined), y: y => (y, undefined) } : Symbol(, Decl(parenthesizedContexualTyping1.ts, 28, 21))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 28, 22))
->x => (x, undefined) : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 28, 25))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 28, 25))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 28, 25))
 >undefined : Symbol(undefined)
 >y : Symbol(y, Decl(parenthesizedContexualTyping1.ts, 28, 46))
->y => (y, undefined) : Symbol((Anonymous function), Decl(parenthesizedContexualTyping1.ts, 28, 49))
 >y : Symbol(y, Decl(parenthesizedContexualTyping1.ts, 28, 49))
 >y : Symbol(y, Decl(parenthesizedContexualTyping1.ts, 28, 49))
 >undefined : Symbol(undefined)
diff --git a/tests/baselines/reference/parenthesizedContexualTyping2.symbols b/tests/baselines/reference/parenthesizedContexualTyping2.symbols
index ae3aab8443729..f7616f07710d5 100644
--- a/tests/baselines/reference/parenthesizedContexualTyping2.symbols
+++ b/tests/baselines/reference/parenthesizedContexualTyping2.symbols
@@ -47,7 +47,6 @@ function fun<T>(...rest: any[]): T {
 var a = fun(x => { x<number>(undefined); return x; }, 10);
 >a : Symbol(a, Decl(parenthesizedContexualTyping2.ts, 14, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping2.ts, 6, 48), Decl(parenthesizedContexualTyping2.ts, 8, 38), Decl(parenthesizedContexualTyping2.ts, 9, 51))
->x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 14, 12))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 14, 12))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 14, 12))
 >undefined : Symbol(undefined)
@@ -56,7 +55,6 @@ var a = fun(x => { x<number>(undefined); return x; }, 10);
 var b = fun((x => { x<number>(undefined); return x; }), 10);
 >b : Symbol(b, Decl(parenthesizedContexualTyping2.ts, 15, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping2.ts, 6, 48), Decl(parenthesizedContexualTyping2.ts, 8, 38), Decl(parenthesizedContexualTyping2.ts, 9, 51))
->x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 15, 13))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 15, 13))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 15, 13))
 >undefined : Symbol(undefined)
@@ -65,7 +63,6 @@ var b = fun((x => { x<number>(undefined); return x; }), 10);
 var c = fun(((x => { x<number>(undefined); return x; })), 10);
 >c : Symbol(c, Decl(parenthesizedContexualTyping2.ts, 16, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping2.ts, 6, 48), Decl(parenthesizedContexualTyping2.ts, 8, 38), Decl(parenthesizedContexualTyping2.ts, 9, 51))
->x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 16, 14))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 16, 14))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 16, 14))
 >undefined : Symbol(undefined)
@@ -74,7 +71,6 @@ var c = fun(((x => { x<number>(undefined); return x; })), 10);
 var d = fun((((x => { x<number>(undefined); return x; }))), 10);
 >d : Symbol(d, Decl(parenthesizedContexualTyping2.ts, 17, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping2.ts, 6, 48), Decl(parenthesizedContexualTyping2.ts, 8, 38), Decl(parenthesizedContexualTyping2.ts, 9, 51))
->x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 17, 15))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 17, 15))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 17, 15))
 >undefined : Symbol(undefined)
@@ -83,12 +79,10 @@ var d = fun((((x => { x<number>(undefined); return x; }))), 10);
 var e = fun(x => { x<number>(undefined); return x; }, x => { x<number>(undefined); return x; }, 10);
 >e : Symbol(e, Decl(parenthesizedContexualTyping2.ts, 19, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping2.ts, 6, 48), Decl(parenthesizedContexualTyping2.ts, 8, 38), Decl(parenthesizedContexualTyping2.ts, 9, 51))
->x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 19, 12))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 19, 12))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 19, 12))
 >undefined : Symbol(undefined)
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 19, 12))
->x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 19, 53))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 19, 53))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 19, 53))
 >undefined : Symbol(undefined)
@@ -97,12 +91,10 @@ var e = fun(x => { x<number>(undefined); return x; }, x => { x<number>(undefined
 var f = fun((x => { x<number>(undefined); return x; }),(x => { x<number>(undefined); return x; }), 10);
 >f : Symbol(f, Decl(parenthesizedContexualTyping2.ts, 20, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping2.ts, 6, 48), Decl(parenthesizedContexualTyping2.ts, 8, 38), Decl(parenthesizedContexualTyping2.ts, 9, 51))
->x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 20, 13))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 20, 13))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 20, 13))
 >undefined : Symbol(undefined)
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 20, 13))
->x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 20, 56))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 20, 56))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 20, 56))
 >undefined : Symbol(undefined)
@@ -111,12 +103,10 @@ var f = fun((x => { x<number>(undefined); return x; }),(x => { x<number>(undefin
 var g = fun(((x => { x<number>(undefined); return x; })),((x => { x<number>(undefined); return x; })), 10);
 >g : Symbol(g, Decl(parenthesizedContexualTyping2.ts, 21, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping2.ts, 6, 48), Decl(parenthesizedContexualTyping2.ts, 8, 38), Decl(parenthesizedContexualTyping2.ts, 9, 51))
->x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 21, 14))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 21, 14))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 21, 14))
 >undefined : Symbol(undefined)
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 21, 14))
->x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 21, 59))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 21, 59))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 21, 59))
 >undefined : Symbol(undefined)
@@ -125,12 +115,10 @@ var g = fun(((x => { x<number>(undefined); return x; })),((x => { x<number>(unde
 var h = fun((((x => { x<number>(undefined); return x; }))),((x => { x<number>(undefined); return x; })), 10);
 >h : Symbol(h, Decl(parenthesizedContexualTyping2.ts, 22, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping2.ts, 6, 48), Decl(parenthesizedContexualTyping2.ts, 8, 38), Decl(parenthesizedContexualTyping2.ts, 9, 51))
->x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 22, 15))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 22, 15))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 22, 15))
 >undefined : Symbol(undefined)
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 22, 15))
->x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 22, 61))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 22, 61))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 22, 61))
 >undefined : Symbol(undefined)
@@ -143,12 +131,10 @@ var i = fun((Math.random() < 0.5 ? x => { x<number>(undefined); return x; } : x
 >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 >Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 25, 34))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 25, 34))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 25, 34))
 >undefined : Symbol(undefined)
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 25, 34))
->x => undefined : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 25, 77))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 25, 77))
 >undefined : Symbol(undefined)
 
@@ -158,12 +144,10 @@ var j = fun((Math.random() < 0.5 ? (x => { x<number>(undefined); return x; }) :
 >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 >Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 26, 36))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 26, 36))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 26, 36))
 >undefined : Symbol(undefined)
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 26, 36))
->x => undefined : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 26, 81))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 26, 81))
 >undefined : Symbol(undefined)
 
@@ -173,15 +157,12 @@ var k = fun((Math.random() < 0.5 ? (x => { x<number>(undefined); return x; }) :
 >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 >Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 27, 36))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 27, 36))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 27, 36))
 >undefined : Symbol(undefined)
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 27, 36))
->x => undefined : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 27, 81))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 27, 81))
 >undefined : Symbol(undefined)
->x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 27, 98))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 27, 98))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 27, 98))
 >undefined : Symbol(undefined)
@@ -193,15 +174,12 @@ var l = fun(((Math.random() < 0.5 ? ((x => { x<number>(undefined); return x; }))
 >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 >Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 28, 38))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 28, 38))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 28, 38))
 >undefined : Symbol(undefined)
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 28, 38))
->x => undefined : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 28, 85))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 28, 85))
 >undefined : Symbol(undefined)
->x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 28, 106))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 28, 106))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 28, 106))
 >undefined : Symbol(undefined)
@@ -210,7 +188,6 @@ var l = fun(((Math.random() < 0.5 ? ((x => { x<number>(undefined); return x; }))
 var lambda1: FuncType = x => { x<number>(undefined); return x; };
 >lambda1 : Symbol(lambda1, Decl(parenthesizedContexualTyping2.ts, 30, 3))
 >FuncType : Symbol(FuncType, Decl(parenthesizedContexualTyping2.ts, 0, 0))
->x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 30, 23))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 30, 23))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 30, 23))
 >undefined : Symbol(undefined)
@@ -219,7 +196,6 @@ var lambda1: FuncType = x => { x<number>(undefined); return x; };
 var lambda2: FuncType = (x => { x<number>(undefined); return x; });
 >lambda2 : Symbol(lambda2, Decl(parenthesizedContexualTyping2.ts, 31, 3))
 >FuncType : Symbol(FuncType, Decl(parenthesizedContexualTyping2.ts, 0, 0))
->x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 31, 25))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 31, 25))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 31, 25))
 >undefined : Symbol(undefined)
@@ -235,14 +211,11 @@ type ObjType = { x: (p: number) => string; y: (p: string) => number };
 var obj1: ObjType = { x: x => (x, undefined), y: y => (y, undefined) };
 >obj1 : Symbol(obj1, Decl(parenthesizedContexualTyping2.ts, 34, 3))
 >ObjType : Symbol(ObjType, Decl(parenthesizedContexualTyping2.ts, 31, 67))
->{ x: x => (x, undefined), y: y => (y, undefined) } : Symbol(, Decl(parenthesizedContexualTyping2.ts, 34, 19))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 34, 21))
->x => (x, undefined) : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 34, 24))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 34, 24))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 34, 24))
 >undefined : Symbol(undefined)
 >y : Symbol(y, Decl(parenthesizedContexualTyping2.ts, 34, 45))
->y => (y, undefined) : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 34, 48))
 >y : Symbol(y, Decl(parenthesizedContexualTyping2.ts, 34, 48))
 >y : Symbol(y, Decl(parenthesizedContexualTyping2.ts, 34, 48))
 >undefined : Symbol(undefined)
@@ -250,14 +223,11 @@ var obj1: ObjType = { x: x => (x, undefined), y: y => (y, undefined) };
 var obj2: ObjType = ({ x: x => (x, undefined), y: y => (y, undefined) });
 >obj2 : Symbol(obj2, Decl(parenthesizedContexualTyping2.ts, 35, 3))
 >ObjType : Symbol(ObjType, Decl(parenthesizedContexualTyping2.ts, 31, 67))
->{ x: x => (x, undefined), y: y => (y, undefined) } : Symbol(, Decl(parenthesizedContexualTyping2.ts, 35, 21))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 35, 22))
->x => (x, undefined) : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 35, 25))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 35, 25))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 35, 25))
 >undefined : Symbol(undefined)
 >y : Symbol(y, Decl(parenthesizedContexualTyping2.ts, 35, 46))
->y => (y, undefined) : Symbol((Anonymous function), Decl(parenthesizedContexualTyping2.ts, 35, 49))
 >y : Symbol(y, Decl(parenthesizedContexualTyping2.ts, 35, 49))
 >y : Symbol(y, Decl(parenthesizedContexualTyping2.ts, 35, 49))
 >undefined : Symbol(undefined)
diff --git a/tests/baselines/reference/parenthesizedContexualTyping3.symbols b/tests/baselines/reference/parenthesizedContexualTyping3.symbols
index aa6cc2e153011..b0d696e2d210b 100644
--- a/tests/baselines/reference/parenthesizedContexualTyping3.symbols
+++ b/tests/baselines/reference/parenthesizedContexualTyping3.symbols
@@ -56,71 +56,58 @@ function tempFun<T>(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T {
 var a = tempFun `${ x => x }  ${ 10 }`
 >a : Symbol(a, Decl(parenthesizedContexualTyping3.ts, 12, 3))
 >tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93))
->x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping3.ts, 12, 19))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 12, 19))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 12, 19))
 
 var b = tempFun `${ (x => x) }  ${ 10 }`
 >b : Symbol(b, Decl(parenthesizedContexualTyping3.ts, 13, 3))
 >tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93))
->x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping3.ts, 13, 21))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 13, 21))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 13, 21))
 
 var c = tempFun `${ ((x => x)) } ${ 10 }`
 >c : Symbol(c, Decl(parenthesizedContexualTyping3.ts, 14, 3))
 >tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93))
->x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping3.ts, 14, 22))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 14, 22))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 14, 22))
 
 var d = tempFun `${ x => x } ${ x => x } ${ 10 }`
 >d : Symbol(d, Decl(parenthesizedContexualTyping3.ts, 15, 3))
 >tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93))
->x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping3.ts, 15, 19))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 15, 19))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 15, 19))
->x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping3.ts, 15, 31))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 15, 31))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 15, 31))
 
 var e = tempFun `${ x => x } ${ (x => x) } ${ 10 }`
 >e : Symbol(e, Decl(parenthesizedContexualTyping3.ts, 16, 3))
 >tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93))
->x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping3.ts, 16, 19))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 16, 19))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 16, 19))
->x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping3.ts, 16, 33))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 16, 33))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 16, 33))
 
 var f = tempFun `${ x => x } ${ ((x => x)) } ${ 10 }`
 >f : Symbol(f, Decl(parenthesizedContexualTyping3.ts, 17, 3))
 >tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93))
->x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping3.ts, 17, 19))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 17, 19))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 17, 19))
->x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping3.ts, 17, 34))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 17, 34))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 17, 34))
 
 var g = tempFun `${ (x => x) } ${ (((x => x))) } ${ 10 }`
 >g : Symbol(g, Decl(parenthesizedContexualTyping3.ts, 18, 3))
 >tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93))
->x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping3.ts, 18, 21))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 18, 21))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 18, 21))
->x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping3.ts, 18, 37))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 18, 37))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 18, 37))
 
 var h = tempFun `${ (x => x) } ${ (((x => x))) } ${ undefined }`
 >h : Symbol(h, Decl(parenthesizedContexualTyping3.ts, 19, 3))
 >tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93))
->x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping3.ts, 19, 21))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 19, 21))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 19, 21))
->x => x : Symbol((Anonymous function), Decl(parenthesizedContexualTyping3.ts, 19, 37))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 19, 37))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 19, 37))
 >undefined : Symbol(undefined)
diff --git a/tests/baselines/reference/parserAccessors4.symbols b/tests/baselines/reference/parserAccessors4.symbols
index 2f35ef8c53ffb..e5dc9f1ecc3a9 100644
--- a/tests/baselines/reference/parserAccessors4.symbols
+++ b/tests/baselines/reference/parserAccessors4.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/parser/ecmascript5/Accessors/parserAccessors4.ts ===
 var v = { set Foo(a) { } };
 >v : Symbol(v, Decl(parserAccessors4.ts, 0, 3))
->{ set Foo(a) { } } : Symbol(, Decl(parserAccessors4.ts, 0, 7))
 >Foo : Symbol(Foo, Decl(parserAccessors4.ts, 0, 9))
 >a : Symbol(a, Decl(parserAccessors4.ts, 0, 18))
 
diff --git a/tests/baselines/reference/parserFunctionPropertyAssignment1.symbols b/tests/baselines/reference/parserFunctionPropertyAssignment1.symbols
index b93b6129b653b..01b555c5e8583 100644
--- a/tests/baselines/reference/parserFunctionPropertyAssignment1.symbols
+++ b/tests/baselines/reference/parserFunctionPropertyAssignment1.symbols
@@ -1,6 +1,5 @@
 === tests/cases/conformance/parser/ecmascript5/PropertyAssignments/parserFunctionPropertyAssignment1.ts ===
 var v = { foo() { } };
 >v : Symbol(v, Decl(parserFunctionPropertyAssignment1.ts, 0, 3))
->{ foo() { } } : Symbol(, Decl(parserFunctionPropertyAssignment1.ts, 0, 7))
 >foo : Symbol(foo, Decl(parserFunctionPropertyAssignment1.ts, 0, 9))
 
diff --git a/tests/baselines/reference/parserFunctionPropertyAssignment2.symbols b/tests/baselines/reference/parserFunctionPropertyAssignment2.symbols
index fee84294b7190..3cd2d8ab32557 100644
--- a/tests/baselines/reference/parserFunctionPropertyAssignment2.symbols
+++ b/tests/baselines/reference/parserFunctionPropertyAssignment2.symbols
@@ -1,5 +1,4 @@
 === tests/cases/conformance/parser/ecmascript5/PropertyAssignments/parserFunctionPropertyAssignment2.ts ===
 var v = { 0() { } };
 >v : Symbol(v, Decl(parserFunctionPropertyAssignment2.ts, 0, 3))
->{ 0() { } } : Symbol(, Decl(parserFunctionPropertyAssignment2.ts, 0, 7))
 
diff --git a/tests/baselines/reference/parserFunctionPropertyAssignment3.symbols b/tests/baselines/reference/parserFunctionPropertyAssignment3.symbols
index 7d8ebb63ae3ab..9b3135c5ed029 100644
--- a/tests/baselines/reference/parserFunctionPropertyAssignment3.symbols
+++ b/tests/baselines/reference/parserFunctionPropertyAssignment3.symbols
@@ -1,5 +1,4 @@
 === tests/cases/conformance/parser/ecmascript5/PropertyAssignments/parserFunctionPropertyAssignment3.ts ===
 var v = { "foo"() { } };
 >v : Symbol(v, Decl(parserFunctionPropertyAssignment3.ts, 0, 3))
->{ "foo"() { } } : Symbol(, Decl(parserFunctionPropertyAssignment3.ts, 0, 7))
 
diff --git a/tests/baselines/reference/parserFunctionPropertyAssignment4.symbols b/tests/baselines/reference/parserFunctionPropertyAssignment4.symbols
index b560ff6765842..2cb8b652e33a8 100644
--- a/tests/baselines/reference/parserFunctionPropertyAssignment4.symbols
+++ b/tests/baselines/reference/parserFunctionPropertyAssignment4.symbols
@@ -1,6 +1,5 @@
 === tests/cases/conformance/parser/ecmascript5/PropertyAssignments/parserFunctionPropertyAssignment4.ts ===
 var v = { 0<T>() { } };
 >v : Symbol(v, Decl(parserFunctionPropertyAssignment4.ts, 0, 3))
->{ 0<T>() { } } : Symbol(, Decl(parserFunctionPropertyAssignment4.ts, 0, 7))
 >T : Symbol(T, Decl(parserFunctionPropertyAssignment4.ts, 0, 12))
 
diff --git a/tests/baselines/reference/parserKeywordsAsIdentifierName1.symbols b/tests/baselines/reference/parserKeywordsAsIdentifierName1.symbols
index 14a4bf4c1f437..67420930affce 100644
--- a/tests/baselines/reference/parserKeywordsAsIdentifierName1.symbols
+++ b/tests/baselines/reference/parserKeywordsAsIdentifierName1.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/parser/ecmascript5/parserKeywordsAsIdentifierName1.ts ===
 var big = {
 >big : Symbol(big, Decl(parserKeywordsAsIdentifierName1.ts, 0, 3))
->{   break : 0,   super : 0,   const : 0} : Symbol(, Decl(parserKeywordsAsIdentifierName1.ts, 0, 9))
 
    break : 0,
 >break : Symbol(break, Decl(parserKeywordsAsIdentifierName1.ts, 0, 11))
diff --git a/tests/baselines/reference/parserObjectLiterals1.symbols b/tests/baselines/reference/parserObjectLiterals1.symbols
index 337171fcd12c2..602c2dd5a3acd 100644
--- a/tests/baselines/reference/parserObjectLiterals1.symbols
+++ b/tests/baselines/reference/parserObjectLiterals1.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/parser/ecmascript5/ObjectLiterals/parserObjectLiterals1.ts ===
 var v = { a: 1, b: 2 };
 >v : Symbol(v, Decl(parserObjectLiterals1.ts, 0, 3))
->{ a: 1, b: 2 } : Symbol(, Decl(parserObjectLiterals1.ts, 0, 7))
 >a : Symbol(a, Decl(parserObjectLiterals1.ts, 0, 9))
 >b : Symbol(b, Decl(parserObjectLiterals1.ts, 0, 15))
 
diff --git a/tests/baselines/reference/parserX_ArrowFunction4.symbols b/tests/baselines/reference/parserX_ArrowFunction4.symbols
index 522b51de2fb4a..bc1838dca4481 100644
--- a/tests/baselines/reference/parserX_ArrowFunction4.symbols
+++ b/tests/baselines/reference/parserX_ArrowFunction4.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrowFunctions/parserX_ArrowFunction4.ts ===
 var v = (a, b) => {
 >v : Symbol(v, Decl(parserX_ArrowFunction4.ts, 0, 3))
->(a, b) => {   } : Symbol((Anonymous function), Decl(parserX_ArrowFunction4.ts, 0, 7))
 >a : Symbol(a, Decl(parserX_ArrowFunction4.ts, 0, 9))
 >b : Symbol(b, Decl(parserX_ArrowFunction4.ts, 0, 11))
    
diff --git a/tests/baselines/reference/plusOperatorWithBooleanType.symbols b/tests/baselines/reference/plusOperatorWithBooleanType.symbols
index f2771db44b791..d8c6beda3bc36 100644
--- a/tests/baselines/reference/plusOperatorWithBooleanType.symbols
+++ b/tests/baselines/reference/plusOperatorWithBooleanType.symbols
@@ -37,7 +37,6 @@ var ResultIsNumber2 = +true;
 
 var ResultIsNumber3 = +{ x: true, y: false };
 >ResultIsNumber3 : Symbol(ResultIsNumber3, Decl(plusOperatorWithBooleanType.ts, 20, 3))
->{ x: true, y: false } : Symbol(, Decl(plusOperatorWithBooleanType.ts, 20, 23))
 >x : Symbol(x, Decl(plusOperatorWithBooleanType.ts, 20, 24))
 >y : Symbol(y, Decl(plusOperatorWithBooleanType.ts, 20, 33))
 
diff --git a/tests/baselines/reference/plusOperatorWithNumberType.symbols b/tests/baselines/reference/plusOperatorWithNumberType.symbols
index 7eda860a9a421..fd62582515edd 100644
--- a/tests/baselines/reference/plusOperatorWithNumberType.symbols
+++ b/tests/baselines/reference/plusOperatorWithNumberType.symbols
@@ -44,16 +44,13 @@ var ResultIsNumber3 = +1;
 
 var ResultIsNumber4 = +{ x: 1, y: 2};
 >ResultIsNumber4 : Symbol(ResultIsNumber4, Decl(plusOperatorWithNumberType.ts, 22, 3))
->{ x: 1, y: 2} : Symbol(, Decl(plusOperatorWithNumberType.ts, 22, 23))
 >x : Symbol(x, Decl(plusOperatorWithNumberType.ts, 22, 24))
 >y : Symbol(y, Decl(plusOperatorWithNumberType.ts, 22, 30))
 
 var ResultIsNumber5 = +{ x: 1, y: (n: number) => { return n; } };
 >ResultIsNumber5 : Symbol(ResultIsNumber5, Decl(plusOperatorWithNumberType.ts, 23, 3))
->{ x: 1, y: (n: number) => { return n; } } : Symbol(, Decl(plusOperatorWithNumberType.ts, 23, 23))
 >x : Symbol(x, Decl(plusOperatorWithNumberType.ts, 23, 24))
 >y : Symbol(y, Decl(plusOperatorWithNumberType.ts, 23, 30))
->(n: number) => { return n; } : Symbol((Anonymous function), Decl(plusOperatorWithNumberType.ts, 23, 33))
 >n : Symbol(n, Decl(plusOperatorWithNumberType.ts, 23, 35))
 >n : Symbol(n, Decl(plusOperatorWithNumberType.ts, 23, 35))
 
diff --git a/tests/baselines/reference/plusOperatorWithStringType.symbols b/tests/baselines/reference/plusOperatorWithStringType.symbols
index c510bb8aa870f..1ff2cec5dff7b 100644
--- a/tests/baselines/reference/plusOperatorWithStringType.symbols
+++ b/tests/baselines/reference/plusOperatorWithStringType.symbols
@@ -44,16 +44,13 @@ var ResultIsNumber3 = +"";
 
 var ResultIsNumber4 = +{ x: "", y: "" };
 >ResultIsNumber4 : Symbol(ResultIsNumber4, Decl(plusOperatorWithStringType.ts, 22, 3))
->{ x: "", y: "" } : Symbol(, Decl(plusOperatorWithStringType.ts, 22, 23))
 >x : Symbol(x, Decl(plusOperatorWithStringType.ts, 22, 24))
 >y : Symbol(y, Decl(plusOperatorWithStringType.ts, 22, 31))
 
 var ResultIsNumber5 = +{ x: "", y: (s: string) => { return s; } };
 >ResultIsNumber5 : Symbol(ResultIsNumber5, Decl(plusOperatorWithStringType.ts, 23, 3))
->{ x: "", y: (s: string) => { return s; } } : Symbol(, Decl(plusOperatorWithStringType.ts, 23, 23))
 >x : Symbol(x, Decl(plusOperatorWithStringType.ts, 23, 24))
 >y : Symbol(y, Decl(plusOperatorWithStringType.ts, 23, 31))
->(s: string) => { return s; } : Symbol((Anonymous function), Decl(plusOperatorWithStringType.ts, 23, 34))
 >s : Symbol(s, Decl(plusOperatorWithStringType.ts, 23, 36))
 >s : Symbol(s, Decl(plusOperatorWithStringType.ts, 23, 36))
 
diff --git a/tests/baselines/reference/prespecializedGenericMembers1.symbols b/tests/baselines/reference/prespecializedGenericMembers1.symbols
index 17a8133baea06..b95432a5fded2 100644
--- a/tests/baselines/reference/prespecializedGenericMembers1.symbols
+++ b/tests/baselines/reference/prespecializedGenericMembers1.symbols
@@ -32,7 +32,6 @@ var cat = new Cat<IKitty>();
 
 var catThing = {
 >catThing : Symbol(catThing, Decl(prespecializedGenericMembers1.ts, 16, 3))
->{    barry: cat} : Symbol(, Decl(prespecializedGenericMembers1.ts, 16, 14))
 
     barry: cat
 >barry : Symbol(barry, Decl(prespecializedGenericMembers1.ts, 16, 16))
diff --git a/tests/baselines/reference/privacyAccessorDeclFile.symbols b/tests/baselines/reference/privacyAccessorDeclFile.symbols
deleted file mode 100644
index 4437ae0b29919..0000000000000
--- a/tests/baselines/reference/privacyAccessorDeclFile.symbols
+++ /dev/null
@@ -1,2217 +0,0 @@
-=== tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts ===
-
-class privateClass {
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
-}
-
-export class publicClass {
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
-}
-
-export class publicClassWithWithPrivateGetAccessorTypes {
->publicClassWithWithPrivateGetAccessorTypes : Symbol(publicClassWithWithPrivateGetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 5, 1))
-
-    static get myPublicStaticMethod(): privateClass { // Error
->myPublicStaticMethod : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 7, 57))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
-
-        return null;
-    }
-    private static get myPrivateStaticMethod(): privateClass {
->myPrivateStaticMethod : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 10, 5))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
-
-        return null;
-    }
-    get myPublicMethod(): privateClass { // Error
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 13, 5))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
-
-        return null;
-    }
-    private get myPrivateMethod(): privateClass {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 16, 5))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
-
-        return null;
-    }
-    static get myPublicStaticMethod1() { // Error
->myPublicStaticMethod1 : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 19, 5))
-
-        return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
-    }
-    private static get myPrivateStaticMethod1() {
->myPrivateStaticMethod1 : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 22, 5))
-
-        return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
-    }
-    get myPublicMethod1() { // Error
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 25, 5))
-
-        return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
-    }
-    private get myPrivateMethod1() {
->myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 28, 5))
-
-        return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
-    }
-}
-
-export class publicClassWithWithPublicGetAccessorTypes {
->publicClassWithWithPublicGetAccessorTypes : Symbol(publicClassWithWithPublicGetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 32, 1))
-
-    static get myPublicStaticMethod(): publicClass {
->myPublicStaticMethod : Symbol(publicClassWithWithPublicGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 34, 56))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
-
-        return null;
-    }
-    private static get myPrivateStaticMethod(): publicClass {
->myPrivateStaticMethod : Symbol(publicClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 37, 5))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
-
-        return null;
-    }
-    get myPublicMethod(): publicClass {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 40, 5))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
-
-        return null;
-    }
-    private get myPrivateMethod(): publicClass {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 43, 5))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
-
-        return null;
-    }
-    static get myPublicStaticMethod1() {
->myPublicStaticMethod1 : Symbol(publicClassWithWithPublicGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 46, 5))
-
-        return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
-    }
-    private static get myPrivateStaticMethod1() {
->myPrivateStaticMethod1 : Symbol(publicClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 49, 5))
-
-        return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
-    }
-    get myPublicMethod1() {
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 52, 5))
-
-        return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
-    }
-    private get myPrivateMethod1() {
->myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 55, 5))
-
-        return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
-    }
-}
-
-class privateClassWithWithPrivateGetAccessorTypes {
->privateClassWithWithPrivateGetAccessorTypes : Symbol(privateClassWithWithPrivateGetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 59, 1))
-
-    static get myPublicStaticMethod(): privateClass {
->myPublicStaticMethod : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 61, 51))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
-
-        return null;
-    }
-    private static get myPrivateStaticMethod(): privateClass {
->myPrivateStaticMethod : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 64, 5))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
-
-        return null;
-    }
-    get myPublicMethod(): privateClass {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 67, 5))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
-
-        return null;
-    }
-    private get myPrivateMethod(): privateClass {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 70, 5))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
-
-        return null;
-    }
-    static get myPublicStaticMethod1() {
->myPublicStaticMethod1 : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 73, 5))
-
-        return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
-    }
-    private static get myPrivateStaticMethod1() {
->myPrivateStaticMethod1 : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 76, 5))
-
-        return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
-    }
-    get myPublicMethod1() {
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 79, 5))
-
-        return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
-    }
-    private get myPrivateMethod1() {
->myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 82, 5))
-
-        return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
-    }
-}
-
-class privateClassWithWithPublicGetAccessorTypes {
->privateClassWithWithPublicGetAccessorTypes : Symbol(privateClassWithWithPublicGetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 86, 1))
-
-    static get myPublicStaticMethod(): publicClass {
->myPublicStaticMethod : Symbol(privateClassWithWithPublicGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 88, 50))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
-
-        return null;
-    }
-    private static get myPrivateStaticMethod(): publicClass {
->myPrivateStaticMethod : Symbol(privateClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 91, 5))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
-
-        return null;
-    }
-    get myPublicMethod(): publicClass {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 94, 5))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
-
-        return null;
-    }
-    private get myPrivateMethod(): publicClass {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 97, 5))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
-
-        return null;
-    }
-    static get myPublicStaticMethod1() {
->myPublicStaticMethod1 : Symbol(privateClassWithWithPublicGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 100, 5))
-
-        return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
-    }
-    private static get myPrivateStaticMethod1() {
->myPrivateStaticMethod1 : Symbol(privateClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 103, 5))
-
-        return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
-    }
-    get myPublicMethod1() {
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 106, 5))
-
-        return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
-    }
-    private get myPrivateMethod1() {
->myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 109, 5))
-
-        return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
-    }
-}
-
-export class publicClassWithWithPrivateSetAccessorTypes {
->publicClassWithWithPrivateSetAccessorTypes : Symbol(publicClassWithWithPrivateSetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 113, 1))
-
-    static set myPublicStaticMethod(param: privateClass) { // Error
->myPublicStaticMethod : Symbol(publicClassWithWithPrivateSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 115, 57))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 116, 36))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
-    }
-    private static set myPrivateStaticMethod(param: privateClass) {
->myPrivateStaticMethod : Symbol(publicClassWithWithPrivateSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 117, 5))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 118, 45))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
-    }
-    set myPublicMethod(param: privateClass) { // Error
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 119, 5))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 120, 23))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
-    }
-    private set myPrivateMethod(param: privateClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 121, 5))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 122, 32))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
-    }
-}
-
-export class publicClassWithWithPublicSetAccessorTypes {
->publicClassWithWithPublicSetAccessorTypes : Symbol(publicClassWithWithPublicSetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 124, 1))
-
-    static set myPublicStaticMethod(param: publicClass) {
->myPublicStaticMethod : Symbol(publicClassWithWithPublicSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 126, 56))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 127, 36))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
-    }
-    private static set myPrivateStaticMethod(param: publicClass) {
->myPrivateStaticMethod : Symbol(publicClassWithWithPublicSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 128, 5))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 129, 45))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
-    }
-    set myPublicMethod(param: publicClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 130, 5))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 131, 23))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
-    }
-    private set myPrivateMethod(param: publicClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 132, 5))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 133, 32))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
-    }
-}
-
-class privateClassWithWithPrivateSetAccessorTypes {
->privateClassWithWithPrivateSetAccessorTypes : Symbol(privateClassWithWithPrivateSetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 135, 1))
-
-    static set myPublicStaticMethod(param: privateClass) {
->myPublicStaticMethod : Symbol(privateClassWithWithPrivateSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 137, 51))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 138, 36))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
-    }
-    private static set myPrivateStaticMethod(param: privateClass) {
->myPrivateStaticMethod : Symbol(privateClassWithWithPrivateSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 139, 5))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 140, 45))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
-    }
-    set myPublicMethod(param: privateClass) { 
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 141, 5))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 142, 23))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
-    }
-    private set myPrivateMethod(param: privateClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 143, 5))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 144, 32))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 0, 0))
-    }
-}
-
-class privateClassWithWithPublicSetAccessorTypes {
->privateClassWithWithPublicSetAccessorTypes : Symbol(privateClassWithWithPublicSetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 146, 1))
-
-    static set myPublicStaticMethod(param: publicClass) {
->myPublicStaticMethod : Symbol(privateClassWithWithPublicSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 148, 50))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 149, 36))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
-    }
-    private static set myPrivateStaticMethod(param: publicClass) {
->myPrivateStaticMethod : Symbol(privateClassWithWithPublicSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 150, 5))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 151, 45))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
-    }
-    set myPublicMethod(param: publicClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 152, 5))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 153, 23))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
-    }
-    private set myPrivateMethod(param: publicClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 154, 5))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 155, 32))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 2, 1))
-    }
-}
-
-export class publicClassWithPrivateModuleGetAccessorTypes {
->publicClassWithPrivateModuleGetAccessorTypes : Symbol(publicClassWithPrivateModuleGetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 157, 1))
-
-    static get myPublicStaticMethod(): privateModule.publicClass { // Error
->myPublicStaticMethod : Symbol(publicClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 159, 59))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-
-        return null;
-    }
-    get myPublicMethod(): privateModule.publicClass { // Error
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 162, 5))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-
-        return null;
-    }
-    static get myPublicStaticMethod1() { // Error
->myPublicStaticMethod1 : Symbol(publicClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 165, 5))
-
-        return new privateModule.publicClass();
->privateModule.publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-    }
-    get myPublicMethod1() { // Error
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 168, 5))
-
-        return new privateModule.publicClass();
->privateModule.publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-    }
-}
-
-export class publicClassWithPrivateModuleSetAccessorTypes {
->publicClassWithPrivateModuleSetAccessorTypes : Symbol(publicClassWithPrivateModuleSetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 172, 1))
-
-    static set myPublicStaticMethod(param: privateModule.publicClass) { // Error
->myPublicStaticMethod : Symbol(publicClassWithPrivateModuleSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 174, 59))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 175, 36))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-    }
-    set myPublicMethod(param: privateModule.publicClass) { // Error
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 176, 5))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 177, 23))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-    }
-}
-
-class privateClassWithPrivateModuleGetAccessorTypes {
->privateClassWithPrivateModuleGetAccessorTypes : Symbol(privateClassWithPrivateModuleGetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 179, 1))
-
-    static get myPublicStaticMethod(): privateModule.publicClass {
->myPublicStaticMethod : Symbol(privateClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 181, 53))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-
-        return null;
-    }
-    get myPublicMethod(): privateModule.publicClass {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 184, 5))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-
-        return null;
-    }
-    static get myPublicStaticMethod1() {
->myPublicStaticMethod1 : Symbol(privateClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 187, 5))
-
-        return new privateModule.publicClass();
->privateModule.publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-    }
-    get myPublicMethod1() {
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 190, 5))
-
-        return new privateModule.publicClass();
->privateModule.publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-    }
-}
-
-class privateClassWithPrivateModuleSetAccessorTypes {
->privateClassWithPrivateModuleSetAccessorTypes : Symbol(privateClassWithPrivateModuleSetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 194, 1))
-
-    static set myPublicStaticMethod(param: privateModule.publicClass) {
->myPublicStaticMethod : Symbol(privateClassWithPrivateModuleSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 196, 53))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 197, 36))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-    }
-    set myPublicMethod(param: privateModule.publicClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 198, 5))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 199, 23))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-    }
-}
-
-export module publicModule {
->publicModule : Symbol(publicModule, Decl(privacyAccessorDeclFile_externalModule.ts, 201, 1))
-
-    class privateClass {
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
-    }
-
-    export class publicClass {
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
-    }
-    export class publicClassWithWithPrivateGetAccessorTypes {
->publicClassWithWithPrivateGetAccessorTypes : Symbol(publicClassWithWithPrivateGetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 208, 5))
-
-        static get myPublicStaticMethod(): privateClass { // Error
->myPublicStaticMethod : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 209, 61))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
-
-            return null;
-        }
-        private static get myPrivateStaticMethod(): privateClass {
->myPrivateStaticMethod : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 212, 9))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
-
-            return null;
-        }
-        get myPublicMethod(): privateClass { // Error
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 215, 9))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
-
-            return null;
-        }
-        private get myPrivateMethod(): privateClass {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 218, 9))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
-
-            return null;
-        }
-        static get myPublicStaticMethod1() { // Error
->myPublicStaticMethod1 : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 221, 9))
-
-            return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
-        }
-        private static get myPrivateStaticMethod1() {
->myPrivateStaticMethod1 : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 224, 9))
-
-            return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
-        }
-        get myPublicMethod1() { // Error
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 227, 9))
-
-            return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
-        }
-        private get myPrivateMethod1() {
->myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 230, 9))
-
-            return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
-        }
-    }
-
-    export class publicClassWithWithPublicGetAccessorTypes {
->publicClassWithWithPublicGetAccessorTypes : Symbol(publicClassWithWithPublicGetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 234, 5))
-
-        static get myPublicStaticMethod(): publicClass {
->myPublicStaticMethod : Symbol(publicClassWithWithPublicGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 236, 60))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
-
-            return null;
-        }
-        private static get myPrivateStaticMethod(): publicClass {
->myPrivateStaticMethod : Symbol(publicClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 239, 9))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
-
-            return null;
-        }
-        get myPublicMethod(): publicClass {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 242, 9))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
-
-            return null;
-        }
-        private get myPrivateMethod(): publicClass {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 245, 9))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
-
-            return null;
-        }
-        static get myPublicStaticMethod1() {
->myPublicStaticMethod1 : Symbol(publicClassWithWithPublicGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 248, 9))
-
-            return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
-        }
-        private static get myPrivateStaticMethod1() {
->myPrivateStaticMethod1 : Symbol(publicClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 251, 9))
-
-            return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
-        }
-        get myPublicMethod1() {
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 254, 9))
-
-            return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
-        }
-        private get myPrivateMethod1() {
->myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 257, 9))
-
-            return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
-        }
-    }
-
-    class privateClassWithWithPrivateGetAccessorTypes {
->privateClassWithWithPrivateGetAccessorTypes : Symbol(privateClassWithWithPrivateGetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 261, 5))
-
-        static get myPublicStaticMethod(): privateClass {
->myPublicStaticMethod : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 263, 55))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
-
-            return null;
-        }
-        private static get myPrivateStaticMethod(): privateClass {
->myPrivateStaticMethod : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 266, 9))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
-
-            return null;
-        }
-        get myPublicMethod(): privateClass {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 269, 9))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
-
-            return null;
-        }
-        private get myPrivateMethod(): privateClass {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 272, 9))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
-
-            return null;
-        }
-        static get myPublicStaticMethod1() {
->myPublicStaticMethod1 : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 275, 9))
-
-            return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
-        }
-        private static get myPrivateStaticMethod1() {
->myPrivateStaticMethod1 : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 278, 9))
-
-            return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
-        }
-        get myPublicMethod1() {
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 281, 9))
-
-            return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
-        }
-        private get myPrivateMethod1() {
->myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 284, 9))
-
-            return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
-        }
-    }
-
-    class privateClassWithWithPublicGetAccessorTypes {
->privateClassWithWithPublicGetAccessorTypes : Symbol(privateClassWithWithPublicGetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 288, 5))
-
-        static get myPublicStaticMethod(): publicClass {
->myPublicStaticMethod : Symbol(privateClassWithWithPublicGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 290, 54))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
-
-            return null;
-        }
-        private static get myPrivateStaticMethod(): publicClass {
->myPrivateStaticMethod : Symbol(privateClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 293, 9))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
-
-            return null;
-        }
-        get myPublicMethod(): publicClass {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 296, 9))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
-
-            return null;
-        }
-        private get myPrivateMethod(): publicClass {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 299, 9))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
-
-            return null;
-        }
-        static get myPublicStaticMethod1() {
->myPublicStaticMethod1 : Symbol(privateClassWithWithPublicGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 302, 9))
-
-            return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
-        }
-        private static get myPrivateStaticMethod1() {
->myPrivateStaticMethod1 : Symbol(privateClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 305, 9))
-
-            return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
-        }
-        get myPublicMethod1() {
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 308, 9))
-
-            return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
-        }
-        private get myPrivateMethod1() {
->myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 311, 9))
-
-            return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
-        }
-    }
-
-    export class publicClassWithWithPrivateSetAccessorTypes {
->publicClassWithWithPrivateSetAccessorTypes : Symbol(publicClassWithWithPrivateSetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 315, 5))
-
-        static set myPublicStaticMethod(param: privateClass) { // Error
->myPublicStaticMethod : Symbol(publicClassWithWithPrivateSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 317, 61))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 318, 40))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
-        }
-        private static set myPrivateStaticMethod(param: privateClass) {
->myPrivateStaticMethod : Symbol(publicClassWithWithPrivateSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 319, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 320, 49))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
-        }
-        set myPublicMethod(param: privateClass) { // Error
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 321, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 322, 27))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
-        }
-        private set myPrivateMethod(param: privateClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 323, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 324, 36))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
-        }
-    }
-
-    export class publicClassWithWithPublicSetAccessorTypes {
->publicClassWithWithPublicSetAccessorTypes : Symbol(publicClassWithWithPublicSetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 326, 5))
-
-        static set myPublicStaticMethod(param: publicClass) {
->myPublicStaticMethod : Symbol(publicClassWithWithPublicSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 328, 60))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 329, 40))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
-        }
-        private static set myPrivateStaticMethod(param: publicClass) {
->myPrivateStaticMethod : Symbol(publicClassWithWithPublicSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 330, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 331, 49))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
-        }
-        set myPublicMethod(param: publicClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 332, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 333, 27))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
-        }
-        private set myPrivateMethod(param: publicClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 334, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 335, 36))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
-        }
-    }
-
-    class privateClassWithWithPrivateSetAccessorTypes {
->privateClassWithWithPrivateSetAccessorTypes : Symbol(privateClassWithWithPrivateSetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 337, 5))
-
-        static set myPublicStaticMethod(param: privateClass) {
->myPublicStaticMethod : Symbol(privateClassWithWithPrivateSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 339, 55))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 340, 40))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
-        }
-        private static set myPrivateStaticMethod(param: privateClass) {
->myPrivateStaticMethod : Symbol(privateClassWithWithPrivateSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 341, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 342, 49))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
-        }
-        set myPublicMethod(param: privateClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 343, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 344, 27))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
-        }
-        private set myPrivateMethod(param: privateClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 345, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 346, 36))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 203, 28))
-        }
-    }
-
-    class privateClassWithWithPublicSetAccessorTypes {
->privateClassWithWithPublicSetAccessorTypes : Symbol(privateClassWithWithPublicSetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 348, 5))
-
-        static set myPublicStaticMethod(param: publicClass) {
->myPublicStaticMethod : Symbol(privateClassWithWithPublicSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 350, 54))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 351, 40))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
-        }
-        private static set myPrivateStaticMethod(param: publicClass) {
->myPrivateStaticMethod : Symbol(privateClassWithWithPublicSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 352, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 353, 49))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
-        }
-        set myPublicMethod(param: publicClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 354, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 355, 27))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
-        }
-        private set myPrivateMethod(param: publicClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 356, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 357, 36))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 205, 5))
-        }
-    }
-
-    export class publicClassWithPrivateModuleGetAccessorTypes {
->publicClassWithPrivateModuleGetAccessorTypes : Symbol(publicClassWithPrivateModuleGetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 359, 5))
-
-        static get myPublicStaticMethod(): privateModule.publicClass { // Error
->myPublicStaticMethod : Symbol(publicClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 361, 63))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-
-            return null;
-        }
-        get myPublicMethod(): privateModule.publicClass { // Error
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 364, 9))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-
-            return null;
-        }
-        static get myPublicStaticMethod1() { // Error
->myPublicStaticMethod1 : Symbol(publicClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 367, 9))
-
-            return new privateModule.publicClass();
->privateModule.publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-        }
-        get myPublicMethod1() { // Error
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 370, 9))
-
-            return new privateModule.publicClass();
->privateModule.publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-        }
-    }
-
-    export class publicClassWithPrivateModuleSetAccessorTypes {
->publicClassWithPrivateModuleSetAccessorTypes : Symbol(publicClassWithPrivateModuleSetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 374, 5))
-
-        static set myPublicStaticMethod(param: privateModule.publicClass) { // Error
->myPublicStaticMethod : Symbol(publicClassWithPrivateModuleSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 376, 63))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 377, 40))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-        }
-        set myPublicMethod(param: privateModule.publicClass) { // Error
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 378, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 379, 27))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-        }
-    }
-
-    class privateClassWithPrivateModuleGetAccessorTypes {
->privateClassWithPrivateModuleGetAccessorTypes : Symbol(privateClassWithPrivateModuleGetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 381, 5))
-
-        static get myPublicStaticMethod(): privateModule.publicClass {
->myPublicStaticMethod : Symbol(privateClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 383, 57))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-
-            return null;
-        }
-        get myPublicMethod(): privateModule.publicClass {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 386, 9))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-
-            return null;
-        }
-        static get myPublicStaticMethod1() {
->myPublicStaticMethod1 : Symbol(privateClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 389, 9))
-
-            return new privateModule.publicClass();
->privateModule.publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-        }
-        get myPublicMethod1() {
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 392, 9))
-
-            return new privateModule.publicClass();
->privateModule.publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-        }
-    }
-
-    class privateClassWithPrivateModuleSetAccessorTypes {
->privateClassWithPrivateModuleSetAccessorTypes : Symbol(privateClassWithPrivateModuleSetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 396, 5))
-
-        static set myPublicStaticMethod(param: privateModule.publicClass) {
->myPublicStaticMethod : Symbol(privateClassWithPrivateModuleSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 398, 57))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 399, 40))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-        }
-        set myPublicMethod(param: privateModule.publicClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 400, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 401, 27))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-        }
-    }
-}
-
-module privateModule {
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
-
-    class privateClass {
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
-    }
-
-    export class publicClass {
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-    }
-    export class publicClassWithWithPrivateGetAccessorTypes {
->publicClassWithWithPrivateGetAccessorTypes : Symbol(publicClassWithWithPrivateGetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 411, 5))
-
-        static get myPublicStaticMethod(): privateClass { 
->myPublicStaticMethod : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 412, 61))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
-
-            return null;
-        }
-        private static get myPrivateStaticMethod(): privateClass {
->myPrivateStaticMethod : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 415, 9))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
-
-            return null;
-        }
-        get myPublicMethod(): privateClass { 
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 418, 9))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
-
-            return null;
-        }
-        private get myPrivateMethod(): privateClass {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 421, 9))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
-
-            return null;
-        }
-        static get myPublicStaticMethod1() { 
->myPublicStaticMethod1 : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 424, 9))
-
-            return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
-        }
-        private static get myPrivateStaticMethod1() {
->myPrivateStaticMethod1 : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 427, 9))
-
-            return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
-        }
-        get myPublicMethod1() { 
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 430, 9))
-
-            return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
-        }
-        private get myPrivateMethod1() {
->myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 433, 9))
-
-            return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
-        }
-    }
-
-    export class publicClassWithWithPublicGetAccessorTypes {
->publicClassWithWithPublicGetAccessorTypes : Symbol(publicClassWithWithPublicGetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 437, 5))
-
-        static get myPublicStaticMethod(): publicClass {
->myPublicStaticMethod : Symbol(publicClassWithWithPublicGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 439, 60))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-
-            return null;
-        }
-        private static get myPrivateStaticMethod(): publicClass {
->myPrivateStaticMethod : Symbol(publicClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 442, 9))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-
-            return null;
-        }
-        get myPublicMethod(): publicClass {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 445, 9))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-
-            return null;
-        }
-        private get myPrivateMethod(): publicClass {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 448, 9))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-
-            return null;
-        }
-        static get myPublicStaticMethod1() {
->myPublicStaticMethod1 : Symbol(publicClassWithWithPublicGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 451, 9))
-
-            return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-        }
-        private static get myPrivateStaticMethod1() {
->myPrivateStaticMethod1 : Symbol(publicClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 454, 9))
-
-            return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-        }
-        get myPublicMethod1() {
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 457, 9))
-
-            return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-        }
-        private get myPrivateMethod1() {
->myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 460, 9))
-
-            return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-        }
-    }
-
-    class privateClassWithWithPrivateGetAccessorTypes {
->privateClassWithWithPrivateGetAccessorTypes : Symbol(privateClassWithWithPrivateGetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 464, 5))
-
-        static get myPublicStaticMethod(): privateClass {
->myPublicStaticMethod : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 466, 55))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
-
-            return null;
-        }
-        private static get myPrivateStaticMethod(): privateClass {
->myPrivateStaticMethod : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 469, 9))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
-
-            return null;
-        }
-        get myPublicMethod(): privateClass {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 472, 9))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
-
-            return null;
-        }
-        private get myPrivateMethod(): privateClass {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 475, 9))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
-
-            return null;
-        }
-        static get myPublicStaticMethod1() {
->myPublicStaticMethod1 : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 478, 9))
-
-            return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
-        }
-        private static get myPrivateStaticMethod1() {
->myPrivateStaticMethod1 : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 481, 9))
-
-            return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
-        }
-        get myPublicMethod1() {
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 484, 9))
-
-            return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
-        }
-        private get myPrivateMethod1() {
->myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 487, 9))
-
-            return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
-        }
-    }
-
-    class privateClassWithWithPublicGetAccessorTypes {
->privateClassWithWithPublicGetAccessorTypes : Symbol(privateClassWithWithPublicGetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 491, 5))
-
-        static get myPublicStaticMethod(): publicClass {
->myPublicStaticMethod : Symbol(privateClassWithWithPublicGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 493, 54))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-
-            return null;
-        }
-        private static get myPrivateStaticMethod(): publicClass {
->myPrivateStaticMethod : Symbol(privateClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 496, 9))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-
-            return null;
-        }
-        get myPublicMethod(): publicClass {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 499, 9))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-
-            return null;
-        }
-        private get myPrivateMethod(): publicClass {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 502, 9))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-
-            return null;
-        }
-        static get myPublicStaticMethod1() {
->myPublicStaticMethod1 : Symbol(privateClassWithWithPublicGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 505, 9))
-
-            return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-        }
-        private static get myPrivateStaticMethod1() {
->myPrivateStaticMethod1 : Symbol(privateClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 508, 9))
-
-            return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-        }
-        get myPublicMethod1() {
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 511, 9))
-
-            return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-        }
-        private get myPrivateMethod1() {
->myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 514, 9))
-
-            return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-        }
-    }
-
-    export class publicClassWithWithPrivateSetAccessorTypes {
->publicClassWithWithPrivateSetAccessorTypes : Symbol(publicClassWithWithPrivateSetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 518, 5))
-
-        static set myPublicStaticMethod(param: privateClass) { 
->myPublicStaticMethod : Symbol(publicClassWithWithPrivateSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 520, 61))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 521, 40))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
-        }
-        private static set myPrivateStaticMethod(param: privateClass) {
->myPrivateStaticMethod : Symbol(publicClassWithWithPrivateSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 522, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 523, 49))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
-        }
-        set myPublicMethod(param: privateClass) { 
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 524, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 525, 27))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
-        }
-        private set myPrivateMethod(param: privateClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 526, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 527, 36))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
-        }
-    }
-
-    export class publicClassWithWithPublicSetAccessorTypes {
->publicClassWithWithPublicSetAccessorTypes : Symbol(publicClassWithWithPublicSetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 529, 5))
-
-        static set myPublicStaticMethod(param: publicClass) {
->myPublicStaticMethod : Symbol(publicClassWithWithPublicSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 531, 60))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 532, 40))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-        }
-        private static set myPrivateStaticMethod(param: publicClass) {
->myPrivateStaticMethod : Symbol(publicClassWithWithPublicSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 533, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 534, 49))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-        }
-        set myPublicMethod(param: publicClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 535, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 536, 27))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-        }
-        private set myPrivateMethod(param: publicClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 537, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 538, 36))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-        }
-    }
-
-    class privateClassWithWithPrivateSetAccessorTypes {
->privateClassWithWithPrivateSetAccessorTypes : Symbol(privateClassWithWithPrivateSetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 540, 5))
-
-        static set myPublicStaticMethod(param: privateClass) {
->myPublicStaticMethod : Symbol(privateClassWithWithPrivateSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 542, 55))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 543, 40))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
-        }
-        private static set myPrivateStaticMethod(param: privateClass) {
->myPrivateStaticMethod : Symbol(privateClassWithWithPrivateSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 544, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 545, 49))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
-        }
-        set myPublicMethod(param: privateClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 546, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 547, 27))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
-        }
-        private set myPrivateMethod(param: privateClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 548, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 549, 36))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_externalModule.ts, 406, 22))
-        }
-    }
-
-    class privateClassWithWithPublicSetAccessorTypes {
->privateClassWithWithPublicSetAccessorTypes : Symbol(privateClassWithWithPublicSetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 551, 5))
-
-        static set myPublicStaticMethod(param: publicClass) {
->myPublicStaticMethod : Symbol(privateClassWithWithPublicSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 553, 54))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 554, 40))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-        }
-        private static set myPrivateStaticMethod(param: publicClass) {
->myPrivateStaticMethod : Symbol(privateClassWithWithPublicSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 555, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 556, 49))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-        }
-        set myPublicMethod(param: publicClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 557, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 558, 27))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-        }
-        private set myPrivateMethod(param: publicClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 559, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 560, 36))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-        }
-    }
-
-    export class publicClassWithPrivateModuleGetAccessorTypes {
->publicClassWithPrivateModuleGetAccessorTypes : Symbol(publicClassWithPrivateModuleGetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 562, 5))
-
-        static get myPublicStaticMethod(): privateModule.publicClass { 
->myPublicStaticMethod : Symbol(publicClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 564, 63))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-
-            return null;
-        }
-        get myPublicMethod(): privateModule.publicClass { 
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 567, 9))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-
-            return null;
-        }
-        static get myPublicStaticMethod1() { 
->myPublicStaticMethod1 : Symbol(publicClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 570, 9))
-
-            return new privateModule.publicClass();
->privateModule.publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-        }
-        get myPublicMethod1() { 
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 573, 9))
-
-            return new privateModule.publicClass();
->privateModule.publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-        }
-    }
-
-    export class publicClassWithPrivateModuleSetAccessorTypes {
->publicClassWithPrivateModuleSetAccessorTypes : Symbol(publicClassWithPrivateModuleSetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 577, 5))
-
-        static set myPublicStaticMethod(param: privateModule.publicClass) { 
->myPublicStaticMethod : Symbol(publicClassWithPrivateModuleSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 579, 63))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 580, 40))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-        }
-        set myPublicMethod(param: privateModule.publicClass) { 
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 581, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 582, 27))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-        }
-    }
-
-    class privateClassWithPrivateModuleGetAccessorTypes {
->privateClassWithPrivateModuleGetAccessorTypes : Symbol(privateClassWithPrivateModuleGetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 584, 5))
-
-        static get myPublicStaticMethod(): privateModule.publicClass {
->myPublicStaticMethod : Symbol(privateClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 586, 57))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-
-            return null;
-        }
-        get myPublicMethod(): privateModule.publicClass {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 589, 9))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-
-            return null;
-        }
-        static get myPublicStaticMethod1() {
->myPublicStaticMethod1 : Symbol(privateClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 592, 9))
-
-            return new privateModule.publicClass();
->privateModule.publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-        }
-        get myPublicMethod1() {
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_externalModule.ts, 595, 9))
-
-            return new privateModule.publicClass();
->privateModule.publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-        }
-    }
-
-    class privateClassWithPrivateModuleSetAccessorTypes {
->privateClassWithPrivateModuleSetAccessorTypes : Symbol(privateClassWithPrivateModuleSetAccessorTypes, Decl(privacyAccessorDeclFile_externalModule.ts, 599, 5))
-
-        static set myPublicStaticMethod(param: privateModule.publicClass) {
->myPublicStaticMethod : Symbol(privateClassWithPrivateModuleSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 601, 57))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 602, 40))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-        }
-        set myPublicMethod(param: privateModule.publicClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_externalModule.ts, 603, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_externalModule.ts, 604, 27))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_externalModule.ts, 404, 1))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_externalModule.ts, 408, 5))
-        }
-    }
-}
-
-=== tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts ===
-class publicClassInGlobal {
->publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyAccessorDeclFile_GlobalFile.ts, 0, 0))
-}
-
-class publicClassInGlobalWithPublicGetAccessorTypes {
->publicClassInGlobalWithPublicGetAccessorTypes : Symbol(publicClassInGlobalWithPublicGetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 1, 1))
-
-    static get myPublicStaticMethod(): publicClassInGlobal {
->myPublicStaticMethod : Symbol(publicClassInGlobalWithPublicGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 3, 53))
->publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyAccessorDeclFile_GlobalFile.ts, 0, 0))
-
-        return null;
-    }
-    private static get myPrivateStaticMethod(): publicClassInGlobal {
->myPrivateStaticMethod : Symbol(publicClassInGlobalWithPublicGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 6, 5))
->publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyAccessorDeclFile_GlobalFile.ts, 0, 0))
-
-        return null;
-    }
-    get myPublicMethod(): publicClassInGlobal {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 9, 5))
->publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyAccessorDeclFile_GlobalFile.ts, 0, 0))
-
-        return null;
-    }
-    private get myPrivateMethod(): publicClassInGlobal {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 12, 5))
->publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyAccessorDeclFile_GlobalFile.ts, 0, 0))
-
-        return null;
-    }
-    static get myPublicStaticMethod1() {
->myPublicStaticMethod1 : Symbol(publicClassInGlobalWithPublicGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 15, 5))
-
-        return new publicClassInGlobal();
->publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyAccessorDeclFile_GlobalFile.ts, 0, 0))
-    }
-    private static get myPrivateStaticMethod1() {
->myPrivateStaticMethod1 : Symbol(publicClassInGlobalWithPublicGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 18, 5))
-
-        return new publicClassInGlobal();
->publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyAccessorDeclFile_GlobalFile.ts, 0, 0))
-    }
-    get myPublicMethod1() {
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 21, 5))
-
-        return new publicClassInGlobal();
->publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyAccessorDeclFile_GlobalFile.ts, 0, 0))
-    }
-    private get myPrivateMethod1() {
->myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 24, 5))
-
-        return new publicClassInGlobal();
->publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyAccessorDeclFile_GlobalFile.ts, 0, 0))
-    }
-}
-
-class publicClassInGlobalWithWithPublicSetAccessorTypes {
->publicClassInGlobalWithWithPublicSetAccessorTypes : Symbol(publicClassInGlobalWithWithPublicSetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 28, 1))
-
-    static set myPublicStaticMethod(param: publicClassInGlobal) {
->myPublicStaticMethod : Symbol(publicClassInGlobalWithWithPublicSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 30, 57))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 31, 36))
->publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyAccessorDeclFile_GlobalFile.ts, 0, 0))
-    }
-    private static set myPrivateStaticMethod(param: publicClassInGlobal) {
->myPrivateStaticMethod : Symbol(publicClassInGlobalWithWithPublicSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 32, 5))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 33, 45))
->publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyAccessorDeclFile_GlobalFile.ts, 0, 0))
-    }
-    set myPublicMethod(param: publicClassInGlobal) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 34, 5))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 35, 23))
->publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyAccessorDeclFile_GlobalFile.ts, 0, 0))
-    }
-    private set myPrivateMethod(param: publicClassInGlobal) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 36, 5))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 37, 32))
->publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyAccessorDeclFile_GlobalFile.ts, 0, 0))
-    }
-}
-
-module publicModuleInGlobal {
->publicModuleInGlobal : Symbol(publicModuleInGlobal, Decl(privacyAccessorDeclFile_GlobalFile.ts, 39, 1))
-
-    class privateClass {
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
-    }
-
-    export class publicClass {
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
-    }
-
-    module privateModule {
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
-
-        class privateClass {
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
-        }
-
-        export class publicClass {
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-        }
-        export class publicClassWithWithPrivateGetAccessorTypes {
->publicClassWithWithPrivateGetAccessorTypes : Symbol(publicClassWithWithPrivateGetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 53, 9))
-
-            static get myPublicStaticMethod(): privateClass {
->myPublicStaticMethod : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 54, 65))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
-
-                return null;
-            }
-            private static get myPrivateStaticMethod(): privateClass {
->myPrivateStaticMethod : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 57, 13))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
-
-                return null;
-            }
-            get myPublicMethod(): privateClass {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 60, 13))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
-
-                return null;
-            }
-            private get myPrivateMethod(): privateClass {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 63, 13))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
-
-                return null;
-            }
-            static get myPublicStaticMethod1() {
->myPublicStaticMethod1 : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 66, 13))
-
-                return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
-            }
-            private static get myPrivateStaticMethod1() {
->myPrivateStaticMethod1 : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 69, 13))
-
-                return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
-            }
-            get myPublicMethod1() {
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 72, 13))
-
-                return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
-            }
-            private get myPrivateMethod1() {
->myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 75, 13))
-
-                return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
-            }
-        }
-
-        export class publicClassWithWithPublicGetAccessorTypes {
->publicClassWithWithPublicGetAccessorTypes : Symbol(publicClassWithWithPublicGetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 79, 9))
-
-            static get myPublicStaticMethod(): publicClass {
->myPublicStaticMethod : Symbol(publicClassWithWithPublicGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 81, 64))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-
-                return null;
-            }
-            private static get myPrivateStaticMethod(): publicClass {
->myPrivateStaticMethod : Symbol(publicClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 84, 13))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-
-                return null;
-            }
-            get myPublicMethod(): publicClass {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 87, 13))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-
-                return null;
-            }
-            private get myPrivateMethod(): publicClass {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 90, 13))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-
-                return null;
-            }
-            static get myPublicStaticMethod1() {
->myPublicStaticMethod1 : Symbol(publicClassWithWithPublicGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 93, 13))
-
-                return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-            }
-            private static get myPrivateStaticMethod1() {
->myPrivateStaticMethod1 : Symbol(publicClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 96, 13))
-
-                return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-            }
-            get myPublicMethod1() {
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 99, 13))
-
-                return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-            }
-            private get myPrivateMethod1() {
->myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 102, 13))
-
-                return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-            }
-        }
-
-        class privateClassWithWithPrivateGetAccessorTypes {
->privateClassWithWithPrivateGetAccessorTypes : Symbol(privateClassWithWithPrivateGetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 106, 9))
-
-            static get myPublicStaticMethod(): privateClass {
->myPublicStaticMethod : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 108, 59))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
-
-                return null;
-            }
-            private static get myPrivateStaticMethod(): privateClass {
->myPrivateStaticMethod : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 111, 13))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
-
-                return null;
-            }
-            get myPublicMethod(): privateClass {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 114, 13))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
-
-                return null;
-            }
-            private get myPrivateMethod(): privateClass {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 117, 13))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
-
-                return null;
-            }
-            static get myPublicStaticMethod1() {
->myPublicStaticMethod1 : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 120, 13))
-
-                return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
-            }
-            private static get myPrivateStaticMethod1() {
->myPrivateStaticMethod1 : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 123, 13))
-
-                return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
-            }
-            get myPublicMethod1() {
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 126, 13))
-
-                return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
-            }
-            private get myPrivateMethod1() {
->myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 129, 13))
-
-                return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
-            }
-        }
-
-        class privateClassWithWithPublicGetAccessorTypes {
->privateClassWithWithPublicGetAccessorTypes : Symbol(privateClassWithWithPublicGetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 133, 9))
-
-            static get myPublicStaticMethod(): publicClass {
->myPublicStaticMethod : Symbol(privateClassWithWithPublicGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 135, 58))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-
-                return null;
-            }
-            private static get myPrivateStaticMethod(): publicClass {
->myPrivateStaticMethod : Symbol(privateClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 138, 13))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-
-                return null;
-            }
-            get myPublicMethod(): publicClass {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 141, 13))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-
-                return null;
-            }
-            private get myPrivateMethod(): publicClass {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 144, 13))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-
-                return null;
-            }
-            static get myPublicStaticMethod1() {
->myPublicStaticMethod1 : Symbol(privateClassWithWithPublicGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 147, 13))
-
-                return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-            }
-            private static get myPrivateStaticMethod1() {
->myPrivateStaticMethod1 : Symbol(privateClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 150, 13))
-
-                return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-            }
-            get myPublicMethod1() {
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 153, 13))
-
-                return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-            }
-            private get myPrivateMethod1() {
->myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 156, 13))
-
-                return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-            }
-        }
-
-        export class publicClassWithWithPrivateSetAccessorTypes {
->publicClassWithWithPrivateSetAccessorTypes : Symbol(publicClassWithWithPrivateSetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 160, 9))
-
-            static set myPublicStaticMethod(param: privateClass) {
->myPublicStaticMethod : Symbol(publicClassWithWithPrivateSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 162, 65))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 163, 44))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
-            }
-            private static set myPrivateStaticMethod(param: privateClass) {
->myPrivateStaticMethod : Symbol(publicClassWithWithPrivateSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 164, 13))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 165, 53))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
-            }
-            set myPublicMethod(param: privateClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 166, 13))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 167, 31))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
-            }
-            private set myPrivateMethod(param: privateClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 168, 13))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 169, 40))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
-            }
-        }
-
-        export class publicClassWithWithPublicSetAccessorTypes {
->publicClassWithWithPublicSetAccessorTypes : Symbol(publicClassWithWithPublicSetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 171, 9))
-
-            static set myPublicStaticMethod(param: publicClass) {
->myPublicStaticMethod : Symbol(publicClassWithWithPublicSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 173, 64))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 174, 44))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-            }
-            private static set myPrivateStaticMethod(param: publicClass) {
->myPrivateStaticMethod : Symbol(publicClassWithWithPublicSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 175, 13))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 176, 53))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-            }
-            set myPublicMethod(param: publicClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 177, 13))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 178, 31))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-            }
-            private set myPrivateMethod(param: publicClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 179, 13))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 180, 40))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-            }
-        }
-
-        class privateClassWithWithPrivateSetAccessorTypes {
->privateClassWithWithPrivateSetAccessorTypes : Symbol(privateClassWithWithPrivateSetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 182, 9))
-
-            static set myPublicStaticMethod(param: privateClass) {
->myPublicStaticMethod : Symbol(privateClassWithWithPrivateSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 184, 59))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 185, 44))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
-            }
-            private static set myPrivateStaticMethod(param: privateClass) {
->myPrivateStaticMethod : Symbol(privateClassWithWithPrivateSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 186, 13))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 187, 53))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
-            }
-            set myPublicMethod(param: privateClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 188, 13))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 189, 31))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
-            }
-            private set myPrivateMethod(param: privateClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 190, 13))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 191, 40))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 48, 26))
-            }
-        }
-
-        class privateClassWithWithPublicSetAccessorTypes {
->privateClassWithWithPublicSetAccessorTypes : Symbol(privateClassWithWithPublicSetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 193, 9))
-
-            static set myPublicStaticMethod(param: publicClass) {
->myPublicStaticMethod : Symbol(privateClassWithWithPublicSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 195, 58))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 196, 44))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-            }
-            private static set myPrivateStaticMethod(param: publicClass) {
->myPrivateStaticMethod : Symbol(privateClassWithWithPublicSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 197, 13))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 198, 53))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-            }
-            set myPublicMethod(param: publicClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 199, 13))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 200, 31))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-            }
-            private set myPrivateMethod(param: publicClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 201, 13))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 202, 40))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-            }
-        }
-
-        export class publicClassWithPrivateModuleGetAccessorTypes {
->publicClassWithPrivateModuleGetAccessorTypes : Symbol(publicClassWithPrivateModuleGetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 204, 9))
-
-            static get myPublicStaticMethod(): privateModule.publicClass {
->myPublicStaticMethod : Symbol(publicClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 206, 67))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-
-                return null;
-            }
-            get myPublicMethod(): privateModule.publicClass {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 209, 13))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-
-                return null;
-            }
-            static get myPublicStaticMethod1() {
->myPublicStaticMethod1 : Symbol(publicClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 212, 13))
-
-                return new privateModule.publicClass();
->privateModule.publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-            }
-            get myPublicMethod1() {
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 215, 13))
-
-                return new privateModule.publicClass();
->privateModule.publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-            }
-        }
-
-        export class publicClassWithPrivateModuleSetAccessorTypes {
->publicClassWithPrivateModuleSetAccessorTypes : Symbol(publicClassWithPrivateModuleSetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 219, 9))
-
-            static set myPublicStaticMethod(param: privateModule.publicClass) {
->myPublicStaticMethod : Symbol(publicClassWithPrivateModuleSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 221, 67))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 222, 44))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-            }
-            set myPublicMethod(param: privateModule.publicClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 223, 13))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 224, 31))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-            }
-        }
-
-        class privateClassWithPrivateModuleGetAccessorTypes {
->privateClassWithPrivateModuleGetAccessorTypes : Symbol(privateClassWithPrivateModuleGetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 226, 9))
-
-            static get myPublicStaticMethod(): privateModule.publicClass {
->myPublicStaticMethod : Symbol(privateClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 228, 61))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-
-                return null;
-            }
-            get myPublicMethod(): privateModule.publicClass {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 231, 13))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-
-                return null;
-            }
-            static get myPublicStaticMethod1() {
->myPublicStaticMethod1 : Symbol(privateClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 234, 13))
-
-                return new privateModule.publicClass();
->privateModule.publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-            }
-            get myPublicMethod1() {
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 237, 13))
-
-                return new privateModule.publicClass();
->privateModule.publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-            }
-        }
-
-        class privateClassWithPrivateModuleSetAccessorTypes {
->privateClassWithPrivateModuleSetAccessorTypes : Symbol(privateClassWithPrivateModuleSetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 241, 9))
-
-            static set myPublicStaticMethod(param: privateModule.publicClass) {
->myPublicStaticMethod : Symbol(privateClassWithPrivateModuleSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 243, 61))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 244, 44))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-            }
-            set myPublicMethod(param: privateModule.publicClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 245, 13))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 246, 31))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-            }
-        }
-    }
-
-    export class publicClassWithWithPrivateGetAccessorTypes {
->publicClassWithWithPrivateGetAccessorTypes : Symbol(publicClassWithWithPrivateGetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 249, 5))
-
-        static get myPublicStaticMethod(): privateClass { // Error
->myPublicStaticMethod : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 251, 61))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
-
-            return null;
-        }
-        private static get myPrivateStaticMethod(): privateClass {
->myPrivateStaticMethod : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 254, 9))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
-
-            return null;
-        }
-        get myPublicMethod(): privateClass { // Error
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 257, 9))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
-
-            return null;
-        }
-        private get myPrivateMethod(): privateClass {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 260, 9))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
-
-            return null;
-        }
-        static get myPublicStaticMethod1() { // Error
->myPublicStaticMethod1 : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 263, 9))
-
-            return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
-        }
-        private static get myPrivateStaticMethod1() {
->myPrivateStaticMethod1 : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 266, 9))
-
-            return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
-        }
-        get myPublicMethod1() { // Error
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 269, 9))
-
-            return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
-        }
-        private get myPrivateMethod1() {
->myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 272, 9))
-
-            return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
-        }
-    }
-
-    export class publicClassWithWithPublicGetAccessorTypes {
->publicClassWithWithPublicGetAccessorTypes : Symbol(publicClassWithWithPublicGetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 276, 5))
-
-        static get myPublicStaticMethod(): publicClass {
->myPublicStaticMethod : Symbol(publicClassWithWithPublicGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 278, 60))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
-
-            return null;
-        }
-        private static get myPrivateStaticMethod(): publicClass {
->myPrivateStaticMethod : Symbol(publicClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 281, 9))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
-
-            return null;
-        }
-        get myPublicMethod(): publicClass {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 284, 9))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
-
-            return null;
-        }
-        private get myPrivateMethod(): publicClass {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 287, 9))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
-
-            return null;
-        }
-        static get myPublicStaticMethod1() {
->myPublicStaticMethod1 : Symbol(publicClassWithWithPublicGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 290, 9))
-
-            return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
-        }
-        private static get myPrivateStaticMethod1() {
->myPrivateStaticMethod1 : Symbol(publicClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 293, 9))
-
-            return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
-        }
-        get myPublicMethod1() {
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 296, 9))
-
-            return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
-        }
-        private get myPrivateMethod1() {
->myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 299, 9))
-
-            return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
-        }
-    }
-
-    class privateClassWithWithPrivateGetAccessorTypes {
->privateClassWithWithPrivateGetAccessorTypes : Symbol(privateClassWithWithPrivateGetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 303, 5))
-
-        static get myPublicStaticMethod(): privateClass {
->myPublicStaticMethod : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 305, 55))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
-
-            return null;
-        }
-        private static get myPrivateStaticMethod(): privateClass {
->myPrivateStaticMethod : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 308, 9))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
-
-            return null;
-        }
-        get myPublicMethod(): privateClass {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 311, 9))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
-
-            return null;
-        }
-        private get myPrivateMethod(): privateClass {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 314, 9))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
-
-            return null;
-        }
-        static get myPublicStaticMethod1() {
->myPublicStaticMethod1 : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 317, 9))
-
-            return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
-        }
-        private static get myPrivateStaticMethod1() {
->myPrivateStaticMethod1 : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 320, 9))
-
-            return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
-        }
-        get myPublicMethod1() {
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 323, 9))
-
-            return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
-        }
-        private get myPrivateMethod1() {
->myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 326, 9))
-
-            return new privateClass();
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
-        }
-    }
-
-    class privateClassWithWithPublicGetAccessorTypes {
->privateClassWithWithPublicGetAccessorTypes : Symbol(privateClassWithWithPublicGetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 330, 5))
-
-        static get myPublicStaticMethod(): publicClass {
->myPublicStaticMethod : Symbol(privateClassWithWithPublicGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 332, 54))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
-
-            return null;
-        }
-        private static get myPrivateStaticMethod(): publicClass {
->myPrivateStaticMethod : Symbol(privateClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 335, 9))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
-
-            return null;
-        }
-        get myPublicMethod(): publicClass {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 338, 9))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
-
-            return null;
-        }
-        private get myPrivateMethod(): publicClass {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 341, 9))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
-
-            return null;
-        }
-        static get myPublicStaticMethod1() {
->myPublicStaticMethod1 : Symbol(privateClassWithWithPublicGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 344, 9))
-
-            return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
-        }
-        private static get myPrivateStaticMethod1() {
->myPrivateStaticMethod1 : Symbol(privateClassWithWithPublicGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 347, 9))
-
-            return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
-        }
-        get myPublicMethod1() {
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 350, 9))
-
-            return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
-        }
-        private get myPrivateMethod1() {
->myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 353, 9))
-
-            return new publicClass();
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
-        }
-    }
-
-    export class publicClassWithWithPrivateSetAccessorTypes {
->publicClassWithWithPrivateSetAccessorTypes : Symbol(publicClassWithWithPrivateSetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 357, 5))
-
-        static set myPublicStaticMethod(param: privateClass) { // Error
->myPublicStaticMethod : Symbol(publicClassWithWithPrivateSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 359, 61))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 360, 40))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
-        }
-        private static set myPrivateStaticMethod(param: privateClass) {
->myPrivateStaticMethod : Symbol(publicClassWithWithPrivateSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 361, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 362, 49))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
-        }
-        set myPublicMethod(param: privateClass) { // Error
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 363, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 364, 27))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
-        }
-        private set myPrivateMethod(param: privateClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 365, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 366, 36))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
-        }
-    }
-
-    export class publicClassWithWithPublicSetAccessorTypes {
->publicClassWithWithPublicSetAccessorTypes : Symbol(publicClassWithWithPublicSetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 368, 5))
-
-        static set myPublicStaticMethod(param: publicClass) {
->myPublicStaticMethod : Symbol(publicClassWithWithPublicSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 370, 60))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 371, 40))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
-        }
-        private static set myPrivateStaticMethod(param: publicClass) {
->myPrivateStaticMethod : Symbol(publicClassWithWithPublicSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 372, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 373, 49))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
-        }
-        set myPublicMethod(param: publicClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 374, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 375, 27))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
-        }
-        private set myPrivateMethod(param: publicClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 376, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 377, 36))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
-        }
-    }
-
-    class privateClassWithWithPrivateSetAccessorTypes {
->privateClassWithWithPrivateSetAccessorTypes : Symbol(privateClassWithWithPrivateSetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 379, 5))
-
-        static set myPublicStaticMethod(param: privateClass) {
->myPublicStaticMethod : Symbol(privateClassWithWithPrivateSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 381, 55))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 382, 40))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
-        }
-        private static set myPrivateStaticMethod(param: privateClass) {
->myPrivateStaticMethod : Symbol(privateClassWithWithPrivateSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 383, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 384, 49))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
-        }
-        set myPublicMethod(param: privateClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 385, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 386, 27))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
-        }
-        private set myPrivateMethod(param: privateClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 387, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 388, 36))
->privateClass : Symbol(privateClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 41, 29))
-        }
-    }
-
-    class privateClassWithWithPublicSetAccessorTypes {
->privateClassWithWithPublicSetAccessorTypes : Symbol(privateClassWithWithPublicSetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 390, 5))
-
-        static set myPublicStaticMethod(param: publicClass) {
->myPublicStaticMethod : Symbol(privateClassWithWithPublicSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 392, 54))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 393, 40))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
-        }
-        private static set myPrivateStaticMethod(param: publicClass) {
->myPrivateStaticMethod : Symbol(privateClassWithWithPublicSetAccessorTypes.myPrivateStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 394, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 395, 49))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
-        }
-        set myPublicMethod(param: publicClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 396, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 397, 27))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
-        }
-        private set myPrivateMethod(param: publicClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 398, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 399, 36))
->publicClass : Symbol(publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 43, 5))
-        }
-    }
-
-    export class publicClassWithPrivateModuleGetAccessorTypes {
->publicClassWithPrivateModuleGetAccessorTypes : Symbol(publicClassWithPrivateModuleGetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 401, 5))
-
-        static get myPublicStaticMethod(): privateModule.publicClass { // Error
->myPublicStaticMethod : Symbol(publicClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 403, 63))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-
-            return null;
-        }
-        get myPublicMethod(): privateModule.publicClass { // Error
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 406, 9))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-
-            return null;
-        }
-        static get myPublicStaticMethod1() { // Error
->myPublicStaticMethod1 : Symbol(publicClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 409, 9))
-
-            return new privateModule.publicClass();
->privateModule.publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-        }
-        get myPublicMethod1() { // Error
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 412, 9))
-
-            return new privateModule.publicClass();
->privateModule.publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-        }
-    }
-
-    export class publicClassWithPrivateModuleSetAccessorTypes {
->publicClassWithPrivateModuleSetAccessorTypes : Symbol(publicClassWithPrivateModuleSetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 416, 5))
-
-        static set myPublicStaticMethod(param: privateModule.publicClass) { // Error
->myPublicStaticMethod : Symbol(publicClassWithPrivateModuleSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 418, 63))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 419, 40))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-        }
-        set myPublicMethod(param: privateModule.publicClass) { // Error
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 420, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 421, 27))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-        }
-    }
-
-    class privateClassWithPrivateModuleGetAccessorTypes {
->privateClassWithPrivateModuleGetAccessorTypes : Symbol(privateClassWithPrivateModuleGetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 423, 5))
-
-        static get myPublicStaticMethod(): privateModule.publicClass {
->myPublicStaticMethod : Symbol(privateClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 425, 57))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-
-            return null;
-        }
-        get myPublicMethod(): privateModule.publicClass {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 428, 9))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-
-            return null;
-        }
-        static get myPublicStaticMethod1() {
->myPublicStaticMethod1 : Symbol(privateClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 431, 9))
-
-            return new privateModule.publicClass();
->privateModule.publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-        }
-        get myPublicMethod1() {
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyAccessorDeclFile_GlobalFile.ts, 434, 9))
-
-            return new privateModule.publicClass();
->privateModule.publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-        }
-    }
-
-    class privateClassWithPrivateModuleSetAccessorTypes {
->privateClassWithPrivateModuleSetAccessorTypes : Symbol(privateClassWithPrivateModuleSetAccessorTypes, Decl(privacyAccessorDeclFile_GlobalFile.ts, 438, 5))
-
-        static set myPublicStaticMethod(param: privateModule.publicClass) {
->myPublicStaticMethod : Symbol(privateClassWithPrivateModuleSetAccessorTypes.myPublicStaticMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 440, 57))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 441, 40))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-        }
-        set myPublicMethod(param: privateModule.publicClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyAccessorDeclFile_GlobalFile.ts, 442, 9))
->param : Symbol(param, Decl(privacyAccessorDeclFile_GlobalFile.ts, 443, 27))
->privateModule : Symbol(privateModule, Decl(privacyAccessorDeclFile_GlobalFile.ts, 46, 5))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyAccessorDeclFile_GlobalFile.ts, 50, 9))
-        }
-    }
-}
diff --git a/tests/baselines/reference/privacyCheckAnonymousFunctionParameter.symbols b/tests/baselines/reference/privacyCheckAnonymousFunctionParameter.symbols
index e2dcf58c5266f..38415655b1e19 100644
--- a/tests/baselines/reference/privacyCheckAnonymousFunctionParameter.symbols
+++ b/tests/baselines/reference/privacyCheckAnonymousFunctionParameter.symbols
@@ -28,7 +28,6 @@ module Query {
 
         return fromDoWhile(test => {
 >fromDoWhile : Symbol(fromDoWhile, Decl(privacyCheckAnonymousFunctionParameter.ts, 4, 14))
->test => {            return true;        } : Symbol((Anonymous function), Decl(privacyCheckAnonymousFunctionParameter.ts, 10, 27))
 >test : Symbol(test, Decl(privacyCheckAnonymousFunctionParameter.ts, 10, 27))
 
             return true;
diff --git a/tests/baselines/reference/privacyClassExtendsClauseDeclFile.symbols b/tests/baselines/reference/privacyClassExtendsClauseDeclFile.symbols
deleted file mode 100644
index e59fda3751921..0000000000000
--- a/tests/baselines/reference/privacyClassExtendsClauseDeclFile.symbols
+++ /dev/null
@@ -1,177 +0,0 @@
-=== tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts ===
-
-export module publicModule {
->publicModule : Symbol(publicModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 0, 0))
-
-    export class publicClassInPublicModule {
->publicClassInPublicModule : Symbol(publicClassInPublicModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 1, 28))
-
-        private f1() {
->f1 : Symbol(f1, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 2, 44))
-        }
-    }
-
-    class privateClassInPublicModule {
->privateClassInPublicModule : Symbol(privateClassInPublicModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 5, 5))
-    }
-
-    class privateClassExtendingPublicClassInModule extends publicClassInPublicModule {
->privateClassExtendingPublicClassInModule : Symbol(privateClassExtendingPublicClassInModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 8, 5))
->publicClassInPublicModule : Symbol(publicClassInPublicModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 1, 28))
-    }
-    class privateClassExtendingPrivateClassInModule extends privateClassInPublicModule {
->privateClassExtendingPrivateClassInModule : Symbol(privateClassExtendingPrivateClassInModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 11, 5))
->privateClassInPublicModule : Symbol(privateClassInPublicModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 5, 5))
-    }
-    export class publicClassExtendingPublicClassInModule extends publicClassInPublicModule {
->publicClassExtendingPublicClassInModule : Symbol(publicClassExtendingPublicClassInModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 13, 5))
->publicClassInPublicModule : Symbol(publicClassInPublicModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 1, 28))
-    }
-    export class publicClassExtendingPrivateClassInModule extends privateClassInPublicModule { // Should error
->publicClassExtendingPrivateClassInModule : Symbol(publicClassExtendingPrivateClassInModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 15, 5))
->privateClassInPublicModule : Symbol(privateClassInPublicModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 5, 5))
-    }
-
-    class privateClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule {
->privateClassExtendingFromPrivateModuleClass : Symbol(privateClassExtendingFromPrivateModuleClass, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 17, 5))
->privateModule.publicClassInPrivateModule : Symbol(privateModule.publicClassInPrivateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 25, 22))
->privateModule : Symbol(privateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 23, 1))
->publicClassInPrivateModule : Symbol(privateModule.publicClassInPrivateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 25, 22))
-    }
-    export class publicClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule { // Should error
->publicClassExtendingFromPrivateModuleClass : Symbol(publicClassExtendingFromPrivateModuleClass, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 20, 5))
->privateModule.publicClassInPrivateModule : Symbol(privateModule.publicClassInPrivateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 25, 22))
->privateModule : Symbol(privateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 23, 1))
->publicClassInPrivateModule : Symbol(privateModule.publicClassInPrivateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 25, 22))
-    }
-}
-
-module privateModule {
->privateModule : Symbol(privateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 23, 1))
-
-    export class publicClassInPrivateModule {
->publicClassInPrivateModule : Symbol(publicClassInPrivateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 25, 22))
-
-        private f1() {
->f1 : Symbol(f1, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 26, 45))
-        }
-    }
-
-    class privateClassInPrivateModule {
->privateClassInPrivateModule : Symbol(privateClassInPrivateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 29, 5))
-    }
-
-    class privateClassExtendingPublicClassInModule extends publicClassInPrivateModule {
->privateClassExtendingPublicClassInModule : Symbol(privateClassExtendingPublicClassInModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 32, 5))
->publicClassInPrivateModule : Symbol(publicClassInPrivateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 25, 22))
-    }
-    class privateClassExtendingPrivateClassInModule extends privateClassInPrivateModule {
->privateClassExtendingPrivateClassInModule : Symbol(privateClassExtendingPrivateClassInModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 35, 5))
->privateClassInPrivateModule : Symbol(privateClassInPrivateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 29, 5))
-    }
-    export class publicClassExtendingPublicClassInModule extends publicClassInPrivateModule {
->publicClassExtendingPublicClassInModule : Symbol(publicClassExtendingPublicClassInModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 37, 5))
->publicClassInPrivateModule : Symbol(publicClassInPrivateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 25, 22))
-    }
-    export class publicClassExtendingPrivateClassInModule extends privateClassInPrivateModule { 
->publicClassExtendingPrivateClassInModule : Symbol(publicClassExtendingPrivateClassInModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 39, 5))
->privateClassInPrivateModule : Symbol(privateClassInPrivateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 29, 5))
-    }
-
-    class privateClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule {
->privateClassExtendingFromPrivateModuleClass : Symbol(privateClassExtendingFromPrivateModuleClass, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 41, 5))
->privateModule.publicClassInPrivateModule : Symbol(publicClassInPrivateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 25, 22))
->privateModule : Symbol(privateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 23, 1))
->publicClassInPrivateModule : Symbol(publicClassInPrivateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 25, 22))
-    }
-    export class publicClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule {
->publicClassExtendingFromPrivateModuleClass : Symbol(publicClassExtendingFromPrivateModuleClass, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 44, 5))
->privateModule.publicClassInPrivateModule : Symbol(publicClassInPrivateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 25, 22))
->privateModule : Symbol(privateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 23, 1))
->publicClassInPrivateModule : Symbol(publicClassInPrivateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 25, 22))
-    }
-}
-
-export class publicClass {
->publicClass : Symbol(publicClass, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 47, 1))
-
-    private f1() {
->f1 : Symbol(f1, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 49, 26))
-    }
-}
-
-class privateClass {
->privateClass : Symbol(privateClass, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 52, 1))
-}
-
-class privateClassExtendingPublicClass extends publicClass {
->privateClassExtendingPublicClass : Symbol(privateClassExtendingPublicClass, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 55, 1))
->publicClass : Symbol(publicClass, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 47, 1))
-}
-class privateClassExtendingPrivateClassInModule extends privateClass {
->privateClassExtendingPrivateClassInModule : Symbol(privateClassExtendingPrivateClassInModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 58, 1))
->privateClass : Symbol(privateClass, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 52, 1))
-}
-export class publicClassExtendingPublicClass extends publicClass {
->publicClassExtendingPublicClass : Symbol(publicClassExtendingPublicClass, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 60, 1))
->publicClass : Symbol(publicClass, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 47, 1))
-}
-export class publicClassExtendingPrivateClass extends privateClass { // Should error
->publicClassExtendingPrivateClass : Symbol(publicClassExtendingPrivateClass, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 62, 1))
->privateClass : Symbol(privateClass, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 52, 1))
-}
-
-class privateClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule {
->privateClassExtendingFromPrivateModuleClass : Symbol(privateClassExtendingFromPrivateModuleClass, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 64, 1))
->privateModule.publicClassInPrivateModule : Symbol(privateModule.publicClassInPrivateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 25, 22))
->privateModule : Symbol(privateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 23, 1))
->publicClassInPrivateModule : Symbol(privateModule.publicClassInPrivateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 25, 22))
-}
-export class publicClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule { // Should error
->publicClassExtendingFromPrivateModuleClass : Symbol(publicClassExtendingFromPrivateModuleClass, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 67, 1))
->privateModule.publicClassInPrivateModule : Symbol(privateModule.publicClassInPrivateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 25, 22))
->privateModule : Symbol(privateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 23, 1))
->publicClassInPrivateModule : Symbol(privateModule.publicClassInPrivateModule, Decl(privacyClassExtendsClauseDeclFile_externalModule.ts, 25, 22))
-}
-
-=== tests/cases/compiler/privacyClassExtendsClauseDeclFile_GlobalFile.ts ===
-module publicModuleInGlobal {
->publicModuleInGlobal : Symbol(publicModuleInGlobal, Decl(privacyClassExtendsClauseDeclFile_GlobalFile.ts, 0, 0))
-
-    export class publicClassInPublicModule {
->publicClassInPublicModule : Symbol(publicClassInPublicModule, Decl(privacyClassExtendsClauseDeclFile_GlobalFile.ts, 0, 29))
-
-        private f1() {
->f1 : Symbol(f1, Decl(privacyClassExtendsClauseDeclFile_GlobalFile.ts, 1, 44))
-        }
-    }
-
-    class privateClassInPublicModule {
->privateClassInPublicModule : Symbol(privateClassInPublicModule, Decl(privacyClassExtendsClauseDeclFile_GlobalFile.ts, 4, 5))
-    }
-
-    class privateClassExtendingPublicClassInModule extends publicClassInPublicModule {
->privateClassExtendingPublicClassInModule : Symbol(privateClassExtendingPublicClassInModule, Decl(privacyClassExtendsClauseDeclFile_GlobalFile.ts, 7, 5))
->publicClassInPublicModule : Symbol(publicClassInPublicModule, Decl(privacyClassExtendsClauseDeclFile_GlobalFile.ts, 0, 29))
-    }
-    class privateClassExtendingPrivateClassInModule extends privateClassInPublicModule {
->privateClassExtendingPrivateClassInModule : Symbol(privateClassExtendingPrivateClassInModule, Decl(privacyClassExtendsClauseDeclFile_GlobalFile.ts, 10, 5))
->privateClassInPublicModule : Symbol(privateClassInPublicModule, Decl(privacyClassExtendsClauseDeclFile_GlobalFile.ts, 4, 5))
-    }
-    export class publicClassExtendingPublicClassInModule extends publicClassInPublicModule {
->publicClassExtendingPublicClassInModule : Symbol(publicClassExtendingPublicClassInModule, Decl(privacyClassExtendsClauseDeclFile_GlobalFile.ts, 12, 5))
->publicClassInPublicModule : Symbol(publicClassInPublicModule, Decl(privacyClassExtendsClauseDeclFile_GlobalFile.ts, 0, 29))
-    }
-    export class publicClassExtendingPrivateClassInModule extends privateClassInPublicModule { // Should error
->publicClassExtendingPrivateClassInModule : Symbol(publicClassExtendingPrivateClassInModule, Decl(privacyClassExtendsClauseDeclFile_GlobalFile.ts, 14, 5))
->privateClassInPublicModule : Symbol(privateClassInPublicModule, Decl(privacyClassExtendsClauseDeclFile_GlobalFile.ts, 4, 5))
-    }
-}
-class publicClassInGlobal {
->publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyClassExtendsClauseDeclFile_GlobalFile.ts, 17, 1))
-}
-class publicClassExtendingPublicClassInGlobal extends publicClassInGlobal {
->publicClassExtendingPublicClassInGlobal : Symbol(publicClassExtendingPublicClassInGlobal, Decl(privacyClassExtendsClauseDeclFile_GlobalFile.ts, 19, 1))
->publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyClassExtendsClauseDeclFile_GlobalFile.ts, 17, 1))
-}
-
diff --git a/tests/baselines/reference/privacyClassImplementsClauseDeclFile.symbols b/tests/baselines/reference/privacyClassImplementsClauseDeclFile.symbols
deleted file mode 100644
index 1d8dd4fec8301..0000000000000
--- a/tests/baselines/reference/privacyClassImplementsClauseDeclFile.symbols
+++ /dev/null
@@ -1,169 +0,0 @@
-=== tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts ===
-
-export module publicModule {
->publicModule : Symbol(publicModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 0, 0))
-
-    export interface publicInterfaceInPublicModule {
->publicInterfaceInPublicModule : Symbol(publicInterfaceInPublicModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 1, 28))
-    }
-
-    interface privateInterfaceInPublicModule {
->privateInterfaceInPublicModule : Symbol(privateInterfaceInPublicModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 3, 5))
-    }
-
-    class privateClassImplementingPublicInterfaceInModule implements publicInterfaceInPublicModule {
->privateClassImplementingPublicInterfaceInModule : Symbol(privateClassImplementingPublicInterfaceInModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 6, 5))
->publicInterfaceInPublicModule : Symbol(publicInterfaceInPublicModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 1, 28))
-    }
-    class privateClassImplementingPrivateInterfaceInModule implements privateInterfaceInPublicModule {
->privateClassImplementingPrivateInterfaceInModule : Symbol(privateClassImplementingPrivateInterfaceInModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 9, 5))
->privateInterfaceInPublicModule : Symbol(privateInterfaceInPublicModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 3, 5))
-    }
-    export class publicClassImplementingPublicInterfaceInModule implements publicInterfaceInPublicModule {
->publicClassImplementingPublicInterfaceInModule : Symbol(publicClassImplementingPublicInterfaceInModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 11, 5))
->publicInterfaceInPublicModule : Symbol(publicInterfaceInPublicModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 1, 28))
-    }
-    export class publicClassImplementingPrivateInterfaceInModule implements privateInterfaceInPublicModule { // Should error
->publicClassImplementingPrivateInterfaceInModule : Symbol(publicClassImplementingPrivateInterfaceInModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 13, 5))
->privateInterfaceInPublicModule : Symbol(privateInterfaceInPublicModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 3, 5))
-    }
-
-    class privateClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule {
->privateClassImplementingFromPrivateModuleInterface : Symbol(privateClassImplementingFromPrivateModuleInterface, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 15, 5))
->privateModule.publicInterfaceInPrivateModule : Symbol(privateModule.publicInterfaceInPrivateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 26, 22))
->privateModule : Symbol(privateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 24, 1))
->publicInterfaceInPrivateModule : Symbol(privateModule.publicInterfaceInPrivateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 26, 22))
-    }
-    export class publicClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule { // Should error
->publicClassImplementingFromPrivateModuleInterface : Symbol(publicClassImplementingFromPrivateModuleInterface, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 18, 5))
->privateModule.publicInterfaceInPrivateModule : Symbol(privateModule.publicInterfaceInPrivateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 26, 22))
->privateModule : Symbol(privateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 24, 1))
->publicInterfaceInPrivateModule : Symbol(privateModule.publicInterfaceInPrivateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 26, 22))
-    }
-
-    export class publicClassImplementingPrivateAndPublicInterface implements privateInterfaceInPublicModule, publicInterfaceInPublicModule { // Should error
->publicClassImplementingPrivateAndPublicInterface : Symbol(publicClassImplementingPrivateAndPublicInterface, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 20, 5))
->privateInterfaceInPublicModule : Symbol(privateInterfaceInPublicModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 3, 5))
->publicInterfaceInPublicModule : Symbol(publicInterfaceInPublicModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 1, 28))
-    }
-}
-
-module privateModule {
->privateModule : Symbol(privateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 24, 1))
-
-    export interface publicInterfaceInPrivateModule {
->publicInterfaceInPrivateModule : Symbol(publicInterfaceInPrivateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 26, 22))
-
-    }
-
-    interface privateInterfaceInPrivateModule {
->privateInterfaceInPrivateModule : Symbol(privateInterfaceInPrivateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 29, 5))
-    }
-
-    class privateClassImplementingPublicInterfaceInModule implements publicInterfaceInPrivateModule {
->privateClassImplementingPublicInterfaceInModule : Symbol(privateClassImplementingPublicInterfaceInModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 32, 5))
->publicInterfaceInPrivateModule : Symbol(publicInterfaceInPrivateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 26, 22))
-    }
-    class privateClassImplementingPrivateInterfaceInModule implements privateInterfaceInPrivateModule {
->privateClassImplementingPrivateInterfaceInModule : Symbol(privateClassImplementingPrivateInterfaceInModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 35, 5))
->privateInterfaceInPrivateModule : Symbol(privateInterfaceInPrivateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 29, 5))
-    }
-    export class publicClassImplementingPublicInterfaceInModule implements publicInterfaceInPrivateModule {
->publicClassImplementingPublicInterfaceInModule : Symbol(publicClassImplementingPublicInterfaceInModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 37, 5))
->publicInterfaceInPrivateModule : Symbol(publicInterfaceInPrivateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 26, 22))
-    }
-    export class publicClassImplementingPrivateInterfaceInModule implements privateInterfaceInPrivateModule { 
->publicClassImplementingPrivateInterfaceInModule : Symbol(publicClassImplementingPrivateInterfaceInModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 39, 5))
->privateInterfaceInPrivateModule : Symbol(privateInterfaceInPrivateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 29, 5))
-    }
-
-    class privateClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule {
->privateClassImplementingFromPrivateModuleInterface : Symbol(privateClassImplementingFromPrivateModuleInterface, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 41, 5))
->privateModule.publicInterfaceInPrivateModule : Symbol(publicInterfaceInPrivateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 26, 22))
->privateModule : Symbol(privateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 24, 1))
->publicInterfaceInPrivateModule : Symbol(publicInterfaceInPrivateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 26, 22))
-    }
-    export class publicClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule {
->publicClassImplementingFromPrivateModuleInterface : Symbol(publicClassImplementingFromPrivateModuleInterface, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 44, 5))
->privateModule.publicInterfaceInPrivateModule : Symbol(publicInterfaceInPrivateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 26, 22))
->privateModule : Symbol(privateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 24, 1))
->publicInterfaceInPrivateModule : Symbol(publicInterfaceInPrivateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 26, 22))
-    }
-}
-
-export interface publicInterface {
->publicInterface : Symbol(publicInterface, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 47, 1))
-
-}
-
-interface privateInterface {
->privateInterface : Symbol(privateInterface, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 51, 1))
-}
-
-class privateClassImplementingPublicInterface implements publicInterface {
->privateClassImplementingPublicInterface : Symbol(privateClassImplementingPublicInterface, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 54, 1))
->publicInterface : Symbol(publicInterface, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 47, 1))
-}
-class privateClassImplementingPrivateInterfaceInModule implements privateInterface {
->privateClassImplementingPrivateInterfaceInModule : Symbol(privateClassImplementingPrivateInterfaceInModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 57, 1))
->privateInterface : Symbol(privateInterface, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 51, 1))
-}
-export class publicClassImplementingPublicInterface implements publicInterface {
->publicClassImplementingPublicInterface : Symbol(publicClassImplementingPublicInterface, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 59, 1))
->publicInterface : Symbol(publicInterface, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 47, 1))
-}
-export class publicClassImplementingPrivateInterface implements privateInterface { // Should error
->publicClassImplementingPrivateInterface : Symbol(publicClassImplementingPrivateInterface, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 61, 1))
->privateInterface : Symbol(privateInterface, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 51, 1))
-}
-
-class privateClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule {
->privateClassImplementingFromPrivateModuleInterface : Symbol(privateClassImplementingFromPrivateModuleInterface, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 63, 1))
->privateModule.publicInterfaceInPrivateModule : Symbol(privateModule.publicInterfaceInPrivateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 26, 22))
->privateModule : Symbol(privateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 24, 1))
->publicInterfaceInPrivateModule : Symbol(privateModule.publicInterfaceInPrivateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 26, 22))
-}
-export class publicClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule { // Should error
->publicClassImplementingFromPrivateModuleInterface : Symbol(publicClassImplementingFromPrivateModuleInterface, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 66, 1))
->privateModule.publicInterfaceInPrivateModule : Symbol(privateModule.publicInterfaceInPrivateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 26, 22))
->privateModule : Symbol(privateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 24, 1))
->publicInterfaceInPrivateModule : Symbol(privateModule.publicInterfaceInPrivateModule, Decl(privacyClassImplementsClauseDeclFile_externalModule.ts, 26, 22))
-}
-
-=== tests/cases/compiler/privacyClassImplementsClauseDeclFile_GlobalFile.ts ===
-module publicModuleInGlobal {
->publicModuleInGlobal : Symbol(publicModuleInGlobal, Decl(privacyClassImplementsClauseDeclFile_GlobalFile.ts, 0, 0))
-
-    export interface publicInterfaceInPublicModule {
->publicInterfaceInPublicModule : Symbol(publicInterfaceInPublicModule, Decl(privacyClassImplementsClauseDeclFile_GlobalFile.ts, 0, 29))
-    }
-
-    interface privateInterfaceInPublicModule {
->privateInterfaceInPublicModule : Symbol(privateInterfaceInPublicModule, Decl(privacyClassImplementsClauseDeclFile_GlobalFile.ts, 2, 5))
-    }
-
-    class privateClassImplementingPublicInterfaceInModule implements publicInterfaceInPublicModule {
->privateClassImplementingPublicInterfaceInModule : Symbol(privateClassImplementingPublicInterfaceInModule, Decl(privacyClassImplementsClauseDeclFile_GlobalFile.ts, 5, 5))
->publicInterfaceInPublicModule : Symbol(publicInterfaceInPublicModule, Decl(privacyClassImplementsClauseDeclFile_GlobalFile.ts, 0, 29))
-    }
-    class privateClassImplementingPrivateInterfaceInModule implements privateInterfaceInPublicModule {
->privateClassImplementingPrivateInterfaceInModule : Symbol(privateClassImplementingPrivateInterfaceInModule, Decl(privacyClassImplementsClauseDeclFile_GlobalFile.ts, 8, 5))
->privateInterfaceInPublicModule : Symbol(privateInterfaceInPublicModule, Decl(privacyClassImplementsClauseDeclFile_GlobalFile.ts, 2, 5))
-    }
-    export class publicClassImplementingPublicInterfaceInModule implements publicInterfaceInPublicModule {
->publicClassImplementingPublicInterfaceInModule : Symbol(publicClassImplementingPublicInterfaceInModule, Decl(privacyClassImplementsClauseDeclFile_GlobalFile.ts, 10, 5))
->publicInterfaceInPublicModule : Symbol(publicInterfaceInPublicModule, Decl(privacyClassImplementsClauseDeclFile_GlobalFile.ts, 0, 29))
-    }
-    export class publicClassImplementingPrivateInterfaceInModule implements privateInterfaceInPublicModule { // Should error
->publicClassImplementingPrivateInterfaceInModule : Symbol(publicClassImplementingPrivateInterfaceInModule, Decl(privacyClassImplementsClauseDeclFile_GlobalFile.ts, 12, 5))
->privateInterfaceInPublicModule : Symbol(privateInterfaceInPublicModule, Decl(privacyClassImplementsClauseDeclFile_GlobalFile.ts, 2, 5))
-    }
-}
-interface publicInterfaceInGlobal {
->publicInterfaceInGlobal : Symbol(publicInterfaceInGlobal, Decl(privacyClassImplementsClauseDeclFile_GlobalFile.ts, 15, 1))
-}
-class publicClassImplementingPublicInterfaceInGlobal implements publicInterfaceInGlobal {
->publicClassImplementingPublicInterfaceInGlobal : Symbol(publicClassImplementingPublicInterfaceInGlobal, Decl(privacyClassImplementsClauseDeclFile_GlobalFile.ts, 17, 1))
->publicInterfaceInGlobal : Symbol(publicInterfaceInGlobal, Decl(privacyClassImplementsClauseDeclFile_GlobalFile.ts, 15, 1))
-}
-
diff --git a/tests/baselines/reference/privacyFunctionParameterDeclFile.symbols b/tests/baselines/reference/privacyFunctionParameterDeclFile.symbols
deleted file mode 100644
index 21373545d2a2a..0000000000000
--- a/tests/baselines/reference/privacyFunctionParameterDeclFile.symbols
+++ /dev/null
@@ -1,1968 +0,0 @@
-=== tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts ===
-
-class privateClass {
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
-}
-
-export class publicClass {
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
-}
-
-export interface publicInterfaceWithPrivateParmeterTypes {
->publicInterfaceWithPrivateParmeterTypes : Symbol(publicInterfaceWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 5, 1))
-
-    new (param: privateClass): publicClass; // Error
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 8, 9))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
-
-    (param: privateClass): publicClass; // Error
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 9, 5))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
-
-    myMethod(param: privateClass): void; // Error
->myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 9, 39))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 10, 13))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
-}
-
-export interface publicInterfaceWithPublicParmeterTypes {
->publicInterfaceWithPublicParmeterTypes : Symbol(publicInterfaceWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 11, 1))
-
-    new (param: publicClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 14, 9))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
-
-    (param: publicClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 15, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
-
-    myMethod(param: publicClass): void;
->myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 15, 38))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 16, 13))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
-}
-
-interface privateInterfaceWithPrivateParmeterTypes {
->privateInterfaceWithPrivateParmeterTypes : Symbol(privateInterfaceWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 17, 1))
-
-    new (param: privateClass): privateClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 20, 9))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
-
-    (param: privateClass): privateClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 21, 5))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
-
-    myMethod(param: privateClass): void;
->myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 21, 40))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 22, 13))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
-}
-
-interface privateInterfaceWithPublicParmeterTypes {
->privateInterfaceWithPublicParmeterTypes : Symbol(privateInterfaceWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 23, 1))
-
-    new (param: publicClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 26, 9))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
-
-    (param: publicClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 27, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
-
-    myMethod(param: publicClass): void;
->myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 27, 38))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 28, 13))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
-}
-
-export class publicClassWithWithPrivateParmeterTypes {
->publicClassWithWithPrivateParmeterTypes : Symbol(publicClassWithWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 29, 1))
-
-    static myPublicStaticMethod(param: privateClass) { // Error
->myPublicStaticMethod : Symbol(publicClassWithWithPrivateParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 31, 54))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 32, 32))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
-    }
-    private static myPrivateStaticMethod(param: privateClass) {
->myPrivateStaticMethod : Symbol(publicClassWithWithPrivateParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 33, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 34, 41))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
-    }
-    myPublicMethod(param: privateClass) { // Error
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 35, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 36, 19))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
-    }
-    private myPrivateMethod(param: privateClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 37, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 38, 28))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
-    }
-    constructor(param: privateClass, private param1: privateClass, public param2: privateClass) { // Error
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 40, 16))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
->param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 40, 36))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
->param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 40, 66))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
-    }
-}
-
-export class publicClassWithWithPublicParmeterTypes {
->publicClassWithWithPublicParmeterTypes : Symbol(publicClassWithWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 42, 1))
-
-    static myPublicStaticMethod(param: publicClass) {
->myPublicStaticMethod : Symbol(publicClassWithWithPublicParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 44, 53))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 45, 32))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
-    }
-    private static myPrivateStaticMethod(param: publicClass) {
->myPrivateStaticMethod : Symbol(publicClassWithWithPublicParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 46, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 47, 41))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
-    }
-    myPublicMethod(param: publicClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 48, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 49, 19))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
-    }
-    private myPrivateMethod(param: publicClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 50, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 51, 28))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
-    }
-    constructor(param: publicClass, private param1: publicClass, public param2: publicClass) {
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 53, 16))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
->param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 53, 35))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
->param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 53, 64))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
-    }
-}
-
-class privateClassWithWithPrivateParmeterTypes {
->privateClassWithWithPrivateParmeterTypes : Symbol(privateClassWithWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 55, 1))
-
-    static myPublicStaticMethod(param: privateClass) {
->myPublicStaticMethod : Symbol(privateClassWithWithPrivateParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 57, 48))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 58, 32))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
-    }
-    private static myPrivateStaticMethod(param: privateClass) {
->myPrivateStaticMethod : Symbol(privateClassWithWithPrivateParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 59, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 60, 41))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
-    }
-    myPublicMethod(param: privateClass) { 
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 61, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 62, 19))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
-    }
-    private myPrivateMethod(param: privateClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 63, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 64, 28))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
-    }
-    constructor(param: privateClass, private param1: privateClass, public param2: privateClass) {
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 66, 16))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
->param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 66, 36))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
->param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 66, 66))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
-    }
-}
-
-class privateClassWithWithPublicParmeterTypes {
->privateClassWithWithPublicParmeterTypes : Symbol(privateClassWithWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 68, 1))
-
-    static myPublicStaticMethod(param: publicClass) {
->myPublicStaticMethod : Symbol(privateClassWithWithPublicParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 70, 47))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 71, 32))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
-    }
-    private static myPrivateStaticMethod(param: publicClass) {
->myPrivateStaticMethod : Symbol(privateClassWithWithPublicParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 72, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 73, 41))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
-    }
-    myPublicMethod(param: publicClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 74, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 75, 19))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
-    }
-    private myPrivateMethod(param: publicClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 76, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 77, 28))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
-    }
-    constructor(param: publicClass, private param1: publicClass, public param2: publicClass) {
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 79, 16))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
->param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 79, 35))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
->param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 79, 64))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
-    }
-}
-
-export function publicFunctionWithPrivateParmeterTypes(param: privateClass) { // Error
->publicFunctionWithPrivateParmeterTypes : Symbol(publicFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 81, 1))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 83, 55))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
-}
-export function publicFunctionWithPublicParmeterTypes(param: publicClass) {
->publicFunctionWithPublicParmeterTypes : Symbol(publicFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 84, 1))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 85, 54))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
-}
-function privateFunctionWithPrivateParmeterTypes(param: privateClass) {
->privateFunctionWithPrivateParmeterTypes : Symbol(privateFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 86, 1))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 87, 49))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
-}
-function privateFunctionWithPublicParmeterTypes(param: publicClass) {
->privateFunctionWithPublicParmeterTypes : Symbol(privateFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 88, 1))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 89, 48))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
-}
-
-export declare function publicAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void; // Error
->publicAmbientFunctionWithPrivateParmeterTypes : Symbol(publicAmbientFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 90, 1))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 92, 70))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
-
-export declare function publicAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
->publicAmbientFunctionWithPublicParmeterTypes : Symbol(publicAmbientFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 92, 97))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 93, 69))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
-
-declare function privateAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void;
->privateAmbientFunctionWithPrivateParmeterTypes : Symbol(privateAmbientFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 93, 95))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 94, 64))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 0, 0))
-
-declare function privateAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
->privateAmbientFunctionWithPublicParmeterTypes : Symbol(privateAmbientFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 94, 91))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 95, 63))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
-
-export interface publicInterfaceWithPrivateModuleParameterTypes {
->publicInterfaceWithPrivateModuleParameterTypes : Symbol(publicInterfaceWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 95, 89))
-
-    new (param: privateModule.publicClass): publicClass; // Error
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 98, 9))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
-
-    (param: privateModule.publicClass): publicClass; // Error
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 99, 5))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
-
-    myMethod(param: privateModule.publicClass): void; // Error
->myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 99, 52))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 100, 13))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-}
-export class publicClassWithPrivateModuleParameterTypes {
->publicClassWithPrivateModuleParameterTypes : Symbol(publicClassWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 101, 1))
-
-    static myPublicStaticMethod(param: privateModule.publicClass) { // Error
->myPublicStaticMethod : Symbol(publicClassWithPrivateModuleParameterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 102, 57))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 103, 32))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-    }
-    myPublicMethod(param: privateModule.publicClass) { // Error
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 104, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 105, 19))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-    }
-    constructor(param: privateModule.publicClass, private param1: privateModule.publicClass, public param2: privateModule.publicClass) { // Error
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 107, 16))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
->param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 107, 49))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
->param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 107, 92))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-    }
-}
-export function publicFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass) { // Error
->publicFunctionWithPrivateModuleParameterTypes : Symbol(publicFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 109, 1))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 110, 62))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-}
-export declare function publicAmbientFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass): void; // Error
->publicAmbientFunctionWithPrivateModuleParameterTypes : Symbol(publicAmbientFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 111, 1))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 112, 77))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-
-interface privateInterfaceWithPrivateModuleParameterTypes {
->privateInterfaceWithPrivateModuleParameterTypes : Symbol(privateInterfaceWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 112, 117))
-
-    new (param: privateModule.publicClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 115, 9))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
-
-    (param: privateModule.publicClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 116, 5))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 2, 1))
-
-    myMethod(param: privateModule.publicClass): void;
->myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 116, 52))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 117, 13))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-}
-class privateClassWithPrivateModuleParameterTypes {
->privateClassWithPrivateModuleParameterTypes : Symbol(privateClassWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 118, 1))
-
-    static myPublicStaticMethod(param: privateModule.publicClass) {
->myPublicStaticMethod : Symbol(privateClassWithPrivateModuleParameterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 119, 51))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 120, 32))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-    }
-    myPublicMethod(param: privateModule.publicClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 121, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 122, 19))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-    }
-    constructor(param: privateModule.publicClass, private param1: privateModule.publicClass, public param2: privateModule.publicClass) {
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 124, 16))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
->param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 124, 49))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
->param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 124, 92))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-    }
-}
-function privateFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass) {
->privateFunctionWithPrivateModuleParameterTypes : Symbol(privateFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 126, 1))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 127, 56))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-}
-declare function privateAmbientFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass): void;
->privateAmbientFunctionWithPrivateModuleParameterTypes : Symbol(privateAmbientFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 128, 1))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 129, 71))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-
-export module publicModule {
->publicModule : Symbol(publicModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 129, 111))
-
-    class privateClass {
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
-    }
-
-    export class publicClass {
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
-    }
-
-
-    export interface publicInterfaceWithPrivateParmeterTypes {
->publicInterfaceWithPrivateParmeterTypes : Symbol(publicInterfaceWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 136, 5))
-
-        new (param: privateClass): publicClass; // Error
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 140, 13))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
-
-        (param: privateClass): publicClass; // Error
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 141, 9))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
-
-        myMethod(param: privateClass): void; // Error
->myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 141, 43))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 142, 17))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
-    }
-
-    export interface publicInterfaceWithPublicParmeterTypes {
->publicInterfaceWithPublicParmeterTypes : Symbol(publicInterfaceWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 143, 5))
-
-        new (param: publicClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 146, 13))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
-
-        (param: publicClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 147, 9))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
-
-        myMethod(param: publicClass): void;
->myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 147, 42))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 148, 17))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
-    }
-
-    interface privateInterfaceWithPrivateParmeterTypes {
->privateInterfaceWithPrivateParmeterTypes : Symbol(privateInterfaceWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 149, 5))
-
-        new (param: privateClass): privateClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 152, 13))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
-
-        (param: privateClass): privateClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 153, 9))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
-
-        myMethod(param: privateClass): void;
->myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 153, 44))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 154, 17))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
-    }
-
-    interface privateInterfaceWithPublicParmeterTypes {
->privateInterfaceWithPublicParmeterTypes : Symbol(privateInterfaceWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 155, 5))
-
-        new (param: publicClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 158, 13))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
-
-        (param: publicClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 159, 9))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
-
-        myMethod(param: publicClass): void;
->myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 159, 42))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 160, 17))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
-    }
-
-    export class publicClassWithWithPrivateParmeterTypes {
->publicClassWithWithPrivateParmeterTypes : Symbol(publicClassWithWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 161, 5))
-
-        static myPublicStaticMethod(param: privateClass) { // Error
->myPublicStaticMethod : Symbol(publicClassWithWithPrivateParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 163, 58))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 164, 36))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
-        }
-        private static myPrivateStaticMethod(param: privateClass) {
->myPrivateStaticMethod : Symbol(publicClassWithWithPrivateParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 165, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 166, 45))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
-        }
-        myPublicMethod(param: privateClass) { // Error
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 167, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 168, 23))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
-        }
-        private myPrivateMethod(param: privateClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 169, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 170, 32))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
-        }
-        constructor(param: privateClass, private param1: privateClass, public param2: privateClass) { // Error
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 172, 20))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
->param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 172, 40))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
->param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 172, 70))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
-        }
-    }
-
-    export class publicClassWithWithPublicParmeterTypes {
->publicClassWithWithPublicParmeterTypes : Symbol(publicClassWithWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 174, 5))
-
-        static myPublicStaticMethod(param: publicClass) {
->myPublicStaticMethod : Symbol(publicClassWithWithPublicParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 176, 57))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 177, 36))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
-        }
-        private static myPrivateStaticMethod(param: publicClass) {
->myPrivateStaticMethod : Symbol(publicClassWithWithPublicParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 178, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 179, 45))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
-        }
-        myPublicMethod(param: publicClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 180, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 181, 23))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
-        }
-        private myPrivateMethod(param: publicClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 182, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 183, 32))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
-        }
-        constructor(param: publicClass, private param1: publicClass, public param2: publicClass) {
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 185, 20))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
->param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 185, 39))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
->param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 185, 68))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
-        }
-    }
-
-    class privateClassWithWithPrivateParmeterTypes {
->privateClassWithWithPrivateParmeterTypes : Symbol(privateClassWithWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 187, 5))
-
-        static myPublicStaticMethod(param: privateClass) {
->myPublicStaticMethod : Symbol(privateClassWithWithPrivateParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 189, 52))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 190, 36))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
-        }
-        private static myPrivateStaticMethod(param: privateClass) {
->myPrivateStaticMethod : Symbol(privateClassWithWithPrivateParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 191, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 192, 45))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
-        }
-        myPublicMethod(param: privateClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 193, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 194, 23))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
-        }
-        private myPrivateMethod(param: privateClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 195, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 196, 32))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
-        }
-        constructor(param: privateClass, private param1: privateClass, public param2: privateClass) {
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 198, 20))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
->param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 198, 40))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
->param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 198, 70))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
-        }
-    }
-
-    class privateClassWithWithPublicParmeterTypes {
->privateClassWithWithPublicParmeterTypes : Symbol(privateClassWithWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 200, 5))
-
-        static myPublicStaticMethod(param: publicClass) {
->myPublicStaticMethod : Symbol(privateClassWithWithPublicParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 202, 51))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 203, 36))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
-        }
-        private static myPrivateStaticMethod(param: publicClass) {
->myPrivateStaticMethod : Symbol(privateClassWithWithPublicParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 204, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 205, 45))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
-        }
-        myPublicMethod(param: publicClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 206, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 207, 23))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
-        }
-        private myPrivateMethod(param: publicClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 208, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 209, 32))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
-        }
-        constructor(param: publicClass, private param1: publicClass, public param2: publicClass) {
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 211, 20))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
->param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 211, 39))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
->param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 211, 68))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
-        }
-    }
-
-    export function publicFunctionWithPrivateParmeterTypes(param: privateClass) { // Error
->publicFunctionWithPrivateParmeterTypes : Symbol(publicFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 213, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 215, 59))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
-    }
-    export function publicFunctionWithPublicParmeterTypes(param: publicClass) {
->publicFunctionWithPublicParmeterTypes : Symbol(publicFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 216, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 217, 58))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
-    }
-    function privateFunctionWithPrivateParmeterTypes(param: privateClass) {
->privateFunctionWithPrivateParmeterTypes : Symbol(privateFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 218, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 219, 53))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
-    }
-    function privateFunctionWithPublicParmeterTypes(param: publicClass) {
->privateFunctionWithPublicParmeterTypes : Symbol(privateFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 220, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 221, 52))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
-    }
-
-    export declare function publicAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void; // Error
->publicAmbientFunctionWithPrivateParmeterTypes : Symbol(publicAmbientFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 222, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 224, 74))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
-
-    export declare function publicAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
->publicAmbientFunctionWithPublicParmeterTypes : Symbol(publicAmbientFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 224, 101))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 225, 73))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
-
-    declare function privateAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void;
->privateAmbientFunctionWithPrivateParmeterTypes : Symbol(privateAmbientFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 225, 99))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 226, 68))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 131, 28))
-
-    declare function privateAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
->privateAmbientFunctionWithPublicParmeterTypes : Symbol(privateAmbientFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 226, 95))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 227, 67))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
-
-    export interface publicInterfaceWithPrivateModuleParameterTypes {
->publicInterfaceWithPrivateModuleParameterTypes : Symbol(publicInterfaceWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 227, 93))
-
-        new (param: privateModule.publicClass): publicClass; // Error
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 230, 13))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
-
-        (param: privateModule.publicClass): publicClass; // Error
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 231, 9))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
-
-        myMethod(param: privateModule.publicClass): void; // Error
->myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 231, 56))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 232, 17))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-    }
-    export class publicClassWithPrivateModuleParameterTypes {
->publicClassWithPrivateModuleParameterTypes : Symbol(publicClassWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 233, 5))
-
-        static myPublicStaticMethod(param: privateModule.publicClass) { // Error
->myPublicStaticMethod : Symbol(publicClassWithPrivateModuleParameterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 234, 61))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 235, 36))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-        }
-        myPublicMethod(param: privateModule.publicClass) { // Error
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 236, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 237, 23))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-        }
-        constructor(param: privateModule.publicClass, private param1: privateModule.publicClass, public param2: privateModule.publicClass) { // Error
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 239, 20))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
->param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 239, 53))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
->param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 239, 96))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-        }
-    }
-    export function publicFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass) { // Error
->publicFunctionWithPrivateModuleParameterTypes : Symbol(publicFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 241, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 242, 66))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-    }
-    export declare function publicAmbientFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass): void; // Error
->publicAmbientFunctionWithPrivateModuleParameterTypes : Symbol(publicAmbientFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 243, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 244, 81))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-
-    interface privateInterfaceWithPrivateModuleParameterTypes {
->privateInterfaceWithPrivateModuleParameterTypes : Symbol(privateInterfaceWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 244, 121))
-
-        new (param: privateModule.publicClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 247, 13))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
-
-        (param: privateModule.publicClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 248, 9))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 133, 5))
-
-        myMethod(param: privateModule.publicClass): void;
->myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 248, 56))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 249, 17))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-    }
-    class privateClassWithPrivateModuleParameterTypes {
->privateClassWithPrivateModuleParameterTypes : Symbol(privateClassWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 250, 5))
-
-        static myPublicStaticMethod(param: privateModule.publicClass) {
->myPublicStaticMethod : Symbol(privateClassWithPrivateModuleParameterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 251, 55))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 252, 36))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-        }
-        myPublicMethod(param: privateModule.publicClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 253, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 254, 23))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-        }
-        constructor(param: privateModule.publicClass, private param1: privateModule.publicClass, public param2: privateModule.publicClass) {
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 256, 20))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
->param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 256, 53))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
->param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 256, 96))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-        }
-    }
-    function privateFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass) {
->privateFunctionWithPrivateModuleParameterTypes : Symbol(privateFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 258, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 259, 60))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-    }
-    declare function privateAmbientFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass): void;
->privateAmbientFunctionWithPrivateModuleParameterTypes : Symbol(privateAmbientFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 260, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 261, 75))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-
-}
-
-module privateModule {
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
-
-    class privateClass {
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
-    }
-
-    export class publicClass {
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-    }
-
-    export interface publicInterfaceWithPrivateParmeterTypes {
->publicInterfaceWithPrivateParmeterTypes : Symbol(publicInterfaceWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 270, 5))
-
-        new (param: privateClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 273, 13))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-
-        (param: privateClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 274, 9))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-
-        myMethod(param: privateClass): void;
->myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 274, 43))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 275, 17))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
-    }
-
-    export interface publicInterfaceWithPublicParmeterTypes {
->publicInterfaceWithPublicParmeterTypes : Symbol(publicInterfaceWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 276, 5))
-
-        new (param: publicClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 279, 13))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-
-        (param: publicClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 280, 9))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-
-        myMethod(param: publicClass): void;
->myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 280, 42))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 281, 17))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-    }
-
-    interface privateInterfaceWithPrivateParmeterTypes {
->privateInterfaceWithPrivateParmeterTypes : Symbol(privateInterfaceWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 282, 5))
-
-        new (param: privateClass): privateClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 285, 13))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
-
-        (param: privateClass): privateClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 286, 9))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
-
-        myMethod(param: privateClass): void;
->myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 286, 44))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 287, 17))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
-    }
-
-    interface privateInterfaceWithPublicParmeterTypes {
->privateInterfaceWithPublicParmeterTypes : Symbol(privateInterfaceWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 288, 5))
-
-        new (param: publicClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 291, 13))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-
-        (param: publicClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 292, 9))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-
-        myMethod(param: publicClass): void;
->myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 292, 42))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 293, 17))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-    }
-
-    export class publicClassWithWithPrivateParmeterTypes {
->publicClassWithWithPrivateParmeterTypes : Symbol(publicClassWithWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 294, 5))
-
-        static myPublicStaticMethod(param: privateClass) {
->myPublicStaticMethod : Symbol(publicClassWithWithPrivateParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 296, 58))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 297, 36))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
-        }
-        private static myPrivateStaticMethod(param: privateClass) {
->myPrivateStaticMethod : Symbol(publicClassWithWithPrivateParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 298, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 299, 45))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
-        }
-        myPublicMethod(param: privateClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 300, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 301, 23))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
-        }
-        private myPrivateMethod(param: privateClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 302, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 303, 32))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
-        }
-        constructor(param: privateClass, private param1: privateClass, public param2: privateClass) {
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 305, 20))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
->param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 305, 40))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
->param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 305, 70))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
-        }
-    }
-
-    export class publicClassWithWithPublicParmeterTypes {
->publicClassWithWithPublicParmeterTypes : Symbol(publicClassWithWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 307, 5))
-
-        static myPublicStaticMethod(param: publicClass) {
->myPublicStaticMethod : Symbol(publicClassWithWithPublicParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 309, 57))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 310, 36))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-        }
-        private static myPrivateStaticMethod(param: publicClass) {
->myPrivateStaticMethod : Symbol(publicClassWithWithPublicParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 311, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 312, 45))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-        }
-        myPublicMethod(param: publicClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 313, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 314, 23))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-        }
-        private myPrivateMethod(param: publicClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 315, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 316, 32))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-        }
-        constructor(param: publicClass, private param1: publicClass, public param2: publicClass) {
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 318, 20))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
->param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 318, 39))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
->param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 318, 68))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-        }
-    }
-
-    class privateClassWithWithPrivateParmeterTypes {
->privateClassWithWithPrivateParmeterTypes : Symbol(privateClassWithWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 320, 5))
-
-        static myPublicStaticMethod(param: privateClass) {
->myPublicStaticMethod : Symbol(privateClassWithWithPrivateParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 322, 52))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 323, 36))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
-        }
-        private static myPrivateStaticMethod(param: privateClass) {
->myPrivateStaticMethod : Symbol(privateClassWithWithPrivateParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 324, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 325, 45))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
-        }
-        myPublicMethod(param: privateClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 326, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 327, 23))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
-        }
-        private myPrivateMethod(param: privateClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 328, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 329, 32))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
-        }
-        constructor(param: privateClass, private param1: privateClass, public param2: privateClass) {
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 331, 20))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
->param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 331, 40))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
->param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 331, 70))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
-        }
-    }
-
-    class privateClassWithWithPublicParmeterTypes {
->privateClassWithWithPublicParmeterTypes : Symbol(privateClassWithWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 333, 5))
-
-        static myPublicStaticMethod(param: publicClass) {
->myPublicStaticMethod : Symbol(privateClassWithWithPublicParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 335, 51))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 336, 36))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-        }
-        private static myPrivateStaticMethod(param: publicClass) {
->myPrivateStaticMethod : Symbol(privateClassWithWithPublicParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 337, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 338, 45))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-        }
-        myPublicMethod(param: publicClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 339, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 340, 23))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-        }
-        private myPrivateMethod(param: publicClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 341, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 342, 32))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-        }
-        constructor(param: publicClass, private param1: publicClass, public param2: publicClass) {
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 344, 20))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
->param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 344, 39))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
->param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 344, 68))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-        }
-    }
-
-    export function publicFunctionWithPrivateParmeterTypes(param: privateClass) {
->publicFunctionWithPrivateParmeterTypes : Symbol(publicFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 346, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 348, 59))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
-    }
-    export function publicFunctionWithPublicParmeterTypes(param: publicClass) {
->publicFunctionWithPublicParmeterTypes : Symbol(publicFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 349, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 350, 58))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-    }
-    function privateFunctionWithPrivateParmeterTypes(param: privateClass) {
->privateFunctionWithPrivateParmeterTypes : Symbol(privateFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 351, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 352, 53))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
-    }
-    function privateFunctionWithPublicParmeterTypes(param: publicClass) {
->privateFunctionWithPublicParmeterTypes : Symbol(privateFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 353, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 354, 52))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-    }
-
-    export declare function publicAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void;
->publicAmbientFunctionWithPrivateParmeterTypes : Symbol(publicAmbientFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 355, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 357, 74))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
-
-    export declare function publicAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
->publicAmbientFunctionWithPublicParmeterTypes : Symbol(publicAmbientFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 357, 101))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 358, 73))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-
-    declare function privateAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void;
->privateAmbientFunctionWithPrivateParmeterTypes : Symbol(privateAmbientFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 358, 99))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 359, 68))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 265, 22))
-
-    declare function privateAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
->privateAmbientFunctionWithPublicParmeterTypes : Symbol(privateAmbientFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 359, 95))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 360, 67))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-
-    export interface publicInterfaceWithPrivateModuleParameterTypes {
->publicInterfaceWithPrivateModuleParameterTypes : Symbol(publicInterfaceWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 360, 93))
-
-        new (param: privateModule.publicClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 363, 13))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-
-        (param: privateModule.publicClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 364, 9))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-
-        myMethod(param: privateModule.publicClass): void;
->myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 364, 56))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 365, 17))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-    }
-    export class publicClassWithPrivateModuleParameterTypes {
->publicClassWithPrivateModuleParameterTypes : Symbol(publicClassWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 366, 5))
-
-        static myPublicStaticMethod(param: privateModule.publicClass) {
->myPublicStaticMethod : Symbol(publicClassWithPrivateModuleParameterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 367, 61))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 368, 36))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-        }
-        myPublicMethod(param: privateModule.publicClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 369, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 370, 23))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-        }
-        constructor(param: privateModule.publicClass, private param1: privateModule.publicClass, public param2: privateModule.publicClass) {
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 372, 20))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
->param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 372, 53))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
->param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 372, 96))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-        }
-    }
-    export function publicFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass) {
->publicFunctionWithPrivateModuleParameterTypes : Symbol(publicFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 374, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 375, 66))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-    }
-    export declare function publicAmbientFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass): void;
->publicAmbientFunctionWithPrivateModuleParameterTypes : Symbol(publicAmbientFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 376, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 377, 81))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-
-    interface privateInterfaceWithPrivateModuleParameterTypes {
->privateInterfaceWithPrivateModuleParameterTypes : Symbol(privateInterfaceWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 377, 121))
-
-        new (param: privateModule.publicClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 380, 13))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-
-        (param: privateModule.publicClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 381, 9))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-
-        myMethod(param: privateModule.publicClass): void;
->myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 381, 56))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 382, 17))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-    }
-    class privateClassWithPrivateModuleParameterTypes {
->privateClassWithPrivateModuleParameterTypes : Symbol(privateClassWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 383, 5))
-
-        static myPublicStaticMethod(param: privateModule.publicClass) {
->myPublicStaticMethod : Symbol(privateClassWithPrivateModuleParameterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 384, 55))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 385, 36))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-        }
-        myPublicMethod(param: privateModule.publicClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 386, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 387, 23))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-        }
-        constructor(param: privateModule.publicClass, private param1: privateModule.publicClass, public param2: privateModule.publicClass) {
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 389, 20))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
->param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 389, 53))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
->param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 389, 96))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-        }
-    }
-    function privateFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass) {
->privateFunctionWithPrivateModuleParameterTypes : Symbol(privateFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 391, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 392, 60))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-    }
-    declare function privateAmbientFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass): void;
->privateAmbientFunctionWithPrivateModuleParameterTypes : Symbol(privateAmbientFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 393, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 394, 75))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 263, 1))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_externalModule.ts, 267, 5))
-}
-
-=== tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts ===
-class publicClassInGlobal {
->publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 0, 0))
-}
-interface publicInterfaceWithPublicParmeterTypesInGlobal {
->publicInterfaceWithPublicParmeterTypesInGlobal : Symbol(publicInterfaceWithPublicParmeterTypesInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 1, 1))
-
-    new (param: publicClassInGlobal): publicClassInGlobal;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 3, 9))
->publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 0, 0))
->publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 0, 0))
-
-    (param: publicClassInGlobal): publicClassInGlobal;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 4, 5))
->publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 0, 0))
->publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 0, 0))
-
-    myMethod(param: publicClassInGlobal): void;
->myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 4, 54))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 5, 13))
->publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 0, 0))
-}
-class publicClassWithWithPublicParmeterTypesInGlobal {
->publicClassWithWithPublicParmeterTypesInGlobal : Symbol(publicClassWithWithPublicParmeterTypesInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 6, 1))
-
-    static myPublicStaticMethod(param: publicClassInGlobal) {
->myPublicStaticMethod : Symbol(publicClassWithWithPublicParmeterTypesInGlobal.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 7, 54))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 8, 32))
->publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 0, 0))
-    }
-    private static myPrivateStaticMethod(param: publicClassInGlobal) {
->myPrivateStaticMethod : Symbol(publicClassWithWithPublicParmeterTypesInGlobal.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 9, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 10, 41))
->publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 0, 0))
-    }
-    myPublicMethod(param: publicClassInGlobal) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 11, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 12, 19))
->publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 0, 0))
-    }
-    private myPrivateMethod(param: publicClassInGlobal) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 13, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 14, 28))
->publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 0, 0))
-    }
-    constructor(param: publicClassInGlobal, private param1: publicClassInGlobal, public param2: publicClassInGlobal) {
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 16, 16))
->publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 0, 0))
->param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 16, 43))
->publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 0, 0))
->param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 16, 80))
->publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 0, 0))
-    }
-}
-function publicFunctionWithPublicParmeterTypesInGlobal(param: publicClassInGlobal) {
->publicFunctionWithPublicParmeterTypesInGlobal : Symbol(publicFunctionWithPublicParmeterTypesInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 18, 1))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 19, 55))
->publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 0, 0))
-}
-declare function publicAmbientFunctionWithPublicParmeterTypesInGlobal(param: publicClassInGlobal): void;
->publicAmbientFunctionWithPublicParmeterTypesInGlobal : Symbol(publicAmbientFunctionWithPublicParmeterTypesInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 20, 1))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 21, 70))
->publicClassInGlobal : Symbol(publicClassInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 0, 0))
-
-module publicModuleInGlobal {
->publicModuleInGlobal : Symbol(publicModuleInGlobal, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 21, 104))
-
-    class privateClass {
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
-    }
-
-    export class publicClass {
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
-    }
-
-    module privateModule {
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
-
-        class privateClass {
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
-        }
-
-        export class publicClass {
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-        }
-
-        export interface publicInterfaceWithPrivateParmeterTypes {
->publicInterfaceWithPrivateParmeterTypes : Symbol(publicInterfaceWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 35, 9))
-
-            new (param: privateClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 38, 17))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-
-            (param: privateClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 39, 13))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-
-            myMethod(param: privateClass): void;
->myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 39, 47))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 40, 21))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
-        }
-
-        export interface publicInterfaceWithPublicParmeterTypes {
->publicInterfaceWithPublicParmeterTypes : Symbol(publicInterfaceWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 41, 9))
-
-            new (param: publicClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 44, 17))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-
-            (param: publicClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 45, 13))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-
-            myMethod(param: publicClass): void;
->myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 45, 46))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 46, 21))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-        }
-
-        interface privateInterfaceWithPrivateParmeterTypes {
->privateInterfaceWithPrivateParmeterTypes : Symbol(privateInterfaceWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 47, 9))
-
-            new (param: privateClass): privateClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 50, 17))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
-
-            (param: privateClass): privateClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 51, 13))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
-
-            myMethod(param: privateClass): void;
->myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 51, 48))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 52, 21))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
-        }
-
-        interface privateInterfaceWithPublicParmeterTypes {
->privateInterfaceWithPublicParmeterTypes : Symbol(privateInterfaceWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 53, 9))
-
-            new (param: publicClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 56, 17))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-
-            (param: publicClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 57, 13))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-
-            myMethod(param: publicClass): void;
->myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 57, 46))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 58, 21))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-        }
-
-        export class publicClassWithWithPrivateParmeterTypes {
->publicClassWithWithPrivateParmeterTypes : Symbol(publicClassWithWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 59, 9))
-
-            static myPublicStaticMethod(param: privateClass) {
->myPublicStaticMethod : Symbol(publicClassWithWithPrivateParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 61, 62))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 62, 40))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
-            }
-            private static myPrivateStaticMethod(param: privateClass) {
->myPrivateStaticMethod : Symbol(publicClassWithWithPrivateParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 63, 13))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 64, 49))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
-            }
-            myPublicMethod(param: privateClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 65, 13))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 66, 27))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
-            }
-            private myPrivateMethod(param: privateClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 67, 13))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 68, 36))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
-            }
-            constructor(param: privateClass, private param1: privateClass, public param2: privateClass) {
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 70, 24))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
->param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 70, 44))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
->param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 70, 74))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
-            }
-        }
-
-        export class publicClassWithWithPublicParmeterTypes {
->publicClassWithWithPublicParmeterTypes : Symbol(publicClassWithWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 72, 9))
-
-            static myPublicStaticMethod(param: publicClass) {
->myPublicStaticMethod : Symbol(publicClassWithWithPublicParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 74, 61))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 75, 40))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-            }
-            private static myPrivateStaticMethod(param: publicClass) {
->myPrivateStaticMethod : Symbol(publicClassWithWithPublicParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 76, 13))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 77, 49))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-            }
-            myPublicMethod(param: publicClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 78, 13))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 79, 27))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-            }
-            private myPrivateMethod(param: publicClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 80, 13))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 81, 36))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-            }
-            constructor(param: publicClass, private param1: publicClass, public param2: publicClass) {
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 83, 24))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
->param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 83, 43))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
->param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 83, 72))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-            }
-        }
-
-        class privateClassWithWithPrivateParmeterTypes {
->privateClassWithWithPrivateParmeterTypes : Symbol(privateClassWithWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 85, 9))
-
-            static myPublicStaticMethod(param: privateClass) {
->myPublicStaticMethod : Symbol(privateClassWithWithPrivateParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 87, 56))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 88, 40))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
-            }
-            private static myPrivateStaticMethod(param: privateClass) {
->myPrivateStaticMethod : Symbol(privateClassWithWithPrivateParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 89, 13))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 90, 49))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
-            }
-            myPublicMethod(param: privateClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 91, 13))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 92, 27))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
-            }
-            private myPrivateMethod(param: privateClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 93, 13))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 94, 36))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
-            }
-            constructor(param: privateClass, private param1: privateClass, public param2: privateClass) {
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 96, 24))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
->param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 96, 44))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
->param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 96, 74))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
-            }
-        }
-
-        class privateClassWithWithPublicParmeterTypes {
->privateClassWithWithPublicParmeterTypes : Symbol(privateClassWithWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 98, 9))
-
-            static myPublicStaticMethod(param: publicClass) {
->myPublicStaticMethod : Symbol(privateClassWithWithPublicParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 100, 55))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 101, 40))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-            }
-            private static myPrivateStaticMethod(param: publicClass) {
->myPrivateStaticMethod : Symbol(privateClassWithWithPublicParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 102, 13))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 103, 49))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-            }
-            myPublicMethod(param: publicClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 104, 13))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 105, 27))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-            }
-            private myPrivateMethod(param: publicClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 106, 13))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 107, 36))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-            }
-            constructor(param: publicClass, private param1: publicClass, public param2: publicClass) {
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 109, 24))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
->param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 109, 43))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
->param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 109, 72))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-            }
-        }
-
-        export function publicFunctionWithPrivateParmeterTypes(param: privateClass) {
->publicFunctionWithPrivateParmeterTypes : Symbol(publicFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 111, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 113, 63))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
-        }
-        export function publicFunctionWithPublicParmeterTypes(param: publicClass) {
->publicFunctionWithPublicParmeterTypes : Symbol(publicFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 114, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 115, 62))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-        }
-        function privateFunctionWithPrivateParmeterTypes(param: privateClass) {
->privateFunctionWithPrivateParmeterTypes : Symbol(privateFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 116, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 117, 57))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
-        }
-        function privateFunctionWithPublicParmeterTypes(param: publicClass) {
->privateFunctionWithPublicParmeterTypes : Symbol(privateFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 118, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 119, 56))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-        }
-
-        export declare function publicAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void;
->publicAmbientFunctionWithPrivateParmeterTypes : Symbol(publicAmbientFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 120, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 122, 78))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
-
-        export declare function publicAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
->publicAmbientFunctionWithPublicParmeterTypes : Symbol(publicAmbientFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 122, 105))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 123, 77))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-
-        declare function privateAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void;
->privateAmbientFunctionWithPrivateParmeterTypes : Symbol(privateAmbientFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 123, 103))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 124, 72))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 30, 26))
-
-        declare function privateAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
->privateAmbientFunctionWithPublicParmeterTypes : Symbol(privateAmbientFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 124, 99))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 125, 71))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-
-        export interface publicInterfaceWithPrivateModuleParameterTypes {
->publicInterfaceWithPrivateModuleParameterTypes : Symbol(publicInterfaceWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 125, 97))
-
-            new (param: privateModule.publicClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 128, 17))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-
-            (param: privateModule.publicClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 129, 13))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-
-            myMethod(param: privateModule.publicClass): void;
->myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 129, 60))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 130, 21))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-        }
-        export class publicClassWithPrivateModuleParameterTypes {
->publicClassWithPrivateModuleParameterTypes : Symbol(publicClassWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 131, 9))
-
-            static myPublicStaticMethod(param: privateModule.publicClass) {
->myPublicStaticMethod : Symbol(publicClassWithPrivateModuleParameterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 132, 65))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 133, 40))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-            }
-            myPublicMethod(param: privateModule.publicClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 134, 13))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 135, 27))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-            }
-            constructor(param: privateModule.publicClass, private param1: privateModule.publicClass, public param2: privateModule.publicClass) {
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 137, 24))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
->param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 137, 57))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
->param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 137, 100))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-            }
-        }
-        export function publicFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass) {
->publicFunctionWithPrivateModuleParameterTypes : Symbol(publicFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 139, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 140, 70))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-        }
-        export declare function publicAmbientFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass): void;
->publicAmbientFunctionWithPrivateModuleParameterTypes : Symbol(publicAmbientFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 141, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 142, 85))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-
-        interface privateInterfaceWithPrivateModuleParameterTypes {
->privateInterfaceWithPrivateModuleParameterTypes : Symbol(privateInterfaceWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 142, 125))
-
-            new (param: privateModule.publicClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 145, 17))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-
-            (param: privateModule.publicClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 146, 13))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-
-            myMethod(param: privateModule.publicClass): void;
->myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 146, 60))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 147, 21))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-        }
-        class privateClassWithPrivateModuleParameterTypes {
->privateClassWithPrivateModuleParameterTypes : Symbol(privateClassWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 148, 9))
-
-            static myPublicStaticMethod(param: privateModule.publicClass) {
->myPublicStaticMethod : Symbol(privateClassWithPrivateModuleParameterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 149, 59))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 150, 40))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-            }
-            myPublicMethod(param: privateModule.publicClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 151, 13))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 152, 27))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-            }
-            constructor(param: privateModule.publicClass, private param1: privateModule.publicClass, public param2: privateModule.publicClass) {
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 154, 24))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
->param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 154, 57))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
->param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 154, 100))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-            }
-        }
-        function privateFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass) {
->privateFunctionWithPrivateModuleParameterTypes : Symbol(privateFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 156, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 157, 64))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-        }
-        declare function privateAmbientFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass): void;
->privateAmbientFunctionWithPrivateModuleParameterTypes : Symbol(privateAmbientFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 158, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 159, 79))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-    }
-
-    export interface publicInterfaceWithPrivateParmeterTypes {
->publicInterfaceWithPrivateParmeterTypes : Symbol(publicInterfaceWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 160, 5))
-
-        new (param: privateClass): publicClass; // Error
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 163, 13))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
-
-        (param: privateClass): publicClass; // Error
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 164, 9))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
-
-        myMethod(param: privateClass): void; // Error
->myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 164, 43))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 165, 17))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
-    }
-
-    export interface publicInterfaceWithPublicParmeterTypes {
->publicInterfaceWithPublicParmeterTypes : Symbol(publicInterfaceWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 166, 5))
-
-        new (param: publicClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 169, 13))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
-
-        (param: publicClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 170, 9))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
-
-        myMethod(param: publicClass): void;
->myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 170, 42))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 171, 17))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
-    }
-
-    interface privateInterfaceWithPrivateParmeterTypes {
->privateInterfaceWithPrivateParmeterTypes : Symbol(privateInterfaceWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 172, 5))
-
-        new (param: privateClass): privateClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 175, 13))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
-
-        (param: privateClass): privateClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 176, 9))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
-
-        myMethod(param: privateClass): void;
->myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 176, 44))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 177, 17))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
-    }
-
-    interface privateInterfaceWithPublicParmeterTypes {
->privateInterfaceWithPublicParmeterTypes : Symbol(privateInterfaceWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 178, 5))
-
-        new (param: publicClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 181, 13))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
-
-        (param: publicClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 182, 9))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
-
-        myMethod(param: publicClass): void;
->myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 182, 42))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 183, 17))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
-    }
-
-    export class publicClassWithWithPrivateParmeterTypes {
->publicClassWithWithPrivateParmeterTypes : Symbol(publicClassWithWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 184, 5))
-
-        static myPublicStaticMethod(param: privateClass) { // Error
->myPublicStaticMethod : Symbol(publicClassWithWithPrivateParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 186, 58))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 187, 36))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
-        }
-        private static myPrivateStaticMethod(param: privateClass) {
->myPrivateStaticMethod : Symbol(publicClassWithWithPrivateParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 188, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 189, 45))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
-        }
-        myPublicMethod(param: privateClass) { // Error
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 190, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 191, 23))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
-        }
-        private myPrivateMethod(param: privateClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 192, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 193, 32))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
-        }
-        constructor(param: privateClass, private param1: privateClass, public param2: privateClass) { // Error
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 195, 20))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
->param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 195, 40))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
->param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 195, 70))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
-        }
-    }
-
-    export class publicClassWithWithPublicParmeterTypes {
->publicClassWithWithPublicParmeterTypes : Symbol(publicClassWithWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 197, 5))
-
-        static myPublicStaticMethod(param: publicClass) {
->myPublicStaticMethod : Symbol(publicClassWithWithPublicParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 199, 57))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 200, 36))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
-        }
-        private static myPrivateStaticMethod(param: publicClass) {
->myPrivateStaticMethod : Symbol(publicClassWithWithPublicParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 201, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 202, 45))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
-        }
-        myPublicMethod(param: publicClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 203, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 204, 23))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
-        }
-        private myPrivateMethod(param: publicClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 205, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 206, 32))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
-        }
-        constructor(param: publicClass, private param1: publicClass, public param2: publicClass) {
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 208, 20))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
->param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 208, 39))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
->param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 208, 68))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
-        }
-    }
-
-    class privateClassWithWithPrivateParmeterTypes {
->privateClassWithWithPrivateParmeterTypes : Symbol(privateClassWithWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 210, 5))
-
-        static myPublicStaticMethod(param: privateClass) {
->myPublicStaticMethod : Symbol(privateClassWithWithPrivateParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 212, 52))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 213, 36))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
-        }
-        private static myPrivateStaticMethod(param: privateClass) {
->myPrivateStaticMethod : Symbol(privateClassWithWithPrivateParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 214, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 215, 45))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
-        }
-        myPublicMethod(param: privateClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 216, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 217, 23))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
-        }
-        private myPrivateMethod(param: privateClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 218, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 219, 32))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
-        }
-        constructor(param: privateClass, private param1: privateClass, public param2: privateClass) {
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 221, 20))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
->param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 221, 40))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
->param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 221, 70))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
-        }
-    }
-
-    class privateClassWithWithPublicParmeterTypes {
->privateClassWithWithPublicParmeterTypes : Symbol(privateClassWithWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 223, 5))
-
-        static myPublicStaticMethod(param: publicClass) {
->myPublicStaticMethod : Symbol(privateClassWithWithPublicParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 225, 51))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 226, 36))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
-        }
-        private static myPrivateStaticMethod(param: publicClass) {
->myPrivateStaticMethod : Symbol(privateClassWithWithPublicParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 227, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 228, 45))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
-        }
-        myPublicMethod(param: publicClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 229, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 230, 23))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
-        }
-        private myPrivateMethod(param: publicClass) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 231, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 232, 32))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
-        }
-        constructor(param: publicClass, private param1: publicClass, public param2: publicClass) {
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 234, 20))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
->param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 234, 39))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
->param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 234, 68))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
-        }
-    }
-
-    export function publicFunctionWithPrivateParmeterTypes(param: privateClass) { // Error
->publicFunctionWithPrivateParmeterTypes : Symbol(publicFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 236, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 238, 59))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
-    }
-    export function publicFunctionWithPublicParmeterTypes(param: publicClass) {
->publicFunctionWithPublicParmeterTypes : Symbol(publicFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 239, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 240, 58))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
-    }
-    function privateFunctionWithPrivateParmeterTypes(param: privateClass) {
->privateFunctionWithPrivateParmeterTypes : Symbol(privateFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 241, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 242, 53))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
-    }
-    function privateFunctionWithPublicParmeterTypes(param: publicClass) {
->privateFunctionWithPublicParmeterTypes : Symbol(privateFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 243, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 244, 52))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
-    }
-
-    export declare function publicAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void; // Error
->publicAmbientFunctionWithPrivateParmeterTypes : Symbol(publicAmbientFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 245, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 247, 74))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
-
-    export declare function publicAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
->publicAmbientFunctionWithPublicParmeterTypes : Symbol(publicAmbientFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 247, 101))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 248, 73))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
-
-    declare function privateAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void;
->privateAmbientFunctionWithPrivateParmeterTypes : Symbol(privateAmbientFunctionWithPrivateParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 248, 99))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 249, 68))
->privateClass : Symbol(privateClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 23, 29))
-
-    declare function privateAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
->privateAmbientFunctionWithPublicParmeterTypes : Symbol(privateAmbientFunctionWithPublicParmeterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 249, 95))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 250, 67))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
-
-    export interface publicInterfaceWithPrivateModuleParameterTypes {
->publicInterfaceWithPrivateModuleParameterTypes : Symbol(publicInterfaceWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 250, 93))
-
-        new (param: privateModule.publicClass): publicClass; // Error
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 253, 13))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
-
-        (param: privateModule.publicClass): publicClass; // Error
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 254, 9))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
-
-        myMethod(param: privateModule.publicClass): void; // Error
->myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 254, 56))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 255, 17))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-    }
-    export class publicClassWithPrivateModuleParameterTypes {
->publicClassWithPrivateModuleParameterTypes : Symbol(publicClassWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 256, 5))
-
-        static myPublicStaticMethod(param: privateModule.publicClass) { // Error
->myPublicStaticMethod : Symbol(publicClassWithPrivateModuleParameterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 257, 61))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 258, 36))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-        }
-        myPublicMethod(param: privateModule.publicClass) { // Error
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 259, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 260, 23))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-        }
-        constructor(param: privateModule.publicClass, private param1: privateModule.publicClass, public param2: privateModule.publicClass) { // Error
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 262, 20))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
->param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 262, 53))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
->param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 262, 96))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-        }
-    }
-    export function publicFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass) { // Error
->publicFunctionWithPrivateModuleParameterTypes : Symbol(publicFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 264, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 265, 66))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-    }
-    export declare function publicAmbientFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass): void; // Error
->publicAmbientFunctionWithPrivateModuleParameterTypes : Symbol(publicAmbientFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 266, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 267, 81))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-
-    interface privateInterfaceWithPrivateModuleParameterTypes {
->privateInterfaceWithPrivateModuleParameterTypes : Symbol(privateInterfaceWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 267, 121))
-
-        new (param: privateModule.publicClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 270, 13))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
-
-        (param: privateModule.publicClass): publicClass;
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 271, 9))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
->publicClass : Symbol(publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 25, 5))
-
-        myMethod(param: privateModule.publicClass): void;
->myMethod : Symbol(myMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 271, 56))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 272, 17))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-    }
-    class privateClassWithPrivateModuleParameterTypes {
->privateClassWithPrivateModuleParameterTypes : Symbol(privateClassWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 273, 5))
-
-        static myPublicStaticMethod(param: privateModule.publicClass) {
->myPublicStaticMethod : Symbol(privateClassWithPrivateModuleParameterTypes.myPublicStaticMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 274, 55))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 275, 36))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-        }
-        myPublicMethod(param: privateModule.publicClass) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 276, 9))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 277, 23))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-        }
-        constructor(param: privateModule.publicClass, private param1: privateModule.publicClass, public param2: privateModule.publicClass) {
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 279, 20))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
->param1 : Symbol(param1, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 279, 53))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
->param2 : Symbol(param2, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 279, 96))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-        }
-    }
-    function privateFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass) {
->privateFunctionWithPrivateModuleParameterTypes : Symbol(privateFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 281, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 282, 60))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-    }
-    declare function privateAmbientFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass): void;
->privateAmbientFunctionWithPrivateModuleParameterTypes : Symbol(privateAmbientFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 283, 5))
->param : Symbol(param, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 284, 75))
->privateModule : Symbol(privateModule, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 28, 5))
->publicClass : Symbol(privateModule.publicClass, Decl(privacyFunctionParameterDeclFile_GlobalFile.ts, 32, 9))
-}
diff --git a/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.symbols b/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.symbols
deleted file mode 100644
index eb17ccffe4421..0000000000000
--- a/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.symbols
+++ /dev/null
@@ -1,169 +0,0 @@
-=== tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts ===
-
-export module publicModule {
->publicModule : Symbol(publicModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 0, 0))
-
-    export interface publicInterfaceInPublicModule {
->publicInterfaceInPublicModule : Symbol(publicInterfaceInPublicModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 1, 28))
-    }
-
-    interface privateInterfaceInPublicModule {
->privateInterfaceInPublicModule : Symbol(privateInterfaceInPublicModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 3, 5))
-    }
-
-    interface privateInterfaceImplementingPublicInterfaceInModule extends publicInterfaceInPublicModule {
->privateInterfaceImplementingPublicInterfaceInModule : Symbol(privateInterfaceImplementingPublicInterfaceInModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 6, 5))
->publicInterfaceInPublicModule : Symbol(publicInterfaceInPublicModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 1, 28))
-    }
-    interface privateInterfaceImplementingPrivateInterfaceInModule extends privateInterfaceInPublicModule {
->privateInterfaceImplementingPrivateInterfaceInModule : Symbol(privateInterfaceImplementingPrivateInterfaceInModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 9, 5))
->privateInterfaceInPublicModule : Symbol(privateInterfaceInPublicModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 3, 5))
-    }
-    export interface publicInterfaceImplementingPublicInterfaceInModule extends publicInterfaceInPublicModule {
->publicInterfaceImplementingPublicInterfaceInModule : Symbol(publicInterfaceImplementingPublicInterfaceInModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 11, 5))
->publicInterfaceInPublicModule : Symbol(publicInterfaceInPublicModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 1, 28))
-    }
-    export interface publicInterfaceImplementingPrivateInterfaceInModule extends privateInterfaceInPublicModule { // Should error
->publicInterfaceImplementingPrivateInterfaceInModule : Symbol(publicInterfaceImplementingPrivateInterfaceInModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 13, 5))
->privateInterfaceInPublicModule : Symbol(privateInterfaceInPublicModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 3, 5))
-    }
-
-    interface privateInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule {
->privateInterfaceImplementingFromPrivateModuleInterface : Symbol(privateInterfaceImplementingFromPrivateModuleInterface, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 15, 5))
->privateModule.publicInterfaceInPrivateModule : Symbol(privateModule.publicInterfaceInPrivateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 26, 22))
->privateModule : Symbol(privateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 24, 1))
->publicInterfaceInPrivateModule : Symbol(privateModule.publicInterfaceInPrivateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 26, 22))
-    }
-    export interface publicInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule { // Should error
->publicInterfaceImplementingFromPrivateModuleInterface : Symbol(publicInterfaceImplementingFromPrivateModuleInterface, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 18, 5))
->privateModule.publicInterfaceInPrivateModule : Symbol(privateModule.publicInterfaceInPrivateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 26, 22))
->privateModule : Symbol(privateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 24, 1))
->publicInterfaceInPrivateModule : Symbol(privateModule.publicInterfaceInPrivateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 26, 22))
-    }
-
-    export interface publicInterfaceImplementingPrivateAndPublicInterface extends privateInterfaceInPublicModule, publicInterfaceInPublicModule { // Should error
->publicInterfaceImplementingPrivateAndPublicInterface : Symbol(publicInterfaceImplementingPrivateAndPublicInterface, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 20, 5))
->privateInterfaceInPublicModule : Symbol(privateInterfaceInPublicModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 3, 5))
->publicInterfaceInPublicModule : Symbol(publicInterfaceInPublicModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 1, 28))
-    }
-}
-
-module privateModule {
->privateModule : Symbol(privateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 24, 1))
-
-    export interface publicInterfaceInPrivateModule {
->publicInterfaceInPrivateModule : Symbol(publicInterfaceInPrivateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 26, 22))
-
-    }
-
-    interface privateInterfaceInPrivateModule {
->privateInterfaceInPrivateModule : Symbol(privateInterfaceInPrivateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 29, 5))
-    }
-
-    interface privateInterfaceImplementingPublicInterfaceInModule extends publicInterfaceInPrivateModule {
->privateInterfaceImplementingPublicInterfaceInModule : Symbol(privateInterfaceImplementingPublicInterfaceInModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 32, 5))
->publicInterfaceInPrivateModule : Symbol(publicInterfaceInPrivateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 26, 22))
-    }
-    interface privateInterfaceImplementingPrivateInterfaceInModule extends privateInterfaceInPrivateModule {
->privateInterfaceImplementingPrivateInterfaceInModule : Symbol(privateInterfaceImplementingPrivateInterfaceInModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 35, 5))
->privateInterfaceInPrivateModule : Symbol(privateInterfaceInPrivateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 29, 5))
-    }
-    export interface publicInterfaceImplementingPublicInterfaceInModule extends publicInterfaceInPrivateModule {
->publicInterfaceImplementingPublicInterfaceInModule : Symbol(publicInterfaceImplementingPublicInterfaceInModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 37, 5))
->publicInterfaceInPrivateModule : Symbol(publicInterfaceInPrivateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 26, 22))
-    }
-    export interface publicInterfaceImplementingPrivateInterfaceInModule extends privateInterfaceInPrivateModule {
->publicInterfaceImplementingPrivateInterfaceInModule : Symbol(publicInterfaceImplementingPrivateInterfaceInModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 39, 5))
->privateInterfaceInPrivateModule : Symbol(privateInterfaceInPrivateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 29, 5))
-    }
-
-    interface privateInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule {
->privateInterfaceImplementingFromPrivateModuleInterface : Symbol(privateInterfaceImplementingFromPrivateModuleInterface, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 41, 5))
->privateModule.publicInterfaceInPrivateModule : Symbol(publicInterfaceInPrivateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 26, 22))
->privateModule : Symbol(privateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 24, 1))
->publicInterfaceInPrivateModule : Symbol(publicInterfaceInPrivateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 26, 22))
-    }
-    export interface publicInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule {
->publicInterfaceImplementingFromPrivateModuleInterface : Symbol(publicInterfaceImplementingFromPrivateModuleInterface, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 44, 5))
->privateModule.publicInterfaceInPrivateModule : Symbol(publicInterfaceInPrivateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 26, 22))
->privateModule : Symbol(privateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 24, 1))
->publicInterfaceInPrivateModule : Symbol(publicInterfaceInPrivateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 26, 22))
-    }
-}
-
-export interface publicInterface {
->publicInterface : Symbol(publicInterface, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 47, 1))
-
-}
-
-interface privateInterface {
->privateInterface : Symbol(privateInterface, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 51, 1))
-}
-
-interface privateInterfaceImplementingPublicInterface extends publicInterface {
->privateInterfaceImplementingPublicInterface : Symbol(privateInterfaceImplementingPublicInterface, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 54, 1))
->publicInterface : Symbol(publicInterface, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 47, 1))
-}
-interface privateInterfaceImplementingPrivateInterfaceInModule extends privateInterface {
->privateInterfaceImplementingPrivateInterfaceInModule : Symbol(privateInterfaceImplementingPrivateInterfaceInModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 57, 1))
->privateInterface : Symbol(privateInterface, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 51, 1))
-}
-export interface publicInterfaceImplementingPublicInterface extends publicInterface {
->publicInterfaceImplementingPublicInterface : Symbol(publicInterfaceImplementingPublicInterface, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 59, 1))
->publicInterface : Symbol(publicInterface, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 47, 1))
-}
-export interface publicInterfaceImplementingPrivateInterface extends privateInterface { // Should error
->publicInterfaceImplementingPrivateInterface : Symbol(publicInterfaceImplementingPrivateInterface, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 61, 1))
->privateInterface : Symbol(privateInterface, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 51, 1))
-}
-
-interface privateInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule {
->privateInterfaceImplementingFromPrivateModuleInterface : Symbol(privateInterfaceImplementingFromPrivateModuleInterface, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 63, 1))
->privateModule.publicInterfaceInPrivateModule : Symbol(privateModule.publicInterfaceInPrivateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 26, 22))
->privateModule : Symbol(privateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 24, 1))
->publicInterfaceInPrivateModule : Symbol(privateModule.publicInterfaceInPrivateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 26, 22))
-}
-export interface publicInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule { // Should error
->publicInterfaceImplementingFromPrivateModuleInterface : Symbol(publicInterfaceImplementingFromPrivateModuleInterface, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 66, 1))
->privateModule.publicInterfaceInPrivateModule : Symbol(privateModule.publicInterfaceInPrivateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 26, 22))
->privateModule : Symbol(privateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 24, 1))
->publicInterfaceInPrivateModule : Symbol(privateModule.publicInterfaceInPrivateModule, Decl(privacyInterfaceExtendsClauseDeclFile_externalModule.ts, 26, 22))
-}
-
-=== tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts ===
-module publicModuleInGlobal {
->publicModuleInGlobal : Symbol(publicModuleInGlobal, Decl(privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts, 0, 0))
-
-    export interface publicInterfaceInPublicModule {
->publicInterfaceInPublicModule : Symbol(publicInterfaceInPublicModule, Decl(privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts, 0, 29))
-    }
-
-    interface privateInterfaceInPublicModule {
->privateInterfaceInPublicModule : Symbol(privateInterfaceInPublicModule, Decl(privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts, 2, 5))
-    }
-
-    interface privateInterfaceImplementingPublicInterfaceInModule extends publicInterfaceInPublicModule {
->privateInterfaceImplementingPublicInterfaceInModule : Symbol(privateInterfaceImplementingPublicInterfaceInModule, Decl(privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts, 5, 5))
->publicInterfaceInPublicModule : Symbol(publicInterfaceInPublicModule, Decl(privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts, 0, 29))
-    }
-    interface privateInterfaceImplementingPrivateInterfaceInModule extends privateInterfaceInPublicModule {
->privateInterfaceImplementingPrivateInterfaceInModule : Symbol(privateInterfaceImplementingPrivateInterfaceInModule, Decl(privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts, 8, 5))
->privateInterfaceInPublicModule : Symbol(privateInterfaceInPublicModule, Decl(privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts, 2, 5))
-    }
-    export interface publicInterfaceImplementingPublicInterfaceInModule extends publicInterfaceInPublicModule {
->publicInterfaceImplementingPublicInterfaceInModule : Symbol(publicInterfaceImplementingPublicInterfaceInModule, Decl(privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts, 10, 5))
->publicInterfaceInPublicModule : Symbol(publicInterfaceInPublicModule, Decl(privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts, 0, 29))
-    }
-    export interface publicInterfaceImplementingPrivateInterfaceInModule extends privateInterfaceInPublicModule { // Should error
->publicInterfaceImplementingPrivateInterfaceInModule : Symbol(publicInterfaceImplementingPrivateInterfaceInModule, Decl(privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts, 12, 5))
->privateInterfaceInPublicModule : Symbol(privateInterfaceInPublicModule, Decl(privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts, 2, 5))
-    }
-}
-interface publicInterfaceInGlobal {
->publicInterfaceInGlobal : Symbol(publicInterfaceInGlobal, Decl(privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts, 15, 1))
-}
-interface publicInterfaceImplementingPublicInterfaceInGlobal extends publicInterfaceInGlobal {
->publicInterfaceImplementingPublicInterfaceInGlobal : Symbol(publicInterfaceImplementingPublicInterfaceInGlobal, Decl(privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts, 17, 1))
->publicInterfaceInGlobal : Symbol(publicInterfaceInGlobal, Decl(privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts, 15, 1))
-}
-
diff --git a/tests/baselines/reference/privacyLocalInternalReferenceImportWithExport.symbols b/tests/baselines/reference/privacyLocalInternalReferenceImportWithExport.symbols
deleted file mode 100644
index ab5f1540ef9a6..0000000000000
--- a/tests/baselines/reference/privacyLocalInternalReferenceImportWithExport.symbols
+++ /dev/null
@@ -1,510 +0,0 @@
-=== tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts ===
-// private elements
-module m_private {
->m_private : Symbol(m_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 0, 0))
-
-    export class c_private {
->c_private : Symbol(c_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 1, 18))
-    }
-    export enum e_private {
->e_private : Symbol(e_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 3, 5))
-
-        Happy,
->Happy : Symbol(e_private.Happy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 4, 27))
-
-        Grumpy
->Grumpy : Symbol(e_private.Grumpy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 5, 14))
-    }
-    export function f_private() {
->f_private : Symbol(f_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 7, 5))
-
-        return new c_private();
->c_private : Symbol(c_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 1, 18))
-    }
-    export var v_private = new c_private();
->v_private : Symbol(v_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 11, 14))
->c_private : Symbol(c_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 1, 18))
-
-    export interface i_private {
->i_private : Symbol(i_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 11, 43))
-    }
-    export module mi_private {
->mi_private : Symbol(mi_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 13, 5))
-
-        export class c {
->c : Symbol(c, Decl(privacyLocalInternalReferenceImportWithExport.ts, 14, 30))
-        }
-    }
-    export module mu_private {
->mu_private : Symbol(mu_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 17, 5))
-
-        export interface i {
->i : Symbol(i, Decl(privacyLocalInternalReferenceImportWithExport.ts, 18, 30))
-        }
-    }
-}
-
-// Public elements
-export module m_public {
->m_public : Symbol(m_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 22, 1))
-
-    export class c_public {
->c_public : Symbol(c_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 25, 24))
-    }
-    export enum e_public {
->e_public : Symbol(e_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 27, 5))
-
-        Happy,
->Happy : Symbol(e_public.Happy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 28, 26))
-
-        Grumpy
->Grumpy : Symbol(e_public.Grumpy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 29, 14))
-    }
-    export function f_public() {
->f_public : Symbol(f_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 31, 5))
-
-        return new c_public();
->c_public : Symbol(c_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 25, 24))
-    }
-    export var v_public = 10;
->v_public : Symbol(v_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 35, 14))
-
-    export interface i_public {
->i_public : Symbol(i_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 35, 29))
-    }
-    export module mi_public {
->mi_public : Symbol(mi_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 37, 5))
-
-        export class c {
->c : Symbol(c, Decl(privacyLocalInternalReferenceImportWithExport.ts, 38, 29))
-        }
-    }
-    export module mu_public {
->mu_public : Symbol(mu_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 41, 5))
-
-        export interface i {
->i : Symbol(i, Decl(privacyLocalInternalReferenceImportWithExport.ts, 42, 29))
-        }
-    }
-}
-
-export module import_public {
->import_public : Symbol(import_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 46, 1))
-
-    // Privacy errors - importing private elements
-    export import im_public_c_private = m_private.c_private;
->im_public_c_private : Symbol(im_public_c_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 48, 29))
->m_private : Symbol(m_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 0, 0))
->c_private : Symbol(im_public_c_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 1, 18))
-
-    export import im_public_e_private = m_private.e_private;
->im_public_e_private : Symbol(im_public_e_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 50, 60))
->m_private : Symbol(m_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 0, 0))
->e_private : Symbol(im_public_e_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 3, 5))
-
-    export import im_public_f_private = m_private.f_private;
->im_public_f_private : Symbol(im_public_f_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 51, 60))
->m_private : Symbol(m_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 0, 0))
->f_private : Symbol(im_public_f_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 7, 5))
-
-    export import im_public_v_private = m_private.v_private;
->im_public_v_private : Symbol(im_public_v_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 52, 60))
->m_private : Symbol(m_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 0, 0))
->v_private : Symbol(im_public_v_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 11, 14))
-
-    export import im_public_i_private = m_private.i_private;
->im_public_i_private : Symbol(im_public_i_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 53, 60))
->m_private : Symbol(m_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 0, 0))
->i_private : Symbol(im_public_i_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 11, 43))
-
-    export import im_public_mi_private = m_private.mi_private;
->im_public_mi_private : Symbol(im_public_mi_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 54, 60))
->m_private : Symbol(m_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 0, 0))
->mi_private : Symbol(im_public_mi_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 13, 5))
-
-    export import im_public_mu_private = m_private.mu_private;
->im_public_mu_private : Symbol(im_public_mu_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 55, 62))
->m_private : Symbol(m_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 0, 0))
->mu_private : Symbol(im_public_mu_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 17, 5))
-
-    // Usage of privacy error imports
-    var privateUse_im_public_c_private = new im_public_c_private();
->privateUse_im_public_c_private : Symbol(privateUse_im_public_c_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 59, 7))
->im_public_c_private : Symbol(im_public_c_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 48, 29))
-
-    export var publicUse_im_public_c_private = new im_public_c_private();
->publicUse_im_public_c_private : Symbol(publicUse_im_public_c_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 60, 14))
->im_public_c_private : Symbol(im_public_c_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 48, 29))
-
-    var privateUse_im_public_e_private = im_public_e_private.Happy;
->privateUse_im_public_e_private : Symbol(privateUse_im_public_e_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 61, 7))
->im_public_e_private.Happy : Symbol(im_public_e_private.Happy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 4, 27))
->im_public_e_private : Symbol(im_public_e_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 50, 60))
->Happy : Symbol(im_public_e_private.Happy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 4, 27))
-
-    export var publicUse_im_public_e_private = im_public_e_private.Grumpy;
->publicUse_im_public_e_private : Symbol(publicUse_im_public_e_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 62, 14))
->im_public_e_private.Grumpy : Symbol(im_public_e_private.Grumpy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 5, 14))
->im_public_e_private : Symbol(im_public_e_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 50, 60))
->Grumpy : Symbol(im_public_e_private.Grumpy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 5, 14))
-
-    var privateUse_im_public_f_private = im_public_f_private();
->privateUse_im_public_f_private : Symbol(privateUse_im_public_f_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 63, 7))
->im_public_f_private : Symbol(im_public_f_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 51, 60))
-
-    export var publicUse_im_public_f_private = im_public_f_private();
->publicUse_im_public_f_private : Symbol(publicUse_im_public_f_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 64, 14))
->im_public_f_private : Symbol(im_public_f_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 51, 60))
-
-    var privateUse_im_public_v_private = im_public_v_private;
->privateUse_im_public_v_private : Symbol(privateUse_im_public_v_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 65, 7))
->im_public_v_private : Symbol(im_public_v_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 52, 60))
-
-    export var publicUse_im_public_v_private = im_public_v_private;
->publicUse_im_public_v_private : Symbol(publicUse_im_public_v_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 66, 14))
->im_public_v_private : Symbol(im_public_v_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 52, 60))
-
-    var privateUse_im_public_i_private: im_public_i_private;
->privateUse_im_public_i_private : Symbol(privateUse_im_public_i_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 67, 7))
->im_public_i_private : Symbol(im_public_i_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 53, 60))
-
-    export var publicUse_im_public_i_private: im_public_i_private;
->publicUse_im_public_i_private : Symbol(publicUse_im_public_i_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 68, 14))
->im_public_i_private : Symbol(im_public_i_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 53, 60))
-
-    var privateUse_im_public_mi_private = new im_public_mi_private.c();
->privateUse_im_public_mi_private : Symbol(privateUse_im_public_mi_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 69, 7))
->im_public_mi_private.c : Symbol(im_public_mi_private.c, Decl(privacyLocalInternalReferenceImportWithExport.ts, 14, 30))
->im_public_mi_private : Symbol(im_public_mi_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 54, 60))
->c : Symbol(im_public_mi_private.c, Decl(privacyLocalInternalReferenceImportWithExport.ts, 14, 30))
-
-    export var publicUse_im_public_mi_private = new im_public_mi_private.c();
->publicUse_im_public_mi_private : Symbol(publicUse_im_public_mi_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 70, 14))
->im_public_mi_private.c : Symbol(im_public_mi_private.c, Decl(privacyLocalInternalReferenceImportWithExport.ts, 14, 30))
->im_public_mi_private : Symbol(im_public_mi_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 54, 60))
->c : Symbol(im_public_mi_private.c, Decl(privacyLocalInternalReferenceImportWithExport.ts, 14, 30))
-
-    var privateUse_im_public_mu_private: im_public_mu_private.i;
->privateUse_im_public_mu_private : Symbol(privateUse_im_public_mu_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 71, 7))
->im_public_mu_private : Symbol(im_public_mu_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 55, 62))
->i : Symbol(im_public_mu_private.i, Decl(privacyLocalInternalReferenceImportWithExport.ts, 18, 30))
-
-    export var publicUse_im_public_mu_private: im_public_mu_private.i;
->publicUse_im_public_mu_private : Symbol(publicUse_im_public_mu_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 72, 14))
->im_public_mu_private : Symbol(im_public_mu_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 55, 62))
->i : Symbol(im_public_mu_private.i, Decl(privacyLocalInternalReferenceImportWithExport.ts, 18, 30))
-
-
-    // No Privacy errors - importing public elements
-    export import im_public_c_public = m_public.c_public;
->im_public_c_public : Symbol(im_public_c_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 72, 70))
->m_public : Symbol(m_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 22, 1))
->c_public : Symbol(im_public_c_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 25, 24))
-
-    export import im_public_e_public = m_public.e_public;
->im_public_e_public : Symbol(im_public_e_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 76, 57))
->m_public : Symbol(m_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 22, 1))
->e_public : Symbol(im_public_e_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 27, 5))
-
-    export import im_public_f_public = m_public.f_public;
->im_public_f_public : Symbol(im_public_f_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 77, 57))
->m_public : Symbol(m_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 22, 1))
->f_public : Symbol(im_public_f_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 31, 5))
-
-    export import im_public_v_public = m_public.v_public;
->im_public_v_public : Symbol(im_public_v_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 78, 57))
->m_public : Symbol(m_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 22, 1))
->v_public : Symbol(im_public_v_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 35, 14))
-
-    export import im_public_i_public = m_public.i_public;
->im_public_i_public : Symbol(im_public_i_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 79, 57))
->m_public : Symbol(m_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 22, 1))
->i_public : Symbol(im_public_i_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 35, 29))
-
-    export import im_public_mi_public = m_public.mi_public;
->im_public_mi_public : Symbol(im_public_mi_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 80, 57))
->m_public : Symbol(m_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 22, 1))
->mi_public : Symbol(im_public_mi_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 37, 5))
-
-    export import im_public_mu_public = m_public.mu_public;
->im_public_mu_public : Symbol(im_public_mu_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 81, 59))
->m_public : Symbol(m_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 22, 1))
->mu_public : Symbol(im_public_mu_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 41, 5))
-
-    // Usage of above
-    var privateUse_im_public_c_public = new im_public_c_public();
->privateUse_im_public_c_public : Symbol(privateUse_im_public_c_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 85, 7))
->im_public_c_public : Symbol(im_public_c_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 72, 70))
-
-    export var publicUse_im_public_c_public = new im_public_c_public();
->publicUse_im_public_c_public : Symbol(publicUse_im_public_c_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 86, 14))
->im_public_c_public : Symbol(im_public_c_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 72, 70))
-
-    var privateUse_im_public_e_public = im_public_e_public.Happy;
->privateUse_im_public_e_public : Symbol(privateUse_im_public_e_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 87, 7))
->im_public_e_public.Happy : Symbol(im_public_e_public.Happy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 28, 26))
->im_public_e_public : Symbol(im_public_e_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 76, 57))
->Happy : Symbol(im_public_e_public.Happy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 28, 26))
-
-    export var publicUse_im_public_e_public = im_public_e_public.Grumpy;
->publicUse_im_public_e_public : Symbol(publicUse_im_public_e_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 88, 14))
->im_public_e_public.Grumpy : Symbol(im_public_e_public.Grumpy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 29, 14))
->im_public_e_public : Symbol(im_public_e_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 76, 57))
->Grumpy : Symbol(im_public_e_public.Grumpy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 29, 14))
-
-    var privateUse_im_public_f_public = im_public_f_public();
->privateUse_im_public_f_public : Symbol(privateUse_im_public_f_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 89, 7))
->im_public_f_public : Symbol(im_public_f_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 77, 57))
-
-    export var publicUse_im_public_f_public = im_public_f_public();
->publicUse_im_public_f_public : Symbol(publicUse_im_public_f_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 90, 14))
->im_public_f_public : Symbol(im_public_f_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 77, 57))
-
-    var privateUse_im_public_v_public = im_public_v_public;
->privateUse_im_public_v_public : Symbol(privateUse_im_public_v_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 91, 7))
->im_public_v_public : Symbol(im_public_v_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 78, 57))
-
-    export var publicUse_im_public_v_public = im_public_v_public;
->publicUse_im_public_v_public : Symbol(publicUse_im_public_v_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 92, 14))
->im_public_v_public : Symbol(im_public_v_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 78, 57))
-
-    var privateUse_im_public_i_public: im_public_i_public;
->privateUse_im_public_i_public : Symbol(privateUse_im_public_i_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 93, 7))
->im_public_i_public : Symbol(im_public_i_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 79, 57))
-
-    export var publicUse_im_public_i_public: im_public_i_public;
->publicUse_im_public_i_public : Symbol(publicUse_im_public_i_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 94, 14))
->im_public_i_public : Symbol(im_public_i_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 79, 57))
-
-    var privateUse_im_public_mi_public = new im_public_mi_public.c();
->privateUse_im_public_mi_public : Symbol(privateUse_im_public_mi_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 95, 7))
->im_public_mi_public.c : Symbol(im_public_mi_public.c, Decl(privacyLocalInternalReferenceImportWithExport.ts, 38, 29))
->im_public_mi_public : Symbol(im_public_mi_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 80, 57))
->c : Symbol(im_public_mi_public.c, Decl(privacyLocalInternalReferenceImportWithExport.ts, 38, 29))
-
-    export var publicUse_im_public_mi_public = new im_public_mi_public.c();
->publicUse_im_public_mi_public : Symbol(publicUse_im_public_mi_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 96, 14))
->im_public_mi_public.c : Symbol(im_public_mi_public.c, Decl(privacyLocalInternalReferenceImportWithExport.ts, 38, 29))
->im_public_mi_public : Symbol(im_public_mi_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 80, 57))
->c : Symbol(im_public_mi_public.c, Decl(privacyLocalInternalReferenceImportWithExport.ts, 38, 29))
-
-    var privateUse_im_public_mu_public: im_public_mu_public.i;
->privateUse_im_public_mu_public : Symbol(privateUse_im_public_mu_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 97, 7))
->im_public_mu_public : Symbol(im_public_mu_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 81, 59))
->i : Symbol(im_public_mu_public.i, Decl(privacyLocalInternalReferenceImportWithExport.ts, 42, 29))
-
-    export var publicUse_im_public_mu_public: im_public_mu_public.i;
->publicUse_im_public_mu_public : Symbol(publicUse_im_public_mu_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 98, 14))
->im_public_mu_public : Symbol(im_public_mu_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 81, 59))
->i : Symbol(im_public_mu_public.i, Decl(privacyLocalInternalReferenceImportWithExport.ts, 42, 29))
-}
-
-module import_private {
->import_private : Symbol(import_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 99, 1))
-
-    // No Privacy errors - importing private elements
-    export import im_private_c_private = m_private.c_private;
->im_private_c_private : Symbol(im_private_c_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 101, 23))
->m_private : Symbol(m_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 0, 0))
->c_private : Symbol(im_private_c_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 1, 18))
-
-    export import im_private_e_private = m_private.e_private;
->im_private_e_private : Symbol(im_private_e_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 103, 61))
->m_private : Symbol(m_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 0, 0))
->e_private : Symbol(im_private_e_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 3, 5))
-
-    export import im_private_f_private = m_private.f_private;
->im_private_f_private : Symbol(im_private_f_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 104, 61))
->m_private : Symbol(m_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 0, 0))
->f_private : Symbol(im_private_f_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 7, 5))
-
-    export import im_private_v_private = m_private.v_private;
->im_private_v_private : Symbol(im_private_v_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 105, 61))
->m_private : Symbol(m_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 0, 0))
->v_private : Symbol(im_private_v_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 11, 14))
-
-    export import im_private_i_private = m_private.i_private;
->im_private_i_private : Symbol(im_private_i_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 106, 61))
->m_private : Symbol(m_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 0, 0))
->i_private : Symbol(im_private_i_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 11, 43))
-
-    export import im_private_mi_private = m_private.mi_private;
->im_private_mi_private : Symbol(im_private_mi_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 107, 61))
->m_private : Symbol(m_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 0, 0))
->mi_private : Symbol(im_private_mi_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 13, 5))
-
-    export import im_private_mu_private = m_private.mu_private;
->im_private_mu_private : Symbol(im_private_mu_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 108, 63))
->m_private : Symbol(m_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 0, 0))
->mu_private : Symbol(im_private_mu_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 17, 5))
-
-    // Usage of above decls
-    var privateUse_im_private_c_private = new im_private_c_private();
->privateUse_im_private_c_private : Symbol(privateUse_im_private_c_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 112, 7))
->im_private_c_private : Symbol(im_private_c_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 101, 23))
-
-    export var publicUse_im_private_c_private = new im_private_c_private();
->publicUse_im_private_c_private : Symbol(publicUse_im_private_c_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 113, 14))
->im_private_c_private : Symbol(im_private_c_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 101, 23))
-
-    var privateUse_im_private_e_private = im_private_e_private.Happy;
->privateUse_im_private_e_private : Symbol(privateUse_im_private_e_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 114, 7))
->im_private_e_private.Happy : Symbol(im_private_e_private.Happy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 4, 27))
->im_private_e_private : Symbol(im_private_e_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 103, 61))
->Happy : Symbol(im_private_e_private.Happy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 4, 27))
-
-    export var publicUse_im_private_e_private = im_private_e_private.Grumpy;
->publicUse_im_private_e_private : Symbol(publicUse_im_private_e_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 115, 14))
->im_private_e_private.Grumpy : Symbol(im_private_e_private.Grumpy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 5, 14))
->im_private_e_private : Symbol(im_private_e_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 103, 61))
->Grumpy : Symbol(im_private_e_private.Grumpy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 5, 14))
-
-    var privateUse_im_private_f_private = im_private_f_private();
->privateUse_im_private_f_private : Symbol(privateUse_im_private_f_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 116, 7))
->im_private_f_private : Symbol(im_private_f_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 104, 61))
-
-    export var publicUse_im_private_f_private = im_private_f_private();
->publicUse_im_private_f_private : Symbol(publicUse_im_private_f_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 117, 14))
->im_private_f_private : Symbol(im_private_f_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 104, 61))
-
-    var privateUse_im_private_v_private = im_private_v_private;
->privateUse_im_private_v_private : Symbol(privateUse_im_private_v_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 118, 7))
->im_private_v_private : Symbol(im_private_v_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 105, 61))
-
-    export var publicUse_im_private_v_private = im_private_v_private;
->publicUse_im_private_v_private : Symbol(publicUse_im_private_v_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 119, 14))
->im_private_v_private : Symbol(im_private_v_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 105, 61))
-
-    var privateUse_im_private_i_private: im_private_i_private;
->privateUse_im_private_i_private : Symbol(privateUse_im_private_i_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 120, 7))
->im_private_i_private : Symbol(im_private_i_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 106, 61))
-
-    export var publicUse_im_private_i_private: im_private_i_private;
->publicUse_im_private_i_private : Symbol(publicUse_im_private_i_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 121, 14))
->im_private_i_private : Symbol(im_private_i_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 106, 61))
-
-    var privateUse_im_private_mi_private = new im_private_mi_private.c();
->privateUse_im_private_mi_private : Symbol(privateUse_im_private_mi_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 122, 7))
->im_private_mi_private.c : Symbol(im_private_mi_private.c, Decl(privacyLocalInternalReferenceImportWithExport.ts, 14, 30))
->im_private_mi_private : Symbol(im_private_mi_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 107, 61))
->c : Symbol(im_private_mi_private.c, Decl(privacyLocalInternalReferenceImportWithExport.ts, 14, 30))
-
-    export var publicUse_im_private_mi_private = new im_private_mi_private.c();
->publicUse_im_private_mi_private : Symbol(publicUse_im_private_mi_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 123, 14))
->im_private_mi_private.c : Symbol(im_private_mi_private.c, Decl(privacyLocalInternalReferenceImportWithExport.ts, 14, 30))
->im_private_mi_private : Symbol(im_private_mi_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 107, 61))
->c : Symbol(im_private_mi_private.c, Decl(privacyLocalInternalReferenceImportWithExport.ts, 14, 30))
-
-    var privateUse_im_private_mu_private: im_private_mu_private.i;
->privateUse_im_private_mu_private : Symbol(privateUse_im_private_mu_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 124, 7))
->im_private_mu_private : Symbol(im_private_mu_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 108, 63))
->i : Symbol(im_private_mu_private.i, Decl(privacyLocalInternalReferenceImportWithExport.ts, 18, 30))
-
-    export var publicUse_im_private_mu_private: im_private_mu_private.i;
->publicUse_im_private_mu_private : Symbol(publicUse_im_private_mu_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 125, 14))
->im_private_mu_private : Symbol(im_private_mu_private, Decl(privacyLocalInternalReferenceImportWithExport.ts, 108, 63))
->i : Symbol(im_private_mu_private.i, Decl(privacyLocalInternalReferenceImportWithExport.ts, 18, 30))
-
-    // No privacy Error - importing public elements
-    export import im_private_c_public = m_public.c_public;
->im_private_c_public : Symbol(im_private_c_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 125, 72))
->m_public : Symbol(m_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 22, 1))
->c_public : Symbol(im_private_c_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 25, 24))
-
-    export import im_private_e_public = m_public.e_public;
->im_private_e_public : Symbol(im_private_e_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 128, 58))
->m_public : Symbol(m_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 22, 1))
->e_public : Symbol(im_private_e_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 27, 5))
-
-    export import im_private_f_public = m_public.f_public;
->im_private_f_public : Symbol(im_private_f_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 129, 58))
->m_public : Symbol(m_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 22, 1))
->f_public : Symbol(im_private_f_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 31, 5))
-
-    export import im_private_v_public = m_public.v_public;
->im_private_v_public : Symbol(im_private_v_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 130, 58))
->m_public : Symbol(m_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 22, 1))
->v_public : Symbol(im_private_v_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 35, 14))
-
-    export import im_private_i_public = m_public.i_public;
->im_private_i_public : Symbol(im_private_i_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 131, 58))
->m_public : Symbol(m_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 22, 1))
->i_public : Symbol(im_private_i_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 35, 29))
-
-    export import im_private_mi_public = m_public.mi_public;
->im_private_mi_public : Symbol(im_private_mi_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 132, 58))
->m_public : Symbol(m_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 22, 1))
->mi_public : Symbol(im_private_mi_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 37, 5))
-
-    export import im_private_mu_public = m_public.mu_public;
->im_private_mu_public : Symbol(im_private_mu_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 133, 60))
->m_public : Symbol(m_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 22, 1))
->mu_public : Symbol(im_private_mu_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 41, 5))
-
-    // Usage of no privacy error imports
-    var privateUse_im_private_c_public = new im_private_c_public();
->privateUse_im_private_c_public : Symbol(privateUse_im_private_c_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 137, 7))
->im_private_c_public : Symbol(im_private_c_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 125, 72))
-
-    export var publicUse_im_private_c_public = new im_private_c_public();
->publicUse_im_private_c_public : Symbol(publicUse_im_private_c_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 138, 14))
->im_private_c_public : Symbol(im_private_c_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 125, 72))
-
-    var privateUse_im_private_e_public = im_private_e_public.Happy;
->privateUse_im_private_e_public : Symbol(privateUse_im_private_e_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 139, 7))
->im_private_e_public.Happy : Symbol(im_private_e_public.Happy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 28, 26))
->im_private_e_public : Symbol(im_private_e_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 128, 58))
->Happy : Symbol(im_private_e_public.Happy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 28, 26))
-
-    export var publicUse_im_private_e_public = im_private_e_public.Grumpy;
->publicUse_im_private_e_public : Symbol(publicUse_im_private_e_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 140, 14))
->im_private_e_public.Grumpy : Symbol(im_private_e_public.Grumpy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 29, 14))
->im_private_e_public : Symbol(im_private_e_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 128, 58))
->Grumpy : Symbol(im_private_e_public.Grumpy, Decl(privacyLocalInternalReferenceImportWithExport.ts, 29, 14))
-
-    var privateUse_im_private_f_public = im_private_f_public();
->privateUse_im_private_f_public : Symbol(privateUse_im_private_f_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 141, 7))
->im_private_f_public : Symbol(im_private_f_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 129, 58))
-
-    export var publicUse_im_private_f_public = im_private_f_public();
->publicUse_im_private_f_public : Symbol(publicUse_im_private_f_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 142, 14))
->im_private_f_public : Symbol(im_private_f_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 129, 58))
-
-    var privateUse_im_private_v_public = im_private_v_public;
->privateUse_im_private_v_public : Symbol(privateUse_im_private_v_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 143, 7))
->im_private_v_public : Symbol(im_private_v_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 130, 58))
-
-    export var publicUse_im_private_v_public = im_private_v_public;
->publicUse_im_private_v_public : Symbol(publicUse_im_private_v_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 144, 14))
->im_private_v_public : Symbol(im_private_v_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 130, 58))
-
-    var privateUse_im_private_i_public: im_private_i_public;
->privateUse_im_private_i_public : Symbol(privateUse_im_private_i_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 145, 7))
->im_private_i_public : Symbol(im_private_i_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 131, 58))
-
-    export var publicUse_im_private_i_public: im_private_i_public;
->publicUse_im_private_i_public : Symbol(publicUse_im_private_i_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 146, 14))
->im_private_i_public : Symbol(im_private_i_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 131, 58))
-
-    var privateUse_im_private_mi_public = new im_private_mi_public.c();
->privateUse_im_private_mi_public : Symbol(privateUse_im_private_mi_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 147, 7))
->im_private_mi_public.c : Symbol(im_private_mi_public.c, Decl(privacyLocalInternalReferenceImportWithExport.ts, 38, 29))
->im_private_mi_public : Symbol(im_private_mi_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 132, 58))
->c : Symbol(im_private_mi_public.c, Decl(privacyLocalInternalReferenceImportWithExport.ts, 38, 29))
-
-    export var publicUse_im_private_mi_public = new im_private_mi_public.c();
->publicUse_im_private_mi_public : Symbol(publicUse_im_private_mi_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 148, 14))
->im_private_mi_public.c : Symbol(im_private_mi_public.c, Decl(privacyLocalInternalReferenceImportWithExport.ts, 38, 29))
->im_private_mi_public : Symbol(im_private_mi_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 132, 58))
->c : Symbol(im_private_mi_public.c, Decl(privacyLocalInternalReferenceImportWithExport.ts, 38, 29))
-
-    var privateUse_im_private_mu_public: im_private_mu_public.i;
->privateUse_im_private_mu_public : Symbol(privateUse_im_private_mu_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 149, 7))
->im_private_mu_public : Symbol(im_private_mu_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 133, 60))
->i : Symbol(im_private_mu_public.i, Decl(privacyLocalInternalReferenceImportWithExport.ts, 42, 29))
-
-    export var publicUse_im_private_mu_public: im_private_mu_public.i;
->publicUse_im_private_mu_public : Symbol(publicUse_im_private_mu_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 150, 14))
->im_private_mu_public : Symbol(im_private_mu_public, Decl(privacyLocalInternalReferenceImportWithExport.ts, 133, 60))
->i : Symbol(im_private_mu_public.i, Decl(privacyLocalInternalReferenceImportWithExport.ts, 42, 29))
-}
diff --git a/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithExport.symbols b/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithExport.symbols
deleted file mode 100644
index 7d6e732ce247f..0000000000000
--- a/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithExport.symbols
+++ /dev/null
@@ -1,297 +0,0 @@
-=== tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts ===
-// private elements
-module m_private {
->m_private : Symbol(m_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 0, 0))
-
-    export class c_private {
->c_private : Symbol(c_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 1, 18))
-    }
-    export enum e_private {
->e_private : Symbol(e_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 3, 5))
-
-        Happy,
->Happy : Symbol(im_public_e_private.Happy, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 4, 27))
-
-        Grumpy
->Grumpy : Symbol(im_public_e_private.Grumpy, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 5, 14))
-    }
-    export function f_private() {
->f_private : Symbol(f_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 7, 5))
-
-        return new c_private();
->c_private : Symbol(c_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 1, 18))
-    }
-    export var v_private = new c_private();
->v_private : Symbol(v_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 11, 14))
->c_private : Symbol(c_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 1, 18))
-
-    export interface i_private {
->i_private : Symbol(i_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 11, 43))
-    }
-    export module mi_private {
->mi_private : Symbol(mi_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 13, 5))
-
-        export class c {
->c : Symbol(c, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 14, 30))
-        }
-    }
-    export module mu_private {
->mu_private : Symbol(mu_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 17, 5))
-
-        export interface i {
->i : Symbol(i, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 18, 30))
-        }
-    }
-}
-
-// Public elements
-export module m_public {
->m_public : Symbol(m_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 22, 1))
-
-    export class c_public {
->c_public : Symbol(c_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 25, 24))
-    }
-    export enum e_public {
->e_public : Symbol(e_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 27, 5))
-
-        Happy,
->Happy : Symbol(im_public_e_public.Happy, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 28, 26))
-
-        Grumpy
->Grumpy : Symbol(im_public_e_public.Grumpy, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 29, 14))
-    }
-    export function f_public() {
->f_public : Symbol(f_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 31, 5))
-
-        return new c_public();
->c_public : Symbol(c_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 25, 24))
-    }
-    export var v_public = 10;
->v_public : Symbol(v_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 35, 14))
-
-    export interface i_public {
->i_public : Symbol(i_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 35, 29))
-    }
-    export module mi_public {
->mi_public : Symbol(mi_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 37, 5))
-
-        export class c {
->c : Symbol(c, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 38, 29))
-        }
-    }
-    export module mu_public {
->mu_public : Symbol(mu_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 41, 5))
-
-        export interface i {
->i : Symbol(i, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 42, 29))
-        }
-    }
-}
-
-// Privacy errors - importing private elements
-export import im_public_c_private = m_private.c_private;
->im_public_c_private : Symbol(im_public_c_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 46, 1))
->m_private : Symbol(m_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 0, 0))
->c_private : Symbol(im_public_c_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 1, 18))
-
-export import im_public_e_private = m_private.e_private;
->im_public_e_private : Symbol(im_public_e_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 49, 56))
->m_private : Symbol(m_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 0, 0))
->e_private : Symbol(im_public_e_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 3, 5))
-
-export import im_public_f_private = m_private.f_private;
->im_public_f_private : Symbol(im_public_f_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 50, 56))
->m_private : Symbol(m_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 0, 0))
->f_private : Symbol(im_public_f_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 7, 5))
-
-export import im_public_v_private = m_private.v_private;
->im_public_v_private : Symbol(im_public_v_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 51, 56))
->m_private : Symbol(m_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 0, 0))
->v_private : Symbol(im_public_v_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 11, 14))
-
-export import im_public_i_private = m_private.i_private;
->im_public_i_private : Symbol(im_public_i_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 52, 56))
->m_private : Symbol(m_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 0, 0))
->i_private : Symbol(im_public_i_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 11, 43))
-
-export import im_public_mi_private = m_private.mi_private;
->im_public_mi_private : Symbol(im_public_mi_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 53, 56))
->m_private : Symbol(m_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 0, 0))
->mi_private : Symbol(im_public_mi_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 13, 5))
-
-export import im_public_mu_private = m_private.mu_private;
->im_public_mu_private : Symbol(im_public_mu_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 54, 58))
->m_private : Symbol(m_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 0, 0))
->mu_private : Symbol(im_public_mu_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 17, 5))
-
-// Usage of privacy error imports
-var privateUse_im_public_c_private = new im_public_c_private();
->privateUse_im_public_c_private : Symbol(privateUse_im_public_c_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 58, 3))
->im_public_c_private : Symbol(im_public_c_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 46, 1))
-
-export var publicUse_im_public_c_private = new im_public_c_private();
->publicUse_im_public_c_private : Symbol(publicUse_im_public_c_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 59, 10))
->im_public_c_private : Symbol(im_public_c_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 46, 1))
-
-var privateUse_im_public_e_private = im_public_e_private.Happy;
->privateUse_im_public_e_private : Symbol(privateUse_im_public_e_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 60, 3))
->im_public_e_private.Happy : Symbol(im_public_e_private.Happy, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 4, 27))
->im_public_e_private : Symbol(im_public_e_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 49, 56))
->Happy : Symbol(im_public_e_private.Happy, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 4, 27))
-
-export var publicUse_im_public_e_private = im_public_e_private.Grumpy;
->publicUse_im_public_e_private : Symbol(publicUse_im_public_e_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 61, 10))
->im_public_e_private.Grumpy : Symbol(im_public_e_private.Grumpy, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 5, 14))
->im_public_e_private : Symbol(im_public_e_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 49, 56))
->Grumpy : Symbol(im_public_e_private.Grumpy, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 5, 14))
-
-var privateUse_im_public_f_private = im_public_f_private();
->privateUse_im_public_f_private : Symbol(privateUse_im_public_f_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 62, 3))
->im_public_f_private : Symbol(im_public_f_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 50, 56))
-
-export var publicUse_im_public_f_private = im_public_f_private();
->publicUse_im_public_f_private : Symbol(publicUse_im_public_f_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 63, 10))
->im_public_f_private : Symbol(im_public_f_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 50, 56))
-
-var privateUse_im_public_v_private = im_public_v_private;
->privateUse_im_public_v_private : Symbol(privateUse_im_public_v_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 64, 3))
->im_public_v_private : Symbol(im_public_v_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 51, 56))
-
-export var publicUse_im_public_v_private = im_public_v_private;
->publicUse_im_public_v_private : Symbol(publicUse_im_public_v_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 65, 10))
->im_public_v_private : Symbol(im_public_v_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 51, 56))
-
-var privateUse_im_public_i_private: im_public_i_private;
->privateUse_im_public_i_private : Symbol(privateUse_im_public_i_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 66, 3))
->im_public_i_private : Symbol(im_public_i_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 52, 56))
-
-export var publicUse_im_public_i_private: im_public_i_private;
->publicUse_im_public_i_private : Symbol(publicUse_im_public_i_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 67, 10))
->im_public_i_private : Symbol(im_public_i_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 52, 56))
-
-var privateUse_im_public_mi_private = new im_public_mi_private.c();
->privateUse_im_public_mi_private : Symbol(privateUse_im_public_mi_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 68, 3))
->im_public_mi_private.c : Symbol(im_public_mi_private.c, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 14, 30))
->im_public_mi_private : Symbol(im_public_mi_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 53, 56))
->c : Symbol(im_public_mi_private.c, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 14, 30))
-
-export var publicUse_im_public_mi_private = new im_public_mi_private.c();
->publicUse_im_public_mi_private : Symbol(publicUse_im_public_mi_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 69, 10))
->im_public_mi_private.c : Symbol(im_public_mi_private.c, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 14, 30))
->im_public_mi_private : Symbol(im_public_mi_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 53, 56))
->c : Symbol(im_public_mi_private.c, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 14, 30))
-
-var privateUse_im_public_mu_private: im_public_mu_private.i;
->privateUse_im_public_mu_private : Symbol(privateUse_im_public_mu_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 70, 3))
->im_public_mu_private : Symbol(im_public_mu_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 54, 58))
->i : Symbol(im_public_mu_private.i, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 18, 30))
-
-export var publicUse_im_public_mu_private: im_public_mu_private.i;
->publicUse_im_public_mu_private : Symbol(publicUse_im_public_mu_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 71, 10))
->im_public_mu_private : Symbol(im_public_mu_private, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 54, 58))
->i : Symbol(im_public_mu_private.i, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 18, 30))
-
-
-// No Privacy errors - importing public elements
-export import im_public_c_public = m_public.c_public;
->im_public_c_public : Symbol(im_public_c_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 71, 66))
->m_public : Symbol(m_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 22, 1))
->c_public : Symbol(im_public_c_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 25, 24))
-
-export import im_public_e_public = m_public.e_public;
->im_public_e_public : Symbol(im_public_e_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 75, 53))
->m_public : Symbol(m_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 22, 1))
->e_public : Symbol(im_public_e_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 27, 5))
-
-export import im_public_f_public = m_public.f_public;
->im_public_f_public : Symbol(im_public_f_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 76, 53))
->m_public : Symbol(m_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 22, 1))
->f_public : Symbol(im_public_f_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 31, 5))
-
-export import im_public_v_public = m_public.v_public;
->im_public_v_public : Symbol(im_public_v_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 77, 53))
->m_public : Symbol(m_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 22, 1))
->v_public : Symbol(im_public_v_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 35, 14))
-
-export import im_public_i_public = m_public.i_public;
->im_public_i_public : Symbol(im_public_i_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 78, 53))
->m_public : Symbol(m_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 22, 1))
->i_public : Symbol(im_public_i_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 35, 29))
-
-export import im_public_mi_public = m_public.mi_public;
->im_public_mi_public : Symbol(im_public_mi_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 79, 53))
->m_public : Symbol(m_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 22, 1))
->mi_public : Symbol(im_public_mi_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 37, 5))
-
-export import im_public_mu_public = m_public.mu_public;
->im_public_mu_public : Symbol(im_public_mu_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 80, 55))
->m_public : Symbol(m_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 22, 1))
->mu_public : Symbol(im_public_mu_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 41, 5))
-
-// Usage of above decls
-var privateUse_im_public_c_public = new im_public_c_public();
->privateUse_im_public_c_public : Symbol(privateUse_im_public_c_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 84, 3))
->im_public_c_public : Symbol(im_public_c_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 71, 66))
-
-export var publicUse_im_public_c_public = new im_public_c_public();
->publicUse_im_public_c_public : Symbol(publicUse_im_public_c_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 85, 10))
->im_public_c_public : Symbol(im_public_c_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 71, 66))
-
-var privateUse_im_public_e_public = im_public_e_public.Happy;
->privateUse_im_public_e_public : Symbol(privateUse_im_public_e_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 86, 3))
->im_public_e_public.Happy : Symbol(im_public_e_public.Happy, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 28, 26))
->im_public_e_public : Symbol(im_public_e_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 75, 53))
->Happy : Symbol(im_public_e_public.Happy, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 28, 26))
-
-export var publicUse_im_public_e_public = im_public_e_public.Grumpy;
->publicUse_im_public_e_public : Symbol(publicUse_im_public_e_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 87, 10))
->im_public_e_public.Grumpy : Symbol(im_public_e_public.Grumpy, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 29, 14))
->im_public_e_public : Symbol(im_public_e_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 75, 53))
->Grumpy : Symbol(im_public_e_public.Grumpy, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 29, 14))
-
-var privateUse_im_public_f_public = im_public_f_public();
->privateUse_im_public_f_public : Symbol(privateUse_im_public_f_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 88, 3))
->im_public_f_public : Symbol(im_public_f_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 76, 53))
-
-export var publicUse_im_public_f_public = im_public_f_public();
->publicUse_im_public_f_public : Symbol(publicUse_im_public_f_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 89, 10))
->im_public_f_public : Symbol(im_public_f_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 76, 53))
-
-var privateUse_im_public_v_public = im_public_v_public;
->privateUse_im_public_v_public : Symbol(privateUse_im_public_v_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 90, 3))
->im_public_v_public : Symbol(im_public_v_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 77, 53))
-
-export var publicUse_im_public_v_public = im_public_v_public;
->publicUse_im_public_v_public : Symbol(publicUse_im_public_v_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 91, 10))
->im_public_v_public : Symbol(im_public_v_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 77, 53))
-
-var privateUse_im_public_i_public: im_public_i_public;
->privateUse_im_public_i_public : Symbol(privateUse_im_public_i_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 92, 3))
->im_public_i_public : Symbol(im_public_i_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 78, 53))
-
-export var publicUse_im_public_i_public: im_public_i_public;
->publicUse_im_public_i_public : Symbol(publicUse_im_public_i_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 93, 10))
->im_public_i_public : Symbol(im_public_i_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 78, 53))
-
-var privateUse_im_public_mi_public = new im_public_mi_public.c();
->privateUse_im_public_mi_public : Symbol(privateUse_im_public_mi_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 94, 3))
->im_public_mi_public.c : Symbol(im_public_mi_public.c, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 38, 29))
->im_public_mi_public : Symbol(im_public_mi_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 79, 53))
->c : Symbol(im_public_mi_public.c, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 38, 29))
-
-export var publicUse_im_public_mi_public = new im_public_mi_public.c();
->publicUse_im_public_mi_public : Symbol(publicUse_im_public_mi_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 95, 10))
->im_public_mi_public.c : Symbol(im_public_mi_public.c, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 38, 29))
->im_public_mi_public : Symbol(im_public_mi_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 79, 53))
->c : Symbol(im_public_mi_public.c, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 38, 29))
-
-var privateUse_im_public_mu_public: im_public_mu_public.i;
->privateUse_im_public_mu_public : Symbol(privateUse_im_public_mu_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 96, 3))
->im_public_mu_public : Symbol(im_public_mu_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 80, 55))
->i : Symbol(im_public_mu_public.i, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 42, 29))
-
-export var publicUse_im_public_mu_public: im_public_mu_public.i;
->publicUse_im_public_mu_public : Symbol(publicUse_im_public_mu_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 97, 10))
->im_public_mu_public : Symbol(im_public_mu_public, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 80, 55))
->i : Symbol(im_public_mu_public.i, Decl(privacyTopLevelInternalReferenceImportWithExport.ts, 42, 29))
-
diff --git a/tests/baselines/reference/promiseChaining.symbols b/tests/baselines/reference/promiseChaining.symbols
index 5e30294c0731e..1ad7044faaecc 100644
--- a/tests/baselines/reference/promiseChaining.symbols
+++ b/tests/baselines/reference/promiseChaining.symbols
@@ -32,14 +32,11 @@ class Chain<T> {
 >this.then : Symbol(then, Decl(promiseChaining.ts, 1, 36))
 >this : Symbol(Chain, Decl(promiseChaining.ts, 0, 0))
 >then : Symbol(then, Decl(promiseChaining.ts, 1, 36))
->x => result : Symbol((Anonymous function), Decl(promiseChaining.ts, 5, 26))
 >x : Symbol(x, Decl(promiseChaining.ts, 5, 26))
 >result : Symbol(result, Decl(promiseChaining.ts, 3, 11))
 >then : Symbol(Chain.then, Decl(promiseChaining.ts, 1, 36))
->x => "abc" : Symbol((Anonymous function), Decl(promiseChaining.ts, 5, 49))
 >x : Symbol(x, Decl(promiseChaining.ts, 5, 49))
 >then : Symbol(Chain.then, Decl(promiseChaining.ts, 1, 36))
->x => x.length : Symbol((Anonymous function), Decl(promiseChaining.ts, 5, 76))
 >x : Symbol(x, Decl(promiseChaining.ts, 5, 76))
 >x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >x : Symbol(x, Decl(promiseChaining.ts, 5, 76))
diff --git a/tests/baselines/reference/promiseTest.symbols b/tests/baselines/reference/promiseTest.symbols
index b09c801e3e71f..229d3e089d0d5 100644
--- a/tests/baselines/reference/promiseTest.symbols
+++ b/tests/baselines/reference/promiseTest.symbols
@@ -39,7 +39,6 @@ var p2 = p.then(function (x) {
 >p.then : Symbol(Promise.then, Decl(promiseTest.ts, 1, 22), Decl(promiseTest.ts, 2, 60))
 >p : Symbol(p, Decl(promiseTest.ts, 7, 3))
 >then : Symbol(Promise.then, Decl(promiseTest.ts, 1, 22), Decl(promiseTest.ts, 2, 60))
->function (x) {    return p;} : Symbol((Anonymous function), Decl(promiseTest.ts, 8, 16))
 >x : Symbol(x, Decl(promiseTest.ts, 8, 26))
 
     return p;
diff --git a/tests/baselines/reference/promiseTypeInference.symbols b/tests/baselines/reference/promiseTypeInference.symbols
index 8669449a3911b..14a77b9cdf242 100644
--- a/tests/baselines/reference/promiseTypeInference.symbols
+++ b/tests/baselines/reference/promiseTypeInference.symbols
@@ -44,7 +44,6 @@ var $$x = load("something").then(s => convert(s));
 >load("something").then : Symbol(Promise.then, Decl(promiseTypeInference.ts, 0, 26))
 >load : Symbol(load, Decl(promiseTypeInference.ts, 5, 1))
 >then : Symbol(Promise.then, Decl(promiseTypeInference.ts, 0, 26))
->s => convert(s) : Symbol((Anonymous function), Decl(promiseTypeInference.ts, 9, 33))
 >s : Symbol(s, Decl(promiseTypeInference.ts, 9, 33))
 >convert : Symbol(convert, Decl(promiseTypeInference.ts, 6, 53))
 >s : Symbol(s, Decl(promiseTypeInference.ts, 9, 33))
diff --git a/tests/baselines/reference/promiseVoidErrorCallback.symbols b/tests/baselines/reference/promiseVoidErrorCallback.symbols
index 8b45a4cc67927..27e7df62ab1a0 100644
--- a/tests/baselines/reference/promiseVoidErrorCallback.symbols
+++ b/tests/baselines/reference/promiseVoidErrorCallback.symbols
@@ -26,16 +26,9 @@ function f1(): Promise<T1> {
 >T1 : Symbol(T1, Decl(promiseVoidErrorCallback.ts, 0, 0))
 
     return Promise.resolve({ __t1: "foo_t1" });
-<<<<<<< HEAD
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 4840, 39), Decl(lib.d.ts, 4847, 54))
 >Promise : Symbol(Promise, Decl(lib.d.ts, 4772, 1), Decl(lib.d.ts, 4858, 11))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 4840, 39), Decl(lib.d.ts, 4847, 54))
-=======
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 4837, 39), Decl(lib.d.ts, 4844, 54))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 4837, 39), Decl(lib.d.ts, 4844, 54))
->{ __t1: "foo_t1" } : Symbol(, Decl(promiseVoidErrorCallback.ts, 13, 27))
->>>>>>> Accept symbol baselines
 >__t1 : Symbol(__t1, Decl(promiseVoidErrorCallback.ts, 13, 28))
 }
 
@@ -46,7 +39,6 @@ function f2(x: T1): T2 {
 >T2 : Symbol(T2, Decl(promiseVoidErrorCallback.ts, 2, 1))
 
     return { __t2: x.__t1 + ":foo_21" };
->{ __t2: x.__t1 + ":foo_21" } : Symbol(, Decl(promiseVoidErrorCallback.ts, 17, 10))
 >__t2 : Symbol(__t2, Decl(promiseVoidErrorCallback.ts, 17, 12))
 >x.__t1 : Symbol(T1.__t1, Decl(promiseVoidErrorCallback.ts, 0, 14))
 >x : Symbol(x, Decl(promiseVoidErrorCallback.ts, 16, 12))
@@ -62,7 +54,6 @@ var x3 = f1()
     .then(f2, (e: Error) => {
 >then : Symbol(Promise.then, Decl(lib.d.ts, 4777, 22), Decl(lib.d.ts, 4784, 158))
 >f2 : Symbol(f2, Decl(promiseVoidErrorCallback.ts, 14, 1))
->(e: Error) => {    throw e;} : Symbol((Anonymous function), Decl(promiseVoidErrorCallback.ts, 21, 13))
 >e : Symbol(e, Decl(promiseVoidErrorCallback.ts, 21, 15))
 >Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11))
 
@@ -71,17 +62,11 @@ var x3 = f1()
 
 })
     .then((x: T2) => {
-<<<<<<< HEAD
 >then : Symbol(Promise.then, Decl(lib.d.ts, 4777, 22), Decl(lib.d.ts, 4784, 158))
-=======
->then : Symbol(Promise.then, Decl(lib.d.ts, 4775, 22), Decl(lib.d.ts, 4782, 158))
->(x: T2) => {    return { __t3: x.__t2 + "bar" };} : Symbol((Anonymous function), Decl(promiseVoidErrorCallback.ts, 24, 10))
->>>>>>> Accept symbol baselines
 >x : Symbol(x, Decl(promiseVoidErrorCallback.ts, 24, 11))
 >T2 : Symbol(T2, Decl(promiseVoidErrorCallback.ts, 2, 1))
 
     return { __t3: x.__t2 + "bar" };
->{ __t3: x.__t2 + "bar" } : Symbol(, Decl(promiseVoidErrorCallback.ts, 25, 10))
 >__t3 : Symbol(__t3, Decl(promiseVoidErrorCallback.ts, 25, 12))
 >x.__t2 : Symbol(T2.__t2, Decl(promiseVoidErrorCallback.ts, 4, 14))
 >x : Symbol(x, Decl(promiseVoidErrorCallback.ts, 24, 11))
diff --git a/tests/baselines/reference/propagationOfPromiseInitialization.symbols b/tests/baselines/reference/propagationOfPromiseInitialization.symbols
index a2621f3b0c627..2289c175168e7 100644
--- a/tests/baselines/reference/propagationOfPromiseInitialization.symbols
+++ b/tests/baselines/reference/propagationOfPromiseInitialization.symbols
@@ -26,14 +26,12 @@ foo.then((x) => {
 >foo.then : Symbol(IPromise.then, Decl(propagationOfPromiseInitialization.ts, 0, 23))
 >foo : Symbol(foo, Decl(propagationOfPromiseInitialization.ts, 4, 3))
 >then : Symbol(IPromise.then, Decl(propagationOfPromiseInitialization.ts, 0, 23))
->(x) => {    // x is inferred to be a number    return "asdf";} : Symbol((Anonymous function), Decl(propagationOfPromiseInitialization.ts, 5, 9))
 >x : Symbol(x, Decl(propagationOfPromiseInitialization.ts, 5, 10))
 
     // x is inferred to be a number
     return "asdf";
 }).then((x) => {
 >then : Symbol(IPromise.then, Decl(propagationOfPromiseInitialization.ts, 0, 23))
->(x) => {    // x is inferred to be string    x.length;    return 123;} : Symbol((Anonymous function), Decl(propagationOfPromiseInitialization.ts, 8, 8))
 >x : Symbol(x, Decl(propagationOfPromiseInitialization.ts, 8, 9))
 
     // x is inferred to be string
diff --git a/tests/baselines/reference/propertyAccessOnTypeParameterWithConstraints.symbols b/tests/baselines/reference/propertyAccessOnTypeParameterWithConstraints.symbols
index 02ada6e6b9ba6..99856e99ae134 100644
--- a/tests/baselines/reference/propertyAccessOnTypeParameterWithConstraints.symbols
+++ b/tests/baselines/reference/propertyAccessOnTypeParameterWithConstraints.symbols
@@ -85,11 +85,9 @@ var r3b = a()['getDate']();
 
 var b = {
 >b : Symbol(b, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 26, 3))
->{    foo: <T extends Date>(x: T) => {        var a = x['getDate'](); // number        return a + x.getDate();    }} : Symbol(, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 26, 7))
 
     foo: <T extends Date>(x: T) => {
 >foo : Symbol(foo, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 26, 9))
-><T extends Date>(x: T) => {        var a = x['getDate'](); // number        return a + x.getDate();    } : Symbol((Anonymous function), Decl(propertyAccessOnTypeParameterWithConstraints.ts, 27, 8))
 >T : Symbol(T, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 27, 10))
 >Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
 >x : Symbol(x, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 27, 26))
diff --git a/tests/baselines/reference/propertyAccessOnTypeParameterWithConstraints2.symbols b/tests/baselines/reference/propertyAccessOnTypeParameterWithConstraints2.symbols
index 655efd3384c4b..29a3b30d45040 100644
--- a/tests/baselines/reference/propertyAccessOnTypeParameterWithConstraints2.symbols
+++ b/tests/baselines/reference/propertyAccessOnTypeParameterWithConstraints2.symbols
@@ -197,11 +197,9 @@ var r3d = a(aB, aB)['foo']();
 
 var b = {
 >b : Symbol(b, Decl(propertyAccessOnTypeParameterWithConstraints2.ts, 67, 3))
->{    foo: <U extends A, T extends A>(x: U, y: T) => {        var a = x['foo'](); // should be string        return a + x.foo();    }} : Symbol(, Decl(propertyAccessOnTypeParameterWithConstraints2.ts, 67, 7))
 
     foo: <U extends A, T extends A>(x: U, y: T) => {
 >foo : Symbol(foo, Decl(propertyAccessOnTypeParameterWithConstraints2.ts, 67, 9))
-><U extends A, T extends A>(x: U, y: T) => {        var a = x['foo'](); // should be string        return a + x.foo();    } : Symbol((Anonymous function), Decl(propertyAccessOnTypeParameterWithConstraints2.ts, 68, 8))
 >U : Symbol(U, Decl(propertyAccessOnTypeParameterWithConstraints2.ts, 68, 10))
 >A : Symbol(A, Decl(propertyAccessOnTypeParameterWithConstraints2.ts, 0, 0))
 >T : Symbol(T, Decl(propertyAccessOnTypeParameterWithConstraints2.ts, 68, 22))
diff --git a/tests/baselines/reference/propertyAccessOnTypeParameterWithoutConstraints.symbols b/tests/baselines/reference/propertyAccessOnTypeParameterWithoutConstraints.symbols
index 10d2190519055..425c7e42aff83 100644
--- a/tests/baselines/reference/propertyAccessOnTypeParameterWithoutConstraints.symbols
+++ b/tests/baselines/reference/propertyAccessOnTypeParameterWithoutConstraints.symbols
@@ -76,11 +76,9 @@ var r3b: string = a()['toString']();
 
 var b = {
 >b : Symbol(b, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 23, 3))
->{    foo: <T>(x: T) => {        var a = x['toString'](); // should be string        return a + x.toString();    }} : Symbol(, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 23, 7))
 
     foo: <T>(x: T) => {
 >foo : Symbol(foo, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 23, 9))
-><T>(x: T) => {        var a = x['toString'](); // should be string        return a + x.toString();    } : Symbol((Anonymous function), Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 24, 8))
 >T : Symbol(T, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 24, 10))
 >x : Symbol(x, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 24, 13))
 >T : Symbol(T, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 24, 10))
diff --git a/tests/baselines/reference/propertyNameWithoutTypeAnnotation.symbols b/tests/baselines/reference/propertyNameWithoutTypeAnnotation.symbols
index 58cfd4c8d0042..45840561fa72f 100644
--- a/tests/baselines/reference/propertyNameWithoutTypeAnnotation.symbols
+++ b/tests/baselines/reference/propertyNameWithoutTypeAnnotation.symbols
@@ -22,7 +22,6 @@ var a: {
 
 var b = {
 >b : Symbol(b, Decl(propertyNameWithoutTypeAnnotation.ts, 12, 3))
->{    foo: null} : Symbol(, Decl(propertyNameWithoutTypeAnnotation.ts, 12, 7))
 
     foo: null
 >foo : Symbol(foo, Decl(propertyNameWithoutTypeAnnotation.ts, 12, 9))
diff --git a/tests/baselines/reference/protectedClassPropertyAccessibleWithinClass.symbols b/tests/baselines/reference/protectedClassPropertyAccessibleWithinClass.symbols
index 319bc7816c081..ccca7ab7501b7 100644
--- a/tests/baselines/reference/protectedClassPropertyAccessibleWithinClass.symbols
+++ b/tests/baselines/reference/protectedClassPropertyAccessibleWithinClass.symbols
@@ -70,7 +70,6 @@ class C2 {
 
     protected get y() { () => this.x; return null; }
 >y : Symbol(y, Decl(protectedClassPropertyAccessibleWithinClass.ts, 17, 24), Decl(protectedClassPropertyAccessibleWithinClass.ts, 18, 52))
->() => this.x : Symbol((Anonymous function), Decl(protectedClassPropertyAccessibleWithinClass.ts, 18, 23))
 >this.x : Symbol(x, Decl(protectedClassPropertyAccessibleWithinClass.ts, 16, 10))
 >this : Symbol(C2, Decl(protectedClassPropertyAccessibleWithinClass.ts, 13, 1))
 >x : Symbol(x, Decl(protectedClassPropertyAccessibleWithinClass.ts, 16, 10))
@@ -78,7 +77,6 @@ class C2 {
     protected set y(x) { () => { this.y = this.x; } }
 >y : Symbol(y, Decl(protectedClassPropertyAccessibleWithinClass.ts, 17, 24), Decl(protectedClassPropertyAccessibleWithinClass.ts, 18, 52))
 >x : Symbol(x, Decl(protectedClassPropertyAccessibleWithinClass.ts, 19, 20))
->() => { this.y = this.x; } : Symbol((Anonymous function), Decl(protectedClassPropertyAccessibleWithinClass.ts, 19, 24))
 >this.y : Symbol(y, Decl(protectedClassPropertyAccessibleWithinClass.ts, 17, 24), Decl(protectedClassPropertyAccessibleWithinClass.ts, 18, 52))
 >this : Symbol(C2, Decl(protectedClassPropertyAccessibleWithinClass.ts, 13, 1))
 >y : Symbol(y, Decl(protectedClassPropertyAccessibleWithinClass.ts, 17, 24), Decl(protectedClassPropertyAccessibleWithinClass.ts, 18, 52))
@@ -88,7 +86,6 @@ class C2 {
 
     protected foo() { () => this.foo; }
 >foo : Symbol(foo, Decl(protectedClassPropertyAccessibleWithinClass.ts, 19, 53))
->() => this.foo : Symbol((Anonymous function), Decl(protectedClassPropertyAccessibleWithinClass.ts, 20, 21))
 >this.foo : Symbol(foo, Decl(protectedClassPropertyAccessibleWithinClass.ts, 19, 53))
 >this : Symbol(C2, Decl(protectedClassPropertyAccessibleWithinClass.ts, 13, 1))
 >foo : Symbol(foo, Decl(protectedClassPropertyAccessibleWithinClass.ts, 19, 53))
@@ -98,7 +95,6 @@ class C2 {
 
     protected static get y() { () => this.x; return null; }
 >y : Symbol(C2.y, Decl(protectedClassPropertyAccessibleWithinClass.ts, 22, 31), Decl(protectedClassPropertyAccessibleWithinClass.ts, 23, 59))
->() => this.x : Symbol((Anonymous function), Decl(protectedClassPropertyAccessibleWithinClass.ts, 23, 30))
 >this.x : Symbol(C2.x, Decl(protectedClassPropertyAccessibleWithinClass.ts, 20, 39))
 >this : Symbol(C2, Decl(protectedClassPropertyAccessibleWithinClass.ts, 13, 1))
 >x : Symbol(C2.x, Decl(protectedClassPropertyAccessibleWithinClass.ts, 20, 39))
@@ -108,7 +104,6 @@ class C2 {
 >x : Symbol(x, Decl(protectedClassPropertyAccessibleWithinClass.ts, 24, 27))
 
         () => { this.y = this.x; }
->() => { this.y = this.x; } : Symbol((Anonymous function), Decl(protectedClassPropertyAccessibleWithinClass.ts, 24, 31))
 >this.y : Symbol(C2.y, Decl(protectedClassPropertyAccessibleWithinClass.ts, 22, 31), Decl(protectedClassPropertyAccessibleWithinClass.ts, 23, 59))
 >this : Symbol(C2, Decl(protectedClassPropertyAccessibleWithinClass.ts, 13, 1))
 >y : Symbol(C2.y, Decl(protectedClassPropertyAccessibleWithinClass.ts, 22, 31), Decl(protectedClassPropertyAccessibleWithinClass.ts, 23, 59))
@@ -118,14 +113,12 @@ class C2 {
      }
     protected static foo() { () => this.foo; }
 >foo : Symbol(C2.foo, Decl(protectedClassPropertyAccessibleWithinClass.ts, 26, 6))
->() => this.foo : Symbol((Anonymous function), Decl(protectedClassPropertyAccessibleWithinClass.ts, 27, 28))
 >this.foo : Symbol(C2.foo, Decl(protectedClassPropertyAccessibleWithinClass.ts, 26, 6))
 >this : Symbol(C2, Decl(protectedClassPropertyAccessibleWithinClass.ts, 13, 1))
 >foo : Symbol(C2.foo, Decl(protectedClassPropertyAccessibleWithinClass.ts, 26, 6))
 
     protected static bar() { () => this.foo(); }
 >bar : Symbol(C2.bar, Decl(protectedClassPropertyAccessibleWithinClass.ts, 27, 46))
->() => this.foo() : Symbol((Anonymous function), Decl(protectedClassPropertyAccessibleWithinClass.ts, 28, 28))
 >this.foo : Symbol(C2.foo, Decl(protectedClassPropertyAccessibleWithinClass.ts, 26, 6))
 >this : Symbol(C2, Decl(protectedClassPropertyAccessibleWithinClass.ts, 13, 1))
 >foo : Symbol(C2.foo, Decl(protectedClassPropertyAccessibleWithinClass.ts, 26, 6))
diff --git a/tests/baselines/reference/protoAsIndexInIndexExpression.symbols b/tests/baselines/reference/protoAsIndexInIndexExpression.symbols
index 5343d8c067cb9..3a5f39c65c638 100644
--- a/tests/baselines/reference/protoAsIndexInIndexExpression.symbols
+++ b/tests/baselines/reference/protoAsIndexInIndexExpression.symbols
@@ -6,11 +6,9 @@ var EntityPrototype = undefined;
 
 var WorkspacePrototype = {
 >WorkspacePrototype : Symbol(WorkspacePrototype, Decl(protoAsIndexInIndexExpression_1.ts, 2, 3))
->{    serialize: function (): any {    }} : Symbol(, Decl(protoAsIndexInIndexExpression_1.ts, 2, 24))
 
     serialize: function (): any {
 >serialize : Symbol(serialize, Decl(protoAsIndexInIndexExpression_1.ts, 2, 26))
->function (): any {    } : Symbol((Anonymous function), Decl(protoAsIndexInIndexExpression_1.ts, 3, 14))
     }
 };
 WorkspacePrototype['__proto__'] = EntityPrototype;
@@ -19,7 +17,6 @@ WorkspacePrototype['__proto__'] = EntityPrototype;
 
 var o = {
 >o : Symbol(o, Decl(protoAsIndexInIndexExpression_1.ts, 8, 3))
->{    "__proto__": 0} : Symbol(, Decl(protoAsIndexInIndexExpression_1.ts, 8, 7))
 
     "__proto__": 0
 };
diff --git a/tests/baselines/reference/quotedPropertyName3.symbols b/tests/baselines/reference/quotedPropertyName3.symbols
index c594787ba30b0..1a84302242574 100644
--- a/tests/baselines/reference/quotedPropertyName3.symbols
+++ b/tests/baselines/reference/quotedPropertyName3.symbols
@@ -8,7 +8,6 @@ class Test {
 
         var x = () => this["prop1"];
 >x : Symbol(x, Decl(quotedPropertyName3.ts, 3, 11))
->() => this["prop1"] : Symbol((Anonymous function), Decl(quotedPropertyName3.ts, 3, 15))
 >this : Symbol(Test, Decl(quotedPropertyName3.ts, 0, 0))
 >"prop1" : Symbol("prop1", Decl(quotedPropertyName3.ts, 0, 12))
 
diff --git a/tests/baselines/reference/recur1.symbols b/tests/baselines/reference/recur1.symbols
index 93329e2ede8ab..a36fe5cc2a76f 100644
--- a/tests/baselines/reference/recur1.symbols
+++ b/tests/baselines/reference/recur1.symbols
@@ -5,7 +5,6 @@ var salt:any = new salt.pepper();
 
 salt.pepper = function() {}
 >salt : Symbol(salt, Decl(recur1.ts, 0, 3))
->function() {} : Symbol((Anonymous function), Decl(recur1.ts, 1, 13))
 
 var cobalt = new cobalt.pitch();   
 >cobalt : Symbol(cobalt, Decl(recur1.ts, 3, 3))
@@ -13,6 +12,5 @@ var cobalt = new cobalt.pitch();
 
 cobalt.pitch = function() {}
 >cobalt : Symbol(cobalt, Decl(recur1.ts, 3, 3))
->function() {} : Symbol((Anonymous function), Decl(recur1.ts, 4, 14))
  
 
diff --git a/tests/baselines/reference/recursiveInitializer.symbols b/tests/baselines/reference/recursiveInitializer.symbols
index 2f1ab68f155b0..56fcbd7b438de 100644
--- a/tests/baselines/reference/recursiveInitializer.symbols
+++ b/tests/baselines/reference/recursiveInitializer.symbols
@@ -55,7 +55,6 @@ var b4 = (!b4) && b4; // expected boolean here. actually 'any'
 // (x:string) => any
 var f = (x: string) => f(x);
 >f : Symbol(f, Decl(recursiveInitializer.ts, 18, 3))
->(x: string) => f(x) : Symbol((Anonymous function), Decl(recursiveInitializer.ts, 18, 7))
 >x : Symbol(x, Decl(recursiveInitializer.ts, 18, 9))
 >f : Symbol(f, Decl(recursiveInitializer.ts, 18, 3))
 >x : Symbol(x, Decl(recursiveInitializer.ts, 18, 9))
diff --git a/tests/baselines/reference/recursiveObjectLiteral.symbols b/tests/baselines/reference/recursiveObjectLiteral.symbols
index d48c89bcdaa0f..8ee5c49b60d23 100644
--- a/tests/baselines/reference/recursiveObjectLiteral.symbols
+++ b/tests/baselines/reference/recursiveObjectLiteral.symbols
@@ -1,7 +1,6 @@
 === tests/cases/compiler/recursiveObjectLiteral.ts ===
 var a = { f: a };
 >a : Symbol(a, Decl(recursiveObjectLiteral.ts, 0, 3))
->{ f: a } : Symbol(, Decl(recursiveObjectLiteral.ts, 0, 7))
 >f : Symbol(f, Decl(recursiveObjectLiteral.ts, 0, 9))
 >a : Symbol(a, Decl(recursiveObjectLiteral.ts, 0, 3))
 
diff --git a/tests/baselines/reference/reservedWords.symbols b/tests/baselines/reference/reservedWords.symbols
index 3bb9a50811fe4..98795f3c719b2 100644
--- a/tests/baselines/reference/reservedWords.symbols
+++ b/tests/baselines/reference/reservedWords.symbols
@@ -1,7 +1,6 @@
 === tests/cases/compiler/reservedWords.ts ===
 var obj = {
 >obj : Symbol(obj, Decl(reservedWords.ts, 0, 3))
->{    if: 0,    debugger: 2,    break: 3,    function: 4} : Symbol(, Decl(reservedWords.ts, 0, 9))
 
     if: 0,
 >if : Symbol(if, Decl(reservedWords.ts, 0, 11))
@@ -20,7 +19,6 @@ var obj = {
 
 var obj2 = {
 >obj2 : Symbol(obj2, Decl(reservedWords.ts, 9, 3))
->{    if: 0,    while: 1,    debugger: 2,    break: 3,    function: 4} : Symbol(, Decl(reservedWords.ts, 9, 10))
 
     if: 0,
 >if : Symbol(if, Decl(reservedWords.ts, 9, 12))
diff --git a/tests/baselines/reference/returnStatement1.symbols b/tests/baselines/reference/returnStatement1.symbols
index 3236b1842ad27..acec9f7600374 100644
--- a/tests/baselines/reference/returnStatement1.symbols
+++ b/tests/baselines/reference/returnStatement1.symbols
@@ -3,7 +3,6 @@ function f() {
 >f : Symbol(f, Decl(returnStatement1.ts, 0, 0))
 
     return function (s) {
->function (s) {        var x = s;    } : Symbol((Anonymous function), Decl(returnStatement1.ts, 1, 10))
 >s : Symbol(s, Decl(returnStatement1.ts, 1, 21))
 
         var x = s;
diff --git a/tests/baselines/reference/returnStatements.symbols b/tests/baselines/reference/returnStatements.symbols
index ed3d68c60931d..e12f3ba5d8a39 100644
--- a/tests/baselines/reference/returnStatements.symbols
+++ b/tests/baselines/reference/returnStatements.symbols
@@ -51,7 +51,6 @@ class D extends C {
 function fn10(): I { return { id: 12 }; } 
 >fn10 : Symbol(fn10, Decl(returnStatements.ts, 17, 1))
 >I : Symbol(I, Decl(returnStatements.ts, 8, 31))
->{ id: 12 } : Symbol(, Decl(returnStatements.ts, 18, 27))
 >id : Symbol(id, Decl(returnStatements.ts, 18, 29))
 
 function fn11(): I { return new C(); }
diff --git a/tests/baselines/reference/returnTypeParameterWithModules.symbols b/tests/baselines/reference/returnTypeParameterWithModules.symbols
index be6d8edae1b90..c4b354ad9205f 100644
--- a/tests/baselines/reference/returnTypeParameterWithModules.symbols
+++ b/tests/baselines/reference/returnTypeParameterWithModules.symbols
@@ -63,7 +63,6 @@ module M2 {
 >C : Symbol(C, Decl(returnTypeParameterWithModules.ts, 10, 31))
 
     return function (x) { return g(f(x)); }
->function (x) { return g(f(x)); } : Symbol((Anonymous function), Decl(returnTypeParameterWithModules.ts, 11, 10))
 >x : Symbol(x, Decl(returnTypeParameterWithModules.ts, 11, 21))
 >g : Symbol(g, Decl(returnTypeParameterWithModules.ts, 10, 38))
 >f : Symbol(f, Decl(returnTypeParameterWithModules.ts, 10, 53))
diff --git a/tests/baselines/reference/selfInCallback.symbols b/tests/baselines/reference/selfInCallback.symbols
index a8bc749921da5..805b77140126c 100644
--- a/tests/baselines/reference/selfInCallback.symbols
+++ b/tests/baselines/reference/selfInCallback.symbols
@@ -17,7 +17,6 @@ class C {
 >this.callback : Symbol(callback, Decl(selfInCallback.ts, 1, 15))
 >this : Symbol(C, Decl(selfInCallback.ts, 0, 0))
 >callback : Symbol(callback, Decl(selfInCallback.ts, 1, 15))
->()=>{this.p1+1} : Symbol((Anonymous function), Decl(selfInCallback.ts, 4, 16))
 >this.p1 : Symbol(p1, Decl(selfInCallback.ts, 0, 9))
 >this : Symbol(C, Decl(selfInCallback.ts, 0, 0))
 >p1 : Symbol(p1, Decl(selfInCallback.ts, 0, 9))
diff --git a/tests/baselines/reference/selfInLambdas.symbols b/tests/baselines/reference/selfInLambdas.symbols
index 9a3d14359e9bd..032de5e776783 100644
--- a/tests/baselines/reference/selfInLambdas.symbols
+++ b/tests/baselines/reference/selfInLambdas.symbols
@@ -24,25 +24,21 @@ interface Window {
 }
 var o = {
 >o : Symbol(o, Decl(selfInLambdas.ts, 10, 3))
->{    counter: 0,    start: function() {        window.onmousemove = () => {            this.counter++            var f = () => this.counter;        }    }} : Symbol(, Decl(selfInLambdas.ts, 10, 7))
 
     counter: 0,
 >counter : Symbol(counter, Decl(selfInLambdas.ts, 10, 9))
 
     start: function() {
 >start : Symbol(start, Decl(selfInLambdas.ts, 12, 15))
->function() {        window.onmousemove = () => {            this.counter++            var f = () => this.counter;        }    } : Symbol((Anonymous function), Decl(selfInLambdas.ts, 14, 10))
 
         window.onmousemove = () => {
 >window.onmousemove : Symbol(Window.onmousemove, Decl(selfInLambdas.ts, 6, 18))
 >window : Symbol(window, Decl(selfInLambdas.ts, 5, 11))
 >onmousemove : Symbol(Window.onmousemove, Decl(selfInLambdas.ts, 6, 18))
->() => {            this.counter++            var f = () => this.counter;        } : Symbol((Anonymous function), Decl(selfInLambdas.ts, 16, 28))
 
             this.counter++
             var f = () => this.counter;
 >f : Symbol(f, Decl(selfInLambdas.ts, 18, 15))
->() => this.counter : Symbol((Anonymous function), Decl(selfInLambdas.ts, 18, 19))
 
         }
 
@@ -63,7 +59,6 @@ class X {
 
 		var outer= () => {
 >outer : Symbol(outer, Decl(selfInLambdas.ts, 32, 5))
->() => {            var x = this.value;            var inner = () => {                var y = this.value;			}			inner();		} : Symbol((Anonymous function), Decl(selfInLambdas.ts, 32, 12))
 
             var x = this.value;
 >x : Symbol(x, Decl(selfInLambdas.ts, 33, 15))
@@ -73,7 +68,6 @@ class X {
 
             var inner = () => {
 >inner : Symbol(inner, Decl(selfInLambdas.ts, 34, 15))
->() => {                var y = this.value;			} : Symbol((Anonymous function), Decl(selfInLambdas.ts, 34, 23))
 
                 var y = this.value;
 >y : Symbol(y, Decl(selfInLambdas.ts, 35, 19))
diff --git a/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.symbols b/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.symbols
index ecb3a082aa5a1..ab79174a43a16 100644
--- a/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.symbols
+++ b/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.symbols
@@ -2,12 +2,9 @@
 [].map(() => [].map(p => ({ X: p })));
 >[].map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
 >map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
->() => [].map(p => ({ X: p })) : Symbol((Anonymous function), Decl(simpleArrowFunctionParameterReferencedInObjectLiteral1.ts, 0, 7))
 >[].map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
 >map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
->p => ({ X: p }) : Symbol((Anonymous function), Decl(simpleArrowFunctionParameterReferencedInObjectLiteral1.ts, 0, 20))
 >p : Symbol(p, Decl(simpleArrowFunctionParameterReferencedInObjectLiteral1.ts, 0, 20))
->{ X: p } : Symbol(, Decl(simpleArrowFunctionParameterReferencedInObjectLiteral1.ts, 0, 26))
 >X : Symbol(X, Decl(simpleArrowFunctionParameterReferencedInObjectLiteral1.ts, 0, 27))
 >p : Symbol(p, Decl(simpleArrowFunctionParameterReferencedInObjectLiteral1.ts, 0, 20))
 
diff --git a/tests/baselines/reference/sourceMapValidationClassWithDefaultConstructorAndCapturedThisStatement.symbols b/tests/baselines/reference/sourceMapValidationClassWithDefaultConstructorAndCapturedThisStatement.symbols
index a2fc1f95c5fdd..44612abacbb8a 100644
--- a/tests/baselines/reference/sourceMapValidationClassWithDefaultConstructorAndCapturedThisStatement.symbols
+++ b/tests/baselines/reference/sourceMapValidationClassWithDefaultConstructorAndCapturedThisStatement.symbols
@@ -7,7 +7,6 @@ class Greeter {
 
     public returnA = () => this.a;
 >returnA : Symbol(returnA, Decl(sourceMapValidationClassWithDefaultConstructorAndCapturedThisStatement.ts, 1, 18))
->() => this.a : Symbol((Anonymous function), Decl(sourceMapValidationClassWithDefaultConstructorAndCapturedThisStatement.ts, 2, 20))
 >this.a : Symbol(a, Decl(sourceMapValidationClassWithDefaultConstructorAndCapturedThisStatement.ts, 0, 15))
 >this : Symbol(Greeter, Decl(sourceMapValidationClassWithDefaultConstructorAndCapturedThisStatement.ts, 0, 0))
 >a : Symbol(a, Decl(sourceMapValidationClassWithDefaultConstructorAndCapturedThisStatement.ts, 0, 15))
diff --git a/tests/baselines/reference/sourceMapValidationFunctionExpressions.symbols b/tests/baselines/reference/sourceMapValidationFunctionExpressions.symbols
index c89f1f2e2a5f7..64e2bdad7e476 100644
--- a/tests/baselines/reference/sourceMapValidationFunctionExpressions.symbols
+++ b/tests/baselines/reference/sourceMapValidationFunctionExpressions.symbols
@@ -4,7 +4,6 @@ var greetings = 0;
 
 var greet = (greeting: string): number => {
 >greet : Symbol(greet, Decl(sourceMapValidationFunctionExpressions.ts, 1, 3))
->(greeting: string): number => {    greetings++;    return greetings;} : Symbol((Anonymous function), Decl(sourceMapValidationFunctionExpressions.ts, 1, 11))
 >greeting : Symbol(greeting, Decl(sourceMapValidationFunctionExpressions.ts, 1, 13))
 
     greetings++;
@@ -18,6 +17,5 @@ greet("Hello");
 
 var incrGreetings = () => greetings++;
 >incrGreetings : Symbol(incrGreetings, Decl(sourceMapValidationFunctionExpressions.ts, 6, 3))
->() => greetings++ : Symbol((Anonymous function), Decl(sourceMapValidationFunctionExpressions.ts, 6, 19))
 >greetings : Symbol(greetings, Decl(sourceMapValidationFunctionExpressions.ts, 0, 3))
 
diff --git a/tests/baselines/reference/sourceMapValidationFunctionPropertyAssignment.symbols b/tests/baselines/reference/sourceMapValidationFunctionPropertyAssignment.symbols
index 600477d5b3989..2718a5e8848fb 100644
--- a/tests/baselines/reference/sourceMapValidationFunctionPropertyAssignment.symbols
+++ b/tests/baselines/reference/sourceMapValidationFunctionPropertyAssignment.symbols
@@ -1,6 +1,5 @@
 === tests/cases/compiler/sourceMapValidationFunctionPropertyAssignment.ts ===
 var x = { n() { } };
 >x : Symbol(x, Decl(sourceMapValidationFunctionPropertyAssignment.ts, 0, 3))
->{ n() { } } : Symbol(, Decl(sourceMapValidationFunctionPropertyAssignment.ts, 0, 7))
 >n : Symbol(n, Decl(sourceMapValidationFunctionPropertyAssignment.ts, 0, 9))
 
diff --git a/tests/baselines/reference/sourceMapWithMultipleFilesWithCopyright.symbols b/tests/baselines/reference/sourceMapWithMultipleFilesWithCopyright.symbols
index d8e0bf34934e2..8ec6f81767279 100644
--- a/tests/baselines/reference/sourceMapWithMultipleFilesWithCopyright.symbols
+++ b/tests/baselines/reference/sourceMapWithMultipleFilesWithCopyright.symbols
@@ -15,7 +15,6 @@ Copyright
 
 var x = {
 >x : Symbol(x, Decl(a.ts, 4, 3))
->{    a: 10,    b: 20} : Symbol(, Decl(a.ts, 4, 7))
 
     a: 10,
 >a : Symbol(a, Decl(a.ts, 4, 9))
diff --git a/tests/baselines/reference/specializationsShouldNotAffectEachOther.symbols b/tests/baselines/reference/specializationsShouldNotAffectEachOther.symbols
index 7286bfaeda126..9f03f8fca018f 100644
--- a/tests/baselines/reference/specializationsShouldNotAffectEachOther.symbols
+++ b/tests/baselines/reference/specializationsShouldNotAffectEachOther.symbols
@@ -17,7 +17,6 @@ function foo() {
 
     var seriesExtent = (series) => null;
 >seriesExtent : Symbol(seriesExtent, Decl(specializationsShouldNotAffectEachOther.ts, 10, 7))
->(series) => null : Symbol((Anonymous function), Decl(specializationsShouldNotAffectEachOther.ts, 10, 22))
 >series : Symbol(series, Decl(specializationsShouldNotAffectEachOther.ts, 10, 24))
 
     var series2: number[];
@@ -40,7 +39,6 @@ var keyExtent2: any[] = series.data.map(function (d: string) { return d; });
 >series : Symbol(series, Decl(specializationsShouldNotAffectEachOther.ts, 5, 3))
 >data : Symbol(Series.data, Decl(specializationsShouldNotAffectEachOther.ts, 1, 19))
 >map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
->function (d: string) { return d; } : Symbol((Anonymous function), Decl(specializationsShouldNotAffectEachOther.ts, 19, 40))
 >d : Symbol(d, Decl(specializationsShouldNotAffectEachOther.ts, 19, 50))
 >d : Symbol(d, Decl(specializationsShouldNotAffectEachOther.ts, 19, 50))
 
diff --git a/tests/baselines/reference/specializedInheritedConstructors1.symbols b/tests/baselines/reference/specializedInheritedConstructors1.symbols
index 80f8ae4575d24..97285e073cc4d 100644
--- a/tests/baselines/reference/specializedInheritedConstructors1.symbols
+++ b/tests/baselines/reference/specializedInheritedConstructors1.symbols
@@ -34,14 +34,12 @@ var m: ViewOptions<Model> = { model: new Model() };
 >m : Symbol(m, Decl(specializedInheritedConstructors1.ts, 12, 3))
 >ViewOptions : Symbol(ViewOptions, Decl(specializedInheritedConstructors1.ts, 0, 0))
 >Model : Symbol(Model, Decl(specializedInheritedConstructors1.ts, 7, 1))
->{ model: new Model() } : Symbol(, Decl(specializedInheritedConstructors1.ts, 12, 27))
 >model : Symbol(model, Decl(specializedInheritedConstructors1.ts, 12, 29))
 >Model : Symbol(Model, Decl(specializedInheritedConstructors1.ts, 7, 1))
 
 var aView = new View({ model: new Model() }); 
 >aView : Symbol(aView, Decl(specializedInheritedConstructors1.ts, 13, 3))
 >View : Symbol(View, Decl(specializedInheritedConstructors1.ts, 2, 1))
->{ model: new Model() } : Symbol(, Decl(specializedInheritedConstructors1.ts, 13, 21))
 >model : Symbol(model, Decl(specializedInheritedConstructors1.ts, 13, 22))
 >Model : Symbol(Model, Decl(specializedInheritedConstructors1.ts, 7, 1))
 
diff --git a/tests/baselines/reference/strictModeUseContextualKeyword.symbols b/tests/baselines/reference/strictModeUseContextualKeyword.symbols
index 925f79fc4b31a..a0a3182b9c62d 100644
--- a/tests/baselines/reference/strictModeUseContextualKeyword.symbols
+++ b/tests/baselines/reference/strictModeUseContextualKeyword.symbols
@@ -24,7 +24,6 @@ function H() {
 
     let {as} = { as: 1 };
 >as : Symbol(as, Decl(strictModeUseContextualKeyword.ts, 10, 9))
->{ as: 1 } : Symbol(, Decl(strictModeUseContextualKeyword.ts, 10, 14))
 >as : Symbol(as, Decl(strictModeUseContextualKeyword.ts, 10, 16))
 }
 
diff --git a/tests/baselines/reference/stringIndexingResults.symbols b/tests/baselines/reference/stringIndexingResults.symbols
index bcfca21e056fc..4890b44bce6fa 100644
--- a/tests/baselines/reference/stringIndexingResults.symbols
+++ b/tests/baselines/reference/stringIndexingResults.symbols
@@ -79,7 +79,6 @@ var r9 = a[1];
 var b: { [x: string]: string } = { y: '' }
 >b : Symbol(b, Decl(stringIndexingResults.ts, 29, 3))
 >x : Symbol(x, Decl(stringIndexingResults.ts, 29, 10))
->{ y: '' } : Symbol(, Decl(stringIndexingResults.ts, 29, 32))
 >y : Symbol(y, Decl(stringIndexingResults.ts, 29, 34))
 
 var r10 = b['y'];
diff --git a/tests/baselines/reference/stringLiteralObjectLiteralDeclaration1.symbols b/tests/baselines/reference/stringLiteralObjectLiteralDeclaration1.symbols
index 0b8827392405e..b4bdeb71c79a9 100644
--- a/tests/baselines/reference/stringLiteralObjectLiteralDeclaration1.symbols
+++ b/tests/baselines/reference/stringLiteralObjectLiteralDeclaration1.symbols
@@ -4,6 +4,5 @@ module m1 {
 
   export var n = { 'foo bar': 4 };
 >n : Symbol(n, Decl(stringLiteralObjectLiteralDeclaration1.ts, 1, 12))
->{ 'foo bar': 4 } : Symbol(, Decl(stringLiteralObjectLiteralDeclaration1.ts, 1, 16))
 }
 
diff --git a/tests/baselines/reference/stringLiteralPropertyNameWithLineContinuation1.symbols b/tests/baselines/reference/stringLiteralPropertyNameWithLineContinuation1.symbols
index 13aa82b07361d..3f7804a18a72b 100644
--- a/tests/baselines/reference/stringLiteralPropertyNameWithLineContinuation1.symbols
+++ b/tests/baselines/reference/stringLiteralPropertyNameWithLineContinuation1.symbols
@@ -1,7 +1,6 @@
 === tests/cases/compiler/stringLiteralPropertyNameWithLineContinuation1.ts ===
 var x = {'text\
 >x : Symbol(x, Decl(stringLiteralPropertyNameWithLineContinuation1.ts, 0, 3))
->{'text\':'hello'} : Symbol(, Decl(stringLiteralPropertyNameWithLineContinuation1.ts, 0, 7))
 
 ':'hello'}
 x.text = "bar"
diff --git a/tests/baselines/reference/stringNamedPropertyAccess.symbols b/tests/baselines/reference/stringNamedPropertyAccess.symbols
index abec459427b7a..583e5da06edd7 100644
--- a/tests/baselines/reference/stringNamedPropertyAccess.symbols
+++ b/tests/baselines/reference/stringNamedPropertyAccess.symbols
@@ -45,7 +45,6 @@ var r3 = a["a b"];
 
 var b = {
 >b : Symbol(b, Decl(stringNamedPropertyAccess.ts, 19, 3))
->{    "a b": 1} : Symbol(, Decl(stringNamedPropertyAccess.ts, 19, 7))
 
     "a b": 1
 }
diff --git a/tests/baselines/reference/stringPropCodeGen.symbols b/tests/baselines/reference/stringPropCodeGen.symbols
index 8f650d9487253..b0d9cb91fc237 100644
--- a/tests/baselines/reference/stringPropCodeGen.symbols
+++ b/tests/baselines/reference/stringPropCodeGen.symbols
@@ -1,11 +1,8 @@
 === tests/cases/compiler/stringPropCodeGen.ts ===
 var a = {
 >a : Symbol(a, Decl(stringPropCodeGen.ts, 0, 3))
->{  "foo" : function() { },  "bar" : 5} : Symbol(, Decl(stringPropCodeGen.ts, 0, 7))
 
   "foo" : function() { },
->function() { } : Symbol((Anonymous function), Decl(stringPropCodeGen.ts, 2, 9))
-
   "bar" : 5
 
 };
diff --git a/tests/baselines/reference/structural1.symbols b/tests/baselines/reference/structural1.symbols
index 0cbdc8bcf526e..78330978cd4d4 100644
--- a/tests/baselines/reference/structural1.symbols
+++ b/tests/baselines/reference/structural1.symbols
@@ -20,7 +20,6 @@ module M {
 
     f({salt:2,pepper:0});
 >f : Symbol(f, Decl(structural1.ts, 4, 5))
->{salt:2,pepper:0} : Symbol(, Decl(structural1.ts, 9, 6))
 >salt : Symbol(salt, Decl(structural1.ts, 9, 7))
 >pepper : Symbol(pepper, Decl(structural1.ts, 9, 14))
 }
diff --git a/tests/baselines/reference/subtypingWithCallSignatures.symbols b/tests/baselines/reference/subtypingWithCallSignatures.symbols
index 5d40856453524..1f7dda99be744 100644
--- a/tests/baselines/reference/subtypingWithCallSignatures.symbols
+++ b/tests/baselines/reference/subtypingWithCallSignatures.symbols
@@ -15,13 +15,11 @@ module CallSignature {
     var r = foo1((x: number) => 1); // ok because base returns void
 >r : Symbol(r, Decl(subtypingWithCallSignatures.ts, 3, 7))
 >foo1 : Symbol(foo1, Decl(subtypingWithCallSignatures.ts, 0, 22), Decl(subtypingWithCallSignatures.ts, 1, 62))
->(x: number) => 1 : Symbol((Anonymous function), Decl(subtypingWithCallSignatures.ts, 3, 17))
 >x : Symbol(x, Decl(subtypingWithCallSignatures.ts, 3, 18))
 
     var r2 = foo1(<T>(x: T) => ''); // ok because base returns void
 >r2 : Symbol(r2, Decl(subtypingWithCallSignatures.ts, 4, 7))
 >foo1 : Symbol(foo1, Decl(subtypingWithCallSignatures.ts, 0, 22), Decl(subtypingWithCallSignatures.ts, 1, 62))
-><T>(x: T) => '' : Symbol((Anonymous function), Decl(subtypingWithCallSignatures.ts, 4, 18))
 >T : Symbol(T, Decl(subtypingWithCallSignatures.ts, 4, 19))
 >x : Symbol(x, Decl(subtypingWithCallSignatures.ts, 4, 22))
 >T : Symbol(T, Decl(subtypingWithCallSignatures.ts, 4, 19))
@@ -40,14 +38,12 @@ module CallSignature {
     var r3 = foo2((x: number, y: number) => 1); // ok because base returns void
 >r3 : Symbol(r3, Decl(subtypingWithCallSignatures.ts, 8, 7))
 >foo2 : Symbol(foo2, Decl(subtypingWithCallSignatures.ts, 4, 35), Decl(subtypingWithCallSignatures.ts, 6, 73))
->(x: number, y: number) => 1 : Symbol((Anonymous function), Decl(subtypingWithCallSignatures.ts, 8, 18))
 >x : Symbol(x, Decl(subtypingWithCallSignatures.ts, 8, 19))
 >y : Symbol(y, Decl(subtypingWithCallSignatures.ts, 8, 29))
 
     var r4 = foo2(<T>(x: T) => ''); // ok because base returns void
 >r4 : Symbol(r4, Decl(subtypingWithCallSignatures.ts, 9, 7))
 >foo2 : Symbol(foo2, Decl(subtypingWithCallSignatures.ts, 4, 35), Decl(subtypingWithCallSignatures.ts, 6, 73))
-><T>(x: T) => '' : Symbol((Anonymous function), Decl(subtypingWithCallSignatures.ts, 9, 18))
 >T : Symbol(T, Decl(subtypingWithCallSignatures.ts, 9, 19))
 >x : Symbol(x, Decl(subtypingWithCallSignatures.ts, 9, 22))
 >T : Symbol(T, Decl(subtypingWithCallSignatures.ts, 9, 19))
diff --git a/tests/baselines/reference/subtypingWithCallSignatures2.symbols b/tests/baselines/reference/subtypingWithCallSignatures2.symbols
index d5771c5d2337a..5aa1021d26070 100644
--- a/tests/baselines/reference/subtypingWithCallSignatures2.symbols
+++ b/tests/baselines/reference/subtypingWithCallSignatures2.symbols
@@ -310,7 +310,6 @@ declare function foo18(a: any): any;
 
 var r1arg1 = <T>(x: T) => [x];
 >r1arg1 : Symbol(r1arg1, Decl(subtypingWithCallSignatures2.ts, 79, 3))
-><T>(x: T) => [x] : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 79, 12))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 79, 14))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 79, 17))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 79, 14))
@@ -318,7 +317,6 @@ var r1arg1 = <T>(x: T) => [x];
 
 var r1arg2 = (x: number) => [1];
 >r1arg2 : Symbol(r1arg2, Decl(subtypingWithCallSignatures2.ts, 80, 3))
->(x: number) => [1] : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 80, 12))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 80, 14))
 
 var r1 = foo1(r1arg1); // any, return types are not subtype of first overload
@@ -338,14 +336,12 @@ var r1b = [r1arg1, r1arg2]; // generic signature, subtype in both directions
 
 var r2arg1 = <T>(x: T) => [''];
 >r2arg1 : Symbol(r2arg1, Decl(subtypingWithCallSignatures2.ts, 85, 3))
-><T>(x: T) => [''] : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 85, 12))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 85, 14))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 85, 17))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 85, 14))
 
 var r2arg2 = (x: number) => [''];
 >r2arg2 : Symbol(r2arg2, Decl(subtypingWithCallSignatures2.ts, 86, 3))
->(x: number) => [''] : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 86, 12))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 86, 14))
 
 var r2 = foo2(r2arg1); 
@@ -365,7 +361,6 @@ var r2b = [r2arg2, r2arg1];
 
 var r3arg1 = <T>(x: T) => x;
 >r3arg1 : Symbol(r3arg1, Decl(subtypingWithCallSignatures2.ts, 91, 3))
-><T>(x: T) => x : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 91, 12))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 91, 14))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 91, 17))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 91, 14))
@@ -373,7 +368,6 @@ var r3arg1 = <T>(x: T) => x;
 
 var r3arg2 = (x: number) => { };
 >r3arg2 : Symbol(r3arg2, Decl(subtypingWithCallSignatures2.ts, 92, 3))
->(x: number) => { } : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 92, 12))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 92, 14))
 
 var r3 = foo3(r3arg1); 
@@ -393,7 +387,6 @@ var r3b = [r3arg2, r3arg1];
 
 var r4arg1 = <T, U>(x: T, y: U) => x;
 >r4arg1 : Symbol(r4arg1, Decl(subtypingWithCallSignatures2.ts, 97, 3))
-><T, U>(x: T, y: U) => x : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 97, 12))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 97, 14))
 >U : Symbol(U, Decl(subtypingWithCallSignatures2.ts, 97, 16))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 97, 20))
@@ -404,7 +397,6 @@ var r4arg1 = <T, U>(x: T, y: U) => x;
 
 var r4arg2 = (x: string, y: number) => '';
 >r4arg2 : Symbol(r4arg2, Decl(subtypingWithCallSignatures2.ts, 98, 3))
->(x: string, y: number) => '' : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 98, 12))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 98, 14))
 >y : Symbol(y, Decl(subtypingWithCallSignatures2.ts, 98, 24))
 
@@ -425,7 +417,6 @@ var r4b = [r4arg2, r4arg1];
 
 var r5arg1 = <T, U>(x: (arg: T) => U) => <T>null;
 >r5arg1 : Symbol(r5arg1, Decl(subtypingWithCallSignatures2.ts, 103, 3))
-><T, U>(x: (arg: T) => U) => <T>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 103, 12))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 103, 14))
 >U : Symbol(U, Decl(subtypingWithCallSignatures2.ts, 103, 16))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 103, 20))
@@ -436,7 +427,6 @@ var r5arg1 = <T, U>(x: (arg: T) => U) => <T>null;
 
 var r5arg2 = (x: (arg: string) => number) => '';
 >r5arg2 : Symbol(r5arg2, Decl(subtypingWithCallSignatures2.ts, 104, 3))
->(x: (arg: string) => number) => '' : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 104, 12))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 104, 14))
 >arg : Symbol(arg, Decl(subtypingWithCallSignatures2.ts, 104, 18))
 
@@ -457,7 +447,6 @@ var r5b = [r5arg2, r5arg1];
 
 var r6arg1 = <T extends Base, U extends Derived>(x: (arg: T) => U) => <T>null;
 >r6arg1 : Symbol(r6arg1, Decl(subtypingWithCallSignatures2.ts, 109, 3))
-><T extends Base, U extends Derived>(x: (arg: T) => U) => <T>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 109, 12))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 109, 14))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
 >U : Symbol(U, Decl(subtypingWithCallSignatures2.ts, 109, 29))
@@ -470,7 +459,6 @@ var r6arg1 = <T extends Base, U extends Derived>(x: (arg: T) => U) => <T>null;
 
 var r6arg2 = (x: (arg: Base) => Derived) => <Base>null;
 >r6arg2 : Symbol(r6arg2, Decl(subtypingWithCallSignatures2.ts, 110, 3))
->(x: (arg: Base) => Derived) => <Base>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 110, 12))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 110, 14))
 >arg : Symbol(arg, Decl(subtypingWithCallSignatures2.ts, 110, 18))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
@@ -494,7 +482,6 @@ var r6b = [r6arg2, r6arg1];
 
 var r7arg1 = <T extends Base, U extends Derived>(x: (arg: T) => U) => (r: T) => <U>null;
 >r7arg1 : Symbol(r7arg1, Decl(subtypingWithCallSignatures2.ts, 115, 3))
-><T extends Base, U extends Derived>(x: (arg: T) => U) => (r: T) => <U>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 115, 12))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 115, 14))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
 >U : Symbol(U, Decl(subtypingWithCallSignatures2.ts, 115, 29))
@@ -503,19 +490,16 @@ var r7arg1 = <T extends Base, U extends Derived>(x: (arg: T) => U) => (r: T) =>
 >arg : Symbol(arg, Decl(subtypingWithCallSignatures2.ts, 115, 53))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 115, 14))
 >U : Symbol(U, Decl(subtypingWithCallSignatures2.ts, 115, 29))
->(r: T) => <U>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 115, 69))
 >r : Symbol(r, Decl(subtypingWithCallSignatures2.ts, 115, 71))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 115, 14))
 >U : Symbol(U, Decl(subtypingWithCallSignatures2.ts, 115, 29))
 
 var r7arg2 = (x: (arg: Base) => Derived) => (r: Base) => <Derived>null;
 >r7arg2 : Symbol(r7arg2, Decl(subtypingWithCallSignatures2.ts, 116, 3))
->(x: (arg: Base) => Derived) => (r: Base) => <Derived>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 116, 12))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 116, 14))
 >arg : Symbol(arg, Decl(subtypingWithCallSignatures2.ts, 116, 18))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures2.ts, 2, 27))
->(r: Base) => <Derived>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 116, 43))
 >r : Symbol(r, Decl(subtypingWithCallSignatures2.ts, 116, 45))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures2.ts, 2, 27))
@@ -537,7 +521,6 @@ var r7b = [r7arg2, r7arg1];
 
 var r8arg1 = <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: T) => U) => (r: T) => <U>null;
 >r8arg1 : Symbol(r8arg1, Decl(subtypingWithCallSignatures2.ts, 121, 3))
-><T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: T) => U) => (r: T) => <U>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 121, 12))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 121, 14))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
 >U : Symbol(U, Decl(subtypingWithCallSignatures2.ts, 121, 29))
@@ -550,14 +533,12 @@ var r8arg1 = <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: T)
 >arg2 : Symbol(arg2, Decl(subtypingWithCallSignatures2.ts, 121, 71))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 121, 14))
 >U : Symbol(U, Decl(subtypingWithCallSignatures2.ts, 121, 29))
->(r: T) => <U>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 121, 88))
 >r : Symbol(r, Decl(subtypingWithCallSignatures2.ts, 121, 90))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 121, 14))
 >U : Symbol(U, Decl(subtypingWithCallSignatures2.ts, 121, 29))
 
 var r8arg2 = (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => <Derived>null;
 >r8arg2 : Symbol(r8arg2, Decl(subtypingWithCallSignatures2.ts, 122, 3))
->(x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => <Derived>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 122, 12))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 122, 14))
 >arg : Symbol(arg, Decl(subtypingWithCallSignatures2.ts, 122, 18))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
@@ -566,7 +547,6 @@ var r8arg2 = (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base
 >arg2 : Symbol(arg2, Decl(subtypingWithCallSignatures2.ts, 122, 45))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures2.ts, 2, 27))
->(r: Base) => <Derived>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 122, 71))
 >r : Symbol(r, Decl(subtypingWithCallSignatures2.ts, 122, 73))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures2.ts, 2, 27))
@@ -588,7 +568,6 @@ var r8b = [r8arg2, r8arg1];
 
 var r9arg1 = <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number }) => U) => (r: T) => <U>null;
 >r9arg1 : Symbol(r9arg1, Decl(subtypingWithCallSignatures2.ts, 127, 3))
-><T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number }) => U) => (r: T) => <U>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 127, 12))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 127, 14))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
 >U : Symbol(U, Decl(subtypingWithCallSignatures2.ts, 127, 29))
@@ -602,14 +581,12 @@ var r9arg1 = <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { f
 >foo : Symbol(foo, Decl(subtypingWithCallSignatures2.ts, 127, 78))
 >bing : Symbol(bing, Decl(subtypingWithCallSignatures2.ts, 127, 91))
 >U : Symbol(U, Decl(subtypingWithCallSignatures2.ts, 127, 29))
->(r: T) => <U>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 127, 116))
 >r : Symbol(r, Decl(subtypingWithCallSignatures2.ts, 127, 118))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 127, 14))
 >U : Symbol(U, Decl(subtypingWithCallSignatures2.ts, 127, 29))
 
 var r9arg2 = (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => <Derived>null;
 >r9arg2 : Symbol(r9arg2, Decl(subtypingWithCallSignatures2.ts, 128, 3))
->(x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => <Derived>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 128, 12))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 128, 14))
 >arg : Symbol(arg, Decl(subtypingWithCallSignatures2.ts, 128, 18))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
@@ -618,7 +595,6 @@ var r9arg2 = (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base
 >arg2 : Symbol(arg2, Decl(subtypingWithCallSignatures2.ts, 128, 45))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures2.ts, 2, 27))
->(r: Base) => <Derived>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 128, 71))
 >r : Symbol(r, Decl(subtypingWithCallSignatures2.ts, 128, 73))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures2.ts, 2, 27))
@@ -640,7 +616,6 @@ var r9b = [r9arg2, r9arg1];
 
 var r10arg1 = <T extends Derived>(...x: T[]) => x[0];
 >r10arg1 : Symbol(r10arg1, Decl(subtypingWithCallSignatures2.ts, 133, 3))
-><T extends Derived>(...x: T[]) => x[0] : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 133, 13))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 133, 15))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures2.ts, 2, 27))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 133, 34))
@@ -649,7 +624,6 @@ var r10arg1 = <T extends Derived>(...x: T[]) => x[0];
 
 var r10arg2 = (...x: Derived[]) => <Derived>null;
 >r10arg2 : Symbol(r10arg2, Decl(subtypingWithCallSignatures2.ts, 134, 3))
->(...x: Derived[]) => <Derived>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 134, 13))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 134, 15))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures2.ts, 2, 27))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures2.ts, 2, 27))
@@ -671,7 +645,6 @@ var r10b = [r10arg2, r10arg1];
 
 var r11arg1 = <T extends Base>(x: T, y: T) => x;
 >r11arg1 : Symbol(r11arg1, Decl(subtypingWithCallSignatures2.ts, 139, 3))
-><T extends Base>(x: T, y: T) => x : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 139, 13))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 139, 15))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 139, 31))
@@ -682,7 +655,6 @@ var r11arg1 = <T extends Base>(x: T, y: T) => x;
 
 var r11arg2 = (x: { foo: string }, y: { foo: string; bar: string }) => <Base>null;
 >r11arg2 : Symbol(r11arg2, Decl(subtypingWithCallSignatures2.ts, 140, 3))
->(x: { foo: string }, y: { foo: string; bar: string }) => <Base>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 140, 13))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 140, 15))
 >foo : Symbol(foo, Decl(subtypingWithCallSignatures2.ts, 140, 19))
 >y : Symbol(y, Decl(subtypingWithCallSignatures2.ts, 140, 34))
@@ -707,7 +679,6 @@ var r11b = [r11arg2, r11arg1];
 
 var r12arg1 = <T extends Array<Base>>(x: Array<Base>, y: T) => <Array<Derived>>null;
 >r12arg1 : Symbol(r12arg1, Decl(subtypingWithCallSignatures2.ts, 145, 3))
-><T extends Array<Base>>(x: Array<Base>, y: T) => <Array<Derived>>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 145, 13))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 145, 15))
 >Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
@@ -721,7 +692,6 @@ var r12arg1 = <T extends Array<Base>>(x: Array<Base>, y: T) => <Array<Derived>>n
 
 var r12arg2 = (x: Array<Base>, y: Array<Derived2>) => <Array<Derived>>null;
 >r12arg2 : Symbol(r12arg2, Decl(subtypingWithCallSignatures2.ts, 146, 3))
->(x: Array<Base>, y: Array<Derived2>) => <Array<Derived>>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 146, 13))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 146, 15))
 >Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
@@ -748,7 +718,6 @@ var r12b = [r12arg2, r12arg1];
 
 var r13arg1 = <T extends Array<Derived>>(x: Array<Base>, y: T) => y;
 >r13arg1 : Symbol(r13arg1, Decl(subtypingWithCallSignatures2.ts, 151, 3))
-><T extends Array<Derived>>(x: Array<Base>, y: T) => y : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 151, 13))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 151, 15))
 >Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures2.ts, 2, 27))
@@ -761,7 +730,6 @@ var r13arg1 = <T extends Array<Derived>>(x: Array<Base>, y: T) => y;
 
 var r13arg2 = (x: Array<Base>, y: Array<Derived>) => <Array<Derived>>null;
 >r13arg2 : Symbol(r13arg2, Decl(subtypingWithCallSignatures2.ts, 152, 3))
->(x: Array<Base>, y: Array<Derived>) => <Array<Derived>>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 152, 13))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 152, 15))
 >Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
@@ -788,7 +756,6 @@ var r13b = [r13arg2, r13arg1];
 
 var r14arg1 = <T>(x: { a: T; b: T }) => x.a;
 >r14arg1 : Symbol(r14arg1, Decl(subtypingWithCallSignatures2.ts, 157, 3))
-><T>(x: { a: T; b: T }) => x.a : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 157, 13))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 157, 15))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 157, 18))
 >a : Symbol(a, Decl(subtypingWithCallSignatures2.ts, 157, 22))
@@ -801,7 +768,6 @@ var r14arg1 = <T>(x: { a: T; b: T }) => x.a;
 
 var r14arg2 = (x: { a: string; b: number }) => <Object>null;
 >r14arg2 : Symbol(r14arg2, Decl(subtypingWithCallSignatures2.ts, 158, 3))
->(x: { a: string; b: number }) => <Object>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 158, 13))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 158, 15))
 >a : Symbol(a, Decl(subtypingWithCallSignatures2.ts, 158, 19))
 >b : Symbol(b, Decl(subtypingWithCallSignatures2.ts, 158, 30))
@@ -824,7 +790,6 @@ var r14b = [r14arg2, r14arg1];
 
 var r15arg1 = <T>(x: T) => <T[]>null
 >r15arg1 : Symbol(r15arg1, Decl(subtypingWithCallSignatures2.ts, 163, 3))
-><T>(x: T) => <T[]>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 163, 13))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 163, 15))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 163, 18))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 163, 15))
@@ -837,7 +802,6 @@ var r15 = foo15(r15arg1); // any
 
 var r16arg1 = <T extends Base>(x: T) => [1];
 >r16arg1 : Symbol(r16arg1, Decl(subtypingWithCallSignatures2.ts, 165, 3))
-><T extends Base>(x: T) => [1] : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 165, 13))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 165, 15))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 165, 31))
@@ -850,7 +814,6 @@ var r16 = foo16(r16arg1);
 
 var r17arg1 = <T>(x: (a: T) => T) => <T[]>null;
 >r17arg1 : Symbol(r17arg1, Decl(subtypingWithCallSignatures2.ts, 167, 3))
-><T>(x: (a: T) => T) => <T[]>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 167, 13))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 167, 15))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 167, 18))
 >a : Symbol(a, Decl(subtypingWithCallSignatures2.ts, 167, 22))
@@ -865,7 +828,6 @@ var r17 = foo17(r17arg1); // any
 
 var r18arg1 = <T>(x: (a: T) => T) => <T[]>null;
 >r18arg1 : Symbol(r18arg1, Decl(subtypingWithCallSignatures2.ts, 169, 3))
-><T>(x: (a: T) => T) => <T[]>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures2.ts, 169, 13))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 169, 15))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 169, 18))
 >a : Symbol(a, Decl(subtypingWithCallSignatures2.ts, 169, 22))
diff --git a/tests/baselines/reference/subtypingWithCallSignatures3.symbols b/tests/baselines/reference/subtypingWithCallSignatures3.symbols
index 72464dc7655bd..666977c62d92f 100644
--- a/tests/baselines/reference/subtypingWithCallSignatures3.symbols
+++ b/tests/baselines/reference/subtypingWithCallSignatures3.symbols
@@ -208,7 +208,6 @@ module Errors {
     var r1 = foo2(<T, U>(x: T) => <U[]>null); // any
 >r1 : Symbol(r1, Decl(subtypingWithCallSignatures3.ts, 55, 7))
 >foo2 : Symbol(foo2, Decl(subtypingWithCallSignatures3.ts, 7, 53), Decl(subtypingWithCallSignatures3.ts, 9, 66))
-><T, U>(x: T) => <U[]>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 55, 18))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 55, 19))
 >U : Symbol(U, Decl(subtypingWithCallSignatures3.ts, 55, 21))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 55, 25))
@@ -217,9 +216,7 @@ module Errors {
 
     var r1a = [(x: number) => [''], <T, U>(x: T) => <U[]>null];
 >r1a : Symbol(r1a, Decl(subtypingWithCallSignatures3.ts, 56, 7))
->(x: number) => [''] : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 56, 15))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 56, 16))
-><T, U>(x: T) => <U[]>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 56, 35))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 56, 37))
 >U : Symbol(U, Decl(subtypingWithCallSignatures3.ts, 56, 39))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 56, 43))
@@ -228,18 +225,15 @@ module Errors {
 
     var r1b = [<T, U>(x: T) => <U[]>null, (x: number) => ['']];
 >r1b : Symbol(r1b, Decl(subtypingWithCallSignatures3.ts, 57, 7))
-><T, U>(x: T) => <U[]>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 57, 15))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 57, 16))
 >U : Symbol(U, Decl(subtypingWithCallSignatures3.ts, 57, 18))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 57, 22))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 57, 16))
 >U : Symbol(U, Decl(subtypingWithCallSignatures3.ts, 57, 18))
->(x: number) => [''] : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 57, 41))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 57, 43))
 
     var r2arg = <T extends Base, U extends Derived, V extends Derived2>(x: (arg: T) => U) => (r: T) => <V>null;
 >r2arg : Symbol(r2arg, Decl(subtypingWithCallSignatures3.ts, 59, 7))
-><T extends Base, U extends Derived, V extends Derived2>(x: (arg: T) => U) => (r: T) => <V>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 59, 15))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 59, 17))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures3.ts, 3, 15))
 >U : Symbol(U, Decl(subtypingWithCallSignatures3.ts, 59, 32))
@@ -250,19 +244,16 @@ module Errors {
 >arg : Symbol(arg, Decl(subtypingWithCallSignatures3.ts, 59, 76))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 59, 17))
 >U : Symbol(U, Decl(subtypingWithCallSignatures3.ts, 59, 32))
->(r: T) => <V>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 59, 92))
 >r : Symbol(r, Decl(subtypingWithCallSignatures3.ts, 59, 94))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 59, 17))
 >V : Symbol(V, Decl(subtypingWithCallSignatures3.ts, 59, 51))
 
     var r2arg2 = (x: (arg: Base) => Derived) => (r: Base) => <Derived2>null;
 >r2arg2 : Symbol(r2arg2, Decl(subtypingWithCallSignatures3.ts, 60, 7))
->(x: (arg: Base) => Derived) => (r: Base) => <Derived2>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 60, 16))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 60, 18))
 >arg : Symbol(arg, Decl(subtypingWithCallSignatures3.ts, 60, 22))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures3.ts, 3, 15))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures3.ts, 4, 31))
->(r: Base) => <Derived2>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 60, 47))
 >r : Symbol(r, Decl(subtypingWithCallSignatures3.ts, 60, 49))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures3.ts, 3, 15))
 >Derived2 : Symbol(Derived2, Decl(subtypingWithCallSignatures3.ts, 5, 47))
@@ -284,7 +275,6 @@ module Errors {
 
     var r3arg = <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => <U>null;
 >r3arg : Symbol(r3arg, Decl(subtypingWithCallSignatures3.ts, 65, 7))
-><T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => <U>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 65, 15))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 65, 17))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures3.ts, 3, 15))
 >U : Symbol(U, Decl(subtypingWithCallSignatures3.ts, 65, 32))
@@ -297,14 +287,12 @@ module Errors {
 >arg2 : Symbol(arg2, Decl(subtypingWithCallSignatures3.ts, 65, 74))
 >foo : Symbol(foo, Decl(subtypingWithCallSignatures3.ts, 65, 81))
 >U : Symbol(U, Decl(subtypingWithCallSignatures3.ts, 65, 32))
->(r: T) => <U>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 65, 106))
 >r : Symbol(r, Decl(subtypingWithCallSignatures3.ts, 65, 108))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 65, 17))
 >U : Symbol(U, Decl(subtypingWithCallSignatures3.ts, 65, 32))
 
     var r3arg2 = (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => <Derived>null;
 >r3arg2 : Symbol(r3arg2, Decl(subtypingWithCallSignatures3.ts, 66, 7))
->(x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => <Derived>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 66, 16))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 66, 18))
 >arg : Symbol(arg, Decl(subtypingWithCallSignatures3.ts, 66, 22))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures3.ts, 3, 15))
@@ -313,7 +301,6 @@ module Errors {
 >arg2 : Symbol(arg2, Decl(subtypingWithCallSignatures3.ts, 66, 49))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures3.ts, 3, 15))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures3.ts, 4, 31))
->(r: Base) => <Derived>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 66, 75))
 >r : Symbol(r, Decl(subtypingWithCallSignatures3.ts, 66, 77))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures3.ts, 3, 15))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures3.ts, 4, 31))
@@ -335,7 +322,6 @@ module Errors {
 
     var r4arg = <T extends Derived>(...x: T[]) => <T>null;
 >r4arg : Symbol(r4arg, Decl(subtypingWithCallSignatures3.ts, 71, 7))
-><T extends Derived>(...x: T[]) => <T>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 71, 15))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 71, 17))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures3.ts, 4, 31))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 71, 36))
@@ -344,7 +330,6 @@ module Errors {
 
     var r4arg2 = (...x: Base[]) => <Base>null;
 >r4arg2 : Symbol(r4arg2, Decl(subtypingWithCallSignatures3.ts, 72, 7))
->(...x: Base[]) => <Base>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 72, 16))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 72, 18))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures3.ts, 3, 15))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures3.ts, 3, 15))
@@ -366,7 +351,6 @@ module Errors {
 
     var r5arg = <T extends Derived>(x: T, y: T) => <T>null;
 >r5arg : Symbol(r5arg, Decl(subtypingWithCallSignatures3.ts, 77, 7))
-><T extends Derived>(x: T, y: T) => <T>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 77, 15))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 77, 17))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures3.ts, 4, 31))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 77, 36))
@@ -377,7 +361,6 @@ module Errors {
 
     var r5arg2 = (x: { foo: string }, y: { foo: string; bar: string }) => <Base>null;
 >r5arg2 : Symbol(r5arg2, Decl(subtypingWithCallSignatures3.ts, 78, 7))
->(x: { foo: string }, y: { foo: string; bar: string }) => <Base>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 78, 16))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 78, 18))
 >foo : Symbol(foo, Decl(subtypingWithCallSignatures3.ts, 78, 22))
 >y : Symbol(y, Decl(subtypingWithCallSignatures3.ts, 78, 37))
@@ -402,7 +385,6 @@ module Errors {
 
     var r6arg = (x: Array<Base>, y: Array<Derived2>) => <Array<Derived>>null;
 >r6arg : Symbol(r6arg, Decl(subtypingWithCallSignatures3.ts, 83, 7))
->(x: Array<Base>, y: Array<Derived2>) => <Array<Derived>>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 83, 15))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 83, 17))
 >Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures3.ts, 3, 15))
@@ -414,7 +396,6 @@ module Errors {
 
     var r6arg2 = <T extends Array<Derived2>>(x: Array<Base>, y: Array<Base>) => <T>null;
 >r6arg2 : Symbol(r6arg2, Decl(subtypingWithCallSignatures3.ts, 84, 7))
-><T extends Array<Derived2>>(x: Array<Base>, y: Array<Base>) => <T>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 84, 16))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 84, 18))
 >Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
 >Derived2 : Symbol(Derived2, Decl(subtypingWithCallSignatures3.ts, 5, 47))
@@ -443,7 +424,6 @@ module Errors {
 
     var r7arg = <T>(x: { a: T; b: T }) => <T>null;
 >r7arg : Symbol(r7arg, Decl(subtypingWithCallSignatures3.ts, 89, 7))
-><T>(x: { a: T; b: T }) => <T>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 89, 15))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 89, 17))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 89, 20))
 >a : Symbol(a, Decl(subtypingWithCallSignatures3.ts, 89, 24))
@@ -454,7 +434,6 @@ module Errors {
 
     var r7arg2 = (x: { a: string; b: number }) => 1;
 >r7arg2 : Symbol(r7arg2, Decl(subtypingWithCallSignatures3.ts, 90, 7))
->(x: { a: string; b: number }) => 1 : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 90, 16))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 90, 18))
 >a : Symbol(a, Decl(subtypingWithCallSignatures3.ts, 90, 22))
 >b : Symbol(b, Decl(subtypingWithCallSignatures3.ts, 90, 33))
@@ -476,7 +455,6 @@ module Errors {
 
     var r7arg3 = <T extends Base>(x: { a: T; b: T }) => 1;
 >r7arg3 : Symbol(r7arg3, Decl(subtypingWithCallSignatures3.ts, 95, 7))
-><T extends Base>(x: { a: T; b: T }) => 1 : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 95, 16))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 95, 18))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures3.ts, 3, 15))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 95, 34))
@@ -502,7 +480,6 @@ module Errors {
 
     var r8arg = <T>(x: (a: T) => T) => <T[]>null;
 >r8arg : Symbol(r8arg, Decl(subtypingWithCallSignatures3.ts, 100, 7))
-><T>(x: (a: T) => T) => <T[]>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 100, 15))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 100, 17))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 100, 20))
 >a : Symbol(a, Decl(subtypingWithCallSignatures3.ts, 100, 24))
@@ -517,7 +494,6 @@ module Errors {
 
     var r9arg = <T>(x: (a: T) => T) => <any[]>null;
 >r9arg : Symbol(r9arg, Decl(subtypingWithCallSignatures3.ts, 103, 7))
-><T>(x: (a: T) => T) => <any[]>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 103, 15))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 103, 17))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 103, 20))
 >a : Symbol(a, Decl(subtypingWithCallSignatures3.ts, 103, 24))
@@ -548,7 +524,6 @@ module WithGenericSignaturesInBaseType {
 
     var r2arg2 = <T>(x: T) => [''];
 >r2arg2 : Symbol(r2arg2, Decl(subtypingWithCallSignatures3.ts, 110, 7))
-><T>(x: T) => [''] : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 110, 16))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 110, 18))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 110, 21))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 110, 18))
@@ -572,7 +547,6 @@ module WithGenericSignaturesInBaseType {
 
     var r3arg2 = <T>(x: T) => <T[]>null;
 >r3arg2 : Symbol(r3arg2, Decl(subtypingWithCallSignatures3.ts, 115, 7))
-><T>(x: T) => <T[]>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures3.ts, 115, 16))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 115, 18))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 115, 21))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 115, 18))
diff --git a/tests/baselines/reference/subtypingWithCallSignatures4.symbols b/tests/baselines/reference/subtypingWithCallSignatures4.symbols
index 4a38a993c698c..382abb58a0d46 100644
--- a/tests/baselines/reference/subtypingWithCallSignatures4.symbols
+++ b/tests/baselines/reference/subtypingWithCallSignatures4.symbols
@@ -221,7 +221,6 @@ declare function foo18(a: any): any;
 
 var r1arg = <T>(x: T) => <T[]>null;
 >r1arg : Symbol(r1arg, Decl(subtypingWithCallSignatures4.ts, 52, 3))
-><T>(x: T) => <T[]>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 52, 11))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 52, 13))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 52, 16))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 52, 13))
@@ -229,7 +228,6 @@ var r1arg = <T>(x: T) => <T[]>null;
 
 var r1arg2 = <T>(x: T) => <T[]>null;
 >r1arg2 : Symbol(r1arg2, Decl(subtypingWithCallSignatures4.ts, 53, 3))
-><T>(x: T) => <T[]>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 53, 12))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 53, 14))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 53, 17))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 53, 14))
@@ -252,14 +250,12 @@ var r1b = [r1arg2, r1arg];
 
 var r2arg = <T>(x: T) => [''];
 >r2arg : Symbol(r2arg, Decl(subtypingWithCallSignatures4.ts, 58, 3))
-><T>(x: T) => [''] : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 58, 11))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 58, 13))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 58, 16))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 58, 13))
 
 var r2arg2 = <T>(x: T) => [''];
 >r2arg2 : Symbol(r2arg2, Decl(subtypingWithCallSignatures4.ts, 59, 3))
-><T>(x: T) => [''] : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 59, 12))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 59, 14))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 59, 17))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 59, 14))
@@ -281,7 +277,6 @@ var r2b = [r2arg2, r2arg];
 
 var r3arg = <T>(x: T) => <T>null;
 >r3arg : Symbol(r3arg, Decl(subtypingWithCallSignatures4.ts, 64, 3))
-><T>(x: T) => <T>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 64, 11))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 64, 13))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 64, 16))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 64, 13))
@@ -289,7 +284,6 @@ var r3arg = <T>(x: T) => <T>null;
 
 var r3arg2 = <T>(x: T) => { };
 >r3arg2 : Symbol(r3arg2, Decl(subtypingWithCallSignatures4.ts, 65, 3))
-><T>(x: T) => { } : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 65, 12))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 65, 14))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 65, 17))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 65, 14))
@@ -311,7 +305,6 @@ var r3b = [r3arg2, r3arg];
 
 var r4arg = <T, U>(x: T, y: U) => '';
 >r4arg : Symbol(r4arg, Decl(subtypingWithCallSignatures4.ts, 70, 3))
-><T, U>(x: T, y: U) => '' : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 70, 11))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 70, 13))
 >U : Symbol(U, Decl(subtypingWithCallSignatures4.ts, 70, 15))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 70, 19))
@@ -321,7 +314,6 @@ var r4arg = <T, U>(x: T, y: U) => '';
 
 var r4arg2 = <T, U>(x: T, y: U) => '';
 >r4arg2 : Symbol(r4arg2, Decl(subtypingWithCallSignatures4.ts, 71, 3))
-><T, U>(x: T, y: U) => '' : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 71, 12))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 71, 14))
 >U : Symbol(U, Decl(subtypingWithCallSignatures4.ts, 71, 16))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 71, 20))
@@ -346,7 +338,6 @@ var r4b = [r4arg2, r4arg];
 
 var r5arg = <T, U>(x: (arg: T) => U) => <T>null;
 >r5arg : Symbol(r5arg, Decl(subtypingWithCallSignatures4.ts, 76, 3))
-><T, U>(x: (arg: T) => U) => <T>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 76, 11))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 76, 13))
 >U : Symbol(U, Decl(subtypingWithCallSignatures4.ts, 76, 15))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 76, 19))
@@ -357,7 +348,6 @@ var r5arg = <T, U>(x: (arg: T) => U) => <T>null;
 
 var r5arg2 = <T, U>(x: (arg: T) => U) => <T>null;
 >r5arg2 : Symbol(r5arg2, Decl(subtypingWithCallSignatures4.ts, 77, 3))
-><T, U>(x: (arg: T) => U) => <T>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 77, 12))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 77, 14))
 >U : Symbol(U, Decl(subtypingWithCallSignatures4.ts, 77, 16))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 77, 20))
@@ -383,7 +373,6 @@ var r5b = [r5arg2, r5arg];
 
 var r6arg = <T extends Base, U extends Derived>(x: (arg: T) => U) => <T>null;
 >r6arg : Symbol(r6arg, Decl(subtypingWithCallSignatures4.ts, 82, 3))
-><T extends Base, U extends Derived>(x: (arg: T) => U) => <T>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 82, 11))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 82, 13))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures4.ts, 0, 0))
 >U : Symbol(U, Decl(subtypingWithCallSignatures4.ts, 82, 28))
@@ -396,7 +385,6 @@ var r6arg = <T extends Base, U extends Derived>(x: (arg: T) => U) => <T>null;
 
 var r6arg2 = <T extends Base>(x: (arg: T) => Derived) => <T>null;
 >r6arg2 : Symbol(r6arg2, Decl(subtypingWithCallSignatures4.ts, 83, 3))
-><T extends Base>(x: (arg: T) => Derived) => <T>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 83, 12))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 83, 14))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures4.ts, 0, 0))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 83, 30))
@@ -422,7 +410,6 @@ var r6b = [r6arg2, r6arg];
 
 var r11arg = <T, U>(x: { foo: T }, y: { foo: U; bar: U }) => <Base>null;
 >r11arg : Symbol(r11arg, Decl(subtypingWithCallSignatures4.ts, 88, 3))
-><T, U>(x: { foo: T }, y: { foo: U; bar: U }) => <Base>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 88, 12))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 88, 14))
 >U : Symbol(U, Decl(subtypingWithCallSignatures4.ts, 88, 16))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 88, 20))
@@ -437,7 +424,6 @@ var r11arg = <T, U>(x: { foo: T }, y: { foo: U; bar: U }) => <Base>null;
 
 var r11arg2 = <T>(x: { foo: T }, y: { foo: T; bar: T }) => <Base>null;
 >r11arg2 : Symbol(r11arg2, Decl(subtypingWithCallSignatures4.ts, 89, 3))
-><T>(x: { foo: T }, y: { foo: T; bar: T }) => <Base>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 89, 13))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 89, 15))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 89, 18))
 >foo : Symbol(foo, Decl(subtypingWithCallSignatures4.ts, 89, 22))
@@ -466,7 +452,6 @@ var r11b = [r11arg2, r11arg];
 
 var r15arg = <U, V>(x: { a: U; b: V; }) => <U[]>null;
 >r15arg : Symbol(r15arg, Decl(subtypingWithCallSignatures4.ts, 94, 3))
-><U, V>(x: { a: U; b: V; }) => <U[]>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 94, 12))
 >U : Symbol(U, Decl(subtypingWithCallSignatures4.ts, 94, 14))
 >V : Symbol(V, Decl(subtypingWithCallSignatures4.ts, 94, 16))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 94, 20))
@@ -478,7 +463,6 @@ var r15arg = <U, V>(x: { a: U; b: V; }) => <U[]>null;
 
 var r15arg2 = <T>(x: { a: T; b: T }) => <T[]>null;
 >r15arg2 : Symbol(r15arg2, Decl(subtypingWithCallSignatures4.ts, 95, 3))
-><T>(x: { a: T; b: T }) => <T[]>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 95, 13))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 95, 15))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 95, 18))
 >a : Symbol(a, Decl(subtypingWithCallSignatures4.ts, 95, 22))
@@ -504,7 +488,6 @@ var r15b = [r15arg2, r15arg];
 
 var r16arg = <T extends Base>(x: { a: T; b: T }) => <T[]>null;
 >r16arg : Symbol(r16arg, Decl(subtypingWithCallSignatures4.ts, 100, 3))
-><T extends Base>(x: { a: T; b: T }) => <T[]>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 100, 12))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 100, 14))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures4.ts, 0, 0))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 100, 30))
@@ -516,7 +499,6 @@ var r16arg = <T extends Base>(x: { a: T; b: T }) => <T[]>null;
 
 var r16arg2 = <T extends Base>(x: { a: T; b: T }) => <T[]>null;
 >r16arg2 : Symbol(r16arg2, Decl(subtypingWithCallSignatures4.ts, 101, 3))
-><T extends Base>(x: { a: T; b: T }) => <T[]>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 101, 13))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 101, 15))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures4.ts, 0, 0))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 101, 31))
@@ -543,7 +525,6 @@ var r16b = [r16arg2, r16arg];
 
 var r17arg = <T>(x: (a: T) => T) => <T[]>null;
 >r17arg : Symbol(r17arg, Decl(subtypingWithCallSignatures4.ts, 106, 3))
-><T>(x: (a: T) => T) => <T[]>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 106, 12))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 106, 14))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 106, 17))
 >a : Symbol(a, Decl(subtypingWithCallSignatures4.ts, 106, 21))
@@ -558,7 +539,6 @@ var r17 = foo17(r17arg);
 
 var r18arg = (x: <T>(a: T) => T) => <any[]>null;
 >r18arg : Symbol(r18arg, Decl(subtypingWithCallSignatures4.ts, 109, 3))
->(x: <T>(a: T) => T) => <any[]>null : Symbol((Anonymous function), Decl(subtypingWithCallSignatures4.ts, 109, 12))
 >x : Symbol(x, Decl(subtypingWithCallSignatures4.ts, 109, 14))
 >T : Symbol(T, Decl(subtypingWithCallSignatures4.ts, 109, 18))
 >a : Symbol(a, Decl(subtypingWithCallSignatures4.ts, 109, 21))
diff --git a/tests/baselines/reference/subtypingWithObjectMembersOptionality.symbols b/tests/baselines/reference/subtypingWithObjectMembersOptionality.symbols
index 9d566b08864d3..7fce581b74b57 100644
--- a/tests/baselines/reference/subtypingWithObjectMembersOptionality.symbols
+++ b/tests/baselines/reference/subtypingWithObjectMembersOptionality.symbols
@@ -78,7 +78,6 @@ var a: { Foo?: Base; };
 
 var b = { Foo: <Derived>null };
 >b : Symbol(b, Decl(subtypingWithObjectMembersOptionality.ts, 40, 3))
->{ Foo: <Derived>null } : Symbol(, Decl(subtypingWithObjectMembersOptionality.ts, 40, 7))
 >Foo : Symbol(Foo, Decl(subtypingWithObjectMembersOptionality.ts, 40, 9))
 >Derived : Symbol(Derived, Decl(subtypingWithObjectMembersOptionality.ts, 2, 31))
 
@@ -145,7 +144,6 @@ module TwoLevels {
 
     var b = { Foo: <Derived2>null };
 >b : Symbol(b, Decl(subtypingWithObjectMembersOptionality.ts, 70, 7))
->{ Foo: <Derived2>null } : Symbol(, Decl(subtypingWithObjectMembersOptionality.ts, 70, 11))
 >Foo : Symbol(Foo, Decl(subtypingWithObjectMembersOptionality.ts, 70, 13))
 >Derived2 : Symbol(Derived2, Decl(subtypingWithObjectMembersOptionality.ts, 3, 47))
 
diff --git a/tests/baselines/reference/subtypingWithOptionalProperties.symbols b/tests/baselines/reference/subtypingWithOptionalProperties.symbols
index 65124a294ce65..44ebbe99fd7da 100644
--- a/tests/baselines/reference/subtypingWithOptionalProperties.symbols
+++ b/tests/baselines/reference/subtypingWithOptionalProperties.symbols
@@ -20,7 +20,6 @@ function f<T>(a: T) {
 var r = f({ s: new Object() }); // ok
 >r : Symbol(r, Decl(subtypingWithOptionalProperties.ts, 8, 3))
 >f : Symbol(f, Decl(subtypingWithOptionalProperties.ts, 0, 0))
->{ s: new Object() } : Symbol(, Decl(subtypingWithOptionalProperties.ts, 8, 10))
 >s : Symbol(s, Decl(subtypingWithOptionalProperties.ts, 8, 11))
 >Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
 
diff --git a/tests/baselines/reference/superAccessInFatArrow1.symbols b/tests/baselines/reference/superAccessInFatArrow1.symbols
index 0485002b52bc0..9b0a0607e0a19 100644
--- a/tests/baselines/reference/superAccessInFatArrow1.symbols
+++ b/tests/baselines/reference/superAccessInFatArrow1.symbols
@@ -24,7 +24,6 @@ module test {
 >this.bar : Symbol(bar, Decl(superAccessInFatArrow1.ts, 5, 30))
 >this : Symbol(B, Decl(superAccessInFatArrow1.ts, 4, 5))
 >bar : Symbol(bar, Decl(superAccessInFatArrow1.ts, 5, 30))
->() => {                super.foo();            } : Symbol((Anonymous function), Decl(superAccessInFatArrow1.ts, 9, 21))
 
                 super.foo();
 >super.foo : Symbol(A.foo, Decl(superAccessInFatArrow1.ts, 1, 20))
diff --git a/tests/baselines/reference/superCallParameterContextualTyping1.symbols b/tests/baselines/reference/superCallParameterContextualTyping1.symbols
index 8b9cad9122281..80876e2ee9d84 100644
--- a/tests/baselines/reference/superCallParameterContextualTyping1.symbols
+++ b/tests/baselines/reference/superCallParameterContextualTyping1.symbols
@@ -21,7 +21,6 @@ class B extends A<number, string> {
     // Ensure 'value' is of type 'number (and not '{}') by using its 'toExponential()' method.
     constructor() { super(value => String(value.toExponential())); }
 >super : Symbol(A, Decl(superCallParameterContextualTyping1.ts, 0, 0))
->value => String(value.toExponential()) : Symbol((Anonymous function), Decl(superCallParameterContextualTyping1.ts, 9, 26))
 >value : Symbol(value, Decl(superCallParameterContextualTyping1.ts, 9, 26))
 >String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
 >value.toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45))
diff --git a/tests/baselines/reference/superCallParameterContextualTyping3.symbols b/tests/baselines/reference/superCallParameterContextualTyping3.symbols
index 9c42055d89ee9..04bc148ac0f27 100644
--- a/tests/baselines/reference/superCallParameterContextualTyping3.symbols
+++ b/tests/baselines/reference/superCallParameterContextualTyping3.symbols
@@ -36,7 +36,6 @@ class C extends CBase<string> {
         // 'p' should have type 'string'.
         super({
 >super : Symbol(CBase, Decl(superCallParameterContextualTyping3.ts, 2, 1))
->{            method(p) {                p.length;            }        } : Symbol(, Decl(superCallParameterContextualTyping3.ts, 16, 14))
 
             method(p) {
 >method : Symbol(method, Decl(superCallParameterContextualTyping3.ts, 16, 15))
@@ -55,7 +54,6 @@ class C extends CBase<string> {
 >super.foo : Symbol(CBase.foo, Decl(superCallParameterContextualTyping3.ts, 6, 5))
 >super : Symbol(CBase, Decl(superCallParameterContextualTyping3.ts, 2, 1))
 >foo : Symbol(CBase.foo, Decl(superCallParameterContextualTyping3.ts, 6, 5))
->{            method(p) {                p.length;            }        } : Symbol(, Decl(superCallParameterContextualTyping3.ts, 24, 18))
 
             method(p) {
 >method : Symbol(method, Decl(superCallParameterContextualTyping3.ts, 24, 19))
diff --git a/tests/baselines/reference/switchBreakStatements.symbols b/tests/baselines/reference/switchBreakStatements.symbols
index 9a3475cd341bf..226262418818a 100644
--- a/tests/baselines/reference/switchBreakStatements.symbols
+++ b/tests/baselines/reference/switchBreakStatements.symbols
@@ -49,7 +49,6 @@ switch ('') {
                             case 'a':
                                 var fn = function () { }
 >fn : Symbol(fn, Decl(switchBreakStatements.ts, 48, 35))
->function () { } : Symbol((Anonymous function), Decl(switchBreakStatements.ts, 48, 40))
 
                                 break EIGHT;
                         }
diff --git a/tests/baselines/reference/switchStatements.symbols b/tests/baselines/reference/switchStatements.symbols
index 100e03f2a6634..fc8f076a12ccc 100644
--- a/tests/baselines/reference/switchStatements.symbols
+++ b/tests/baselines/reference/switchStatements.symbols
@@ -32,10 +32,7 @@ switch (x) {
     case /[a-z]/:
     case[]:
     case {}:
->{} : Symbol(, Decl(switchStatements.ts, 17, 8))
-
     case { id: 12 }:
->{ id: 12 } : Symbol(, Decl(switchStatements.ts, 18, 8))
 >id : Symbol(id, Decl(switchStatements.ts, 18, 10))
 
     case['a']:
@@ -51,12 +48,10 @@ switch (x) {
 >fn : Symbol(M.fn, Decl(switchStatements.ts, 0, 10))
 
     case <T>(x: number) => '':
-><T>(x: number) => '' : Symbol((Anonymous function), Decl(switchStatements.ts, 23, 8))
 >T : Symbol(T, Decl(switchStatements.ts, 23, 10))
 >x : Symbol(x, Decl(switchStatements.ts, 23, 13))
 
     case (<T>(x: number) => '')(2):
-><T>(x: number) => '' : Symbol((Anonymous function), Decl(switchStatements.ts, 24, 10))
 >T : Symbol(T, Decl(switchStatements.ts, 24, 11))
 >x : Symbol(x, Decl(switchStatements.ts, 24, 14))
 
@@ -80,7 +75,6 @@ switch (new C()) {
 >D : Symbol(D, Decl(switchStatements.ts, 29, 23))
 
     case { id: 12, name: '' }:
->{ id: 12, name: '' } : Symbol(, Decl(switchStatements.ts, 34, 8))
 >id : Symbol(id, Decl(switchStatements.ts, 34, 10))
 >name : Symbol(name, Decl(switchStatements.ts, 34, 18))
 
@@ -104,20 +98,15 @@ switch (new Object()) { }
 switch (/[a-z]/) { }
 switch ([]) { }
 switch ({}) { }
->{} : Symbol(, Decl(switchStatements.ts, 47, 8))
-
 switch ({ id: 12 }) { }
->{ id: 12 } : Symbol(, Decl(switchStatements.ts, 48, 8))
 >id : Symbol(id, Decl(switchStatements.ts, 48, 9))
 
 switch (['a']) { }
 switch (<T>(x: number) => '') { }
-><T>(x: number) => '' : Symbol((Anonymous function), Decl(switchStatements.ts, 50, 8))
 >T : Symbol(T, Decl(switchStatements.ts, 50, 9))
 >x : Symbol(x, Decl(switchStatements.ts, 50, 12))
 
 switch ((<T>(x: T) => '')(1)) { }
-><T>(x: T) => '' : Symbol((Anonymous function), Decl(switchStatements.ts, 51, 9))
 >T : Symbol(T, Decl(switchStatements.ts, 51, 10))
 >x : Symbol(x, Decl(switchStatements.ts, 51, 13))
 >T : Symbol(T, Decl(switchStatements.ts, 51, 10))
diff --git a/tests/baselines/reference/symbolDeclarationEmit10.symbols b/tests/baselines/reference/symbolDeclarationEmit10.symbols
index 39b7ba76f45d4..5dba2268d2641 100644
--- a/tests/baselines/reference/symbolDeclarationEmit10.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit10.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/Symbols/symbolDeclarationEmit10.ts ===
 var obj = {
 >obj : Symbol(obj, Decl(symbolDeclarationEmit10.ts, 0, 3))
->{    get [Symbol.isConcatSpreadable]() { return '' },    set [Symbol.isConcatSpreadable](x) { }} : Symbol(, Decl(symbolDeclarationEmit10.ts, 0, 9))
 
     get [Symbol.isConcatSpreadable]() { return '' },
 >Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1243, 24))
diff --git a/tests/baselines/reference/symbolDeclarationEmit8.symbols b/tests/baselines/reference/symbolDeclarationEmit8.symbols
index 0bd55049b0d5e..7879d28b02f52 100644
--- a/tests/baselines/reference/symbolDeclarationEmit8.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit8.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/Symbols/symbolDeclarationEmit8.ts ===
 var obj = {
 >obj : Symbol(obj, Decl(symbolDeclarationEmit8.ts, 0, 3))
->{    [Symbol.isConcatSpreadable]: 0} : Symbol(, Decl(symbolDeclarationEmit8.ts, 0, 9))
 
     [Symbol.isConcatSpreadable]: 0
 >Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1243, 24))
diff --git a/tests/baselines/reference/symbolDeclarationEmit9.symbols b/tests/baselines/reference/symbolDeclarationEmit9.symbols
index 7a4ea8fd55cb0..17901fb713aac 100644
--- a/tests/baselines/reference/symbolDeclarationEmit9.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit9.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/Symbols/symbolDeclarationEmit9.ts ===
 var obj = {
 >obj : Symbol(obj, Decl(symbolDeclarationEmit9.ts, 0, 3))
->{    [Symbol.isConcatSpreadable]() { }} : Symbol(, Decl(symbolDeclarationEmit9.ts, 0, 9))
 
     [Symbol.isConcatSpreadable]() { }
 >Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1243, 24))
diff --git a/tests/baselines/reference/symbolProperty1.symbols b/tests/baselines/reference/symbolProperty1.symbols
index 486dfd7f57f74..9c911623b74aa 100644
--- a/tests/baselines/reference/symbolProperty1.symbols
+++ b/tests/baselines/reference/symbolProperty1.symbols
@@ -4,7 +4,6 @@ var s: symbol;
 
 var x = {
 >x : Symbol(x, Decl(symbolProperty1.ts, 1, 3))
->{    [s]: 0,    [s]() { },    get [s]() {        return 0;    }} : Symbol(, Decl(symbolProperty1.ts, 1, 7))
 
     [s]: 0,
 >s : Symbol(s, Decl(symbolProperty1.ts, 0, 3))
diff --git a/tests/baselines/reference/symbolProperty18.symbols b/tests/baselines/reference/symbolProperty18.symbols
index d069a88368f34..89df72d65430d 100644
--- a/tests/baselines/reference/symbolProperty18.symbols
+++ b/tests/baselines/reference/symbolProperty18.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/Symbols/symbolProperty18.ts ===
 var i = {
 >i : Symbol(i, Decl(symbolProperty18.ts, 0, 3))
->{    [Symbol.iterator]: 0,    [Symbol.toStringTag]() { return "" },    set [Symbol.toPrimitive](p: boolean) { }} : Symbol(, Decl(symbolProperty18.ts, 0, 7))
 
     [Symbol.iterator]: 0,
 >Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31))
diff --git a/tests/baselines/reference/symbolProperty19.symbols b/tests/baselines/reference/symbolProperty19.symbols
index 0a4f105cb828d..3ee9ed595c2ad 100644
--- a/tests/baselines/reference/symbolProperty19.symbols
+++ b/tests/baselines/reference/symbolProperty19.symbols
@@ -1,10 +1,8 @@
 === tests/cases/conformance/es6/Symbols/symbolProperty19.ts ===
 var i = {
 >i : Symbol(i, Decl(symbolProperty19.ts, 0, 3))
->{    [Symbol.iterator]: { p: null },    [Symbol.toStringTag]() { return { p: undefined }; }} : Symbol(, Decl(symbolProperty19.ts, 0, 7))
 
     [Symbol.iterator]: { p: null },
-<<<<<<< HEAD
 >Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31))
 >Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11))
 >iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31))
@@ -14,19 +12,6 @@ var i = {
 >Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24))
 >Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11))
 >toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24))
-=======
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
->{ p: null } : Symbol(, Decl(symbolProperty19.ts, 1, 22))
->p : Symbol(p, Decl(symbolProperty19.ts, 1, 24))
-
-    [Symbol.toStringTag]() { return { p: undefined }; }
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24))
->{ p: undefined } : Symbol(, Decl(symbolProperty19.ts, 2, 35))
->>>>>>> Accept symbol baselines
 >p : Symbol(p, Decl(symbolProperty19.ts, 2, 37))
 >undefined : Symbol(undefined)
 }
diff --git a/tests/baselines/reference/symbolProperty2.symbols b/tests/baselines/reference/symbolProperty2.symbols
index 82b20127f363a..b52c4087d7143 100644
--- a/tests/baselines/reference/symbolProperty2.symbols
+++ b/tests/baselines/reference/symbolProperty2.symbols
@@ -5,7 +5,6 @@ var s = Symbol();
 
 var x = {
 >x : Symbol(x, Decl(symbolProperty2.ts, 1, 3))
->{    [s]: 0,    [s]() { },    get [s]() {        return 0;    }} : Symbol(, Decl(symbolProperty2.ts, 1, 7))
 
     [s]: 0,
 >s : Symbol(s, Decl(symbolProperty2.ts, 0, 3))
diff --git a/tests/baselines/reference/symbolProperty20.symbols b/tests/baselines/reference/symbolProperty20.symbols
index 8750b0e0e099d..ad4f0c7952351 100644
--- a/tests/baselines/reference/symbolProperty20.symbols
+++ b/tests/baselines/reference/symbolProperty20.symbols
@@ -18,19 +18,11 @@ interface I {
 var i: I = {
 >i : Symbol(i, Decl(symbolProperty20.ts, 5, 3))
 >I : Symbol(I, Decl(symbolProperty20.ts, 0, 0))
->{    [Symbol.iterator]: s => s,    [Symbol.toStringTag](n) { return n; }} : Symbol(, Decl(symbolProperty20.ts, 5, 10))
 
     [Symbol.iterator]: s => s,
-<<<<<<< HEAD
 >Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31))
 >Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11))
 >iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31))
-=======
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
->s => s : Symbol((Anonymous function), Decl(symbolProperty20.ts, 6, 22))
->>>>>>> Accept symbol baselines
 >s : Symbol(s, Decl(symbolProperty20.ts, 6, 22))
 >s : Symbol(s, Decl(symbolProperty20.ts, 6, 22))
 
diff --git a/tests/baselines/reference/symbolProperty21.symbols b/tests/baselines/reference/symbolProperty21.symbols
index c83aad9b078f4..09997f687d53f 100644
--- a/tests/baselines/reference/symbolProperty21.symbols
+++ b/tests/baselines/reference/symbolProperty21.symbols
@@ -32,7 +32,6 @@ declare function foo<T, U>(p: I<T, U>): { t: T; u: U };
 
 foo({
 >foo : Symbol(foo, Decl(symbolProperty21.ts, 3, 1))
->{    [Symbol.isConcatSpreadable]: "",    [Symbol.toPrimitive]: 0,    [Symbol.unscopables]: true} : Symbol(, Decl(symbolProperty21.ts, 7, 4))
 
     [Symbol.isConcatSpreadable]: "",
 >Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1243, 24))
diff --git a/tests/baselines/reference/symbolProperty22.symbols b/tests/baselines/reference/symbolProperty22.symbols
index 42feb27aa19b9..b62037e32a507 100644
--- a/tests/baselines/reference/symbolProperty22.symbols
+++ b/tests/baselines/reference/symbolProperty22.symbols
@@ -27,17 +27,9 @@ declare function foo<T, U>(p1: T, p2: I<T, U>): U;
 
 foo("", { [Symbol.unscopables]: s => s.length });
 >foo : Symbol(foo, Decl(symbolProperty22.ts, 2, 1))
-<<<<<<< HEAD
 >Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1297, 24))
 >Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11))
 >unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1297, 24))
-=======
->{ [Symbol.unscopables]: s => s.length } : Symbol(, Decl(symbolProperty22.ts, 6, 7))
->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1284, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1284, 24))
->s => s.length : Symbol((Anonymous function), Decl(symbolProperty22.ts, 6, 31))
->>>>>>> Accept symbol baselines
 >s : Symbol(s, Decl(symbolProperty22.ts, 6, 31))
 >s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >s : Symbol(s, Decl(symbolProperty22.ts, 6, 31))
diff --git a/tests/baselines/reference/symbolProperty27.symbols b/tests/baselines/reference/symbolProperty27.symbols
index f0ede58e84d77..69fe473e17c3f 100644
--- a/tests/baselines/reference/symbolProperty27.symbols
+++ b/tests/baselines/reference/symbolProperty27.symbols
@@ -8,7 +8,6 @@ class C1 {
 >toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24))
 
         return {};
->{} : Symbol(, Decl(symbolProperty27.ts, 2, 14))
     }
 }
 
diff --git a/tests/baselines/reference/symbolProperty28.symbols b/tests/baselines/reference/symbolProperty28.symbols
index c52a3fa9b68c3..cf6ab1f5edba1 100644
--- a/tests/baselines/reference/symbolProperty28.symbols
+++ b/tests/baselines/reference/symbolProperty28.symbols
@@ -8,7 +8,6 @@ class C1 {
 >toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24))
 
         return { x: "" };
->{ x: "" } : Symbol(, Decl(symbolProperty28.ts, 2, 14))
 >x : Symbol(x, Decl(symbolProperty28.ts, 2, 16))
     }
 }
diff --git a/tests/baselines/reference/symbolProperty4.symbols b/tests/baselines/reference/symbolProperty4.symbols
index ab0fa9d282fd2..4e17e561bce0e 100644
--- a/tests/baselines/reference/symbolProperty4.symbols
+++ b/tests/baselines/reference/symbolProperty4.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/Symbols/symbolProperty4.ts ===
 var x = {
 >x : Symbol(x, Decl(symbolProperty4.ts, 0, 3))
->{    [Symbol()]: 0,    [Symbol()]() { },    get [Symbol()]() {        return 0;    }} : Symbol(, Decl(symbolProperty4.ts, 0, 7))
 
     [Symbol()]: 0,
 >Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11))
diff --git a/tests/baselines/reference/symbolProperty5.symbols b/tests/baselines/reference/symbolProperty5.symbols
index 6cca8227cf0cb..7b57003e607a0 100644
--- a/tests/baselines/reference/symbolProperty5.symbols
+++ b/tests/baselines/reference/symbolProperty5.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/Symbols/symbolProperty5.ts ===
 var x = {
 >x : Symbol(x, Decl(symbolProperty5.ts, 0, 3))
->{    [Symbol.iterator]: 0,    [Symbol.toPrimitive]() { },    get [Symbol.toStringTag]() {        return 0;    }} : Symbol(, Decl(symbolProperty5.ts, 0, 7))
 
     [Symbol.iterator]: 0,
 >Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31))
diff --git a/tests/baselines/reference/symbolProperty55.symbols b/tests/baselines/reference/symbolProperty55.symbols
index 3b791f7866c4a..05eeace3b869e 100644
--- a/tests/baselines/reference/symbolProperty55.symbols
+++ b/tests/baselines/reference/symbolProperty55.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/Symbols/symbolProperty55.ts ===
 var obj = {
 >obj : Symbol(obj, Decl(symbolProperty55.ts, 0, 3))
->{    [Symbol.iterator]: 0} : Symbol(, Decl(symbolProperty55.ts, 0, 9))
 
     [Symbol.iterator]: 0
 >Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31))
diff --git a/tests/baselines/reference/symbolProperty56.symbols b/tests/baselines/reference/symbolProperty56.symbols
index df865f79077d1..a4e335cc7d7c3 100644
--- a/tests/baselines/reference/symbolProperty56.symbols
+++ b/tests/baselines/reference/symbolProperty56.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/Symbols/symbolProperty56.ts ===
 var obj = {
 >obj : Symbol(obj, Decl(symbolProperty56.ts, 0, 3))
->{    [Symbol.iterator]: 0} : Symbol(, Decl(symbolProperty56.ts, 0, 9))
 
     [Symbol.iterator]: 0
 >Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31))
diff --git a/tests/baselines/reference/symbolProperty57.symbols b/tests/baselines/reference/symbolProperty57.symbols
index 82a0c9fc90ae6..249545872b1d0 100644
--- a/tests/baselines/reference/symbolProperty57.symbols
+++ b/tests/baselines/reference/symbolProperty57.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/Symbols/symbolProperty57.ts ===
 var obj = {
 >obj : Symbol(obj, Decl(symbolProperty57.ts, 0, 3))
->{    [Symbol.iterator]: 0} : Symbol(, Decl(symbolProperty57.ts, 0, 9))
 
     [Symbol.iterator]: 0
 >Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31))
diff --git a/tests/baselines/reference/symbolType11.symbols b/tests/baselines/reference/symbolType11.symbols
index 0a5806e6431ab..d40e0e7272474 100644
--- a/tests/baselines/reference/symbolType11.symbols
+++ b/tests/baselines/reference/symbolType11.symbols
@@ -23,6 +23,5 @@ s || 1;
 >s : Symbol(s, Decl(symbolType11.ts, 0, 3))
 
 ({}) || s;
->{} : Symbol(, Decl(symbolType11.ts, 6, 1))
 >s : Symbol(s, Decl(symbolType11.ts, 0, 3))
 
diff --git a/tests/baselines/reference/systemModule13.symbols b/tests/baselines/reference/systemModule13.symbols
index 97b811ef18f64..d9e64335c2bdd 100644
--- a/tests/baselines/reference/systemModule13.symbols
+++ b/tests/baselines/reference/systemModule13.symbols
@@ -8,10 +8,8 @@ export let [x,y,z] = [1, 2, 3];
 export const {a: z0, b: {c: z1}} = {a: true, b: {c: "123"}};
 >z0 : Symbol(z0, Decl(systemModule13.ts, 2, 14))
 >z1 : Symbol(z1, Decl(systemModule13.ts, 2, 25))
->{a: true, b: {c: "123"}} : Symbol(, Decl(systemModule13.ts, 2, 34))
 >a : Symbol(a, Decl(systemModule13.ts, 2, 36))
 >b : Symbol(b, Decl(systemModule13.ts, 2, 44))
->{c: "123"} : Symbol(, Decl(systemModule13.ts, 2, 47))
 >c : Symbol(c, Decl(systemModule13.ts, 2, 49))
 
 for ([x] of [[1]]) {}
diff --git a/tests/baselines/reference/systemModule8.symbols b/tests/baselines/reference/systemModule8.symbols
index 320e47ed38e15..3365ce7e37d8d 100644
--- a/tests/baselines/reference/systemModule8.symbols
+++ b/tests/baselines/reference/systemModule8.symbols
@@ -80,10 +80,8 @@ export let [y] = [1];
 export const {a: z0, b: {c: z1}} = {a: true, b: {c: "123"}};
 >z0 : Symbol(z0, Decl(systemModule8.ts, 28, 14))
 >z1 : Symbol(z1, Decl(systemModule8.ts, 28, 25))
->{a: true, b: {c: "123"}} : Symbol(, Decl(systemModule8.ts, 28, 34))
 >a : Symbol(a, Decl(systemModule8.ts, 28, 36))
 >b : Symbol(b, Decl(systemModule8.ts, 28, 44))
->{c: "123"} : Symbol(, Decl(systemModule8.ts, 28, 47))
 >c : Symbol(c, Decl(systemModule8.ts, 28, 49))
 
 for ([x] of [[1]]) {}
diff --git a/tests/baselines/reference/taggedTemplateContextualTyping1.symbols b/tests/baselines/reference/taggedTemplateContextualTyping1.symbols
index 6677a920d0923..f042978fa8c9b 100644
--- a/tests/baselines/reference/taggedTemplateContextualTyping1.symbols
+++ b/tests/baselines/reference/taggedTemplateContextualTyping1.symbols
@@ -49,7 +49,6 @@ function tempTag1<T>(...rest: any[]): T {
 // so this test will error.
 tempTag1 `${ x => { x<number>(undefined); return x; }                   }${ 10 }`;
 >tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 1, 48), Decl(taggedTemplateContextualTyping1.ts, 3, 79), Decl(taggedTemplateContextualTyping1.ts, 4, 92))
->x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(taggedTemplateContextualTyping1.ts, 13, 12))
 >x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 13, 12))
 >x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 13, 12))
 >undefined : Symbol(undefined)
@@ -57,12 +56,10 @@ tempTag1 `${ x => { x<number>(undefined); return x; }                   }${ 10 }
 
 tempTag1 `${ x => { x<number>(undefined); return x; }                   }${ y => { y<number>(undefined); return y; }                  }${ 10 }`;
 >tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 1, 48), Decl(taggedTemplateContextualTyping1.ts, 3, 79), Decl(taggedTemplateContextualTyping1.ts, 4, 92))
->x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(taggedTemplateContextualTyping1.ts, 14, 12))
 >x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 14, 12))
 >x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 14, 12))
 >undefined : Symbol(undefined)
 >x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 14, 12))
->y => { y<number>(undefined); return y; } : Symbol((Anonymous function), Decl(taggedTemplateContextualTyping1.ts, 14, 75))
 >y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 14, 75))
 >y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 14, 75))
 >undefined : Symbol(undefined)
@@ -70,12 +67,10 @@ tempTag1 `${ x => { x<number>(undefined); return x; }                   }${ y =>
 
 tempTag1 `${ x => { x<number>(undefined); return x; }                   }${ (y: <T>(p: T) => T) => { y<number>(undefined); return y } }${ undefined }`;
 >tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 1, 48), Decl(taggedTemplateContextualTyping1.ts, 3, 79), Decl(taggedTemplateContextualTyping1.ts, 4, 92))
->x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(taggedTemplateContextualTyping1.ts, 15, 12))
 >x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 15, 12))
 >x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 15, 12))
 >undefined : Symbol(undefined)
 >x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 15, 12))
->(y: <T>(p: T) => T) => { y<number>(undefined); return y } : Symbol((Anonymous function), Decl(taggedTemplateContextualTyping1.ts, 15, 75))
 >y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 15, 77))
 >T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 15, 81))
 >p : Symbol(p, Decl(taggedTemplateContextualTyping1.ts, 15, 84))
@@ -88,7 +83,6 @@ tempTag1 `${ x => { x<number>(undefined); return x; }                   }${ (y:
 
 tempTag1 `${ (x: <T>(p: T) => T) => { x<number>(undefined); return x; } }${ y => { y<number>(undefined); return y; }                  }${ undefined }`;
 >tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 1, 48), Decl(taggedTemplateContextualTyping1.ts, 3, 79), Decl(taggedTemplateContextualTyping1.ts, 4, 92))
->(x: <T>(p: T) => T) => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(taggedTemplateContextualTyping1.ts, 16, 12))
 >x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 16, 14))
 >T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 16, 18))
 >p : Symbol(p, Decl(taggedTemplateContextualTyping1.ts, 16, 21))
@@ -97,7 +91,6 @@ tempTag1 `${ (x: <T>(p: T) => T) => { x<number>(undefined); return x; } }${ y =>
 >x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 16, 14))
 >undefined : Symbol(undefined)
 >x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 16, 14))
->y => { y<number>(undefined); return y; } : Symbol((Anonymous function), Decl(taggedTemplateContextualTyping1.ts, 16, 75))
 >y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 16, 75))
 >y : Symbol(y, Decl(taggedTemplateContextualTyping1.ts, 16, 75))
 >undefined : Symbol(undefined)
diff --git a/tests/baselines/reference/taggedTemplateContextualTyping2.symbols b/tests/baselines/reference/taggedTemplateContextualTyping2.symbols
index 8e1c2db714c98..6918c5606a8d9 100644
--- a/tests/baselines/reference/taggedTemplateContextualTyping2.symbols
+++ b/tests/baselines/reference/taggedTemplateContextualTyping2.symbols
@@ -51,7 +51,6 @@ function tempTag2(...rest: any[]): any {
 // so this test will error.
 tempTag2 `${ x => { x<number>(undefined); return x; }         }${ 0 }`;
 >tempTag2 : Symbol(tempTag2, Decl(taggedTemplateContextualTyping2.ts, 2, 52), Decl(taggedTemplateContextualTyping2.ts, 4, 87), Decl(taggedTemplateContextualTyping2.ts, 5, 101))
->x => { x<number>(undefined); return x; } : Symbol((Anonymous function), Decl(taggedTemplateContextualTyping2.ts, 14, 12))
 >x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 14, 12))
 >x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 14, 12))
 >undefined : Symbol(undefined)
@@ -59,19 +58,16 @@ tempTag2 `${ x => { x<number>(undefined); return x; }         }${ 0 }`;
 
 tempTag2 `${ x => { x<number, string>(undefined); return x; } }${ y => { y<string, number>(null); return y; } }${ "hello" }`;
 >tempTag2 : Symbol(tempTag2, Decl(taggedTemplateContextualTyping2.ts, 2, 52), Decl(taggedTemplateContextualTyping2.ts, 4, 87), Decl(taggedTemplateContextualTyping2.ts, 5, 101))
->x => { x<number, string>(undefined); return x; } : Symbol((Anonymous function), Decl(taggedTemplateContextualTyping2.ts, 15, 12))
 >x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 15, 12))
 >x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 15, 12))
 >undefined : Symbol(undefined)
 >x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 15, 12))
->y => { y<string, number>(null); return y; } : Symbol((Anonymous function), Decl(taggedTemplateContextualTyping2.ts, 15, 65))
 >y : Symbol(y, Decl(taggedTemplateContextualTyping2.ts, 15, 65))
 >y : Symbol(y, Decl(taggedTemplateContextualTyping2.ts, 15, 65))
 >y : Symbol(y, Decl(taggedTemplateContextualTyping2.ts, 15, 65))
 
 tempTag2 `${ x => { x<number, string>(undefined); return x; } }${ undefined }${ "hello" }`;
 >tempTag2 : Symbol(tempTag2, Decl(taggedTemplateContextualTyping2.ts, 2, 52), Decl(taggedTemplateContextualTyping2.ts, 4, 87), Decl(taggedTemplateContextualTyping2.ts, 5, 101))
->x => { x<number, string>(undefined); return x; } : Symbol((Anonymous function), Decl(taggedTemplateContextualTyping2.ts, 16, 12))
 >x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 16, 12))
 >x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 16, 12))
 >undefined : Symbol(undefined)
diff --git a/tests/baselines/reference/targetTypeArgs.symbols b/tests/baselines/reference/targetTypeArgs.symbols
index 9518ad8e56958..6c1b2cd9cfe68 100644
--- a/tests/baselines/reference/targetTypeArgs.symbols
+++ b/tests/baselines/reference/targetTypeArgs.symbols
@@ -10,14 +10,12 @@ function foo(callback: (x: string) => void) {
 
 foo(function(x) { x });
 >foo : Symbol(foo, Decl(targetTypeArgs.ts, 0, 0))
->function(x) { x } : Symbol((Anonymous function), Decl(targetTypeArgs.ts, 4, 4))
 >x : Symbol(x, Decl(targetTypeArgs.ts, 4, 13))
 >x : Symbol(x, Decl(targetTypeArgs.ts, 4, 13))
 
 [1].forEach(function(v,i,a) { v });
 >[1].forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
 >forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
->function(v,i,a) { v } : Symbol((Anonymous function), Decl(targetTypeArgs.ts, 6, 12))
 >v : Symbol(v, Decl(targetTypeArgs.ts, 6, 21))
 >i : Symbol(i, Decl(targetTypeArgs.ts, 6, 23))
 >a : Symbol(a, Decl(targetTypeArgs.ts, 6, 25))
@@ -26,7 +24,6 @@ foo(function(x) { x });
 ["hello"].every(function(v,i,a) {return true;});
 >["hello"].every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
 >every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
->function(v,i,a) {return true;} : Symbol((Anonymous function), Decl(targetTypeArgs.ts, 7, 16))
 >v : Symbol(v, Decl(targetTypeArgs.ts, 7, 25))
 >i : Symbol(i, Decl(targetTypeArgs.ts, 7, 27))
 >a : Symbol(a, Decl(targetTypeArgs.ts, 7, 29))
@@ -34,7 +31,6 @@ foo(function(x) { x });
 [1].every(function(v,i,a) {return true;});
 >[1].every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
 >every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
->function(v,i,a) {return true;} : Symbol((Anonymous function), Decl(targetTypeArgs.ts, 8, 10))
 >v : Symbol(v, Decl(targetTypeArgs.ts, 8, 19))
 >i : Symbol(i, Decl(targetTypeArgs.ts, 8, 21))
 >a : Symbol(a, Decl(targetTypeArgs.ts, 8, 23))
@@ -42,7 +38,6 @@ foo(function(x) { x });
 [1].every(function(v,i,a) {return true;});
 >[1].every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
 >every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
->function(v,i,a) {return true;} : Symbol((Anonymous function), Decl(targetTypeArgs.ts, 9, 10))
 >v : Symbol(v, Decl(targetTypeArgs.ts, 9, 19))
 >i : Symbol(i, Decl(targetTypeArgs.ts, 9, 21))
 >a : Symbol(a, Decl(targetTypeArgs.ts, 9, 23))
@@ -50,7 +45,6 @@ foo(function(x) { x });
 ["s"].every(function(v,i,a) {return true;});
 >["s"].every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
 >every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
->function(v,i,a) {return true;} : Symbol((Anonymous function), Decl(targetTypeArgs.ts, 10, 12))
 >v : Symbol(v, Decl(targetTypeArgs.ts, 10, 21))
 >i : Symbol(i, Decl(targetTypeArgs.ts, 10, 23))
 >a : Symbol(a, Decl(targetTypeArgs.ts, 10, 25))
@@ -58,7 +52,6 @@ foo(function(x) { x });
 ["s"].forEach(function(v,i,a) { v });
 >["s"].forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
 >forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
->function(v,i,a) { v } : Symbol((Anonymous function), Decl(targetTypeArgs.ts, 11, 14))
 >v : Symbol(v, Decl(targetTypeArgs.ts, 11, 23))
 >i : Symbol(i, Decl(targetTypeArgs.ts, 11, 25))
 >a : Symbol(a, Decl(targetTypeArgs.ts, 11, 27))
diff --git a/tests/baselines/reference/targetTypeCalls.symbols b/tests/baselines/reference/targetTypeCalls.symbols
index 7196565d49600..7a5ade57e8cb7 100644
--- a/tests/baselines/reference/targetTypeCalls.symbols
+++ b/tests/baselines/reference/targetTypeCalls.symbols
@@ -2,32 +2,22 @@
 var fra1: (v:any)=>string = function() { return function (v:string) {return v;}; }() // should work
 >fra1 : Symbol(fra1, Decl(targetTypeCalls.ts, 0, 3))
 >v : Symbol(v, Decl(targetTypeCalls.ts, 0, 11))
->function() { return function (v:string) {return v;}; } : Symbol((Anonymous function), Decl(targetTypeCalls.ts, 0, 27))
->function (v:string) {return v;} : Symbol((Anonymous function), Decl(targetTypeCalls.ts, 0, 47))
 >v : Symbol(v, Decl(targetTypeCalls.ts, 0, 58))
 >v : Symbol(v, Decl(targetTypeCalls.ts, 0, 58))
 
 var fra2: (v:any)=>number = function() { return function () { return 0; } }() // should work
 >fra2 : Symbol(fra2, Decl(targetTypeCalls.ts, 1, 3))
 >v : Symbol(v, Decl(targetTypeCalls.ts, 1, 11))
->function() { return function () { return 0; } } : Symbol((Anonymous function), Decl(targetTypeCalls.ts, 1, 27))
->function () { return 0; } : Symbol((Anonymous function), Decl(targetTypeCalls.ts, 1, 47))
 
 var fra3: (v:any)=>string = function() { return function() { return function(v) {return v;};}(); }() // should work
 >fra3 : Symbol(fra3, Decl(targetTypeCalls.ts, 3, 3))
 >v : Symbol(v, Decl(targetTypeCalls.ts, 3, 11))
->function() { return function() { return function(v) {return v;};}(); } : Symbol((Anonymous function), Decl(targetTypeCalls.ts, 3, 27))
->function() { return function(v) {return v;};} : Symbol((Anonymous function), Decl(targetTypeCalls.ts, 3, 47))
->function(v) {return v;} : Symbol((Anonymous function), Decl(targetTypeCalls.ts, 3, 67))
 >v : Symbol(v, Decl(targetTypeCalls.ts, 3, 77))
 >v : Symbol(v, Decl(targetTypeCalls.ts, 3, 77))
 
 var fra4: (v:any)=>void = function() { return function() { return function(v) {return v;};}(); }() // should work
 >fra4 : Symbol(fra4, Decl(targetTypeCalls.ts, 4, 3))
 >v : Symbol(v, Decl(targetTypeCalls.ts, 4, 11))
->function() { return function() { return function(v) {return v;};}(); } : Symbol((Anonymous function), Decl(targetTypeCalls.ts, 4, 25))
->function() { return function(v) {return v;};} : Symbol((Anonymous function), Decl(targetTypeCalls.ts, 4, 45))
->function(v) {return v;} : Symbol((Anonymous function), Decl(targetTypeCalls.ts, 4, 65))
 >v : Symbol(v, Decl(targetTypeCalls.ts, 4, 75))
 >v : Symbol(v, Decl(targetTypeCalls.ts, 4, 75))
 
diff --git a/tests/baselines/reference/targetTypeObjectLiteral.symbols b/tests/baselines/reference/targetTypeObjectLiteral.symbols
index 0c1a18a12d22b..f387b60ddf602 100644
--- a/tests/baselines/reference/targetTypeObjectLiteral.symbols
+++ b/tests/baselines/reference/targetTypeObjectLiteral.symbols
@@ -4,14 +4,12 @@ var z: { x: number; y: (w:string)=>number;} = {
 >x : Symbol(x, Decl(targetTypeObjectLiteral.ts, 0, 8))
 >y : Symbol(y, Decl(targetTypeObjectLiteral.ts, 0, 19))
 >w : Symbol(w, Decl(targetTypeObjectLiteral.ts, 0, 24))
->{    x: 12,    y: function(w) {        return 0;    }} : Symbol(, Decl(targetTypeObjectLiteral.ts, 0, 45))
 
     x: 12,
 >x : Symbol(x, Decl(targetTypeObjectLiteral.ts, 0, 47))
 
     y: function(w) {
 >y : Symbol(y, Decl(targetTypeObjectLiteral.ts, 2, 10))
->function(w) {        return 0;    } : Symbol((Anonymous function), Decl(targetTypeObjectLiteral.ts, 4, 6))
 >w : Symbol(w, Decl(targetTypeObjectLiteral.ts, 4, 16))
 
         return 0;
diff --git a/tests/baselines/reference/targetTypeObjectLiteralToAny.symbols b/tests/baselines/reference/targetTypeObjectLiteralToAny.symbols
index 8f84203743c2a..dbac3b573661a 100644
--- a/tests/baselines/reference/targetTypeObjectLiteralToAny.symbols
+++ b/tests/baselines/reference/targetTypeObjectLiteralToAny.symbols
@@ -12,12 +12,10 @@ function suggest(){
 >TypeScriptKeywords.forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
 >TypeScriptKeywords : Symbol(TypeScriptKeywords, Decl(targetTypeObjectLiteralToAny.ts, 1, 4))
 >forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
->function(keyword) {								result.push({text:keyword, type:"keyword"}); // this should not cause a crash - push should be typed to any	} : Symbol((Anonymous function), Decl(targetTypeObjectLiteralToAny.ts, 4, 28))
 >keyword : Symbol(keyword, Decl(targetTypeObjectLiteralToAny.ts, 4, 37))
 
 		result.push({text:keyword, type:"keyword"}); // this should not cause a crash - push should be typed to any
 >result : Symbol(result, Decl(targetTypeObjectLiteralToAny.ts, 2, 4))
->{text:keyword, type:"keyword"} : Symbol(, Decl(targetTypeObjectLiteralToAny.ts, 5, 14))
 >text : Symbol(text, Decl(targetTypeObjectLiteralToAny.ts, 5, 15))
 >keyword : Symbol(keyword, Decl(targetTypeObjectLiteralToAny.ts, 4, 37))
 >type : Symbol(type, Decl(targetTypeObjectLiteralToAny.ts, 5, 28))
diff --git a/tests/baselines/reference/targetTypingOnFunctions.symbols b/tests/baselines/reference/targetTypingOnFunctions.symbols
index 95cfe424e0cc9..ccf669ffa671f 100644
--- a/tests/baselines/reference/targetTypingOnFunctions.symbols
+++ b/tests/baselines/reference/targetTypingOnFunctions.symbols
@@ -2,7 +2,6 @@
 var fu: (s: string) => string = function (s) { return s.toLowerCase() };
 >fu : Symbol(fu, Decl(targetTypingOnFunctions.ts, 0, 3))
 >s : Symbol(s, Decl(targetTypingOnFunctions.ts, 0, 9))
->function (s) { return s.toLowerCase() } : Symbol((Anonymous function), Decl(targetTypingOnFunctions.ts, 0, 31))
 >s : Symbol(s, Decl(targetTypingOnFunctions.ts, 0, 42))
 >s.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51))
 >s : Symbol(s, Decl(targetTypingOnFunctions.ts, 0, 42))
@@ -11,7 +10,6 @@ var fu: (s: string) => string = function (s) { return s.toLowerCase() };
 var zu = fu = function (s) { return s.toLowerCase() };
 >zu : Symbol(zu, Decl(targetTypingOnFunctions.ts, 2, 3))
 >fu : Symbol(fu, Decl(targetTypingOnFunctions.ts, 0, 3))
->function (s) { return s.toLowerCase() } : Symbol((Anonymous function), Decl(targetTypingOnFunctions.ts, 2, 13))
 >s : Symbol(s, Decl(targetTypingOnFunctions.ts, 2, 24))
 >s.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51))
 >s : Symbol(s, Decl(targetTypingOnFunctions.ts, 2, 24))
diff --git a/tests/baselines/reference/templateStringInArrowFunction.symbols b/tests/baselines/reference/templateStringInArrowFunction.symbols
index ea48714238101..7d1c1a20cba5d 100644
--- a/tests/baselines/reference/templateStringInArrowFunction.symbols
+++ b/tests/baselines/reference/templateStringInArrowFunction.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/templates/templateStringInArrowFunction.ts ===
 var x = x => `abc${ x }def`;
 >x : Symbol(x, Decl(templateStringInArrowFunction.ts, 0, 3))
->x => `abc${ x }def` : Symbol((Anonymous function), Decl(templateStringInArrowFunction.ts, 0, 7))
 >x : Symbol(x, Decl(templateStringInArrowFunction.ts, 0, 7))
 >x : Symbol(x, Decl(templateStringInArrowFunction.ts, 0, 7))
 
diff --git a/tests/baselines/reference/templateStringInArrowFunctionES6.symbols b/tests/baselines/reference/templateStringInArrowFunctionES6.symbols
index b375317c08ef6..c78790d4cd633 100644
--- a/tests/baselines/reference/templateStringInArrowFunctionES6.symbols
+++ b/tests/baselines/reference/templateStringInArrowFunctionES6.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/templates/templateStringInArrowFunctionES6.ts ===
 var x = x => `abc${ x }def`;
 >x : Symbol(x, Decl(templateStringInArrowFunctionES6.ts, 0, 3))
->x => `abc${ x }def` : Symbol((Anonymous function), Decl(templateStringInArrowFunctionES6.ts, 0, 7))
 >x : Symbol(x, Decl(templateStringInArrowFunctionES6.ts, 0, 7))
 >x : Symbol(x, Decl(templateStringInArrowFunctionES6.ts, 0, 7))
 
diff --git a/tests/baselines/reference/templateStringInFunctionExpression.symbols b/tests/baselines/reference/templateStringInFunctionExpression.symbols
index 9a93e123b4f12..26674e5e6aa8d 100644
--- a/tests/baselines/reference/templateStringInFunctionExpression.symbols
+++ b/tests/baselines/reference/templateStringInFunctionExpression.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/templates/templateStringInFunctionExpression.ts ===
 var x = function y() {
 >x : Symbol(x, Decl(templateStringInFunctionExpression.ts, 0, 3))
->function y() {    `abc${ 0 }def`    return `abc${ 0 }def`;} : Symbol(y, Decl(templateStringInFunctionExpression.ts, 0, 7))
 >y : Symbol(y, Decl(templateStringInFunctionExpression.ts, 0, 7))
 
     `abc${ 0 }def`
diff --git a/tests/baselines/reference/templateStringInFunctionExpressionES6.symbols b/tests/baselines/reference/templateStringInFunctionExpressionES6.symbols
index a9fd9e996aa4f..1f500b0e74d62 100644
--- a/tests/baselines/reference/templateStringInFunctionExpressionES6.symbols
+++ b/tests/baselines/reference/templateStringInFunctionExpressionES6.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/templates/templateStringInFunctionExpressionES6.ts ===
 var x = function y() {
 >x : Symbol(x, Decl(templateStringInFunctionExpressionES6.ts, 0, 3))
->function y() {    `abc${ 0 }def`    return `abc${ 0 }def`;} : Symbol(y, Decl(templateStringInFunctionExpressionES6.ts, 0, 7))
 >y : Symbol(y, Decl(templateStringInFunctionExpressionES6.ts, 0, 7))
 
     `abc${ 0 }def`
diff --git a/tests/baselines/reference/templateStringInInOperator.symbols b/tests/baselines/reference/templateStringInInOperator.symbols
index 96844878122ce..89eb5a380cfac 100644
--- a/tests/baselines/reference/templateStringInInOperator.symbols
+++ b/tests/baselines/reference/templateStringInInOperator.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/templates/templateStringInInOperator.ts ===
 var x = `${ "hi" }` in { hi: 10, hello: 20};
 >x : Symbol(x, Decl(templateStringInInOperator.ts, 0, 3))
->{ hi: 10, hello: 20} : Symbol(, Decl(templateStringInInOperator.ts, 0, 22))
 >hi : Symbol(hi, Decl(templateStringInInOperator.ts, 0, 24))
 >hello : Symbol(hello, Decl(templateStringInInOperator.ts, 0, 32))
 
diff --git a/tests/baselines/reference/templateStringInInOperatorES6.symbols b/tests/baselines/reference/templateStringInInOperatorES6.symbols
index 1f71f3fb15623..710ed18af3cdc 100644
--- a/tests/baselines/reference/templateStringInInOperatorES6.symbols
+++ b/tests/baselines/reference/templateStringInInOperatorES6.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/templates/templateStringInInOperatorES6.ts ===
 var x = `${ "hi" }` in { hi: 10, hello: 20};
 >x : Symbol(x, Decl(templateStringInInOperatorES6.ts, 0, 3))
->{ hi: 10, hello: 20} : Symbol(, Decl(templateStringInInOperatorES6.ts, 0, 22))
 >hi : Symbol(hi, Decl(templateStringInInOperatorES6.ts, 0, 24))
 >hello : Symbol(hello, Decl(templateStringInInOperatorES6.ts, 0, 32))
 
diff --git a/tests/baselines/reference/templateStringInPropertyAssignment.symbols b/tests/baselines/reference/templateStringInPropertyAssignment.symbols
index 23fa8da69c748..a4c5df2270113 100644
--- a/tests/baselines/reference/templateStringInPropertyAssignment.symbols
+++ b/tests/baselines/reference/templateStringInPropertyAssignment.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/templates/templateStringInPropertyAssignment.ts ===
 var x = {
 >x : Symbol(x, Decl(templateStringInPropertyAssignment.ts, 0, 3))
->{    a: `abc${ 123 }def${ 456 }ghi`} : Symbol(, Decl(templateStringInPropertyAssignment.ts, 0, 7))
 
     a: `abc${ 123 }def${ 456 }ghi`
 >a : Symbol(a, Decl(templateStringInPropertyAssignment.ts, 0, 9))
diff --git a/tests/baselines/reference/templateStringInPropertyAssignmentES6.symbols b/tests/baselines/reference/templateStringInPropertyAssignmentES6.symbols
index bc297bdf1f2f4..ac888a52235e4 100644
--- a/tests/baselines/reference/templateStringInPropertyAssignmentES6.symbols
+++ b/tests/baselines/reference/templateStringInPropertyAssignmentES6.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/templates/templateStringInPropertyAssignmentES6.ts ===
 var x = {
 >x : Symbol(x, Decl(templateStringInPropertyAssignmentES6.ts, 0, 3))
->{    a: `abc${ 123 }def${ 456 }ghi`} : Symbol(, Decl(templateStringInPropertyAssignmentES6.ts, 0, 7))
 
     a: `abc${ 123 }def${ 456 }ghi`
 >a : Symbol(a, Decl(templateStringInPropertyAssignmentES6.ts, 0, 9))
diff --git a/tests/baselines/reference/templateStringWithEmbeddedArrowFunction.symbols b/tests/baselines/reference/templateStringWithEmbeddedArrowFunction.symbols
index dcc817f0ea32f..9a8e6a2545543 100644
--- a/tests/baselines/reference/templateStringWithEmbeddedArrowFunction.symbols
+++ b/tests/baselines/reference/templateStringWithEmbeddedArrowFunction.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/templates/templateStringWithEmbeddedArrowFunction.ts ===
 var x = `abc${ x => x }def`;
 >x : Symbol(x, Decl(templateStringWithEmbeddedArrowFunction.ts, 0, 3))
->x => x : Symbol((Anonymous function), Decl(templateStringWithEmbeddedArrowFunction.ts, 0, 14))
 >x : Symbol(x, Decl(templateStringWithEmbeddedArrowFunction.ts, 0, 14))
 >x : Symbol(x, Decl(templateStringWithEmbeddedArrowFunction.ts, 0, 14))
 
diff --git a/tests/baselines/reference/templateStringWithEmbeddedArrowFunctionES6.symbols b/tests/baselines/reference/templateStringWithEmbeddedArrowFunctionES6.symbols
index 3222c85961fff..343e78d0dc0b8 100644
--- a/tests/baselines/reference/templateStringWithEmbeddedArrowFunctionES6.symbols
+++ b/tests/baselines/reference/templateStringWithEmbeddedArrowFunctionES6.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/templates/templateStringWithEmbeddedArrowFunctionES6.ts ===
 var x = `abc${ x => x }def`;
 >x : Symbol(x, Decl(templateStringWithEmbeddedArrowFunctionES6.ts, 0, 3))
->x => x : Symbol((Anonymous function), Decl(templateStringWithEmbeddedArrowFunctionES6.ts, 0, 14))
 >x : Symbol(x, Decl(templateStringWithEmbeddedArrowFunctionES6.ts, 0, 14))
 >x : Symbol(x, Decl(templateStringWithEmbeddedArrowFunctionES6.ts, 0, 14))
 
diff --git a/tests/baselines/reference/templateStringWithEmbeddedFunctionExpression.symbols b/tests/baselines/reference/templateStringWithEmbeddedFunctionExpression.symbols
index d6a0f1e3f4ac9..eb790b782b0f3 100644
--- a/tests/baselines/reference/templateStringWithEmbeddedFunctionExpression.symbols
+++ b/tests/baselines/reference/templateStringWithEmbeddedFunctionExpression.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/templates/templateStringWithEmbeddedFunctionExpression.ts ===
 var x = `abc${ function y() { return y; } }def`;
 >x : Symbol(x, Decl(templateStringWithEmbeddedFunctionExpression.ts, 0, 3))
->function y() { return y; } : Symbol(y, Decl(templateStringWithEmbeddedFunctionExpression.ts, 0, 14))
 >y : Symbol(y, Decl(templateStringWithEmbeddedFunctionExpression.ts, 0, 14))
 >y : Symbol(y, Decl(templateStringWithEmbeddedFunctionExpression.ts, 0, 14))
 
diff --git a/tests/baselines/reference/templateStringWithEmbeddedFunctionExpressionES6.symbols b/tests/baselines/reference/templateStringWithEmbeddedFunctionExpressionES6.symbols
index 513e1eb1daa7f..87fb7d4b53713 100644
--- a/tests/baselines/reference/templateStringWithEmbeddedFunctionExpressionES6.symbols
+++ b/tests/baselines/reference/templateStringWithEmbeddedFunctionExpressionES6.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/templates/templateStringWithEmbeddedFunctionExpressionES6.ts ===
 var x = `abc${ function y() { return y; } }def`;
 >x : Symbol(x, Decl(templateStringWithEmbeddedFunctionExpressionES6.ts, 0, 3))
->function y() { return y; } : Symbol(y, Decl(templateStringWithEmbeddedFunctionExpressionES6.ts, 0, 14))
 >y : Symbol(y, Decl(templateStringWithEmbeddedFunctionExpressionES6.ts, 0, 14))
 >y : Symbol(y, Decl(templateStringWithEmbeddedFunctionExpressionES6.ts, 0, 14))
 
diff --git a/tests/baselines/reference/templateStringWithEmbeddedInOperator.symbols b/tests/baselines/reference/templateStringWithEmbeddedInOperator.symbols
index 5018064ae446a..c1c6ce2daa557 100644
--- a/tests/baselines/reference/templateStringWithEmbeddedInOperator.symbols
+++ b/tests/baselines/reference/templateStringWithEmbeddedInOperator.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/templates/templateStringWithEmbeddedInOperator.ts ===
 var x = `abc${ "hi" in { hi: 10, hello: 20} }def`;
 >x : Symbol(x, Decl(templateStringWithEmbeddedInOperator.ts, 0, 3))
->{ hi: 10, hello: 20} : Symbol(, Decl(templateStringWithEmbeddedInOperator.ts, 0, 22))
 >hi : Symbol(hi, Decl(templateStringWithEmbeddedInOperator.ts, 0, 24))
 >hello : Symbol(hello, Decl(templateStringWithEmbeddedInOperator.ts, 0, 32))
 
diff --git a/tests/baselines/reference/templateStringWithEmbeddedInOperatorES6.symbols b/tests/baselines/reference/templateStringWithEmbeddedInOperatorES6.symbols
index 4acdd4742d126..7651708853798 100644
--- a/tests/baselines/reference/templateStringWithEmbeddedInOperatorES6.symbols
+++ b/tests/baselines/reference/templateStringWithEmbeddedInOperatorES6.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/templates/templateStringWithEmbeddedInOperatorES6.ts ===
 var x = `abc${ "hi" in { hi: 10, hello: 20} }def`;
 >x : Symbol(x, Decl(templateStringWithEmbeddedInOperatorES6.ts, 0, 3))
->{ hi: 10, hello: 20} : Symbol(, Decl(templateStringWithEmbeddedInOperatorES6.ts, 0, 22))
 >hi : Symbol(hi, Decl(templateStringWithEmbeddedInOperatorES6.ts, 0, 24))
 >hello : Symbol(hello, Decl(templateStringWithEmbeddedInOperatorES6.ts, 0, 32))
 
diff --git a/tests/baselines/reference/templateStringWithEmbeddedObjectLiteral.symbols b/tests/baselines/reference/templateStringWithEmbeddedObjectLiteral.symbols
index 20cda3ab5e40b..0e287d84772d0 100644
--- a/tests/baselines/reference/templateStringWithEmbeddedObjectLiteral.symbols
+++ b/tests/baselines/reference/templateStringWithEmbeddedObjectLiteral.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/templates/templateStringWithEmbeddedObjectLiteral.ts ===
 var x = `abc${ { x: 10, y: 20 } }def`;
 >x : Symbol(x, Decl(templateStringWithEmbeddedObjectLiteral.ts, 0, 3))
->{ x: 10, y: 20 } : Symbol(, Decl(templateStringWithEmbeddedObjectLiteral.ts, 0, 14))
 >x : Symbol(x, Decl(templateStringWithEmbeddedObjectLiteral.ts, 0, 16))
 >y : Symbol(y, Decl(templateStringWithEmbeddedObjectLiteral.ts, 0, 23))
 
diff --git a/tests/baselines/reference/templateStringWithEmbeddedObjectLiteralES6.symbols b/tests/baselines/reference/templateStringWithEmbeddedObjectLiteralES6.symbols
index 25b7ed110d854..b7c1f271c5ab2 100644
--- a/tests/baselines/reference/templateStringWithEmbeddedObjectLiteralES6.symbols
+++ b/tests/baselines/reference/templateStringWithEmbeddedObjectLiteralES6.symbols
@@ -1,7 +1,6 @@
 === tests/cases/conformance/es6/templates/templateStringWithEmbeddedObjectLiteralES6.ts ===
 var x = `abc${ { x: 10, y: 20 } }def`;
 >x : Symbol(x, Decl(templateStringWithEmbeddedObjectLiteralES6.ts, 0, 3))
->{ x: 10, y: 20 } : Symbol(, Decl(templateStringWithEmbeddedObjectLiteralES6.ts, 0, 14))
 >x : Symbol(x, Decl(templateStringWithEmbeddedObjectLiteralES6.ts, 0, 16))
 >y : Symbol(y, Decl(templateStringWithEmbeddedObjectLiteralES6.ts, 0, 23))
 
diff --git a/tests/baselines/reference/ternaryExpressionSourceMap.symbols b/tests/baselines/reference/ternaryExpressionSourceMap.symbols
index 19e23f37f7f2c..5893e5cb2c5cf 100644
--- a/tests/baselines/reference/ternaryExpressionSourceMap.symbols
+++ b/tests/baselines/reference/ternaryExpressionSourceMap.symbols
@@ -6,6 +6,4 @@ var x = 1;
 var foo = x ? () => 0 : () => 0;
 >foo : Symbol(foo, Decl(ternaryExpressionSourceMap.ts, 2, 3))
 >x : Symbol(x, Decl(ternaryExpressionSourceMap.ts, 1, 3))
->() => 0 : Symbol((Anonymous function), Decl(ternaryExpressionSourceMap.ts, 2, 13))
->() => 0 : Symbol((Anonymous function), Decl(ternaryExpressionSourceMap.ts, 2, 23))
 
diff --git a/tests/baselines/reference/thisBinding2.symbols b/tests/baselines/reference/thisBinding2.symbols
index ee671f09413ee..60c11c2e959a0 100644
--- a/tests/baselines/reference/thisBinding2.symbols
+++ b/tests/baselines/reference/thisBinding2.symbols
@@ -10,7 +10,6 @@ class C {
 >this.x : Symbol(x, Decl(thisBinding2.ts, 0, 9))
 >this : Symbol(C, Decl(thisBinding2.ts, 0, 0))
 >x : Symbol(x, Decl(thisBinding2.ts, 0, 9))
->() => {   var x = 1;   return this.x;  } : Symbol((Anonymous function), Decl(thisBinding2.ts, 3, 18))
 
    var x = 1;
 >x : Symbol(x, Decl(thisBinding2.ts, 4, 6))
@@ -25,7 +24,6 @@ class C {
 >this.x : Symbol(x, Decl(thisBinding2.ts, 0, 9))
 >this : Symbol(C, Decl(thisBinding2.ts, 0, 0))
 >x : Symbol(x, Decl(thisBinding2.ts, 0, 9))
->function() {   var x = 1;   return this.x;  } : Symbol((Anonymous function), Decl(thisBinding2.ts, 7, 10))
 
    var x = 1;
 >x : Symbol(x, Decl(thisBinding2.ts, 8, 6))
@@ -42,18 +40,15 @@ declare function setTimeout(expression: any, msec?: number, language?: any): num
 
 var messenger = {
 >messenger : Symbol(messenger, Decl(thisBinding2.ts, 14, 3))
->{    message: "Hello World",    start: function () {        return setTimeout(() => { var x = this.message; }, 3000);    }} : Symbol(, Decl(thisBinding2.ts, 14, 15))
 
     message: "Hello World",
 >message : Symbol(message, Decl(thisBinding2.ts, 14, 17))
 
     start: function () {
 >start : Symbol(start, Decl(thisBinding2.ts, 15, 27))
->function () {        return setTimeout(() => { var x = this.message; }, 3000);    } : Symbol((Anonymous function), Decl(thisBinding2.ts, 16, 10))
 
         return setTimeout(() => { var x = this.message; }, 3000);
 >setTimeout : Symbol(setTimeout, Decl(thisBinding2.ts, 12, 1))
->() => { var x = this.message; } : Symbol((Anonymous function), Decl(thisBinding2.ts, 17, 26))
 >x : Symbol(x, Decl(thisBinding2.ts, 17, 37))
     }
 };
diff --git a/tests/baselines/reference/thisCapture1.symbols b/tests/baselines/reference/thisCapture1.symbols
index 48055b8ef299b..fade5bbeca339 100644
--- a/tests/baselines/reference/thisCapture1.symbols
+++ b/tests/baselines/reference/thisCapture1.symbols
@@ -14,7 +14,6 @@ class X {
 
         return ret.always(() => {
 >ret : Symbol(ret, Decl(thisCapture1.ts, 3, 11))
->() => {            this.y = 0;        } : Symbol((Anonymous function), Decl(thisCapture1.ts, 4, 26))
 
             this.y = 0;
 >this.y : Symbol(y, Decl(thisCapture1.ts, 0, 9))
diff --git a/tests/baselines/reference/thisExpressionInIndexExpression.symbols b/tests/baselines/reference/thisExpressionInIndexExpression.symbols
index d73bc7d146e0a..b7df97a696b5f 100644
--- a/tests/baselines/reference/thisExpressionInIndexExpression.symbols
+++ b/tests/baselines/reference/thisExpressionInIndexExpression.symbols
@@ -3,7 +3,6 @@ function f() {
 >f : Symbol(f, Decl(thisExpressionInIndexExpression.ts, 0, 0))
 
     return r => r[this];
->r => r[this] : Symbol((Anonymous function), Decl(thisExpressionInIndexExpression.ts, 1, 10))
 >r : Symbol(r, Decl(thisExpressionInIndexExpression.ts, 1, 10))
 >r : Symbol(r, Decl(thisExpressionInIndexExpression.ts, 1, 10))
 }
diff --git a/tests/baselines/reference/thisExpressionOfGenericObject.symbols b/tests/baselines/reference/thisExpressionOfGenericObject.symbols
index c39eddbc3737a..f923b675e5d64 100644
--- a/tests/baselines/reference/thisExpressionOfGenericObject.symbols
+++ b/tests/baselines/reference/thisExpressionOfGenericObject.symbols
@@ -9,7 +9,6 @@ class MyClass1<T> {
 
     constructor() {
         () => this;
->() => this : Symbol((Anonymous function), Decl(thisExpressionOfGenericObject.ts, 2, 19))
 >this : Symbol(MyClass1, Decl(thisExpressionOfGenericObject.ts, 0, 0))
     }
 }
diff --git a/tests/baselines/reference/thisInInnerFunctions.symbols b/tests/baselines/reference/thisInInnerFunctions.symbols
index cc109894a63d9..70c9106f9f853 100644
--- a/tests/baselines/reference/thisInInnerFunctions.symbols
+++ b/tests/baselines/reference/thisInInnerFunctions.symbols
@@ -14,7 +14,6 @@ class Foo {
             this.y = "hi"; // 'this' should be not type to 'Foo' either
             var f = () => this.y;  // 'this' should be not type to 'Foo' either
 >f : Symbol(f, Decl(thisInInnerFunctions.ts, 5, 15))
->() => this.y : Symbol((Anonymous function), Decl(thisInInnerFunctions.ts, 5, 19))
         }
     }
 }
@@ -24,11 +23,8 @@ function test() {
 
     var x = () => {
 >x : Symbol(x, Decl(thisInInnerFunctions.ts, 11, 7))
->() => {        (() => this)();        this;    } : Symbol((Anonymous function), Decl(thisInInnerFunctions.ts, 11, 11))
 
         (() => this)();
->() => this : Symbol((Anonymous function), Decl(thisInInnerFunctions.ts, 12, 9))
-
         this;
     };
 }
diff --git a/tests/baselines/reference/thisInLambda.symbols b/tests/baselines/reference/thisInLambda.symbols
index 818bc32a308c6..e760c1b1c0212 100644
--- a/tests/baselines/reference/thisInLambda.symbols
+++ b/tests/baselines/reference/thisInLambda.symbols
@@ -15,7 +15,6 @@ class Foo {
 
         var f = () => this.x; // 'this' should be type 'Foo' as well
 >f : Symbol(f, Decl(thisInLambda.ts, 4, 11))
->() => this.x : Symbol((Anonymous function), Decl(thisInLambda.ts, 4, 15))
 >this.x : Symbol(x, Decl(thisInLambda.ts, 0, 11))
 >this : Symbol(Foo, Decl(thisInLambda.ts, 0, 0))
 >x : Symbol(x, Decl(thisInLambda.ts, 0, 11))
@@ -32,11 +31,9 @@ class myCls {
     constructor () {
         myFn(() => {
 >myFn : Symbol(myFn, Decl(thisInLambda.ts, 6, 1))
->() => {            myFn(() => {                var x = this;            });        } : Symbol((Anonymous function), Decl(thisInLambda.ts, 11, 13))
 
             myFn(() => {
 >myFn : Symbol(myFn, Decl(thisInLambda.ts, 6, 1))
->() => {                var x = this;            } : Symbol((Anonymous function), Decl(thisInLambda.ts, 12, 17))
 
                 var x = this;
 >x : Symbol(x, Decl(thisInLambda.ts, 13, 19))
diff --git a/tests/baselines/reference/thisInObjectLiterals.symbols b/tests/baselines/reference/thisInObjectLiterals.symbols
index 610d5d2970c5e..cb351ccd45756 100644
--- a/tests/baselines/reference/thisInObjectLiterals.symbols
+++ b/tests/baselines/reference/thisInObjectLiterals.symbols
@@ -11,7 +11,6 @@ class MyClass {
         //type of 'this' in an object literal is the containing scope's this
         var t = { x: this, y: this.t };
 >t : Symbol(t, Decl(thisInObjectLiterals.ts, 5, 11), Decl(thisInObjectLiterals.ts, 6, 11))
->{ x: this, y: this.t } : Symbol(, Decl(thisInObjectLiterals.ts, 5, 15))
 >x : Symbol(x, Decl(thisInObjectLiterals.ts, 5, 17))
 >this : Symbol(MyClass, Decl(thisInObjectLiterals.ts, 0, 0))
 >y : Symbol(y, Decl(thisInObjectLiterals.ts, 5, 26))
@@ -30,7 +29,6 @@ class MyClass {
 //type of 'this' in an object literal property of a function type is Any
 var obj = {
 >obj : Symbol(obj, Decl(thisInObjectLiterals.ts, 11, 3), Decl(thisInObjectLiterals.ts, 16, 3))
->{    f() {        return this.spaaace;    }} : Symbol(, Decl(thisInObjectLiterals.ts, 11, 9))
 
     f() {
 >f : Symbol(f, Decl(thisInObjectLiterals.ts, 11, 11))
diff --git a/tests/baselines/reference/thisInPropertyBoundDeclarations.symbols b/tests/baselines/reference/thisInPropertyBoundDeclarations.symbols
index 6878015ab7c63..6a5f1417cd086 100644
--- a/tests/baselines/reference/thisInPropertyBoundDeclarations.symbols
+++ b/tests/baselines/reference/thisInPropertyBoundDeclarations.symbols
@@ -10,7 +10,6 @@ class Bug {
 >Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
 
      (that: Bug, name: string) => {
->(that: Bug, name: string) => {         that.foo(name);     } : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 3, 39))
 >that : Symbol(that, Decl(thisInPropertyBoundDeclarations.ts, 4, 6))
 >Bug : Symbol(Bug, Decl(thisInPropertyBoundDeclarations.ts, 0, 0))
 >name : Symbol(name, Decl(thisInPropertyBoundDeclarations.ts, 4, 16))
@@ -41,14 +40,12 @@ class A {
 
     prop1 = function() {
 >prop1 : Symbol(prop1, Decl(thisInPropertyBoundDeclarations.ts, 15, 9))
->function() {        this;    } : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 16, 11))
 
         this;
     };
 
     prop2 = function() {
 >prop2 : Symbol(prop2, Decl(thisInPropertyBoundDeclarations.ts, 18, 6))
->function() {        function inner() {            this;        }        () => this;    } : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 20, 11))
 
         function inner() {
 >inner : Symbol(inner, Decl(thisInPropertyBoundDeclarations.ts, 20, 24))
@@ -56,13 +53,10 @@ class A {
             this;
         }
         () => this;
->() => this : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 23, 9))
-
     };
 
     prop3 = () => {
 >prop3 : Symbol(prop3, Decl(thisInPropertyBoundDeclarations.ts, 25, 6))
->() => {        function inner() {            this;        }    } : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 27, 11))
 
         function inner() {
 >inner : Symbol(inner, Decl(thisInPropertyBoundDeclarations.ts, 27, 19))
@@ -73,24 +67,18 @@ class A {
 
     prop4 = {
 >prop4 : Symbol(prop4, Decl(thisInPropertyBoundDeclarations.ts, 31, 6))
->{        a: function() { return this; },    } : Symbol(, Decl(thisInPropertyBoundDeclarations.ts, 33, 11))
 
         a: function() { return this; },
 >a : Symbol(a, Decl(thisInPropertyBoundDeclarations.ts, 33, 13))
->function() { return this; } : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 34, 10))
 
     };
 
     prop5 = () => {
 >prop5 : Symbol(prop5, Decl(thisInPropertyBoundDeclarations.ts, 35, 6))
->() => {        return {            a: function() { return this; },        };    } : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 37, 11))
 
         return {
->{            a: function() { return this; },        } : Symbol(, Decl(thisInPropertyBoundDeclarations.ts, 38, 14))
-
             a: function() { return this; },
 >a : Symbol(a, Decl(thisInPropertyBoundDeclarations.ts, 38, 16))
->function() { return this; } : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 39, 14))
 
         };
     };
@@ -105,52 +93,36 @@ class B {
 
     prop2 = () => this;
 >prop2 : Symbol(prop2, Decl(thisInPropertyBoundDeclarations.ts, 45, 17))
->() => this : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 47, 11))
 >this : Symbol(B, Decl(thisInPropertyBoundDeclarations.ts, 42, 1))
 
     prop3 = () => () => () => () => this;
 >prop3 : Symbol(prop3, Decl(thisInPropertyBoundDeclarations.ts, 47, 23))
->() => () => () => () => this : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 49, 11))
->() => () => () => this : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 49, 17))
->() => () => this : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 49, 23))
->() => this : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 49, 29))
 >this : Symbol(B, Decl(thisInPropertyBoundDeclarations.ts, 42, 1))
 
     prop4 = '  ' +
 >prop4 : Symbol(prop4, Decl(thisInPropertyBoundDeclarations.ts, 49, 41))
 
     function() {
->function() {    } : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 51, 18))
-
     } +
     ' ' +
     (() => () => () => this);
->() => () => () => this : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 55, 5))
->() => () => this : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 55, 10))
->() => this : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 55, 16))
 >this : Symbol(B, Decl(thisInPropertyBoundDeclarations.ts, 42, 1))
 
     prop5 = {
 >prop5 : Symbol(prop5, Decl(thisInPropertyBoundDeclarations.ts, 55, 29))
->{        a: () => { return this; }    } : Symbol(, Decl(thisInPropertyBoundDeclarations.ts, 57, 11))
 
         a: () => { return this; }
 >a : Symbol(a, Decl(thisInPropertyBoundDeclarations.ts, 57, 13))
->() => { return this; } : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 58, 10))
 >this : Symbol(B, Decl(thisInPropertyBoundDeclarations.ts, 42, 1))
 
     };
 
     prop6 = () => {
 >prop6 : Symbol(prop6, Decl(thisInPropertyBoundDeclarations.ts, 59, 6))
->() => {        return {            a: () => { return this; }        };    } : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 61, 11))
 
         return {
->{            a: () => { return this; }        } : Symbol(, Decl(thisInPropertyBoundDeclarations.ts, 62, 14))
-
             a: () => { return this; }
 >a : Symbol(a, Decl(thisInPropertyBoundDeclarations.ts, 62, 16))
->() => { return this; } : Symbol((Anonymous function), Decl(thisInPropertyBoundDeclarations.ts, 63, 14))
 >this : Symbol(B, Decl(thisInPropertyBoundDeclarations.ts, 42, 1))
 
         };
diff --git a/tests/baselines/reference/thisReferencedInFunctionInsideArrowFunction1.symbols b/tests/baselines/reference/thisReferencedInFunctionInsideArrowFunction1.symbols
index a73ede4a221e5..7197239714024 100644
--- a/tests/baselines/reference/thisReferencedInFunctionInsideArrowFunction1.symbols
+++ b/tests/baselines/reference/thisReferencedInFunctionInsideArrowFunction1.symbols
@@ -1,7 +1,6 @@
 === tests/cases/compiler/thisReferencedInFunctionInsideArrowFunction1.ts ===
 var foo = (dummy) => { };
 >foo : Symbol(foo, Decl(thisReferencedInFunctionInsideArrowFunction1.ts, 0, 3))
->(dummy) => { } : Symbol((Anonymous function), Decl(thisReferencedInFunctionInsideArrowFunction1.ts, 0, 9))
 >dummy : Symbol(dummy, Decl(thisReferencedInFunctionInsideArrowFunction1.ts, 0, 11))
 
 function test()
@@ -9,10 +8,7 @@ function test()
 {
     foo(() =>
 >foo : Symbol(foo, Decl(thisReferencedInFunctionInsideArrowFunction1.ts, 0, 3))
->() =>        function () { return this; } : Symbol((Anonymous function), Decl(thisReferencedInFunctionInsideArrowFunction1.ts, 3, 8))
 
         function () { return this; }
->function () { return this; } : Symbol((Anonymous function), Decl(thisReferencedInFunctionInsideArrowFunction1.ts, 3, 13))
-
     );
 }
diff --git a/tests/baselines/reference/throwInEnclosingStatements.symbols b/tests/baselines/reference/throwInEnclosingStatements.symbols
index 841bdde7b25a2..007894047dee4 100644
--- a/tests/baselines/reference/throwInEnclosingStatements.symbols
+++ b/tests/baselines/reference/throwInEnclosingStatements.symbols
@@ -8,7 +8,6 @@ function fn(x) {
 }
 
 <T>(x: T) => { throw x; }
-><T>(x: T) => { throw x; } : Symbol((Anonymous function), Decl(throwInEnclosingStatements.ts, 2, 1))
 >T : Symbol(T, Decl(throwInEnclosingStatements.ts, 4, 1))
 >x : Symbol(x, Decl(throwInEnclosingStatements.ts, 4, 4))
 >T : Symbol(T, Decl(throwInEnclosingStatements.ts, 4, 1))
@@ -45,7 +44,6 @@ for (var i = 0; ;) { throw i; }
 
 for (var idx in {}) { throw idx; }
 >idx : Symbol(idx, Decl(throwInEnclosingStatements.ts, 21, 8))
->{} : Symbol(, Decl(throwInEnclosingStatements.ts, 21, 15))
 >idx : Symbol(idx, Decl(throwInEnclosingStatements.ts, 21, 8))
 
 do { throw null; }while(true)
@@ -82,7 +80,6 @@ class C<T> {
 
 var aa = {
 >aa : Symbol(aa, Decl(throwInEnclosingStatements.ts, 39, 3))
->{    id:12,    biz() {        throw this;    }} : Symbol(, Decl(throwInEnclosingStatements.ts, 39, 8))
 
     id:12,
 >id : Symbol(id, Decl(throwInEnclosingStatements.ts, 39, 10))
diff --git a/tests/baselines/reference/throwStatements.symbols b/tests/baselines/reference/throwStatements.symbols
index 9dd6b9d5d4a8a..cb65755a145aa 100644
--- a/tests/baselines/reference/throwStatements.symbols
+++ b/tests/baselines/reference/throwStatements.symbols
@@ -120,7 +120,6 @@ throw aGenericClass;
 
 var anObjectLiteral = { id: 12 };
 >anObjectLiteral : Symbol(anObjectLiteral, Decl(throwStatements.ts, 46, 3))
->{ id: 12 } : Symbol(, Decl(throwStatements.ts, 46, 21))
 >id : Symbol(id, Decl(throwStatements.ts, 46, 23))
 
 throw anObjectLiteral;
@@ -138,7 +137,6 @@ throw aFunction('');
 
 var aLambda = (x) => 2;
 >aLambda : Symbol(aLambda, Decl(throwStatements.ts, 52, 3))
->(x) => 2 : Symbol((Anonymous function), Decl(throwStatements.ts, 52, 13))
 >x : Symbol(x, Decl(throwStatements.ts, 52, 15))
 
 throw aLambda;
@@ -191,16 +189,12 @@ throw undefined;
 
 throw 'a string';
 throw function () { return 'a string' };
->function () { return 'a string' } : Symbol((Anonymous function), Decl(throwStatements.ts, 74, 5))
-
 throw <T>(x:T) => 42;
-><T>(x:T) => 42 : Symbol((Anonymous function), Decl(throwStatements.ts, 75, 5))
 >T : Symbol(T, Decl(throwStatements.ts, 75, 7))
 >x : Symbol(x, Decl(throwStatements.ts, 75, 10))
 >T : Symbol(T, Decl(throwStatements.ts, 75, 7))
 
 throw { x: 12, y: 13 };
->{ x: 12, y: 13 } : Symbol(, Decl(throwStatements.ts, 76, 5))
 >x : Symbol(x, Decl(throwStatements.ts, 76, 7))
 >y : Symbol(y, Decl(throwStatements.ts, 76, 14))
 
diff --git a/tests/baselines/reference/tooFewArgumentsInGenericFunctionTypedArgument.symbols b/tests/baselines/reference/tooFewArgumentsInGenericFunctionTypedArgument.symbols
index 2a0aa5b74e586..79d5bc3e7a7e9 100644
--- a/tests/baselines/reference/tooFewArgumentsInGenericFunctionTypedArgument.symbols
+++ b/tests/baselines/reference/tooFewArgumentsInGenericFunctionTypedArgument.symbols
@@ -72,7 +72,6 @@ var r1a = _.map(c2, (x) => { return x.toFixed() });
 >_ : Symbol(_, Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 10, 3))
 >map : Symbol(Combinators.map, Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 5, 23), Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 6, 77))
 >c2 : Symbol(c2, Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 9, 3))
->(x) => { return x.toFixed() } : Symbol((Anonymous function), Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 11, 19))
 >x : Symbol(x, Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 11, 21))
 >x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
 >x : Symbol(x, Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 11, 21))
@@ -80,7 +79,6 @@ var r1a = _.map(c2, (x) => { return x.toFixed() });
 
 var rf1 = (x: number) => { return x.toFixed() };
 >rf1 : Symbol(rf1, Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 12, 3))
->(x: number) => { return x.toFixed() } : Symbol((Anonymous function), Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 12, 9))
 >x : Symbol(x, Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 12, 11))
 >x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
 >x : Symbol(x, Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 12, 11))
diff --git a/tests/baselines/reference/topLevelLambda2.symbols b/tests/baselines/reference/topLevelLambda2.symbols
index 93ade112e85bf..712d0a1611afc 100644
--- a/tests/baselines/reference/topLevelLambda2.symbols
+++ b/tests/baselines/reference/topLevelLambda2.symbols
@@ -5,5 +5,4 @@ function foo(x:any) {}
 
 foo(()=>this.window);
 >foo : Symbol(foo, Decl(topLevelLambda2.ts, 0, 0))
->()=>this.window : Symbol((Anonymous function), Decl(topLevelLambda2.ts, 2, 4))
 
diff --git a/tests/baselines/reference/topLevelLambda3.symbols b/tests/baselines/reference/topLevelLambda3.symbols
index 940e35e2918dd..6ec9476ff743a 100644
--- a/tests/baselines/reference/topLevelLambda3.symbols
+++ b/tests/baselines/reference/topLevelLambda3.symbols
@@ -1,5 +1,4 @@
 === tests/cases/compiler/topLevelLambda3.ts ===
 var f = () => {this.window;}
 >f : Symbol(f, Decl(topLevelLambda3.ts, 0, 3))
->() => {this.window;} : Symbol((Anonymous function), Decl(topLevelLambda3.ts, 0, 7))
 
diff --git a/tests/baselines/reference/topLevelLambda4.symbols b/tests/baselines/reference/topLevelLambda4.symbols
index 86ec6f6139d7d..a4f403a762ffd 100644
--- a/tests/baselines/reference/topLevelLambda4.symbols
+++ b/tests/baselines/reference/topLevelLambda4.symbols
@@ -1,5 +1,4 @@
 === tests/cases/compiler/topLevelLambda4.ts ===
 export var x = () => this.window;
 >x : Symbol(x, Decl(topLevelLambda4.ts, 0, 10))
->() => this.window : Symbol((Anonymous function), Decl(topLevelLambda4.ts, 0, 14))
 
diff --git a/tests/baselines/reference/trailingCommasES3.symbols b/tests/baselines/reference/trailingCommasES3.symbols
index 5d1112e052e8f..f176c9765c957 100644
--- a/tests/baselines/reference/trailingCommasES3.symbols
+++ b/tests/baselines/reference/trailingCommasES3.symbols
@@ -2,24 +2,20 @@
 
 var o1 = { a: 1, b: 2 };
 >o1 : Symbol(o1, Decl(trailingCommasES3.ts, 1, 3))
->{ a: 1, b: 2 } : Symbol(, Decl(trailingCommasES3.ts, 1, 8))
 >a : Symbol(a, Decl(trailingCommasES3.ts, 1, 10))
 >b : Symbol(b, Decl(trailingCommasES3.ts, 1, 16))
 
 var o2 = { a: 1, b: 2, };
 >o2 : Symbol(o2, Decl(trailingCommasES3.ts, 2, 3))
->{ a: 1, b: 2, } : Symbol(, Decl(trailingCommasES3.ts, 2, 8))
 >a : Symbol(a, Decl(trailingCommasES3.ts, 2, 10))
 >b : Symbol(b, Decl(trailingCommasES3.ts, 2, 16))
 
 var o3 = { a: 1, };
 >o3 : Symbol(o3, Decl(trailingCommasES3.ts, 3, 3))
->{ a: 1, } : Symbol(, Decl(trailingCommasES3.ts, 3, 8))
 >a : Symbol(a, Decl(trailingCommasES3.ts, 3, 10))
 
 var o4 = {};
 >o4 : Symbol(o4, Decl(trailingCommasES3.ts, 4, 3))
->{} : Symbol(, Decl(trailingCommasES3.ts, 4, 8))
 
 var a1 = [1, 2];
 >a1 : Symbol(a1, Decl(trailingCommasES3.ts, 6, 3))
diff --git a/tests/baselines/reference/trailingCommasES5.symbols b/tests/baselines/reference/trailingCommasES5.symbols
index 75a2544ee5dd4..1cf7a32154769 100644
--- a/tests/baselines/reference/trailingCommasES5.symbols
+++ b/tests/baselines/reference/trailingCommasES5.symbols
@@ -2,24 +2,20 @@
 
 var o1 = { a: 1, b: 2 };
 >o1 : Symbol(o1, Decl(trailingCommasES5.ts, 1, 3))
->{ a: 1, b: 2 } : Symbol(, Decl(trailingCommasES5.ts, 1, 8))
 >a : Symbol(a, Decl(trailingCommasES5.ts, 1, 10))
 >b : Symbol(b, Decl(trailingCommasES5.ts, 1, 16))
 
 var o2 = { a: 1, b: 2, };
 >o2 : Symbol(o2, Decl(trailingCommasES5.ts, 2, 3))
->{ a: 1, b: 2, } : Symbol(, Decl(trailingCommasES5.ts, 2, 8))
 >a : Symbol(a, Decl(trailingCommasES5.ts, 2, 10))
 >b : Symbol(b, Decl(trailingCommasES5.ts, 2, 16))
 
 var o3 = { a: 1, };
 >o3 : Symbol(o3, Decl(trailingCommasES5.ts, 3, 3))
->{ a: 1, } : Symbol(, Decl(trailingCommasES5.ts, 3, 8))
 >a : Symbol(a, Decl(trailingCommasES5.ts, 3, 10))
 
 var o4 = {};
 >o4 : Symbol(o4, Decl(trailingCommasES5.ts, 4, 3))
->{} : Symbol(, Decl(trailingCommasES5.ts, 4, 8))
 
 var a1 = [1, 2];
 >a1 : Symbol(a1, Decl(trailingCommasES5.ts, 6, 3))
diff --git a/tests/baselines/reference/tsxEmit1.symbols b/tests/baselines/reference/tsxEmit1.symbols
index 7eccc1172bbad..284f6cd9ce748 100644
--- a/tests/baselines/reference/tsxEmit1.symbols
+++ b/tests/baselines/reference/tsxEmit1.symbols
@@ -91,7 +91,6 @@ class SomeClass {
 		var rewrites1 = <div>{() => this}</div>;
 >rewrites1 : Symbol(rewrites1, Decl(tsxEmit1.tsx, 24, 5))
 >div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit1.tsx, 1, 22))
->() => this : Symbol((Anonymous function), Decl(tsxEmit1.tsx, 24, 24))
 >this : Symbol(SomeClass, Decl(tsxEmit1.tsx, 20, 43))
 
 		var rewrites2 = <div>{[p, ...p, p]}</div>;
@@ -104,14 +103,12 @@ class SomeClass {
 		var rewrites3 = <div>{{p}}</div>;
 >rewrites3 : Symbol(rewrites3, Decl(tsxEmit1.tsx, 26, 5))
 >div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit1.tsx, 1, 22))
->{p} : Symbol(, Decl(tsxEmit1.tsx, 26, 24))
 >p : Symbol(p, Decl(tsxEmit1.tsx, 26, 25))
 
 		var rewrites4 = <div a={() => this}></div>;
 >rewrites4 : Symbol(rewrites4, Decl(tsxEmit1.tsx, 28, 5))
 >div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit1.tsx, 1, 22))
 >a : Symbol(unknown)
->() => this : Symbol((Anonymous function), Decl(tsxEmit1.tsx, 28, 26))
 >this : Symbol(SomeClass, Decl(tsxEmit1.tsx, 20, 43))
 
 		var rewrites5 = <div a={[p, ...p, p]}></div>;
@@ -126,7 +123,6 @@ class SomeClass {
 >rewrites6 : Symbol(rewrites6, Decl(tsxEmit1.tsx, 30, 5))
 >div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit1.tsx, 1, 22))
 >a : Symbol(unknown)
->{p} : Symbol(, Decl(tsxEmit1.tsx, 30, 26))
 >p : Symbol(p, Decl(tsxEmit1.tsx, 30, 27))
 	}
 }
diff --git a/tests/baselines/reference/tsxGenericArrowFunctionParsing.symbols b/tests/baselines/reference/tsxGenericArrowFunctionParsing.symbols
index 297a584d52803..8bd68b2e8e7e5 100644
--- a/tests/baselines/reference/tsxGenericArrowFunctionParsing.symbols
+++ b/tests/baselines/reference/tsxGenericArrowFunctionParsing.symbols
@@ -25,7 +25,6 @@ x1.isElement;
 // This is a generic function
 var x2 = <T extends {}>() => {};
 >x2 : Symbol(x2, Decl(tsxGenericArrowFunctionParsing.tsx, 11, 3))
-><T extends {}>() => {} : Symbol((Anonymous function), Decl(tsxGenericArrowFunctionParsing.tsx, 11, 8))
 >T : Symbol(T, Decl(tsxGenericArrowFunctionParsing.tsx, 11, 10))
 
 x2();
@@ -34,7 +33,6 @@ x2();
 // This is a generic function
 var x3 = <T, T1>() => {};
 >x3 : Symbol(x3, Decl(tsxGenericArrowFunctionParsing.tsx, 15, 3))
-><T, T1>() => {} : Symbol((Anonymous function), Decl(tsxGenericArrowFunctionParsing.tsx, 15, 8))
 >T : Symbol(T, Decl(tsxGenericArrowFunctionParsing.tsx, 15, 10))
 >T1 : Symbol(T1, Decl(tsxGenericArrowFunctionParsing.tsx, 15, 12))
 
diff --git a/tests/baselines/reference/tsxInArrowFunction.symbols b/tests/baselines/reference/tsxInArrowFunction.symbols
index 4342434300cde..814f2577bf095 100644
--- a/tests/baselines/reference/tsxInArrowFunction.symbols
+++ b/tests/baselines/reference/tsxInArrowFunction.symbols
@@ -22,14 +22,12 @@ declare namespace JSX {
 // didn't work
 <div>{() => <div text="wat" />}</div>;
 >div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33))
->() => <div text="wat" /> : Symbol((Anonymous function), Decl(tsxInArrowFunction.tsx, 12, 6))
 >div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33))
 >text : Symbol(text, Decl(tsxInArrowFunction.tsx, 4, 14))
 
 // didn't work
 <div>{x => <div text="wat" />}</div>;
 >div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33))
->x => <div text="wat" /> : Symbol((Anonymous function), Decl(tsxInArrowFunction.tsx, 15, 6))
 >x : Symbol(x, Decl(tsxInArrowFunction.tsx, 15, 6))
 >div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33))
 >text : Symbol(text, Decl(tsxInArrowFunction.tsx, 4, 14))
@@ -37,14 +35,12 @@ declare namespace JSX {
 // worked
 <div>{() => (<div text="wat" />)}</div>;
 >div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33))
->() => (<div text="wat" />) : Symbol((Anonymous function), Decl(tsxInArrowFunction.tsx, 18, 6))
 >div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33))
 >text : Symbol(text, Decl(tsxInArrowFunction.tsx, 4, 14))
 
 // worked (!)
 <div>{() => <div text="wat"></div>}</div>;
 >div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33))
->() => <div text="wat"></div> : Symbol((Anonymous function), Decl(tsxInArrowFunction.tsx, 21, 6))
 >div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33))
 >text : Symbol(text, Decl(tsxInArrowFunction.tsx, 4, 14))
 
diff --git a/tests/baselines/reference/tsxReactEmit1.symbols b/tests/baselines/reference/tsxReactEmit1.symbols
index 1787c391a3964..c9e819c82d3e3 100644
--- a/tests/baselines/reference/tsxReactEmit1.symbols
+++ b/tests/baselines/reference/tsxReactEmit1.symbols
@@ -95,12 +95,7 @@ class SomeClass {
 		var rewrites1 = <div>{() => this}</div>;
 >rewrites1 : Symbol(rewrites1, Decl(tsxReactEmit1.tsx, 25, 5))
 >div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit1.tsx, 1, 22))
-<<<<<<< HEAD
 >this : Symbol(SomeClass, Decl(tsxReactEmit1.tsx, 21, 45))
-=======
->() => this : Symbol((Anonymous function), Decl(tsxReactEmit1.tsx, 24, 24))
->this : Symbol(SomeClass, Decl(tsxReactEmit1.tsx, 20, 45))
->>>>>>> Accept symbol baselines
 
 		var rewrites2 = <div>{[p, ...p, p]}</div>;
 >rewrites2 : Symbol(rewrites2, Decl(tsxReactEmit1.tsx, 26, 5))
@@ -112,23 +107,13 @@ class SomeClass {
 		var rewrites3 = <div>{{p}}</div>;
 >rewrites3 : Symbol(rewrites3, Decl(tsxReactEmit1.tsx, 27, 5))
 >div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit1.tsx, 1, 22))
-<<<<<<< HEAD
 >p : Symbol(p, Decl(tsxReactEmit1.tsx, 27, 25))
-=======
->{p} : Symbol(, Decl(tsxReactEmit1.tsx, 26, 24))
->p : Symbol(p, Decl(tsxReactEmit1.tsx, 26, 25))
->>>>>>> Accept symbol baselines
 
 		var rewrites4 = <div a={() => this}></div>;
 >rewrites4 : Symbol(rewrites4, Decl(tsxReactEmit1.tsx, 29, 5))
 >div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit1.tsx, 1, 22))
 >a : Symbol(unknown)
-<<<<<<< HEAD
 >this : Symbol(SomeClass, Decl(tsxReactEmit1.tsx, 21, 45))
-=======
->() => this : Symbol((Anonymous function), Decl(tsxReactEmit1.tsx, 28, 26))
->this : Symbol(SomeClass, Decl(tsxReactEmit1.tsx, 20, 45))
->>>>>>> Accept symbol baselines
 
 		var rewrites5 = <div a={[p, ...p, p]}></div>;
 >rewrites5 : Symbol(rewrites5, Decl(tsxReactEmit1.tsx, 30, 5))
@@ -142,12 +127,7 @@ class SomeClass {
 >rewrites6 : Symbol(rewrites6, Decl(tsxReactEmit1.tsx, 31, 5))
 >div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit1.tsx, 1, 22))
 >a : Symbol(unknown)
-<<<<<<< HEAD
 >p : Symbol(p, Decl(tsxReactEmit1.tsx, 31, 27))
-=======
->{p} : Symbol(, Decl(tsxReactEmit1.tsx, 30, 26))
->p : Symbol(p, Decl(tsxReactEmit1.tsx, 30, 27))
->>>>>>> Accept symbol baselines
 	}
 }
 
diff --git a/tests/baselines/reference/tsxTypeErrors.symbols b/tests/baselines/reference/tsxTypeErrors.symbols
index 5d21e28b8cc18..bfe0c5686403e 100644
--- a/tests/baselines/reference/tsxTypeErrors.symbols
+++ b/tests/baselines/reference/tsxTypeErrors.symbols
@@ -13,7 +13,6 @@ var a2 = <img srce="foo.jpg" />
 // A built-in element with a badly-typed attribute value (error)
 var thing = { oops: 100 };
 >thing : Symbol(thing, Decl(tsxTypeErrors.tsx, 8, 3))
->{ oops: 100 } : Symbol(, Decl(tsxTypeErrors.tsx, 8, 11))
 >oops : Symbol(oops, Decl(tsxTypeErrors.tsx, 8, 13))
 
 var a3 = <div id={thing} />
@@ -60,7 +59,6 @@ var b2 = <MyClass pt={{x: 4, y: 'oops'}} />;
 >b2 : Symbol(b2, Decl(tsxTypeErrors.tsx, 31, 3))
 >MyClass : Symbol(MyClass, Decl(tsxTypeErrors.tsx, 12, 31))
 >pt : Symbol(unknown)
->{x: 4, y: 'oops'} : Symbol(, Decl(tsxTypeErrors.tsx, 31, 22))
 >x : Symbol(x, Decl(tsxTypeErrors.tsx, 31, 23))
 >y : Symbol(y, Decl(tsxTypeErrors.tsx, 31, 28))
 
diff --git a/tests/baselines/reference/typeAnnotationBestCommonTypeInArrayLiteral.symbols b/tests/baselines/reference/typeAnnotationBestCommonTypeInArrayLiteral.symbols
index e20ca063af2e8..f172c91f26525 100644
--- a/tests/baselines/reference/typeAnnotationBestCommonTypeInArrayLiteral.symbols
+++ b/tests/baselines/reference/typeAnnotationBestCommonTypeInArrayLiteral.symbols
@@ -24,15 +24,11 @@ var menuData: IMenuItem[] = [
 >menuData : Symbol(menuData, Decl(typeAnnotationBestCommonTypeInArrayLiteral.ts, 8, 3))
 >IMenuItem : Symbol(IMenuItem, Decl(typeAnnotationBestCommonTypeInArrayLiteral.ts, 0, 0))
     {
->{        "id": "ourLogo",        "type": "image",        "link": "",        "icon": "modules/menu/logo.svg"    } : Symbol(, Decl(typeAnnotationBestCommonTypeInArrayLiteral.ts, 8, 29))
-
         "id": "ourLogo",
         "type": "image",
         "link": "",
         "icon": "modules/menu/logo.svg"
     }, {
->{        "id": "productName",        "type": "default",        "link": "",        "text": "Product Name"    } : Symbol(, Decl(typeAnnotationBestCommonTypeInArrayLiteral.ts, 14, 6))
-
         "id": "productName",
         "type": "default",
         "link": "",
diff --git a/tests/baselines/reference/typeArgInference.symbols b/tests/baselines/reference/typeArgInference.symbols
index 1e91429751fcb..37318e35906a6 100644
--- a/tests/baselines/reference/typeArgInference.symbols
+++ b/tests/baselines/reference/typeArgInference.symbols
@@ -37,7 +37,6 @@ interface I {
 }
 var o = { a: 3, b: "test" };
 >o : Symbol(o, Decl(typeArgInference.ts, 4, 3))
->{ a: 3, b: "test" } : Symbol(, Decl(typeArgInference.ts, 4, 7))
 >a : Symbol(a, Decl(typeArgInference.ts, 4, 9))
 >b : Symbol(b, Decl(typeArgInference.ts, 4, 15))
 
diff --git a/tests/baselines/reference/typeArgInferenceWithNull.symbols b/tests/baselines/reference/typeArgInferenceWithNull.symbols
index ced4c2e379353..565508eb7821d 100644
--- a/tests/baselines/reference/typeArgInferenceWithNull.symbols
+++ b/tests/baselines/reference/typeArgInferenceWithNull.symbols
@@ -19,7 +19,6 @@ function fn5<T extends { x: string }>(n: T) { }
 
 fn5({ x: null });
 >fn5 : Symbol(fn5, Decl(typeArgInferenceWithNull.ts, 3, 10))
->{ x: null } : Symbol(, Decl(typeArgInferenceWithNull.ts, 6, 4))
 >x : Symbol(x, Decl(typeArgInferenceWithNull.ts, 6, 5))
 
 function fn6<T extends { x: string }>(n: T, fun: (x: T) => void, n2: T) { }
@@ -36,10 +35,7 @@ function fn6<T extends { x: string }>(n: T, fun: (x: T) => void, n2: T) { }
 
 fn6({ x: null }, y => { }, { x: "" }); // y has type { x: any }, but ideally would have type { x: string }
 >fn6 : Symbol(fn6, Decl(typeArgInferenceWithNull.ts, 6, 17))
->{ x: null } : Symbol(, Decl(typeArgInferenceWithNull.ts, 9, 4))
 >x : Symbol(x, Decl(typeArgInferenceWithNull.ts, 9, 5))
->y => { } : Symbol((Anonymous function), Decl(typeArgInferenceWithNull.ts, 9, 16))
 >y : Symbol(y, Decl(typeArgInferenceWithNull.ts, 9, 16))
->{ x: "" } : Symbol(, Decl(typeArgInferenceWithNull.ts, 9, 26))
 >x : Symbol(x, Decl(typeArgInferenceWithNull.ts, 9, 28))
 
diff --git a/tests/baselines/reference/typeArgumentsInFunctionExpressions.symbols b/tests/baselines/reference/typeArgumentsInFunctionExpressions.symbols
index 172a6f64b2f32..1f8cc74e30ed7 100644
--- a/tests/baselines/reference/typeArgumentsInFunctionExpressions.symbols
+++ b/tests/baselines/reference/typeArgumentsInFunctionExpressions.symbols
@@ -1,7 +1,6 @@
 === tests/cases/compiler/typeArgumentsInFunctionExpressions.ts ===
 var obj = function f<T>(a: T) { // should not error
 >obj : Symbol(obj, Decl(typeArgumentsInFunctionExpressions.ts, 0, 3))
->function f<T>(a: T) { // should not error    var x: T;    return a;} : Symbol(f, Decl(typeArgumentsInFunctionExpressions.ts, 0, 9))
 >f : Symbol(f, Decl(typeArgumentsInFunctionExpressions.ts, 0, 9))
 >T : Symbol(T, Decl(typeArgumentsInFunctionExpressions.ts, 0, 21))
 >a : Symbol(a, Decl(typeArgumentsInFunctionExpressions.ts, 0, 24))
@@ -18,7 +17,6 @@ var obj = function f<T>(a: T) { // should not error
  
 var obj2 = function f<T>(a: T): T { // should not error
 >obj2 : Symbol(obj2, Decl(typeArgumentsInFunctionExpressions.ts, 5, 3))
->function f<T>(a: T): T { // should not error    var x: T;    return a;} : Symbol(f, Decl(typeArgumentsInFunctionExpressions.ts, 5, 10))
 >f : Symbol(f, Decl(typeArgumentsInFunctionExpressions.ts, 5, 10))
 >T : Symbol(T, Decl(typeArgumentsInFunctionExpressions.ts, 5, 22))
 >a : Symbol(a, Decl(typeArgumentsInFunctionExpressions.ts, 5, 25))
diff --git a/tests/baselines/reference/typeGuardFunction.symbols b/tests/baselines/reference/typeGuardFunction.symbols
index 7a8343ca77536..13ad30de5c548 100644
--- a/tests/baselines/reference/typeGuardFunction.symbols
+++ b/tests/baselines/reference/typeGuardFunction.symbols
@@ -152,7 +152,6 @@ class D {
 // Arrow function
 let f1 = (p1: A): p1 is C => false;
 >f1 : Symbol(f1, Decl(typeGuardFunction.ts, 62, 3))
->(p1: A): p1 is C => false : Symbol((Anonymous function), Decl(typeGuardFunction.ts, 62, 8))
 >p1 : Symbol(p1, Decl(typeGuardFunction.ts, 62, 10))
 >A : Symbol(A, Decl(typeGuardFunction.ts, 0, 0))
 >p1 : Symbol(p1, Decl(typeGuardFunction.ts, 62, 10))
@@ -170,7 +169,6 @@ declare function f2(p1: (p1: A) => p1 is C);
 // Function expressions
 f2(function(p1: A): p1 is C {
 >f2 : Symbol(f2, Decl(typeGuardFunction.ts, 62, 35))
->function(p1: A): p1 is C {    return true;} : Symbol((Anonymous function), Decl(typeGuardFunction.ts, 68, 3))
 >p1 : Symbol(p1, Decl(typeGuardFunction.ts, 68, 12))
 >A : Symbol(A, Decl(typeGuardFunction.ts, 0, 0))
 >p1 : Symbol(p1, Decl(typeGuardFunction.ts, 68, 12))
diff --git a/tests/baselines/reference/typeGuardsDefeat.symbols b/tests/baselines/reference/typeGuardsDefeat.symbols
index 18245fd46bf97..e5b2b4b2047d7 100644
--- a/tests/baselines/reference/typeGuardsDefeat.symbols
+++ b/tests/baselines/reference/typeGuardsDefeat.symbols
@@ -42,7 +42,6 @@ function foo2(x: number | string) {
     else {
         var f = function () {
 >f : Symbol(f, Decl(typeGuardsDefeat.ts, 19, 11))
->function () {            return x * x;        } : Symbol((Anonymous function), Decl(typeGuardsDefeat.ts, 19, 15))
 
             return x * x;
 >x : Symbol(x, Decl(typeGuardsDefeat.ts, 14, 14))
@@ -71,7 +70,6 @@ function foo3(x: number | string) {
     else {
         var f = () => x * x;
 >f : Symbol(f, Decl(typeGuardsDefeat.ts, 31, 11))
->() => x * x : Symbol((Anonymous function), Decl(typeGuardsDefeat.ts, 31, 15))
 >x : Symbol(x, Decl(typeGuardsDefeat.ts, 26, 14))
 >x : Symbol(x, Decl(typeGuardsDefeat.ts, 26, 14))
     }
diff --git a/tests/baselines/reference/typeGuardsInFunction.symbols b/tests/baselines/reference/typeGuardsInFunction.symbols
index 8efb2113e14e0..32a37f62a070f 100644
--- a/tests/baselines/reference/typeGuardsInFunction.symbols
+++ b/tests/baselines/reference/typeGuardsInFunction.symbols
@@ -108,7 +108,6 @@ function f2(param: string | number) {
     // variables in function expressions
     var r = function (param1: string | number) {
 >r : Symbol(r, Decl(typeGuardsInFunction.ts, 42, 7))
->function (param1: string | number) {        // global vars in function declaration        num = typeof var1 === "string" && var1.length; // string        // variables from outer function declaration        num = typeof var2 === "string" && var2.length; // string        // parameters in outer declaration        num = typeof param === "string" && param.length; // string        // local        var var3: string | number;        num = typeof var3 === "string" && var3.length; // string        num = typeof param1 === "string" && param1.length; // string    } : Symbol((Anonymous function), Decl(typeGuardsInFunction.ts, 42, 11))
 >param1 : Symbol(param1, Decl(typeGuardsInFunction.ts, 42, 22))
 
         // global vars in function declaration
@@ -168,7 +167,6 @@ function f3(param: string | number) {
     // variables in function expressions
     var r = ((param1: string | number) => {
 >r : Symbol(r, Decl(typeGuardsInFunction.ts, 63, 7))
->(param1: string | number) => {        // global vars in function declaration        num = typeof var1 === "string" && var1.length; // string        // variables from outer function declaration        num = typeof var2 === "string" && var2.length; // string        // parameters in outer declaration        num = typeof param === "string" && param.length; // string        // local        var var3: string | number;        num = typeof var3 === "string" && var3.length; // string        num = typeof param1 === "string" && param1.length; // string    } : Symbol((Anonymous function), Decl(typeGuardsInFunction.ts, 63, 13))
 >param1 : Symbol(param1, Decl(typeGuardsInFunction.ts, 63, 14))
 
         // global vars in function declaration
diff --git a/tests/baselines/reference/typeGuardsInFunctionAndModuleBlock.symbols b/tests/baselines/reference/typeGuardsInFunctionAndModuleBlock.symbols
index af76639a467ce..d1140e3af6016 100644
--- a/tests/baselines/reference/typeGuardsInFunctionAndModuleBlock.symbols
+++ b/tests/baselines/reference/typeGuardsInFunctionAndModuleBlock.symbols
@@ -12,7 +12,6 @@ function foo(x: number | string | boolean) {
 >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 2, 13))
 
         : function f() {
->function f() {            var b = x; // number | boolean            return typeof x === "boolean"                ? x.toString() // boolean                : x.toString(); // number        } : Symbol(f, Decl(typeGuardsInFunctionAndModuleBlock.ts, 5, 9))
 >f : Symbol(f, Decl(typeGuardsInFunctionAndModuleBlock.ts, 5, 9))
 
             var b = x; // number | boolean
@@ -45,7 +44,6 @@ function foo2(x: number | string | boolean) {
 >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 12, 14))
 
         : function f(a: number | boolean) {
->function f(a: number | boolean) {            var b = x; // new scope - number | boolean            return typeof x === "boolean"                ? x.toString() // boolean                : x.toString(); // number        } : Symbol(f, Decl(typeGuardsInFunctionAndModuleBlock.ts, 15, 9))
 >f : Symbol(f, Decl(typeGuardsInFunctionAndModuleBlock.ts, 15, 9))
 >a : Symbol(a, Decl(typeGuardsInFunctionAndModuleBlock.ts, 15, 21))
 
@@ -80,8 +78,6 @@ function foo3(x: number | string | boolean) {
 >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 22, 14))
 
         : (() => {
->() => {            var b = x; // new scope - number | boolean            return typeof x === "boolean"                ? x.toString() // boolean                : x.toString(); // number        } : Symbol((Anonymous function), Decl(typeGuardsInFunctionAndModuleBlock.ts, 25, 11))
-
             var b = x; // new scope - number | boolean
 >b : Symbol(b, Decl(typeGuardsInFunctionAndModuleBlock.ts, 26, 15))
 >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 22, 14))
@@ -112,7 +108,6 @@ function foo4(x: number | string | boolean) {
 >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 32, 14))
 
         : ((a: number | boolean) => {
->(a: number | boolean) => {            var b = x; // new scope - number | boolean            return typeof x === "boolean"                ? x.toString() // boolean                : x.toString(); // number        } : Symbol((Anonymous function), Decl(typeGuardsInFunctionAndModuleBlock.ts, 35, 11))
 >a : Symbol(a, Decl(typeGuardsInFunctionAndModuleBlock.ts, 35, 12))
 
             var b = x; // new scope - number | boolean
diff --git a/tests/baselines/reference/typeGuardsObjectMethods.symbols b/tests/baselines/reference/typeGuardsObjectMethods.symbols
index e5a2c3bd47e4e..3f585c1e4c621 100644
--- a/tests/baselines/reference/typeGuardsObjectMethods.symbols
+++ b/tests/baselines/reference/typeGuardsObjectMethods.symbols
@@ -15,7 +15,6 @@ var var1: string | number;
 
 var obj1 = {
 >obj1 : Symbol(obj1, Decl(typeGuardsObjectMethods.ts, 8, 3))
->{    // Inside method    method(param: string | number) {        // global vars in function declaration        num = typeof var1 === "string" && var1.length; // string        // variables in function declaration        var var2: string | number;        num = typeof var2 === "string" && var2.length; // string        // parameters in function declaration        num = typeof param === "string" && param.length; // string        return strOrNum;    },    get prop() {        // global vars in function declaration        num = typeof var1 === "string" && var1.length; // string        // variables in function declaration        var var2: string | number;        num = typeof var2 === "string" && var2.length; // string        return strOrNum;    },    set prop(param: string | number) {        // global vars in function declaration        num = typeof var1 === "string" && var1.length; // string        // variables in function declaration        var var2: string | number;        num = typeof var2 === "string" && var2.length; // string        // parameters in function declaration        num = typeof param === "string" && param.length; // string    }} : Symbol(, Decl(typeGuardsObjectMethods.ts, 8, 10))
 
     // Inside method
     method(param: string | number) {
diff --git a/tests/baselines/reference/typeInferenceFixEarly.symbols b/tests/baselines/reference/typeInferenceFixEarly.symbols
index 0739a3dab5177..6e91d741a81a7 100644
--- a/tests/baselines/reference/typeInferenceFixEarly.symbols
+++ b/tests/baselines/reference/typeInferenceFixEarly.symbols
@@ -10,6 +10,5 @@ declare function f<T>(p: (t: T) => T): T;
 
 f(n => 3);
 >f : Symbol(f, Decl(typeInferenceFixEarly.ts, 0, 0))
->n => 3 : Symbol((Anonymous function), Decl(typeInferenceFixEarly.ts, 2, 2))
 >n : Symbol(n, Decl(typeInferenceFixEarly.ts, 2, 2))
 
diff --git a/tests/baselines/reference/typeInferenceReturnTypeCallback.symbols b/tests/baselines/reference/typeInferenceReturnTypeCallback.symbols
index e3df0c48df9ca..a7322f7e69ba8 100644
--- a/tests/baselines/reference/typeInferenceReturnTypeCallback.symbols
+++ b/tests/baselines/reference/typeInferenceReturnTypeCallback.symbols
@@ -56,7 +56,6 @@ class Cons<T> implements IList<T>{
 >foldRight : Symbol(foldRight, Decl(typeInferenceReturnTypeCallback.ts, 15, 5))
 >Nil : Symbol(Nil, Decl(typeInferenceReturnTypeCallback.ts, 2, 1))
 >U : Symbol(U, Decl(typeInferenceReturnTypeCallback.ts, 11, 8))
->(t, acc) => {            return new Cons<U>();        } : Symbol((Anonymous function), Decl(typeInferenceReturnTypeCallback.ts, 12, 43))
 >t : Symbol(t, Decl(typeInferenceReturnTypeCallback.ts, 12, 45))
 >acc : Symbol(acc, Decl(typeInferenceReturnTypeCallback.ts, 12, 47))
 
diff --git a/tests/baselines/reference/typeInferenceWithTypeAnnotation.symbols b/tests/baselines/reference/typeInferenceWithTypeAnnotation.symbols
index 003d4b776a82b..47d7ef080ed8a 100644
--- a/tests/baselines/reference/typeInferenceWithTypeAnnotation.symbols
+++ b/tests/baselines/reference/typeInferenceWithTypeAnnotation.symbols
@@ -10,7 +10,6 @@ declare function f<T>(p: (t: T) => T): T;
 
 f((n: number) => n); 
 >f : Symbol(f, Decl(typeInferenceWithTypeAnnotation.ts, 0, 0))
->(n: number) => n : Symbol((Anonymous function), Decl(typeInferenceWithTypeAnnotation.ts, 2, 2))
 >n : Symbol(n, Decl(typeInferenceWithTypeAnnotation.ts, 2, 3))
 >n : Symbol(n, Decl(typeInferenceWithTypeAnnotation.ts, 2, 3))
 
diff --git a/tests/baselines/reference/typeLiteralCallback.symbols b/tests/baselines/reference/typeLiteralCallback.symbols
index 5256baf641d0f..14bdd2406120e 100644
--- a/tests/baselines/reference/typeLiteralCallback.symbols
+++ b/tests/baselines/reference/typeLiteralCallback.symbols
@@ -36,7 +36,6 @@ test.fail(arg => foo.reject(arg));
 >test.fail : Symbol(bar.fail, Decl(typeLiteralCallback.ts, 5, 18))
 >test : Symbol(test, Decl(typeLiteralCallback.ts, 9, 3))
 >fail : Symbol(bar.fail, Decl(typeLiteralCallback.ts, 5, 18))
->arg => foo.reject(arg) : Symbol((Anonymous function), Decl(typeLiteralCallback.ts, 11, 10))
 >arg : Symbol(arg, Decl(typeLiteralCallback.ts, 11, 10))
 >foo.reject : Symbol(Foo.reject, Decl(typeLiteralCallback.ts, 0, 18))
 >foo : Symbol(foo, Decl(typeLiteralCallback.ts, 3, 3))
@@ -47,7 +46,6 @@ test.fail2(arg => foo.reject(arg));  // Should be OK.  Was: Error: Supplied para
 >test.fail2 : Symbol(bar.fail2, Decl(typeLiteralCallback.ts, 6, 41))
 >test : Symbol(test, Decl(typeLiteralCallback.ts, 9, 3))
 >fail2 : Symbol(bar.fail2, Decl(typeLiteralCallback.ts, 6, 41))
->arg => foo.reject(arg) : Symbol((Anonymous function), Decl(typeLiteralCallback.ts, 12, 11))
 >arg : Symbol(arg, Decl(typeLiteralCallback.ts, 12, 11))
 >foo.reject : Symbol(Foo.reject, Decl(typeLiteralCallback.ts, 0, 18))
 >foo : Symbol(foo, Decl(typeLiteralCallback.ts, 3, 3))
diff --git a/tests/baselines/reference/typeOfThisInFunctionExpression.symbols b/tests/baselines/reference/typeOfThisInFunctionExpression.symbols
index 382f909fa7e77..59a7b11bc9f1f 100644
--- a/tests/baselines/reference/typeOfThisInFunctionExpression.symbols
+++ b/tests/baselines/reference/typeOfThisInFunctionExpression.symbols
@@ -13,7 +13,6 @@ function fn() {
 
 var t = function () {
 >t : Symbol(t, Decl(typeOfThisInFunctionExpression.ts, 7, 3))
->function () {    var p = this;    var p: any;} : Symbol((Anonymous function), Decl(typeOfThisInFunctionExpression.ts, 7, 7))
 
     var p = this;
 >p : Symbol(p, Decl(typeOfThisInFunctionExpression.ts, 8, 7), Decl(typeOfThisInFunctionExpression.ts, 9, 7))
@@ -24,7 +23,6 @@ var t = function () {
 
 var t2 = function f() {
 >t2 : Symbol(t2, Decl(typeOfThisInFunctionExpression.ts, 12, 3))
->function f() {    var x = this;    var x: any;} : Symbol(f, Decl(typeOfThisInFunctionExpression.ts, 12, 8))
 >f : Symbol(f, Decl(typeOfThisInFunctionExpression.ts, 12, 8))
 
     var x = this;
@@ -39,7 +37,6 @@ class C {
 
     x = function () {
 >x : Symbol(x, Decl(typeOfThisInFunctionExpression.ts, 17, 9))
->function () {        var q: any;        var q = this;    } : Symbol((Anonymous function), Decl(typeOfThisInFunctionExpression.ts, 18, 7))
 
         var q: any;
 >q : Symbol(q, Decl(typeOfThisInFunctionExpression.ts, 19, 11), Decl(typeOfThisInFunctionExpression.ts, 20, 11))
@@ -49,7 +46,6 @@ class C {
     }
     y = function ff() {
 >y : Symbol(y, Decl(typeOfThisInFunctionExpression.ts, 21, 5))
->function ff() {        var q: any;        var q = this;    } : Symbol(ff, Decl(typeOfThisInFunctionExpression.ts, 22, 7))
 >ff : Symbol(ff, Decl(typeOfThisInFunctionExpression.ts, 22, 7))
 
         var q: any;
@@ -75,7 +71,6 @@ module M {
 
     var t = function () {
 >t : Symbol(t, Decl(typeOfThisInFunctionExpression.ts, 34, 7))
->function () {        var p = this;        var p: any;    } : Symbol((Anonymous function), Decl(typeOfThisInFunctionExpression.ts, 34, 11))
 
         var p = this;
 >p : Symbol(p, Decl(typeOfThisInFunctionExpression.ts, 35, 11), Decl(typeOfThisInFunctionExpression.ts, 36, 11))
@@ -86,7 +81,6 @@ module M {
 
     var t2 = function f() {
 >t2 : Symbol(t2, Decl(typeOfThisInFunctionExpression.ts, 39, 7))
->function f() {        var x = this;        var x: any;    } : Symbol(f, Decl(typeOfThisInFunctionExpression.ts, 39, 12))
 >f : Symbol(f, Decl(typeOfThisInFunctionExpression.ts, 39, 12))
 
         var x = this;
diff --git a/tests/baselines/reference/typeParameterAsTypeParameterConstraintTransitively.symbols b/tests/baselines/reference/typeParameterAsTypeParameterConstraintTransitively.symbols
index 182ae85e8682c..90276a96b3db8 100644
--- a/tests/baselines/reference/typeParameterAsTypeParameterConstraintTransitively.symbols
+++ b/tests/baselines/reference/typeParameterAsTypeParameterConstraintTransitively.symbols
@@ -49,12 +49,9 @@ foo(1, 2, 3);
 
 foo({ x: 1 }, { x: 1, y: '' }, { x: 2, y: '', z: true });
 >foo : Symbol(foo, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 8, 9))
->{ x: 1 } : Symbol(, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 14, 4))
 >x : Symbol(x, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 14, 5))
->{ x: 1, y: '' } : Symbol(, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 14, 13))
 >x : Symbol(x, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 14, 15))
 >y : Symbol(y, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 14, 21))
->{ x: 2, y: '', z: true } : Symbol(, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 14, 30))
 >x : Symbol(x, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 14, 32))
 >y : Symbol(y, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 14, 38))
 >z : Symbol(z, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 14, 45))
@@ -69,19 +66,15 @@ foo(a, b, { foo: 1, bar: '', hm: true });
 >foo : Symbol(foo, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 8, 9))
 >a : Symbol(a, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 6, 3))
 >b : Symbol(b, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 7, 3))
->{ foo: 1, bar: '', hm: true } : Symbol(, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 16, 9))
 >foo : Symbol(foo, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 16, 11))
 >bar : Symbol(bar, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 16, 19))
 >hm : Symbol(hm, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 16, 28))
 
 foo((x: number, y) => { }, (x) => { }, () => { });
 >foo : Symbol(foo, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 8, 9))
->(x: number, y) => { } : Symbol((Anonymous function), Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 17, 4))
 >x : Symbol(x, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 17, 5))
 >y : Symbol(y, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 17, 15))
->(x) => { } : Symbol((Anonymous function), Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 17, 26))
 >x : Symbol(x, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 17, 28))
->() => { } : Symbol((Anonymous function), Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 17, 38))
 
 function foo2<T extends A, U, V>(x: T, y: U, z: V): V { return z; }
 >foo2 : Symbol(foo2, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 17, 50))
@@ -115,7 +108,6 @@ foo(b, b, { foo: 1, bar: '', hm: '' });
 >foo : Symbol(foo, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 8, 9))
 >b : Symbol(b, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 7, 3))
 >b : Symbol(b, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 7, 3))
->{ foo: 1, bar: '', hm: '' } : Symbol(, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 23, 9))
 >foo : Symbol(foo, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 23, 11))
 >bar : Symbol(bar, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 23, 19))
 >hm : Symbol(hm, Decl(typeParameterAsTypeParameterConstraintTransitively.ts, 23, 28))
diff --git a/tests/baselines/reference/typeParameterAsTypeParameterConstraintTransitively2.symbols b/tests/baselines/reference/typeParameterAsTypeParameterConstraintTransitively2.symbols
index 7aa094c18d19d..5635d0e61ed54 100644
--- a/tests/baselines/reference/typeParameterAsTypeParameterConstraintTransitively2.symbols
+++ b/tests/baselines/reference/typeParameterAsTypeParameterConstraintTransitively2.symbols
@@ -49,12 +49,9 @@ foo(1, 2, '');
 
 foo({ x: 1 }, { x: 1, y: '' }, { x: 2, y: 2, z: true });
 >foo : Symbol(foo, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 8, 9))
->{ x: 1 } : Symbol(, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 14, 4))
 >x : Symbol(x, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 14, 5))
->{ x: 1, y: '' } : Symbol(, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 14, 13))
 >x : Symbol(x, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 14, 15))
 >y : Symbol(y, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 14, 21))
->{ x: 2, y: 2, z: true } : Symbol(, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 14, 30))
 >x : Symbol(x, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 14, 32))
 >y : Symbol(y, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 14, 38))
 >z : Symbol(z, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 14, 44))
@@ -68,7 +65,6 @@ foo(a, b, a);
 foo(a, { foo: 1, bar: '', hm: true }, b);
 >foo : Symbol(foo, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 8, 9))
 >a : Symbol(a, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 6, 3))
->{ foo: 1, bar: '', hm: true } : Symbol(, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 16, 6))
 >foo : Symbol(foo, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 16, 8))
 >bar : Symbol(bar, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 16, 16))
 >hm : Symbol(hm, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 16, 25))
@@ -76,13 +72,10 @@ foo(a, { foo: 1, bar: '', hm: true }, b);
 
 foo((x: number, y: string) => { }, (x, y: boolean) => { }, () => { });
 >foo : Symbol(foo, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 8, 9))
->(x: number, y: string) => { } : Symbol((Anonymous function), Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 17, 4))
 >x : Symbol(x, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 17, 5))
 >y : Symbol(y, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 17, 15))
->(x, y: boolean) => { } : Symbol((Anonymous function), Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 17, 34))
 >x : Symbol(x, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 17, 36))
 >y : Symbol(y, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 17, 38))
->() => { } : Symbol((Anonymous function), Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 17, 58))
 
 function foo2<T extends A, U extends A, V extends A>(x: T, y: U, z: V): V { return z; }
 >foo2 : Symbol(foo2, Decl(typeParameterAsTypeParameterConstraintTransitively2.ts, 17, 70))
diff --git a/tests/baselines/reference/typeParameterCompatibilityAccrossDeclarations.symbols b/tests/baselines/reference/typeParameterCompatibilityAccrossDeclarations.symbols
index 02d0aef6eb398..eb1aeeaca2725 100644
--- a/tests/baselines/reference/typeParameterCompatibilityAccrossDeclarations.symbols
+++ b/tests/baselines/reference/typeParameterCompatibilityAccrossDeclarations.symbols
@@ -1,11 +1,9 @@
 === tests/cases/compiler/typeParameterCompatibilityAccrossDeclarations.ts ===
 var a = {
 >a : Symbol(a, Decl(typeParameterCompatibilityAccrossDeclarations.ts, 0, 3))
->{   x: function <T>(y: T): T { return null; }} : Symbol(, Decl(typeParameterCompatibilityAccrossDeclarations.ts, 0, 7))
 
    x: function <T>(y: T): T { return null; }
 >x : Symbol(x, Decl(typeParameterCompatibilityAccrossDeclarations.ts, 0, 9))
->function <T>(y: T): T { return null; } : Symbol((Anonymous function), Decl(typeParameterCompatibilityAccrossDeclarations.ts, 1, 5))
 >T : Symbol(T, Decl(typeParameterCompatibilityAccrossDeclarations.ts, 1, 16))
 >y : Symbol(y, Decl(typeParameterCompatibilityAccrossDeclarations.ts, 1, 19))
 >T : Symbol(T, Decl(typeParameterCompatibilityAccrossDeclarations.ts, 1, 16))
@@ -13,11 +11,9 @@ var a = {
 }
 var a2 = {
 >a2 : Symbol(a2, Decl(typeParameterCompatibilityAccrossDeclarations.ts, 3, 3))
->{   x: function (y: any): any { return null; }} : Symbol(, Decl(typeParameterCompatibilityAccrossDeclarations.ts, 3, 8))
 
    x: function (y: any): any { return null; }
 >x : Symbol(x, Decl(typeParameterCompatibilityAccrossDeclarations.ts, 3, 10))
->function (y: any): any { return null; } : Symbol((Anonymous function), Decl(typeParameterCompatibilityAccrossDeclarations.ts, 4, 5))
 >y : Symbol(y, Decl(typeParameterCompatibilityAccrossDeclarations.ts, 4, 16))
 }
 export interface I {
diff --git a/tests/baselines/reference/typeParameterFixingWithConstraints.symbols b/tests/baselines/reference/typeParameterFixingWithConstraints.symbols
index b5a13e97dd8dc..94e1b8172cb55 100644
--- a/tests/baselines/reference/typeParameterFixingWithConstraints.symbols
+++ b/tests/baselines/reference/typeParameterFixingWithConstraints.symbols
@@ -34,10 +34,7 @@ foo.foo({ bar: null }, bar => null, bar => null);
 >foo.foo : Symbol(IFoo.foo, Decl(typeParameterFixingWithConstraints.ts, 4, 16))
 >foo : Symbol(foo, Decl(typeParameterFixingWithConstraints.ts, 8, 3))
 >foo : Symbol(IFoo.foo, Decl(typeParameterFixingWithConstraints.ts, 4, 16))
->{ bar: null } : Symbol(, Decl(typeParameterFixingWithConstraints.ts, 9, 8))
 >bar : Symbol(bar, Decl(typeParameterFixingWithConstraints.ts, 9, 9))
->bar => null : Symbol((Anonymous function), Decl(typeParameterFixingWithConstraints.ts, 9, 22))
 >bar : Symbol(bar, Decl(typeParameterFixingWithConstraints.ts, 9, 22))
->bar => null : Symbol((Anonymous function), Decl(typeParameterFixingWithConstraints.ts, 9, 35))
 >bar : Symbol(bar, Decl(typeParameterFixingWithConstraints.ts, 9, 35))
 
diff --git a/tests/baselines/reference/typeParameterFixingWithContextSensitiveArguments.symbols b/tests/baselines/reference/typeParameterFixingWithContextSensitiveArguments.symbols
index 6a68761eeda62..fcf8fcb8dc474 100644
--- a/tests/baselines/reference/typeParameterFixingWithContextSensitiveArguments.symbols
+++ b/tests/baselines/reference/typeParameterFixingWithContextSensitiveArguments.symbols
@@ -37,7 +37,6 @@ var d = f(b, x => x.a, a); // type [A, A]
 >d : Symbol(d, Decl(typeParameterFixingWithContextSensitiveArguments.ts, 6, 3))
 >f : Symbol(f, Decl(typeParameterFixingWithContextSensitiveArguments.ts, 0, 0))
 >b : Symbol(b, Decl(typeParameterFixingWithContextSensitiveArguments.ts, 4, 9))
->x => x.a : Symbol((Anonymous function), Decl(typeParameterFixingWithContextSensitiveArguments.ts, 6, 12))
 >x : Symbol(x, Decl(typeParameterFixingWithContextSensitiveArguments.ts, 6, 12))
 >x.a : Symbol(A.a, Decl(typeParameterFixingWithContextSensitiveArguments.ts, 1, 13))
 >x : Symbol(x, Decl(typeParameterFixingWithContextSensitiveArguments.ts, 6, 12))
@@ -48,7 +47,6 @@ var d2 = f(b, x => x.a, null); // type [B, A]
 >d2 : Symbol(d2, Decl(typeParameterFixingWithContextSensitiveArguments.ts, 7, 3))
 >f : Symbol(f, Decl(typeParameterFixingWithContextSensitiveArguments.ts, 0, 0))
 >b : Symbol(b, Decl(typeParameterFixingWithContextSensitiveArguments.ts, 4, 9))
->x => x.a : Symbol((Anonymous function), Decl(typeParameterFixingWithContextSensitiveArguments.ts, 7, 13))
 >x : Symbol(x, Decl(typeParameterFixingWithContextSensitiveArguments.ts, 7, 13))
 >x.a : Symbol(A.a, Decl(typeParameterFixingWithContextSensitiveArguments.ts, 1, 13))
 >x : Symbol(x, Decl(typeParameterFixingWithContextSensitiveArguments.ts, 7, 13))
@@ -58,7 +56,6 @@ var d3 = f(b, x => x.b, null); // type [B, any]
 >d3 : Symbol(d3, Decl(typeParameterFixingWithContextSensitiveArguments.ts, 8, 3))
 >f : Symbol(f, Decl(typeParameterFixingWithContextSensitiveArguments.ts, 0, 0))
 >b : Symbol(b, Decl(typeParameterFixingWithContextSensitiveArguments.ts, 4, 9))
->x => x.b : Symbol((Anonymous function), Decl(typeParameterFixingWithContextSensitiveArguments.ts, 8, 13))
 >x : Symbol(x, Decl(typeParameterFixingWithContextSensitiveArguments.ts, 8, 13))
 >x.b : Symbol(B.b, Decl(typeParameterFixingWithContextSensitiveArguments.ts, 2, 23))
 >x : Symbol(x, Decl(typeParameterFixingWithContextSensitiveArguments.ts, 8, 13))
diff --git a/tests/baselines/reference/typeParameterFixingWithContextSensitiveArguments4.symbols b/tests/baselines/reference/typeParameterFixingWithContextSensitiveArguments4.symbols
index 4222dc780e150..d8f7abea60644 100644
--- a/tests/baselines/reference/typeParameterFixingWithContextSensitiveArguments4.symbols
+++ b/tests/baselines/reference/typeParameterFixingWithContextSensitiveArguments4.symbols
@@ -42,10 +42,8 @@ var d = f(a, b, x => x, x => <any>x); // Type [A, B]
 >f : Symbol(f, Decl(typeParameterFixingWithContextSensitiveArguments4.ts, 0, 0))
 >a : Symbol(a, Decl(typeParameterFixingWithContextSensitiveArguments4.ts, 4, 3))
 >b : Symbol(b, Decl(typeParameterFixingWithContextSensitiveArguments4.ts, 4, 9))
->x => x : Symbol((Anonymous function), Decl(typeParameterFixingWithContextSensitiveArguments4.ts, 6, 15))
 >x : Symbol(x, Decl(typeParameterFixingWithContextSensitiveArguments4.ts, 6, 15))
 >x : Symbol(x, Decl(typeParameterFixingWithContextSensitiveArguments4.ts, 6, 15))
->x => <any>x : Symbol((Anonymous function), Decl(typeParameterFixingWithContextSensitiveArguments4.ts, 6, 23))
 >x : Symbol(x, Decl(typeParameterFixingWithContextSensitiveArguments4.ts, 6, 23))
 >x : Symbol(x, Decl(typeParameterFixingWithContextSensitiveArguments4.ts, 6, 23))
 
diff --git a/tests/baselines/reference/typeParameterFixingWithContextSensitiveArguments5.symbols b/tests/baselines/reference/typeParameterFixingWithContextSensitiveArguments5.symbols
index 80b0c122e7ac0..5ba8aee8dba54 100644
--- a/tests/baselines/reference/typeParameterFixingWithContextSensitiveArguments5.symbols
+++ b/tests/baselines/reference/typeParameterFixingWithContextSensitiveArguments5.symbols
@@ -42,12 +42,10 @@ var d = f(a, b, u2 => u2.b, t2 => t2);
 >f : Symbol(f, Decl(typeParameterFixingWithContextSensitiveArguments5.ts, 0, 0))
 >a : Symbol(a, Decl(typeParameterFixingWithContextSensitiveArguments5.ts, 4, 3))
 >b : Symbol(b, Decl(typeParameterFixingWithContextSensitiveArguments5.ts, 4, 9))
->u2 => u2.b : Symbol((Anonymous function), Decl(typeParameterFixingWithContextSensitiveArguments5.ts, 6, 15))
 >u2 : Symbol(u2, Decl(typeParameterFixingWithContextSensitiveArguments5.ts, 6, 15))
 >u2.b : Symbol(B.b, Decl(typeParameterFixingWithContextSensitiveArguments5.ts, 2, 23))
 >u2 : Symbol(u2, Decl(typeParameterFixingWithContextSensitiveArguments5.ts, 6, 15))
 >b : Symbol(B.b, Decl(typeParameterFixingWithContextSensitiveArguments5.ts, 2, 23))
->t2 => t2 : Symbol((Anonymous function), Decl(typeParameterFixingWithContextSensitiveArguments5.ts, 6, 27))
 >t2 : Symbol(t2, Decl(typeParameterFixingWithContextSensitiveArguments5.ts, 6, 27))
 >t2 : Symbol(t2, Decl(typeParameterFixingWithContextSensitiveArguments5.ts, 6, 27))
 
diff --git a/tests/baselines/reference/typeParametersAvailableInNestedScope.symbols b/tests/baselines/reference/typeParametersAvailableInNestedScope.symbols
index 72190471cc5d4..905ccba8f3f11 100644
--- a/tests/baselines/reference/typeParametersAvailableInNestedScope.symbols
+++ b/tests/baselines/reference/typeParametersAvailableInNestedScope.symbols
@@ -9,7 +9,6 @@ class C<T> {
 
     x = <U>(a: U) => {
 >x : Symbol(x, Decl(typeParametersAvailableInNestedScope.ts, 1, 12))
-><U>(a: U) => {        var y: T;        return y;    } : Symbol((Anonymous function), Decl(typeParametersAvailableInNestedScope.ts, 3, 7))
 >U : Symbol(U, Decl(typeParametersAvailableInNestedScope.ts, 3, 9))
 >a : Symbol(a, Decl(typeParametersAvailableInNestedScope.ts, 3, 12))
 >U : Symbol(U, Decl(typeParametersAvailableInNestedScope.ts, 3, 9))
diff --git a/tests/baselines/reference/typeVal.symbols b/tests/baselines/reference/typeVal.symbols
index aa291ca31da8b..353b187a48ed9 100644
--- a/tests/baselines/reference/typeVal.symbols
+++ b/tests/baselines/reference/typeVal.symbols
@@ -9,7 +9,6 @@ interface I {
 var I:I = { I: 3};
 >I : Symbol(I, Decl(typeVal.ts, 0, 0), Decl(typeVal.ts, 4, 3))
 >I : Symbol(I, Decl(typeVal.ts, 0, 0), Decl(typeVal.ts, 4, 3))
->{ I: 3} : Symbol(, Decl(typeVal.ts, 4, 9))
 >I : Symbol(I, Decl(typeVal.ts, 4, 11))
 
 I.I=4;
diff --git a/tests/baselines/reference/typeofInterface.symbols b/tests/baselines/reference/typeofInterface.symbols
index a93145738f404..9aa305e0a30ff 100644
--- a/tests/baselines/reference/typeofInterface.symbols
+++ b/tests/baselines/reference/typeofInterface.symbols
@@ -23,6 +23,5 @@ var j: typeof k.foo = { a: "hello" };
 >k.foo : Symbol(I.foo, Decl(typeofInterface.ts, 3, 14))
 >k : Symbol(k, Decl(typeofInterface.ts, 7, 3))
 >foo : Symbol(I.foo, Decl(typeofInterface.ts, 3, 14))
->{ a: "hello" } : Symbol(, Decl(typeofInterface.ts, 8, 21))
 >a : Symbol(a, Decl(typeofInterface.ts, 8, 23))
 
diff --git a/tests/baselines/reference/typeofOperatorWithBooleanType.symbols b/tests/baselines/reference/typeofOperatorWithBooleanType.symbols
index a68b0a67e2b5c..39276e6162562 100644
--- a/tests/baselines/reference/typeofOperatorWithBooleanType.symbols
+++ b/tests/baselines/reference/typeofOperatorWithBooleanType.symbols
@@ -37,7 +37,6 @@ var ResultIsString2 = typeof true;
 
 var ResultIsString3 = typeof { x: true, y: false };
 >ResultIsString3 : Symbol(ResultIsString3, Decl(typeofOperatorWithBooleanType.ts, 20, 3))
->{ x: true, y: false } : Symbol(, Decl(typeofOperatorWithBooleanType.ts, 20, 28))
 >x : Symbol(x, Decl(typeofOperatorWithBooleanType.ts, 20, 30))
 >y : Symbol(y, Decl(typeofOperatorWithBooleanType.ts, 20, 39))
 
@@ -106,7 +105,6 @@ r: typeof foo;
 
 var y = { a: true, b: false};
 >y : Symbol(y, Decl(typeofOperatorWithBooleanType.ts, 45, 3))
->{ a: true, b: false} : Symbol(, Decl(typeofOperatorWithBooleanType.ts, 45, 7))
 >a : Symbol(a, Decl(typeofOperatorWithBooleanType.ts, 45, 9))
 >b : Symbol(b, Decl(typeofOperatorWithBooleanType.ts, 45, 18))
 
diff --git a/tests/baselines/reference/typeofOperatorWithNumberType.symbols b/tests/baselines/reference/typeofOperatorWithNumberType.symbols
index c77b7cc1a1e07..df49b7dccb6f0 100644
--- a/tests/baselines/reference/typeofOperatorWithNumberType.symbols
+++ b/tests/baselines/reference/typeofOperatorWithNumberType.symbols
@@ -44,16 +44,13 @@ var ResultIsString3 = typeof 1;
 
 var ResultIsString4 = typeof { x: 1, y: 2};
 >ResultIsString4 : Symbol(ResultIsString4, Decl(typeofOperatorWithNumberType.ts, 22, 3))
->{ x: 1, y: 2} : Symbol(, Decl(typeofOperatorWithNumberType.ts, 22, 28))
 >x : Symbol(x, Decl(typeofOperatorWithNumberType.ts, 22, 30))
 >y : Symbol(y, Decl(typeofOperatorWithNumberType.ts, 22, 36))
 
 var ResultIsString5 = typeof { x: 1, y: (n: number) => { return n; } };
 >ResultIsString5 : Symbol(ResultIsString5, Decl(typeofOperatorWithNumberType.ts, 23, 3))
->{ x: 1, y: (n: number) => { return n; } } : Symbol(, Decl(typeofOperatorWithNumberType.ts, 23, 28))
 >x : Symbol(x, Decl(typeofOperatorWithNumberType.ts, 23, 30))
 >y : Symbol(y, Decl(typeofOperatorWithNumberType.ts, 23, 36))
->(n: number) => { return n; } : Symbol((Anonymous function), Decl(typeofOperatorWithNumberType.ts, 23, 39))
 >n : Symbol(n, Decl(typeofOperatorWithNumberType.ts, 23, 41))
 >n : Symbol(n, Decl(typeofOperatorWithNumberType.ts, 23, 41))
 
@@ -146,7 +143,6 @@ r: typeof foo;
 
 var y = { a: 1, b: 2 };
 >y : Symbol(y, Decl(typeofOperatorWithNumberType.ts, 52, 3))
->{ a: 1, b: 2 } : Symbol(, Decl(typeofOperatorWithNumberType.ts, 52, 7))
 >a : Symbol(a, Decl(typeofOperatorWithNumberType.ts, 52, 9))
 >b : Symbol(b, Decl(typeofOperatorWithNumberType.ts, 52, 15))
 
diff --git a/tests/baselines/reference/typeofOperatorWithStringType.symbols b/tests/baselines/reference/typeofOperatorWithStringType.symbols
index c6ba3220005fd..6da22469f839f 100644
--- a/tests/baselines/reference/typeofOperatorWithStringType.symbols
+++ b/tests/baselines/reference/typeofOperatorWithStringType.symbols
@@ -44,16 +44,13 @@ var ResultIsString3 = typeof "";
 
 var ResultIsString4 = typeof { x: "", y: "" };
 >ResultIsString4 : Symbol(ResultIsString4, Decl(typeofOperatorWithStringType.ts, 22, 3))
->{ x: "", y: "" } : Symbol(, Decl(typeofOperatorWithStringType.ts, 22, 28))
 >x : Symbol(x, Decl(typeofOperatorWithStringType.ts, 22, 30))
 >y : Symbol(y, Decl(typeofOperatorWithStringType.ts, 22, 37))
 
 var ResultIsString5 = typeof { x: "", y: (s: string) => { return s; } };
 >ResultIsString5 : Symbol(ResultIsString5, Decl(typeofOperatorWithStringType.ts, 23, 3))
->{ x: "", y: (s: string) => { return s; } } : Symbol(, Decl(typeofOperatorWithStringType.ts, 23, 28))
 >x : Symbol(x, Decl(typeofOperatorWithStringType.ts, 23, 30))
 >y : Symbol(y, Decl(typeofOperatorWithStringType.ts, 23, 37))
->(s: string) => { return s; } : Symbol((Anonymous function), Decl(typeofOperatorWithStringType.ts, 23, 40))
 >s : Symbol(s, Decl(typeofOperatorWithStringType.ts, 23, 42))
 >s : Symbol(s, Decl(typeofOperatorWithStringType.ts, 23, 42))
 
@@ -145,7 +142,6 @@ r: typeof foo;
 
 var y = { a: "", b: "" };
 >y : Symbol(y, Decl(typeofOperatorWithStringType.ts, 52, 3))
->{ a: "", b: "" } : Symbol(, Decl(typeofOperatorWithStringType.ts, 52, 7))
 >a : Symbol(a, Decl(typeofOperatorWithStringType.ts, 52, 9))
 >b : Symbol(b, Decl(typeofOperatorWithStringType.ts, 52, 16))
 
diff --git a/tests/baselines/reference/typesWithOptionalProperty.symbols b/tests/baselines/reference/typesWithOptionalProperty.symbols
index de7a6458c8c5b..9c5461010990a 100644
--- a/tests/baselines/reference/typesWithOptionalProperty.symbols
+++ b/tests/baselines/reference/typesWithOptionalProperty.symbols
@@ -30,22 +30,18 @@ var a: {
 
 var b = { foo: '' };
 >b : Symbol(b, Decl(typesWithOptionalProperty.ts, 14, 3))
->{ foo: '' } : Symbol(, Decl(typesWithOptionalProperty.ts, 14, 7))
 >foo : Symbol(foo, Decl(typesWithOptionalProperty.ts, 14, 9))
 
 var c = { foo: '', bar: 3 };
 >c : Symbol(c, Decl(typesWithOptionalProperty.ts, 15, 3))
->{ foo: '', bar: 3 } : Symbol(, Decl(typesWithOptionalProperty.ts, 15, 7))
 >foo : Symbol(foo, Decl(typesWithOptionalProperty.ts, 15, 9))
 >bar : Symbol(bar, Decl(typesWithOptionalProperty.ts, 15, 18))
 
 var d = { foo: '', bar: 3, baz: () => '' };
 >d : Symbol(d, Decl(typesWithOptionalProperty.ts, 16, 3))
->{ foo: '', bar: 3, baz: () => '' } : Symbol(, Decl(typesWithOptionalProperty.ts, 16, 7))
 >foo : Symbol(foo, Decl(typesWithOptionalProperty.ts, 16, 9))
 >bar : Symbol(bar, Decl(typesWithOptionalProperty.ts, 16, 18))
 >baz : Symbol(baz, Decl(typesWithOptionalProperty.ts, 16, 26))
->() => '' : Symbol((Anonymous function), Decl(typesWithOptionalProperty.ts, 16, 31))
 
 var i: I;
 >i : Symbol(i, Decl(typesWithOptionalProperty.ts, 18, 3))
diff --git a/tests/baselines/reference/uncaughtCompilerError1.symbols b/tests/baselines/reference/uncaughtCompilerError1.symbols
index 7adc9d3122217..ab265163a86de 100644
--- a/tests/baselines/reference/uncaughtCompilerError1.symbols
+++ b/tests/baselines/reference/uncaughtCompilerError1.symbols
@@ -21,7 +21,6 @@ function f() {
 >tokens : Symbol(tokens, Decl(uncaughtCompilerError1.ts, 0, 37))
 
             return { appendText: '\"\"', advanceCount: 1 };
->{ appendText: '\"\"', advanceCount: 1 } : Symbol(, Decl(uncaughtCompilerError1.ts, 5, 18))
 >appendText : Symbol(appendText, Decl(uncaughtCompilerError1.ts, 5, 20))
 >advanceCount : Symbol(advanceCount, Decl(uncaughtCompilerError1.ts, 5, 40))
         }
@@ -32,7 +31,6 @@ function f() {
 >index : Symbol(index, Decl(uncaughtCompilerError1.ts, 0, 11))
 
             return { appendText: '\"\"', advanceCount: 1 };
->{ appendText: '\"\"', advanceCount: 1 } : Symbol(, Decl(uncaughtCompilerError1.ts, 8, 18))
 >appendText : Symbol(appendText, Decl(uncaughtCompilerError1.ts, 8, 20))
 >advanceCount : Symbol(advanceCount, Decl(uncaughtCompilerError1.ts, 8, 40))
         }
diff --git a/tests/baselines/reference/undefinedArgumentInference.symbols b/tests/baselines/reference/undefinedArgumentInference.symbols
index 59e099ed98021..da362bd66cca5 100644
--- a/tests/baselines/reference/undefinedArgumentInference.symbols
+++ b/tests/baselines/reference/undefinedArgumentInference.symbols
@@ -17,7 +17,6 @@ function foo1<T>(f1: { x: T; y: T }): T {
 var z1 = foo1({ x: undefined, y: undefined }); 
 >z1 : Symbol(z1, Decl(undefinedArgumentInference.ts, 6, 3))
 >foo1 : Symbol(foo1, Decl(undefinedArgumentInference.ts, 0, 0))
->{ x: undefined, y: undefined } : Symbol(, Decl(undefinedArgumentInference.ts, 6, 14))
 >x : Symbol(x, Decl(undefinedArgumentInference.ts, 6, 15))
 >undefined : Symbol(undefined)
 >y : Symbol(y, Decl(undefinedArgumentInference.ts, 6, 29))
diff --git a/tests/baselines/reference/underscoreTest1.symbols b/tests/baselines/reference/underscoreTest1.symbols
index c20bd6057358b..128ce83051a64 100644
--- a/tests/baselines/reference/underscoreTest1.symbols
+++ b/tests/baselines/reference/underscoreTest1.symbols
@@ -12,7 +12,6 @@ _.each([1, 2, 3], (num) => alert(num.toString()));
 >_.each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 394, 43), Decl(underscoreTest1_underscore.ts, 396, 77))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 394, 43), Decl(underscoreTest1_underscore.ts, 396, 77))
->(num) => alert(num.toString()) : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 5, 17))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 5, 19))
 >alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
 >num.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
@@ -23,11 +22,9 @@ _.each({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => alert(valu
 >_.each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 394, 43), Decl(underscoreTest1_underscore.ts, 396, 77))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 394, 43), Decl(underscoreTest1_underscore.ts, 396, 77))
->{ one: 1, two: 2, three: 3 } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 6, 7))
 >one : Symbol(one, Decl(underscoreTest1_underscoreTests.ts, 6, 8))
 >two : Symbol(two, Decl(underscoreTest1_underscoreTests.ts, 6, 16))
 >three : Symbol(three, Decl(underscoreTest1_underscoreTests.ts, 6, 24))
->(value: number, key?: string) => alert(value.toString()) : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 6, 36))
 >value : Symbol(value, Decl(underscoreTest1_underscoreTests.ts, 6, 38))
 >key : Symbol(key, Decl(underscoreTest1_underscoreTests.ts, 6, 52))
 >alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
@@ -39,7 +36,6 @@ _.map([1, 2, 3], (num) => num * 3);
 >_.map : Symbol(Underscore.Static.map, Decl(underscoreTest1_underscore.ts, 399, 90), Decl(underscoreTest1_underscore.ts, 401, 75))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >map : Symbol(Underscore.Static.map, Decl(underscoreTest1_underscore.ts, 399, 90), Decl(underscoreTest1_underscore.ts, 401, 75))
->(num) => num * 3 : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 8, 16))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 8, 18))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 8, 18))
 
@@ -47,11 +43,9 @@ _.map({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => value * 3);
 >_.map : Symbol(Underscore.Static.map, Decl(underscoreTest1_underscore.ts, 399, 90), Decl(underscoreTest1_underscore.ts, 401, 75))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >map : Symbol(Underscore.Static.map, Decl(underscoreTest1_underscore.ts, 399, 90), Decl(underscoreTest1_underscore.ts, 401, 75))
->{ one: 1, two: 2, three: 3 } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 9, 6))
 >one : Symbol(one, Decl(underscoreTest1_underscoreTests.ts, 9, 7))
 >two : Symbol(two, Decl(underscoreTest1_underscoreTests.ts, 9, 15))
 >three : Symbol(three, Decl(underscoreTest1_underscoreTests.ts, 9, 23))
->(value: number, key?: string) => value * 3 : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 9, 35))
 >value : Symbol(value, Decl(underscoreTest1_underscoreTests.ts, 9, 37))
 >key : Symbol(key, Decl(underscoreTest1_underscoreTests.ts, 9, 51))
 >value : Symbol(value, Decl(underscoreTest1_underscoreTests.ts, 9, 37))
@@ -61,7 +55,6 @@ var sum = _.reduce([1, 2, 3], (memo, num) => memo + num, 0);
 >_.reduce : Symbol(Underscore.Static.reduce, Decl(underscoreTest1_underscore.ts, 404, 89), Decl(underscoreTest1_underscore.ts, 406, 90), Decl(underscoreTest1_underscore.ts, 407, 92), Decl(underscoreTest1_underscore.ts, 408, 100))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >reduce : Symbol(Underscore.Static.reduce, Decl(underscoreTest1_underscore.ts, 404, 89), Decl(underscoreTest1_underscore.ts, 406, 90), Decl(underscoreTest1_underscore.ts, 407, 92), Decl(underscoreTest1_underscore.ts, 408, 100))
->(memo, num) => memo + num : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 11, 29))
 >memo : Symbol(memo, Decl(underscoreTest1_underscoreTests.ts, 11, 31))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 11, 36))
 >memo : Symbol(memo, Decl(underscoreTest1_underscoreTests.ts, 11, 31))
@@ -76,7 +69,6 @@ var flat = _.reduceRight(list, (a, b) => a.concat(b), []);
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >reduceRight : Symbol(Underscore.Static.reduceRight, Decl(underscoreTest1_underscore.ts, 417, 102), Decl(underscoreTest1_underscore.ts, 419, 95), Decl(underscoreTest1_underscore.ts, 420, 97), Decl(underscoreTest1_underscore.ts, 421, 105))
 >list : Symbol(list, Decl(underscoreTest1_underscoreTests.ts, 13, 3))
->(a, b) => a.concat(b) : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 14, 30))
 >a : Symbol(a, Decl(underscoreTest1_underscoreTests.ts, 14, 32))
 >b : Symbol(b, Decl(underscoreTest1_underscoreTests.ts, 14, 34))
 >a.concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
@@ -89,7 +81,6 @@ var even = _.find([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0);
 >_.find : Symbol(Underscore.Static.find, Decl(underscoreTest1_underscore.ts, 426, 101), Decl(underscoreTest1_underscore.ts, 428, 77))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >find : Symbol(Underscore.Static.find, Decl(underscoreTest1_underscore.ts, 426, 101), Decl(underscoreTest1_underscore.ts, 428, 77))
->(num) => num % 2 == 0 : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 16, 37))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 16, 39))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 16, 39))
 
@@ -98,21 +89,17 @@ var evens = _.filter([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0);
 >_.filter : Symbol(Underscore.Static.filter, Decl(underscoreTest1_underscore.ts, 431, 89), Decl(underscoreTest1_underscore.ts, 433, 81))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >filter : Symbol(Underscore.Static.filter, Decl(underscoreTest1_underscore.ts, 431, 89), Decl(underscoreTest1_underscore.ts, 433, 81))
->(num) => num % 2 == 0 : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 18, 40))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 18, 42))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 18, 42))
 
 var listOfPlays = [{ title: "Cymbeline", author: "Shakespeare", year: 1611 }, { title: "The Tempest", author: "Shakespeare", year: 1611 }, { title: "Other", author: "Not Shakespeare", year: 2012 }];
 >listOfPlays : Symbol(listOfPlays, Decl(underscoreTest1_underscoreTests.ts, 20, 3))
->{ title: "Cymbeline", author: "Shakespeare", year: 1611 } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 20, 19))
 >title : Symbol(title, Decl(underscoreTest1_underscoreTests.ts, 20, 20))
 >author : Symbol(author, Decl(underscoreTest1_underscoreTests.ts, 20, 40))
 >year : Symbol(year, Decl(underscoreTest1_underscoreTests.ts, 20, 63))
->{ title: "The Tempest", author: "Shakespeare", year: 1611 } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 20, 77))
 >title : Symbol(title, Decl(underscoreTest1_underscoreTests.ts, 20, 79))
 >author : Symbol(author, Decl(underscoreTest1_underscoreTests.ts, 20, 101))
 >year : Symbol(year, Decl(underscoreTest1_underscoreTests.ts, 20, 124))
->{ title: "Other", author: "Not Shakespeare", year: 2012 } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 20, 138))
 >title : Symbol(title, Decl(underscoreTest1_underscoreTests.ts, 20, 140))
 >author : Symbol(author, Decl(underscoreTest1_underscoreTests.ts, 20, 156))
 >year : Symbol(year, Decl(underscoreTest1_underscoreTests.ts, 20, 183))
@@ -122,7 +109,6 @@ _.where(listOfPlays, { author: "Shakespeare", year: 1611 });
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >where : Symbol(Underscore.Static.where, Decl(underscoreTest1_underscore.ts, 436, 91), Decl(underscoreTest1_underscore.ts, 438, 53))
 >listOfPlays : Symbol(listOfPlays, Decl(underscoreTest1_underscoreTests.ts, 20, 3))
->{ author: "Shakespeare", year: 1611 } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 21, 20))
 >author : Symbol(author, Decl(underscoreTest1_underscoreTests.ts, 21, 22))
 >year : Symbol(year, Decl(underscoreTest1_underscoreTests.ts, 21, 45))
 
@@ -131,7 +117,6 @@ var odds = _.reject([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0);
 >_.reject : Symbol(Underscore.Static.reject, Decl(underscoreTest1_underscore.ts, 442, 65), Decl(underscoreTest1_underscore.ts, 444, 81))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >reject : Symbol(Underscore.Static.reject, Decl(underscoreTest1_underscore.ts, 442, 65), Decl(underscoreTest1_underscore.ts, 444, 81))
->(num) => num % 2 == 0 : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 23, 39))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 23, 41))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 23, 41))
 
@@ -160,13 +145,10 @@ _.invoke([[5, 1, 7], [3, 2, 1]], 'sort');
 
 var stooges = [{ name: 'moe', age: 40 }, { name: 'larry', age: 50 }, { name: 'curly', age: 60 }];
 >stooges : Symbol(stooges, Decl(underscoreTest1_underscoreTests.ts, 33, 3))
->{ name: 'moe', age: 40 } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 33, 15))
 >name : Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 33, 16))
 >age : Symbol(age, Decl(underscoreTest1_underscoreTests.ts, 33, 29))
->{ name: 'larry', age: 50 } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 33, 40))
 >name : Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 33, 42))
 >age : Symbol(age, Decl(underscoreTest1_underscoreTests.ts, 33, 57))
->{ name: 'curly', age: 60 } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 33, 68))
 >name : Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 33, 70))
 >age : Symbol(age, Decl(underscoreTest1_underscoreTests.ts, 33, 85))
 
@@ -181,7 +163,6 @@ _.max(stooges, (stooge) => stooge.age);
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >max : Symbol(Underscore.Static.max, Decl(underscoreTest1_underscore.ts, 466, 66), Decl(underscoreTest1_underscore.ts, 468, 73))
 >stooges : Symbol(stooges, Decl(underscoreTest1_underscoreTests.ts, 33, 3))
->(stooge) => stooge.age : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 36, 14))
 >stooge : Symbol(stooge, Decl(underscoreTest1_underscoreTests.ts, 36, 16))
 >stooge.age : Symbol(age, Decl(underscoreTest1_underscoreTests.ts, 33, 29))
 >stooge : Symbol(stooge, Decl(underscoreTest1_underscoreTests.ts, 36, 16))
@@ -200,7 +181,6 @@ _.sortBy([1, 2, 3, 4, 5, 6], (num) => Math.sin(num));
 >_.sortBy : Symbol(Underscore.Static.sortBy, Decl(underscoreTest1_underscore.ts, 472, 83), Decl(underscoreTest1_underscore.ts, 474, 77), Decl(underscoreTest1_underscore.ts, 475, 87), Decl(underscoreTest1_underscore.ts, 476, 56))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >sortBy : Symbol(Underscore.Static.sortBy, Decl(underscoreTest1_underscore.ts, 472, 83), Decl(underscoreTest1_underscore.ts, 474, 77), Decl(underscoreTest1_underscore.ts, 475, 87), Decl(underscoreTest1_underscore.ts, 476, 56))
->(num) => Math.sin(num) : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 41, 28))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 41, 30))
 >Math.sin : Symbol(Math.sin, Decl(lib.d.ts, 615, 29))
 >Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
@@ -213,7 +193,6 @@ _([1.3, 2.1, 2.4]).groupBy((e: number, i?: number, list?: number[]) => Math.floo
 >_([1.3, 2.1, 2.4]).groupBy : Symbol(Underscore.WrappedArray.groupBy, Decl(underscoreTest1_underscore.ts, 112, 42), Decl(underscoreTest1_underscore.ts, 113, 77))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >groupBy : Symbol(Underscore.WrappedArray.groupBy, Decl(underscoreTest1_underscore.ts, 112, 42), Decl(underscoreTest1_underscore.ts, 113, 77))
->(e: number, i?: number, list?: number[]) => Math.floor(e) : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 45, 27))
 >e : Symbol(e, Decl(underscoreTest1_underscoreTests.ts, 45, 28))
 >i : Symbol(i, Decl(underscoreTest1_underscoreTests.ts, 45, 38))
 >list : Symbol(list, Decl(underscoreTest1_underscoreTests.ts, 45, 50))
@@ -226,7 +205,6 @@ _.groupBy([1.3, 2.1, 2.4], (num: number) => Math.floor(num));
 >_.groupBy : Symbol(Underscore.Static.groupBy, Decl(underscoreTest1_underscore.ts, 477, 66), Decl(underscoreTest1_underscore.ts, 479, 91), Decl(underscoreTest1_underscore.ts, 480, 101), Decl(underscoreTest1_underscore.ts, 481, 69))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >groupBy : Symbol(Underscore.Static.groupBy, Decl(underscoreTest1_underscore.ts, 477, 66), Decl(underscoreTest1_underscore.ts, 479, 91), Decl(underscoreTest1_underscore.ts, 480, 101), Decl(underscoreTest1_underscore.ts, 481, 69))
->(num: number) => Math.floor(num) : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 46, 26))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 46, 28))
 >Math.floor : Symbol(Math.floor, Decl(lib.d.ts, 582, 27))
 >Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
@@ -242,7 +220,6 @@ _.countBy([1, 2, 3, 4, 5], (num) => num % 2 == 0 ? 'even' : 'odd');
 >_.countBy : Symbol(Underscore.Static.countBy, Decl(underscoreTest1_underscore.ts, 482, 79), Decl(underscoreTest1_underscore.ts, 484, 94), Decl(underscoreTest1_underscore.ts, 485, 104), Decl(underscoreTest1_underscore.ts, 486, 72))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >countBy : Symbol(Underscore.Static.countBy, Decl(underscoreTest1_underscore.ts, 482, 79), Decl(underscoreTest1_underscore.ts, 484, 94), Decl(underscoreTest1_underscore.ts, 485, 104), Decl(underscoreTest1_underscore.ts, 486, 72))
->(num) => num % 2 == 0 ? 'even' : 'odd' : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 49, 26))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 49, 28))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 49, 28))
 
@@ -257,7 +234,6 @@ _.size({ one: 1, two: 2, three: 3 });
 >_.size : Symbol(Underscore.Static.size, Decl(underscoreTest1_underscore.ts, 493, 45), Decl(underscoreTest1_underscore.ts, 495, 35))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >size : Symbol(Underscore.Static.size, Decl(underscoreTest1_underscore.ts, 493, 45), Decl(underscoreTest1_underscore.ts, 495, 35))
->{ one: 1, two: 2, three: 3 } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 55, 7))
 >one : Symbol(one, Decl(underscoreTest1_underscoreTests.ts, 55, 8))
 >two : Symbol(two, Decl(underscoreTest1_underscoreTests.ts, 55, 16))
 >three : Symbol(three, Decl(underscoreTest1_underscoreTests.ts, 55, 24))
@@ -394,7 +370,6 @@ _.range(0);
 
 var func = function (greeting) { return greeting + ': ' + this.name };
 >func : Symbol(func, Decl(underscoreTest1_underscoreTests.ts, 90, 3))
->function (greeting) { return greeting + ': ' + this.name } : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 90, 10))
 >greeting : Symbol(greeting, Decl(underscoreTest1_underscoreTests.ts, 90, 21))
 >greeting : Symbol(greeting, Decl(underscoreTest1_underscoreTests.ts, 90, 21))
 
@@ -406,7 +381,6 @@ var func2 = _.bind(func, { name: 'moe' }, 'hi');
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >bind : Symbol(Underscore.Static.bind, Decl(underscoreTest1_underscore.ts, 547, 68), Decl(underscoreTest1_underscore.ts, 549, 58))
 >func : Symbol(func, Decl(underscoreTest1_underscoreTests.ts, 90, 3))
->{ name: 'moe' } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 93, 24))
 >name : Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 93, 26))
 
 func2();
@@ -414,19 +388,16 @@ func2();
 
 var buttonView = {
 >buttonView : Symbol(buttonView, Decl(underscoreTest1_underscoreTests.ts, 96, 3))
->{    label: 'underscore',    onClick: function () { alert('clicked: ' + this.label); },    onHover: function () { alert('hovering: ' + this.label); }} : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 96, 16))
 
     label: 'underscore',
 >label : Symbol(label, Decl(underscoreTest1_underscoreTests.ts, 96, 18))
 
     onClick: function () { alert('clicked: ' + this.label); },
 >onClick : Symbol(onClick, Decl(underscoreTest1_underscoreTests.ts, 97, 24))
->function () { alert('clicked: ' + this.label); } : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 98, 12))
 >alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
 
     onHover: function () { alert('hovering: ' + this.label); }
 >onHover : Symbol(onHover, Decl(underscoreTest1_underscoreTests.ts, 98, 62))
->function () { alert('hovering: ' + this.label); } : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 99, 12))
 >alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
 
 };
@@ -447,7 +418,6 @@ var fibonacci = _.memoize(function (n) {
 >_.memoize : Symbol(Underscore.Static.memoize, Decl(underscoreTest1_underscore.ts, 554, 58))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >memoize : Symbol(Underscore.Static.memoize, Decl(underscoreTest1_underscore.ts, 554, 58))
->function (n) {    return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);} : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 104, 26))
 >n : Symbol(n, Decl(underscoreTest1_underscoreTests.ts, 104, 36))
 
     return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);
@@ -465,7 +435,6 @@ var log = _.bind((message?: string, ...rest: string[]) => { }, Date);
 >_.bind : Symbol(Underscore.Static.bind, Decl(underscoreTest1_underscore.ts, 547, 68), Decl(underscoreTest1_underscore.ts, 549, 58))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >bind : Symbol(Underscore.Static.bind, Decl(underscoreTest1_underscore.ts, 547, 68), Decl(underscoreTest1_underscore.ts, 549, 58))
->(message?: string, ...rest: string[]) => { } : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 108, 17))
 >message : Symbol(message, Decl(underscoreTest1_underscoreTests.ts, 108, 18))
 >rest : Symbol(rest, Decl(underscoreTest1_underscoreTests.ts, 108, 35))
 >Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
@@ -480,12 +449,10 @@ _.defer(function () { alert('deferred'); });
 >_.defer : Symbol(Underscore.Static.defer, Decl(underscoreTest1_underscore.ts, 558, 68))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >defer : Symbol(Underscore.Static.defer, Decl(underscoreTest1_underscore.ts, 558, 68))
->function () { alert('deferred'); } : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 111, 8))
 >alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
 
 var updatePosition = () => alert('updating position...');
 >updatePosition : Symbol(updatePosition, Decl(underscoreTest1_underscoreTests.ts, 113, 3))
->() => alert('updating position...') : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 113, 20))
 >alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
 
 var throttled = _.throttle(updatePosition, 100);
@@ -501,7 +468,6 @@ $(null).scroll(throttled);
 
 var calculateLayout = () => alert('calculating layout...');
 >calculateLayout : Symbol(calculateLayout, Decl(underscoreTest1_underscoreTests.ts, 117, 3))
->() => alert('calculating layout...') : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 117, 21))
 >alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
 
 var lazyLayout = _.debounce(calculateLayout, 300);
@@ -517,7 +483,6 @@ $(null).resize(lazyLayout);
 
 var createApplication = () => alert('creating application...');
 >createApplication : Symbol(createApplication, Decl(underscoreTest1_underscoreTests.ts, 121, 3))
->() => alert('creating application...') : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 121, 23))
 >alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
 
 var initialize = _.once(createApplication);
@@ -538,7 +503,6 @@ var notes: any[];
 
 var render = () => alert("rendering...");
 >render : Symbol(render, Decl(underscoreTest1_underscoreTests.ts, 127, 3))
->() => alert("rendering...") : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 127, 12))
 >alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
 
 var renderNotes = _.after(notes.length, render);
@@ -556,16 +520,13 @@ _.each(notes, (note) => note.asyncSave({ success: renderNotes }));
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 394, 43), Decl(underscoreTest1_underscore.ts, 396, 77))
 >notes : Symbol(notes, Decl(underscoreTest1_underscoreTests.ts, 126, 3))
->(note) => note.asyncSave({ success: renderNotes }) : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 129, 13))
 >note : Symbol(note, Decl(underscoreTest1_underscoreTests.ts, 129, 15))
 >note : Symbol(note, Decl(underscoreTest1_underscoreTests.ts, 129, 15))
->{ success: renderNotes } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 129, 39))
 >success : Symbol(success, Decl(underscoreTest1_underscoreTests.ts, 129, 40))
 >renderNotes : Symbol(renderNotes, Decl(underscoreTest1_underscoreTests.ts, 128, 3))
 
 var hello = function (name) { return "hello: " + name; };
 >hello : Symbol(hello, Decl(underscoreTest1_underscoreTests.ts, 131, 3))
->function (name) { return "hello: " + name; } : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 131, 11))
 >name : Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 131, 22))
 >name : Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 131, 22))
 
@@ -575,7 +536,6 @@ hello = _.wrap(hello, (func, arg) => { return "before, " + func(arg) + ", after"
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >wrap : Symbol(Underscore.Static.wrap, Decl(underscoreTest1_underscore.ts, 568, 61))
 >hello : Symbol(hello, Decl(underscoreTest1_underscoreTests.ts, 131, 3))
->(func, arg) => { return "before, " + func(arg) + ", after"; } : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 132, 21))
 >func : Symbol(func, Decl(underscoreTest1_underscoreTests.ts, 132, 23))
 >arg : Symbol(arg, Decl(underscoreTest1_underscoreTests.ts, 132, 28))
 >func : Symbol(func, Decl(underscoreTest1_underscoreTests.ts, 132, 23))
@@ -586,13 +546,11 @@ hello("moe");
 
 var greet = function (name) { return "hi: " + name; };
 >greet : Symbol(greet, Decl(underscoreTest1_underscoreTests.ts, 135, 3))
->function (name) { return "hi: " + name; } : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 135, 11))
 >name : Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 135, 22))
 >name : Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 135, 22))
 
 var exclaim = function (statement) { return statement + "!"; };
 >exclaim : Symbol(exclaim, Decl(underscoreTest1_underscoreTests.ts, 136, 3))
->function (statement) { return statement + "!"; } : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 136, 13))
 >statement : Symbol(statement, Decl(underscoreTest1_underscoreTests.ts, 136, 24))
 >statement : Symbol(statement, Decl(underscoreTest1_underscoreTests.ts, 136, 24))
 
@@ -613,7 +571,6 @@ _.keys({ one: 1, two: 2, three: 3 });
 >_.keys : Symbol(Underscore.Static.keys, Decl(underscoreTest1_underscore.ts, 572, 48))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >keys : Symbol(Underscore.Static.keys, Decl(underscoreTest1_underscore.ts, 572, 48))
->{ one: 1, two: 2, three: 3 } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 142, 7))
 >one : Symbol(one, Decl(underscoreTest1_underscoreTests.ts, 142, 8))
 >two : Symbol(two, Decl(underscoreTest1_underscoreTests.ts, 142, 16))
 >three : Symbol(three, Decl(underscoreTest1_underscoreTests.ts, 142, 24))
@@ -622,7 +579,6 @@ _.values({ one: 1, two: 2, three: 3 });
 >_.values : Symbol(Underscore.Static.values, Decl(underscoreTest1_underscore.ts, 574, 36))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >values : Symbol(Underscore.Static.values, Decl(underscoreTest1_underscore.ts, 574, 36))
->{ one: 1, two: 2, three: 3 } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 143, 9))
 >one : Symbol(one, Decl(underscoreTest1_underscoreTests.ts, 143, 10))
 >two : Symbol(two, Decl(underscoreTest1_underscoreTests.ts, 143, 18))
 >three : Symbol(three, Decl(underscoreTest1_underscoreTests.ts, 143, 26))
@@ -631,7 +587,6 @@ _.pairs({ one: 1, two: 2, three: 3 });
 >_.pairs : Symbol(Underscore.Static.pairs, Decl(underscoreTest1_underscore.ts, 576, 35))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >pairs : Symbol(Underscore.Static.pairs, Decl(underscoreTest1_underscore.ts, 576, 35))
->{ one: 1, two: 2, three: 3 } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 144, 8))
 >one : Symbol(one, Decl(underscoreTest1_underscoreTests.ts, 144, 9))
 >two : Symbol(two, Decl(underscoreTest1_underscoreTests.ts, 144, 17))
 >three : Symbol(three, Decl(underscoreTest1_underscoreTests.ts, 144, 25))
@@ -640,7 +595,6 @@ _.invert({ Moe: "Moses", Larry: "Louis", Curly: "Jerome" });
 >_.invert : Symbol(Underscore.Static.invert, Decl(underscoreTest1_underscore.ts, 578, 36))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >invert : Symbol(Underscore.Static.invert, Decl(underscoreTest1_underscore.ts, 578, 36))
->{ Moe: "Moses", Larry: "Louis", Curly: "Jerome" } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 145, 9))
 >Moe : Symbol(Moe, Decl(underscoreTest1_underscoreTests.ts, 145, 10))
 >Larry : Symbol(Larry, Decl(underscoreTest1_underscoreTests.ts, 145, 24))
 >Curly : Symbol(Curly, Decl(underscoreTest1_underscoreTests.ts, 145, 40))
@@ -655,16 +609,13 @@ _.extend({ name: 'moe' }, { age: 50 });
 >_.extend : Symbol(Underscore.Static.extend, Decl(underscoreTest1_underscore.ts, 583, 39))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >extend : Symbol(Underscore.Static.extend, Decl(underscoreTest1_underscore.ts, 583, 39))
->{ name: 'moe' } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 147, 9))
 >name : Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 147, 10))
->{ age: 50 } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 147, 25))
 >age : Symbol(age, Decl(underscoreTest1_underscoreTests.ts, 147, 27))
 
 _.pick({ name: 'moe', age: 50, userid: 'moe1' }, 'name', 'age');
 >_.pick : Symbol(Underscore.Static.pick, Decl(underscoreTest1_underscore.ts, 585, 56))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >pick : Symbol(Underscore.Static.pick, Decl(underscoreTest1_underscore.ts, 585, 56))
->{ name: 'moe', age: 50, userid: 'moe1' } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 148, 7))
 >name : Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 148, 8))
 >age : Symbol(age, Decl(underscoreTest1_underscoreTests.ts, 148, 21))
 >userid : Symbol(userid, Decl(underscoreTest1_underscoreTests.ts, 148, 30))
@@ -673,14 +624,12 @@ _.omit({ name: 'moe', age: 50, userid: 'moe1' }, 'userid');
 >_.omit : Symbol(Underscore.Static.omit, Decl(underscoreTest1_underscore.ts, 587, 49))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >omit : Symbol(Underscore.Static.omit, Decl(underscoreTest1_underscore.ts, 587, 49))
->{ name: 'moe', age: 50, userid: 'moe1' } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 149, 7))
 >name : Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 149, 8))
 >age : Symbol(age, Decl(underscoreTest1_underscoreTests.ts, 149, 21))
 >userid : Symbol(userid, Decl(underscoreTest1_underscoreTests.ts, 149, 30))
 
 var iceCream = { flavor: "chocolate" };
 >iceCream : Symbol(iceCream, Decl(underscoreTest1_underscoreTests.ts, 151, 3))
->{ flavor: "chocolate" } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 151, 14))
 >flavor : Symbol(flavor, Decl(underscoreTest1_underscoreTests.ts, 151, 16))
 
 _.defaults(iceCream, { flavor: "vanilla", sprinkles: "lots" });
@@ -688,7 +637,6 @@ _.defaults(iceCream, { flavor: "vanilla", sprinkles: "lots" });
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >defaults : Symbol(Underscore.Static.defaults, Decl(underscoreTest1_underscore.ts, 589, 49))
 >iceCream : Symbol(iceCream, Decl(underscoreTest1_underscoreTests.ts, 151, 3))
->{ flavor: "vanilla", sprinkles: "lots" } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 152, 20))
 >flavor : Symbol(flavor, Decl(underscoreTest1_underscoreTests.ts, 152, 22))
 >sprinkles : Symbol(sprinkles, Decl(underscoreTest1_underscoreTests.ts, 152, 41))
 
@@ -696,7 +644,6 @@ _.clone({ name: 'moe' });
 >_.clone : Symbol(Underscore.Static.clone, Decl(underscoreTest1_underscore.ts, 591, 54))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >clone : Symbol(Underscore.Static.clone, Decl(underscoreTest1_underscore.ts, 591, 54))
->{ name: 'moe' } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 154, 8))
 >name : Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 154, 9))
 
 _.chain([1, 2, 3, 200])
@@ -710,7 +657,6 @@ _.chain([1, 2, 3, 200])
 
     .filter(function (num) { return num % 2 == 0; })
 >filter : Symbol(Underscore.ChainedArray.filter, Decl(underscoreTest1_underscore.ts, 254, 80))
->function (num) { return num % 2 == 0; } : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 157, 12))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 157, 22))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 157, 22))
 
@@ -720,7 +666,6 @@ _.chain([1, 2, 3, 200])
 
     .map(function (num) { return num * num })
 >map : Symbol(Underscore.ChainedArray.map, Decl(underscoreTest1_underscore.ts, 240, 81))
->function (num) { return num * num } : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 159, 9))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 159, 19))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 159, 19))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 159, 19))
@@ -732,20 +677,17 @@ _.has({ a: 1, b: 2, c: 3 }, "b");
 >_.has : Symbol(Underscore.Static.has, Decl(underscoreTest1_underscore.ts, 595, 63))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >has : Symbol(Underscore.Static.has, Decl(underscoreTest1_underscore.ts, 595, 63))
->{ a: 1, b: 2, c: 3 } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 162, 6))
 >a : Symbol(a, Decl(underscoreTest1_underscoreTests.ts, 162, 7))
 >b : Symbol(b, Decl(underscoreTest1_underscoreTests.ts, 162, 13))
 >c : Symbol(c, Decl(underscoreTest1_underscoreTests.ts, 162, 19))
 
 var moe = { name: 'moe', luckyNumbers: [13, 27, 34] };
 >moe : Symbol(moe, Decl(underscoreTest1_underscoreTests.ts, 164, 3))
->{ name: 'moe', luckyNumbers: [13, 27, 34] } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 164, 9))
 >name : Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 164, 11))
 >luckyNumbers : Symbol(luckyNumbers, Decl(underscoreTest1_underscoreTests.ts, 164, 24))
 
 var clone = { name: 'moe', luckyNumbers: [13, 27, 34] };
 >clone : Symbol(clone, Decl(underscoreTest1_underscoreTests.ts, 165, 3))
->{ name: 'moe', luckyNumbers: [13, 27, 34] } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 165, 11))
 >name : Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 165, 13))
 >luckyNumbers : Symbol(luckyNumbers, Decl(underscoreTest1_underscoreTests.ts, 165, 26))
 
@@ -769,7 +711,6 @@ _.isEmpty({});
 >_.isEmpty : Symbol(Underscore.Static.isEmpty, Decl(underscoreTest1_underscore.ts, 599, 49))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >isEmpty : Symbol(Underscore.Static.isEmpty, Decl(underscoreTest1_underscore.ts, 599, 49))
->{} : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 170, 10))
 
 _.isElement($('body')[0]);
 >_.isElement : Symbol(Underscore.Static.isElement, Decl(underscoreTest1_underscore.ts, 601, 38))
@@ -778,7 +719,6 @@ _.isElement($('body')[0]);
 >$ : Symbol($, Decl(underscoreTest1_underscoreTests.ts, 2, 11))
 
 (function () { return _.isArray(arguments); })();
->function () { return _.isArray(arguments); } : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 174, 1))
 >_.isArray : Symbol(Underscore.Static.isArray, Decl(underscoreTest1_underscore.ts, 602, 40))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >isArray : Symbol(Underscore.Static.isArray, Decl(underscoreTest1_underscore.ts, 602, 40))
@@ -793,7 +733,6 @@ _.isObject({});
 >_.isObject : Symbol(Underscore.Static.isObject, Decl(underscoreTest1_underscore.ts, 603, 38))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >isObject : Symbol(Underscore.Static.isObject, Decl(underscoreTest1_underscore.ts, 603, 38))
->{} : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 177, 11))
 
 _.isObject(1);
 >_.isObject : Symbol(Underscore.Static.isObject, Decl(underscoreTest1_underscore.ts, 603, 38))
@@ -892,7 +831,6 @@ var underscore = _.noConflict();
 
 var moe2 = { name: 'moe' };
 >moe2 : Symbol(moe2, Decl(underscoreTest1_underscoreTests.ts, 213, 3))
->{ name: 'moe' } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 213, 10))
 >name : Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 213, 12))
 
 moe2 === _.identity(moe);
@@ -909,7 +847,6 @@ _.times(3, function (n) { genie.grantWishNumber(n); });
 >_.times : Symbol(Underscore.Static.times, Decl(underscoreTest1_underscore.ts, 619, 33))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >times : Symbol(Underscore.Static.times, Decl(underscoreTest1_underscore.ts, 619, 33))
->function (n) { genie.grantWishNumber(n); } : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 218, 10))
 >n : Symbol(n, Decl(underscoreTest1_underscoreTests.ts, 218, 21))
 >genie : Symbol(genie, Decl(underscoreTest1_underscoreTests.ts, 216, 3))
 >n : Symbol(n, Decl(underscoreTest1_underscoreTests.ts, 218, 21))
@@ -923,11 +860,9 @@ _.mixin({
 >_.mixin : Symbol(Underscore.Static.mixin, Decl(underscoreTest1_underscore.ts, 624, 49))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >mixin : Symbol(Underscore.Static.mixin, Decl(underscoreTest1_underscore.ts, 624, 49))
->{    capitalize: function (string) {        return string.charAt(0).toUpperCase() + string.substring(1).toLowerCase();    }} : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 222, 8))
 
     capitalize: function (string) {
 >capitalize : Symbol(capitalize, Decl(underscoreTest1_underscoreTests.ts, 222, 9))
->function (string) {        return string.charAt(0).toUpperCase() + string.substring(1).toLowerCase();    } : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 223, 15))
 >string : Symbol(string, Decl(underscoreTest1_underscoreTests.ts, 223, 26))
 
         return string.charAt(0).toUpperCase() + string.substring(1).toLowerCase();
@@ -950,10 +885,8 @@ _.escape('Curly, Larry & Moe');
 
 var object = { cheese: 'crumpets', stuff: function () { return 'nonsense'; } };
 >object : Symbol(object, Decl(underscoreTest1_underscoreTests.ts, 233, 3))
->{ cheese: 'crumpets', stuff: function () { return 'nonsense'; } } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 233, 12))
 >cheese : Symbol(cheese, Decl(underscoreTest1_underscoreTests.ts, 233, 14))
 >stuff : Symbol(stuff, Decl(underscoreTest1_underscoreTests.ts, 233, 34))
->function () { return 'nonsense'; } : Symbol((Anonymous function), Decl(underscoreTest1_underscoreTests.ts, 233, 41))
 
 _.result(object, 'cheese');
 >_.result : Symbol(Underscore.Static.result, Decl(underscoreTest1_underscore.ts, 633, 36))
@@ -975,7 +908,6 @@ var compiled = _.template("hello: <%= name %>");
 
 compiled({ name: 'moe' });
 >compiled : Symbol(compiled, Decl(underscoreTest1_underscoreTests.ts, 238, 3))
->{ name: 'moe' } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 239, 9))
 >name : Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 239, 10))
 
 var list2 = "<% _.each(people, function(name) { %> <li><%= name %></li> <% }); %>";
@@ -986,7 +918,6 @@ _.template(list2, { people: ['moe', 'curly', 'larry'] });
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >template : Symbol(Underscore.Static.template, Decl(underscoreTest1_underscore.ts, 637, 43), Decl(underscoreTest1_underscore.ts, 639, 64))
 >list2 : Symbol(list2, Decl(underscoreTest1_underscoreTests.ts, 240, 3))
->{ people: ['moe', 'curly', 'larry'] } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 241, 17))
 >people : Symbol(people, Decl(underscoreTest1_underscoreTests.ts, 241, 19))
 
 var template = _.template("<b><%- value %></b>");
@@ -997,7 +928,6 @@ var template = _.template("<b><%- value %></b>");
 
 template({ value: '<script>' });
 >template : Symbol(template, Decl(underscoreTest1_underscoreTests.ts, 242, 3))
->{ value: '<script>' } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 243, 9))
 >value : Symbol(value, Decl(underscoreTest1_underscoreTests.ts, 243, 10))
 
 var compiled2 = _.template("<% print('Hello ' + epithet); %>");
@@ -1008,14 +938,12 @@ var compiled2 = _.template("<% print('Hello ' + epithet); %>");
 
 compiled2({ epithet: "stooge" });
 >compiled2 : Symbol(compiled2, Decl(underscoreTest1_underscoreTests.ts, 244, 3))
->{ epithet: "stooge" } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 245, 10))
 >epithet : Symbol(epithet, Decl(underscoreTest1_underscoreTests.ts, 245, 11))
 
 _.templateSettings = {
 >_.templateSettings : Symbol(Underscore.Static.templateSettings, Decl(underscoreTest1_underscore.ts, 635, 51))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >templateSettings : Symbol(Underscore.Static.templateSettings, Decl(underscoreTest1_underscore.ts, 635, 51))
->{    interpolate: /\{\{(.+?)\}\}/g} : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 246, 20))
 
     interpolate: /\{\{(.+?)\}\}/g
 >interpolate : Symbol(interpolate, Decl(underscoreTest1_underscoreTests.ts, 246, 22))
@@ -1029,16 +957,13 @@ var template2 = _.template("Hello {{ name }}!");
 
 template2({ name: "Mustache" });
 >template2 : Symbol(template2, Decl(underscoreTest1_underscoreTests.ts, 249, 3))
->{ name: "Mustache" } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 250, 10))
 >name : Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 250, 11))
 
 _.template("Using 'with': <%= data.answer %>", { answer: 'no' }, { variable: 'data' });
 >_.template : Symbol(Underscore.Static.template, Decl(underscoreTest1_underscore.ts, 637, 43), Decl(underscoreTest1_underscore.ts, 639, 64))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
 >template : Symbol(Underscore.Static.template, Decl(underscoreTest1_underscore.ts, 637, 43), Decl(underscoreTest1_underscore.ts, 639, 64))
->{ answer: 'no' } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 251, 46))
 >answer : Symbol(answer, Decl(underscoreTest1_underscoreTests.ts, 251, 48))
->{ variable: 'data' } : Symbol(, Decl(underscoreTest1_underscoreTests.ts, 251, 64))
 >variable : Symbol(variable, Decl(underscoreTest1_underscoreTests.ts, 251, 66))
 
 === tests/cases/compiler/underscoreTest1_underscore.ts ===
diff --git a/tests/baselines/reference/untypedArgumentInLambdaExpression.symbols b/tests/baselines/reference/untypedArgumentInLambdaExpression.symbols
index c55048a3e5b81..bbcb223cb85c0 100644
--- a/tests/baselines/reference/untypedArgumentInLambdaExpression.symbols
+++ b/tests/baselines/reference/untypedArgumentInLambdaExpression.symbols
@@ -6,7 +6,6 @@ declare function f(fn: (a: string) => string);
  
 f((input): string => {
 >f : Symbol(f, Decl(untypedArgumentInLambdaExpression.ts, 0, 0))
->(input): string => {    return "." + input;} : Symbol((Anonymous function), Decl(untypedArgumentInLambdaExpression.ts, 2, 2))
 >input : Symbol(input, Decl(untypedArgumentInLambdaExpression.ts, 2, 3))
 
     return "." + input;
diff --git a/tests/baselines/reference/unusedImportDeclaration.symbols b/tests/baselines/reference/unusedImportDeclaration.symbols
index 85689196bc57c..5506c4ad6b67c 100644
--- a/tests/baselines/reference/unusedImportDeclaration.symbols
+++ b/tests/baselines/reference/unusedImportDeclaration.symbols
@@ -5,7 +5,6 @@ import B = require("unusedImportDeclaration_testerB");
 var thingy: B = {
 >thingy : Symbol(thingy, Decl(unusedImportDeclaration_testerA.ts, 1, 3))
 >B : Symbol(B, Decl(unusedImportDeclaration_testerA.ts, 0, 0))
->{    me: "A"} : Symbol(, Decl(unusedImportDeclaration_testerA.ts, 1, 15))
 
     me: "A"
 >me : Symbol(me, Decl(unusedImportDeclaration_testerA.ts, 1, 17))
diff --git a/tests/baselines/reference/validMultipleVariableDeclarations.symbols b/tests/baselines/reference/validMultipleVariableDeclarations.symbols
index 88cf2cf6c3d9c..467c061c6fa88 100644
--- a/tests/baselines/reference/validMultipleVariableDeclarations.symbols
+++ b/tests/baselines/reference/validMultipleVariableDeclarations.symbols
@@ -37,21 +37,18 @@ var p: Point;
 
 var p = { x: 1, y: 2 };
 >p : Symbol(p, Decl(validMultipleVariableDeclarations.ts, 17, 3), Decl(validMultipleVariableDeclarations.ts, 18, 3), Decl(validMultipleVariableDeclarations.ts, 19, 3), Decl(validMultipleVariableDeclarations.ts, 20, 3), Decl(validMultipleVariableDeclarations.ts, 21, 3), Decl(validMultipleVariableDeclarations.ts, 22, 3), Decl(validMultipleVariableDeclarations.ts, 23, 3))
->{ x: 1, y: 2 } : Symbol(, Decl(validMultipleVariableDeclarations.ts, 18, 7))
 >x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 18, 9))
 >y : Symbol(y, Decl(validMultipleVariableDeclarations.ts, 18, 15))
 
 var p: Point = { x: 0, y: undefined };
 >p : Symbol(p, Decl(validMultipleVariableDeclarations.ts, 17, 3), Decl(validMultipleVariableDeclarations.ts, 18, 3), Decl(validMultipleVariableDeclarations.ts, 19, 3), Decl(validMultipleVariableDeclarations.ts, 20, 3), Decl(validMultipleVariableDeclarations.ts, 21, 3), Decl(validMultipleVariableDeclarations.ts, 22, 3), Decl(validMultipleVariableDeclarations.ts, 23, 3))
 >Point : Symbol(Point, Decl(validMultipleVariableDeclarations.ts, 13, 1))
->{ x: 0, y: undefined } : Symbol(, Decl(validMultipleVariableDeclarations.ts, 19, 14))
 >x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 19, 16))
 >y : Symbol(y, Decl(validMultipleVariableDeclarations.ts, 19, 22))
 >undefined : Symbol(undefined)
 
 var p = { x: 1, y: <number>undefined };
 >p : Symbol(p, Decl(validMultipleVariableDeclarations.ts, 17, 3), Decl(validMultipleVariableDeclarations.ts, 18, 3), Decl(validMultipleVariableDeclarations.ts, 19, 3), Decl(validMultipleVariableDeclarations.ts, 20, 3), Decl(validMultipleVariableDeclarations.ts, 21, 3), Decl(validMultipleVariableDeclarations.ts, 22, 3), Decl(validMultipleVariableDeclarations.ts, 23, 3))
->{ x: 1, y: <number>undefined } : Symbol(, Decl(validMultipleVariableDeclarations.ts, 20, 7))
 >x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 20, 9))
 >y : Symbol(y, Decl(validMultipleVariableDeclarations.ts, 20, 15))
 >undefined : Symbol(undefined)
@@ -60,7 +57,6 @@ var p: { x: number; y: number; } = { x: 1, y: 2 };
 >p : Symbol(p, Decl(validMultipleVariableDeclarations.ts, 17, 3), Decl(validMultipleVariableDeclarations.ts, 18, 3), Decl(validMultipleVariableDeclarations.ts, 19, 3), Decl(validMultipleVariableDeclarations.ts, 20, 3), Decl(validMultipleVariableDeclarations.ts, 21, 3), Decl(validMultipleVariableDeclarations.ts, 22, 3), Decl(validMultipleVariableDeclarations.ts, 23, 3))
 >x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 21, 8))
 >y : Symbol(y, Decl(validMultipleVariableDeclarations.ts, 21, 19))
->{ x: 1, y: 2 } : Symbol(, Decl(validMultipleVariableDeclarations.ts, 21, 34))
 >x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 21, 36))
 >y : Symbol(y, Decl(validMultipleVariableDeclarations.ts, 21, 42))
 
@@ -68,7 +64,6 @@ var p = <{ x: number; y: number; }>{ x: 0, y: undefined };
 >p : Symbol(p, Decl(validMultipleVariableDeclarations.ts, 17, 3), Decl(validMultipleVariableDeclarations.ts, 18, 3), Decl(validMultipleVariableDeclarations.ts, 19, 3), Decl(validMultipleVariableDeclarations.ts, 20, 3), Decl(validMultipleVariableDeclarations.ts, 21, 3), Decl(validMultipleVariableDeclarations.ts, 22, 3), Decl(validMultipleVariableDeclarations.ts, 23, 3))
 >x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 22, 10))
 >y : Symbol(y, Decl(validMultipleVariableDeclarations.ts, 22, 21))
->{ x: 0, y: undefined } : Symbol(, Decl(validMultipleVariableDeclarations.ts, 22, 35))
 >x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 22, 36))
 >y : Symbol(y, Decl(validMultipleVariableDeclarations.ts, 22, 42))
 >undefined : Symbol(undefined)
@@ -79,12 +74,10 @@ var p: typeof p;
 
 var fn = function (s: string) { return 42; }
 >fn : Symbol(fn, Decl(validMultipleVariableDeclarations.ts, 25, 3), Decl(validMultipleVariableDeclarations.ts, 26, 3), Decl(validMultipleVariableDeclarations.ts, 27, 3), Decl(validMultipleVariableDeclarations.ts, 28, 3), Decl(validMultipleVariableDeclarations.ts, 29, 3), Decl(validMultipleVariableDeclarations.ts, 30, 3))
->function (s: string) { return 42; } : Symbol((Anonymous function), Decl(validMultipleVariableDeclarations.ts, 25, 8))
 >s : Symbol(s, Decl(validMultipleVariableDeclarations.ts, 25, 19))
 
 var fn = (s: string) => 3;
 >fn : Symbol(fn, Decl(validMultipleVariableDeclarations.ts, 25, 3), Decl(validMultipleVariableDeclarations.ts, 26, 3), Decl(validMultipleVariableDeclarations.ts, 27, 3), Decl(validMultipleVariableDeclarations.ts, 28, 3), Decl(validMultipleVariableDeclarations.ts, 29, 3), Decl(validMultipleVariableDeclarations.ts, 30, 3))
->(s: string) => 3 : Symbol((Anonymous function), Decl(validMultipleVariableDeclarations.ts, 26, 8))
 >s : Symbol(s, Decl(validMultipleVariableDeclarations.ts, 26, 10))
 
 var fn: (s: string) => number;
diff --git a/tests/baselines/reference/validUseOfThisInSuper.symbols b/tests/baselines/reference/validUseOfThisInSuper.symbols
index 8129586088d16..2e71c859a4fee 100644
--- a/tests/baselines/reference/validUseOfThisInSuper.symbols
+++ b/tests/baselines/reference/validUseOfThisInSuper.symbols
@@ -14,7 +14,6 @@ class Super extends Base {
     constructor() {
         super((() => this)()); // ok since this is not the case: The constructor declares parameter properties or the containing class declares instance member variables with initializers.
 >super : Symbol(Base, Decl(validUseOfThisInSuper.ts, 0, 0))
->() => this : Symbol((Anonymous function), Decl(validUseOfThisInSuper.ts, 6, 15))
 >this : Symbol(Super, Decl(validUseOfThisInSuper.ts, 3, 1))
     }
 }
diff --git a/tests/baselines/reference/varArgParamTypeCheck.symbols b/tests/baselines/reference/varArgParamTypeCheck.symbols
index 1fc8930ae4519..b87afc740e36e 100644
--- a/tests/baselines/reference/varArgParamTypeCheck.symbols
+++ b/tests/baselines/reference/varArgParamTypeCheck.symbols
@@ -13,28 +13,23 @@ sequence(
 >sequence : Symbol(sequence, Decl(varArgParamTypeCheck.ts, 0, 0))
 
     function bar() {
->function bar() {    } : Symbol(bar, Decl(varArgParamTypeCheck.ts, 6, 9))
 >bar : Symbol(bar, Decl(varArgParamTypeCheck.ts, 6, 9))
 
     },
     function foo() {
->function foo() {        callback(()=>{            this();        });    } : Symbol(foo, Decl(varArgParamTypeCheck.ts, 8, 6))
 >foo : Symbol(foo, Decl(varArgParamTypeCheck.ts, 8, 6))
 
         callback(()=>{
 >callback : Symbol(callback, Decl(varArgParamTypeCheck.ts, 1, 1))
->()=>{            this();        } : Symbol((Anonymous function), Decl(varArgParamTypeCheck.ts, 10, 17))
 
             this();
         });
     },
     function baz() {
->function baz() {        callback(()=>{            this();        });    } : Symbol(baz, Decl(varArgParamTypeCheck.ts, 13, 6))
 >baz : Symbol(baz, Decl(varArgParamTypeCheck.ts, 13, 6))
 
         callback(()=>{
 >callback : Symbol(callback, Decl(varArgParamTypeCheck.ts, 1, 1))
->()=>{            this();        } : Symbol((Anonymous function), Decl(varArgParamTypeCheck.ts, 15, 17))
 
             this();
         });
diff --git a/tests/baselines/reference/varInFunctionInVarInitializer.symbols b/tests/baselines/reference/varInFunctionInVarInitializer.symbols
index 031001321e7aa..3cae133dd0b5c 100644
--- a/tests/baselines/reference/varInFunctionInVarInitializer.symbols
+++ b/tests/baselines/reference/varInFunctionInVarInitializer.symbols
@@ -1,7 +1,6 @@
 === tests/cases/compiler/varInFunctionInVarInitializer.ts ===
 var a = function () {
 >a : Symbol(a, Decl(varInFunctionInVarInitializer.ts, 0, 3))
->function () {    var c = 1;    return c;} : Symbol((Anonymous function), Decl(varInFunctionInVarInitializer.ts, 0, 7))
 
     var c = 1;
 >c : Symbol(c, Decl(varInFunctionInVarInitializer.ts, 1, 7))
diff --git a/tests/baselines/reference/vardecl.symbols b/tests/baselines/reference/vardecl.symbols
index 62160b42239e3..979790877c1e6 100644
--- a/tests/baselines/reference/vardecl.symbols
+++ b/tests/baselines/reference/vardecl.symbols
@@ -16,7 +16,6 @@ var varWithInitialValue = 30;
 
 var withComplicatedValue = { x: 30, y: 70, desc: "position" };
 >withComplicatedValue : Symbol(withComplicatedValue, Decl(vardecl.ts, 8, 3))
->{ x: 30, y: 70, desc: "position" } : Symbol(, Decl(vardecl.ts, 8, 26))
 >x : Symbol(x, Decl(vardecl.ts, 8, 28))
 >y : Symbol(y, Decl(vardecl.ts, 8, 35))
 >desc : Symbol(desc, Decl(vardecl.ts, 8, 42))
@@ -45,7 +44,6 @@ complicatedArrayVar.push({ x: 30, y : 'hello world' });
 >complicatedArrayVar.push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
 >complicatedArrayVar : Symbol(complicatedArrayVar, Decl(vardecl.ts, 18, 3))
 >push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
->{ x: 30, y : 'hello world' } : Symbol(, Decl(vardecl.ts, 19, 25))
 >x : Symbol(x, Decl(vardecl.ts, 19, 26))
 >y : Symbol(y, Decl(vardecl.ts, 19, 33))
 
diff --git a/tests/baselines/reference/variableDeclarator1.symbols b/tests/baselines/reference/variableDeclarator1.symbols
index 9aa861cbffc8a..3d0a6be70c0e3 100644
--- a/tests/baselines/reference/variableDeclarator1.symbols
+++ b/tests/baselines/reference/variableDeclarator1.symbols
@@ -1,7 +1,6 @@
 === tests/cases/compiler/variableDeclarator1.ts ===
 var a = function () {
 >a : Symbol(a, Decl(variableDeclarator1.ts, 0, 3))
->function () {        var c = 1;        return c;    } : Symbol((Anonymous function), Decl(variableDeclarator1.ts, 0, 7))
 
         var c = 1;
 >c : Symbol(c, Decl(variableDeclarator1.ts, 1, 11))
diff --git a/tests/baselines/reference/voidFunctionAssignmentCompat.symbols b/tests/baselines/reference/voidFunctionAssignmentCompat.symbols
index 55e2c6fe769f1..7664215ba952b 100644
--- a/tests/baselines/reference/voidFunctionAssignmentCompat.symbols
+++ b/tests/baselines/reference/voidFunctionAssignmentCompat.symbols
@@ -1,19 +1,15 @@
 === tests/cases/compiler/voidFunctionAssignmentCompat.ts ===
 var fa = function(): any { return 3; }
 >fa : Symbol(fa, Decl(voidFunctionAssignmentCompat.ts, 0, 3))
->function(): any { return 3; } : Symbol((Anonymous function), Decl(voidFunctionAssignmentCompat.ts, 0, 8))
 
 fa = function() { } // should not work
 >fa : Symbol(fa, Decl(voidFunctionAssignmentCompat.ts, 0, 3))
->function() { } : Symbol((Anonymous function), Decl(voidFunctionAssignmentCompat.ts, 1, 4))
 
 var fv = function(): void {}
 >fv : Symbol(fv, Decl(voidFunctionAssignmentCompat.ts, 3, 3))
->function(): void {} : Symbol((Anonymous function), Decl(voidFunctionAssignmentCompat.ts, 3, 8))
 
 fv = function() { return 0; } // should work
 >fv : Symbol(fv, Decl(voidFunctionAssignmentCompat.ts, 3, 3))
->function() { return 0; } : Symbol((Anonymous function), Decl(voidFunctionAssignmentCompat.ts, 4, 4))
 
 function execAny(callback:(val:any)=>any) { return callback(0) }
 >execAny : Symbol(execAny, Decl(voidFunctionAssignmentCompat.ts, 4, 29))
@@ -23,7 +19,6 @@ function execAny(callback:(val:any)=>any) { return callback(0) }
 
 execAny(function () {}); // should work
 >execAny : Symbol(execAny, Decl(voidFunctionAssignmentCompat.ts, 4, 29))
->function () {} : Symbol((Anonymous function), Decl(voidFunctionAssignmentCompat.ts, 7, 8))
 
 function execVoid(callback:(val:any)=>void) { callback(0); }
 >execVoid : Symbol(execVoid, Decl(voidFunctionAssignmentCompat.ts, 7, 24))
@@ -33,32 +28,23 @@ function execVoid(callback:(val:any)=>void) { callback(0); }
 
 execVoid(function () {return 0;}); // should work
 >execVoid : Symbol(execVoid, Decl(voidFunctionAssignmentCompat.ts, 7, 24))
->function () {return 0;} : Symbol((Anonymous function), Decl(voidFunctionAssignmentCompat.ts, 10, 9))
 
 var fra: (v:any)=>any = function() { return function () {}; } // should work
 >fra : Symbol(fra, Decl(voidFunctionAssignmentCompat.ts, 12, 3))
 >v : Symbol(v, Decl(voidFunctionAssignmentCompat.ts, 12, 10))
->function() { return function () {}; } : Symbol((Anonymous function), Decl(voidFunctionAssignmentCompat.ts, 12, 23))
->function () {} : Symbol((Anonymous function), Decl(voidFunctionAssignmentCompat.ts, 12, 43))
 
 var frv: (v:any)=>void = function() { return function () { return 0; } } // should work
 >frv : Symbol(frv, Decl(voidFunctionAssignmentCompat.ts, 13, 3))
 >v : Symbol(v, Decl(voidFunctionAssignmentCompat.ts, 13, 10))
->function() { return function () { return 0; } } : Symbol((Anonymous function), Decl(voidFunctionAssignmentCompat.ts, 13, 24))
->function () { return 0; } : Symbol((Anonymous function), Decl(voidFunctionAssignmentCompat.ts, 13, 44))
 
 var fra3: (v:any)=>string = (function() { return function (v:string) {return v;}; })() // should work
 >fra3 : Symbol(fra3, Decl(voidFunctionAssignmentCompat.ts, 15, 3))
 >v : Symbol(v, Decl(voidFunctionAssignmentCompat.ts, 15, 11))
->function() { return function (v:string) {return v;}; } : Symbol((Anonymous function), Decl(voidFunctionAssignmentCompat.ts, 15, 29))
->function (v:string) {return v;} : Symbol((Anonymous function), Decl(voidFunctionAssignmentCompat.ts, 15, 48))
 >v : Symbol(v, Decl(voidFunctionAssignmentCompat.ts, 15, 59))
 >v : Symbol(v, Decl(voidFunctionAssignmentCompat.ts, 15, 59))
 
 var frv3: (v:any)=>number = (function() { return function () { return 0; } })() // should work
 >frv3 : Symbol(frv3, Decl(voidFunctionAssignmentCompat.ts, 16, 3))
 >v : Symbol(v, Decl(voidFunctionAssignmentCompat.ts, 16, 11))
->function() { return function () { return 0; } } : Symbol((Anonymous function), Decl(voidFunctionAssignmentCompat.ts, 16, 29))
->function () { return 0; } : Symbol((Anonymous function), Decl(voidFunctionAssignmentCompat.ts, 16, 48))
 
 
diff --git a/tests/baselines/reference/voidOperatorWithBooleanType.symbols b/tests/baselines/reference/voidOperatorWithBooleanType.symbols
index 733c7fbe77d7e..1d044a6d9c66d 100644
--- a/tests/baselines/reference/voidOperatorWithBooleanType.symbols
+++ b/tests/baselines/reference/voidOperatorWithBooleanType.symbols
@@ -37,7 +37,6 @@ var ResultIsAny2 = void true;
 
 var ResultIsAny3 = void { x: true, y: false };
 >ResultIsAny3 : Symbol(ResultIsAny3, Decl(voidOperatorWithBooleanType.ts, 20, 3))
->{ x: true, y: false } : Symbol(, Decl(voidOperatorWithBooleanType.ts, 20, 23))
 >x : Symbol(x, Decl(voidOperatorWithBooleanType.ts, 20, 25))
 >y : Symbol(y, Decl(voidOperatorWithBooleanType.ts, 20, 34))
 
diff --git a/tests/baselines/reference/voidOperatorWithNumberType.symbols b/tests/baselines/reference/voidOperatorWithNumberType.symbols
index 25b2bf45372fe..43f10478499da 100644
--- a/tests/baselines/reference/voidOperatorWithNumberType.symbols
+++ b/tests/baselines/reference/voidOperatorWithNumberType.symbols
@@ -44,16 +44,13 @@ var ResultIsAny3 = void 1;
 
 var ResultIsAny4 = void { x: 1, y: 2};
 >ResultIsAny4 : Symbol(ResultIsAny4, Decl(voidOperatorWithNumberType.ts, 22, 3))
->{ x: 1, y: 2} : Symbol(, Decl(voidOperatorWithNumberType.ts, 22, 23))
 >x : Symbol(x, Decl(voidOperatorWithNumberType.ts, 22, 25))
 >y : Symbol(y, Decl(voidOperatorWithNumberType.ts, 22, 31))
 
 var ResultIsAny5 = void { x: 1, y: (n: number) => { return n; } };
 >ResultIsAny5 : Symbol(ResultIsAny5, Decl(voidOperatorWithNumberType.ts, 23, 3))
->{ x: 1, y: (n: number) => { return n; } } : Symbol(, Decl(voidOperatorWithNumberType.ts, 23, 23))
 >x : Symbol(x, Decl(voidOperatorWithNumberType.ts, 23, 25))
 >y : Symbol(y, Decl(voidOperatorWithNumberType.ts, 23, 31))
->(n: number) => { return n; } : Symbol((Anonymous function), Decl(voidOperatorWithNumberType.ts, 23, 34))
 >n : Symbol(n, Decl(voidOperatorWithNumberType.ts, 23, 36))
 >n : Symbol(n, Decl(voidOperatorWithNumberType.ts, 23, 36))
 
diff --git a/tests/baselines/reference/voidOperatorWithStringType.symbols b/tests/baselines/reference/voidOperatorWithStringType.symbols
index fd05c444087fb..ab834bf1243ca 100644
--- a/tests/baselines/reference/voidOperatorWithStringType.symbols
+++ b/tests/baselines/reference/voidOperatorWithStringType.symbols
@@ -44,16 +44,13 @@ var ResultIsAny3 = void "";
 
 var ResultIsAny4 = void { x: "", y: "" };
 >ResultIsAny4 : Symbol(ResultIsAny4, Decl(voidOperatorWithStringType.ts, 22, 3))
->{ x: "", y: "" } : Symbol(, Decl(voidOperatorWithStringType.ts, 22, 23))
 >x : Symbol(x, Decl(voidOperatorWithStringType.ts, 22, 25))
 >y : Symbol(y, Decl(voidOperatorWithStringType.ts, 22, 32))
 
 var ResultIsAny5 = void { x: "", y: (s: string) => { return s; } };
 >ResultIsAny5 : Symbol(ResultIsAny5, Decl(voidOperatorWithStringType.ts, 23, 3))
->{ x: "", y: (s: string) => { return s; } } : Symbol(, Decl(voidOperatorWithStringType.ts, 23, 23))
 >x : Symbol(x, Decl(voidOperatorWithStringType.ts, 23, 25))
 >y : Symbol(y, Decl(voidOperatorWithStringType.ts, 23, 32))
->(s: string) => { return s; } : Symbol((Anonymous function), Decl(voidOperatorWithStringType.ts, 23, 35))
 >s : Symbol(s, Decl(voidOperatorWithStringType.ts, 23, 37))
 >s : Symbol(s, Decl(voidOperatorWithStringType.ts, 23, 37))
 
diff --git a/tests/baselines/reference/whileBreakStatements.symbols b/tests/baselines/reference/whileBreakStatements.symbols
index d9bdf0c74a88d..2ac7721621da5 100644
--- a/tests/baselines/reference/whileBreakStatements.symbols
+++ b/tests/baselines/reference/whileBreakStatements.symbols
@@ -39,7 +39,6 @@ EIGHT:
 while (true) {
     var fn = function () { }
 >fn : Symbol(fn, Decl(whileBreakStatements.ts, 38, 7))
->function () { } : Symbol((Anonymous function), Decl(whileBreakStatements.ts, 38, 12))
 
     break EIGHT;
 }
diff --git a/tests/baselines/reference/whileContinueStatements.symbols b/tests/baselines/reference/whileContinueStatements.symbols
index d0e795c5fd966..67508556f70cf 100644
--- a/tests/baselines/reference/whileContinueStatements.symbols
+++ b/tests/baselines/reference/whileContinueStatements.symbols
@@ -45,7 +45,6 @@ EIGHT:
 while (true) {
     var fn = function () { }
 >fn : Symbol(fn, Decl(whileContinueStatements.ts, 44, 7))
->function () { } : Symbol((Anonymous function), Decl(whileContinueStatements.ts, 44, 12))
 
     continue EIGHT;
 }
diff --git a/tests/baselines/reference/widenedTypes1.symbols b/tests/baselines/reference/widenedTypes1.symbols
index bf8453beacc59..27d1ca7a68b85 100644
--- a/tests/baselines/reference/widenedTypes1.symbols
+++ b/tests/baselines/reference/widenedTypes1.symbols
@@ -8,12 +8,10 @@ var b = undefined;
 
 var c = {x: null};
 >c : Symbol(c, Decl(widenedTypes1.ts, 3, 3))
->{x: null} : Symbol(, Decl(widenedTypes1.ts, 3, 7))
 >x : Symbol(x, Decl(widenedTypes1.ts, 3, 9))
 
 var d = [{x: null}];
 >d : Symbol(d, Decl(widenedTypes1.ts, 4, 3))
->{x: null} : Symbol(, Decl(widenedTypes1.ts, 4, 9))
 >x : Symbol(x, Decl(widenedTypes1.ts, 4, 10))
 
 var f = [null, null];
@@ -26,7 +24,6 @@ var g = [undefined, undefined];
 
 var h = [{x: undefined}];
 >h : Symbol(h, Decl(widenedTypes1.ts, 7, 3))
->{x: undefined} : Symbol(, Decl(widenedTypes1.ts, 7, 9))
 >x : Symbol(x, Decl(widenedTypes1.ts, 7, 10))
 >undefined : Symbol(undefined)
 
diff --git a/tests/baselines/reference/withImportDecl.symbols b/tests/baselines/reference/withImportDecl.symbols
index a6b00abcc1dd4..ae41e927cfacb 100644
--- a/tests/baselines/reference/withImportDecl.symbols
+++ b/tests/baselines/reference/withImportDecl.symbols
@@ -17,7 +17,6 @@ var varWithInitialValue = 30;
 
 var withComplicatedValue = { x: 30, y: 70, desc: "position" };
 >withComplicatedValue : Symbol(withComplicatedValue, Decl(withImportDecl_1.ts, 9, 3))
->{ x: 30, y: 70, desc: "position" } : Symbol(, Decl(withImportDecl_1.ts, 9, 26))
 >x : Symbol(x, Decl(withImportDecl_1.ts, 9, 28))
 >y : Symbol(y, Decl(withImportDecl_1.ts, 9, 35))
 >desc : Symbol(desc, Decl(withImportDecl_1.ts, 9, 42))
@@ -42,8 +41,6 @@ function simpleFunction() {
 >simpleFunction : Symbol(simpleFunction, Decl(withImportDecl_1.ts, 17, 36))
 
     return {
->{        x: "Hello",        y: "word",        n: 2    } : Symbol(, Decl(withImportDecl_1.ts, 21, 10))
-
         x: "Hello",
 >x : Symbol(x, Decl(withImportDecl_1.ts, 21, 12))
 
diff --git a/tests/baselines/reference/wrappedAndRecursiveConstraints3.symbols b/tests/baselines/reference/wrappedAndRecursiveConstraints3.symbols
index f08912b359d99..06279a5c2640d 100644
--- a/tests/baselines/reference/wrappedAndRecursiveConstraints3.symbols
+++ b/tests/baselines/reference/wrappedAndRecursiveConstraints3.symbols
@@ -35,7 +35,6 @@ class C<T extends { length: number }> {
 var c = new C({ length: 2 });
 >c : Symbol(c, Decl(wrappedAndRecursiveConstraints3.ts, 12, 3))
 >C : Symbol(C, Decl(wrappedAndRecursiveConstraints3.ts, 0, 0))
->{ length: 2 } : Symbol(, Decl(wrappedAndRecursiveConstraints3.ts, 12, 14))
 >length : Symbol(length, Decl(wrappedAndRecursiveConstraints3.ts, 12, 15))
 
 var r = c.foo({ length: 3, charAt: (x: number) => { '' } });
@@ -43,10 +42,8 @@ var r = c.foo({ length: 3, charAt: (x: number) => { '' } });
 >c.foo : Symbol(C.foo, Decl(wrappedAndRecursiveConstraints3.ts, 3, 25))
 >c : Symbol(c, Decl(wrappedAndRecursiveConstraints3.ts, 12, 3))
 >foo : Symbol(C.foo, Decl(wrappedAndRecursiveConstraints3.ts, 3, 25))
->{ length: 3, charAt: (x: number) => { '' } } : Symbol(, Decl(wrappedAndRecursiveConstraints3.ts, 13, 14))
 >length : Symbol(length, Decl(wrappedAndRecursiveConstraints3.ts, 13, 15))
 >charAt : Symbol(charAt, Decl(wrappedAndRecursiveConstraints3.ts, 13, 26))
->(x: number) => { '' } : Symbol((Anonymous function), Decl(wrappedAndRecursiveConstraints3.ts, 13, 34))
 >x : Symbol(x, Decl(wrappedAndRecursiveConstraints3.ts, 13, 36))
 
 var r2 = r('');

From 1d92d8e881b518b77acf96823b1b4d4881c0f6f6 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Tue, 14 Jul 2015 15:10:24 -0700
Subject: [PATCH 36/57] Update error messages and fix error reporting for
 computed property names and accessors

---
 src/compiler/declarationEmitter.ts            |  87 ++--
 .../diagnosticInformationMap.generated.ts     |  85 +---
 src/compiler/diagnosticMessages.json          | 255 +-----------
 .../aliasInaccessibleModule.errors.txt        |   4 +-
 .../aliasInaccessibleModule2.errors.txt       |   4 +-
 ...otationVisibilityErrorAccessors.errors.txt |  44 +-
 ...ibilityErrorParameterOfFunction.errors.txt |  20 +-
 ...bilityErrorReturnTypeOfFunction.errors.txt |  16 +-
 ...otationVisibilityErrorTypeAlias.errors.txt |  16 +-
 ...ationVisibilityErrorTypeLiteral.errors.txt |  72 ++--
 ...ibilityErrorVariableDeclaration.errors.txt |  16 +-
 .../reference/declInput-2.errors.txt          |  20 +-
 ...onEmitDestructuringPrivacyError.errors.txt |   4 +-
 ...tendsClauseWithVisibilityErrors.errors.txt |   8 +-
 .../privacyAccessorDeclFile.errors.txt        | 214 ++++++----
 .../privacyCheckTypeOfFunction.errors.txt     |   8 +-
 ...CheckTypeOfInvisibleModuleError.errors.txt |   8 +-
 ...eckTypeOfInvisibleModuleNoError.errors.txt |   4 +-
 ...ivacyClassExtendsClauseDeclFile.errors.txt |  31 +-
 ...cyClassImplementsClauseDeclFile.errors.txt |  35 +-
 ...rivacyFunctionParameterDeclFile.errors.txt | 370 +++++++++++------
 ...ivacyFunctionReturnTypeDeclFile.errors.txt | 388 ++++++++++++------
 .../reference/privacyGloImport.errors.txt     |   8 +-
 .../privacyGloImportParseErrors.errors.txt    |   8 +-
 .../reference/privacyImport.errors.txt        |   8 +-
 ...yInterfaceExtendsClauseDeclFile.errors.txt |  35 +-
 ...ternalReferenceImportWithExport.errors.txt |  42 +-
 ...nalReferenceImportWithoutExport.errors.txt |  30 +-
 ...ternalReferenceImportWithExport.errors.txt |  42 +-
 ...nalReferenceImportWithoutExport.errors.txt |  30 +-
 ...TypeParameterOfFunctionDeclFile.errors.txt | 176 ++++----
 ...cyTypeParametersOfClassDeclFile.errors.txt |  24 +-
 ...peParametersOfInterfaceDeclFile.errors.txt | 115 ++++--
 .../reference/privacyVarDeclFile.errors.txt   | 190 ++++++---
 .../symbolDeclarationEmit12.errors.txt        |  16 +-
 35 files changed, 1317 insertions(+), 1116 deletions(-)

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index 2d426bed8615b..aa29ab393a10b 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -783,7 +783,7 @@ namespace ts {
         }
 
         function getTypeAnnotationFromAccessor(getAccessor: AccessorDeclaration, setAccessor: AccessorDeclaration): TypeNode {
-            if (getAccessor) {
+            if (getAccessor && getAccessor.type) {
                 return getAccessor.type // Getter - return type
             }
             if (setAccessor && setAccessor.parameters.length > 0) {
@@ -1193,7 +1193,7 @@ namespace ts {
                         // TODO: Cache the result
                         let writer = createNewTextWriterWithSymbolWriter();
                         let previousErrorNode = currentErrorNode;
-                        currentErrorNode = node.name;
+                        currentErrorNode = accessors.getAccessor ? accessors.getAccessor.name : node.name;
                         resolver.writeTypeOfDeclaration(node, getEnclosingDeclaration(node), TypeFormatFlags.UseTypeOfFunction, writer);
                         currentErrorNode = previousErrorNode;
                     }
@@ -1201,7 +1201,11 @@ namespace ts {
             }
 
             function visitPropertyDeclaration(node: PropertyDeclaration): void {
-                if (hasDynamicName(node) || node.flags & NodeFlags.Private) {
+                if (hasDynamicName(node)) {
+                    return;
+                }
+
+                if (node.flags & NodeFlags.Private && node.parent.kind !== SyntaxKind.Constructor) {
                     return;
                 }
 
@@ -1416,8 +1420,13 @@ namespace ts {
             return false;
         }
 
-        function getNameText(node: ParameterDeclaration|PropertyDeclaration|VariableDeclaration): string {
-            return (<Identifier>node.name).text;
+        function getNameText(node: ParameterDeclaration|PropertyDeclaration|VariableDeclaration|FunctionDeclaration| AccessorDeclaration| MethodDeclaration): string {
+            if (node.name.kind === SyntaxKind.Identifier) {
+                return (<Identifier>node.name).text;
+            }
+            else if (node.name.kind === SyntaxKind.ComputedPropertyName) {
+                return getTextOfNode(node.name);
+            }
         }
 
         function reportDeclarationAccessiblityMessage(referencedDeclaration: Declaration, errorNode: Node): void {
@@ -1428,102 +1437,92 @@ namespace ts {
             let referencedDeclarationName = (<Identifier>referencedDeclaration.name).text;
             let container = errorNode;
 
-            while (true) {
+            while (container) {
                 switch (container.kind) {
-                    case SyntaxKind.ClassDeclaration:
-                        diagnostics.push(createDiagnosticForNode(errorNode,
-                            Diagnostics.Extends_clause_of_exported_class_0_has_or_is_using_private_name_1,
-                            (<ClassDeclaration>container).name.text, referencedDeclarationName));
-                        return;
-                    case SyntaxKind.InterfaceDeclaration:
-                        diagnostics.push(createDiagnosticForNode(errorNode,
-                            Diagnostics.Extends_clause_of_exported_interface_0_has_or_is_using_private_name_1,
-                            (<InterfaceDeclaration>container).name.text, referencedDeclarationName));
+                    case SyntaxKind.HeritageClause:
+                        if ((<HeritageClause>container).token === SyntaxKind.ExtendsKeyword) {
+                            diagnostics.push(createDiagnosticForNode(errorNode,
+                                Diagnostics.Extends_clause_references_inaccessible_name_0, referencedDeclarationName));
+                        }
+                        else {
+                            diagnostics.push(createDiagnosticForNode(errorNode,
+                                Diagnostics.Implements_clause_references_inaccessible_name_0, referencedDeclarationName));
+                        }
                         return;
                     case SyntaxKind.BindingElement:
                     case SyntaxKind.VariableDeclaration:
                         diagnostics.push(createDiagnosticForNode(errorNode,
-                            Diagnostics.Exported_variable_0_has_or_is_using_private_name_1,
+                            Diagnostics.Type_of_variable_0_references_inaccessible_name_1,
                             getNameText(<VariableDeclaration>container), referencedDeclarationName));
                         return;
                     case SyntaxKind.PropertySignature:
-                        diagnostics.push(createDiagnosticForNode(errorNode,
-                            Diagnostics.Public_property_0_of_exported_class_has_or_is_using_private_name_1,
-                            getNameText(<PropertyDeclaration>container), referencedDeclarationName));
-                        return;
                     case SyntaxKind.PropertyDeclaration:
+                    case SyntaxKind.SetAccessor:
                         diagnostics.push(createDiagnosticForNode(errorNode,
-                            Diagnostics.Property_0_of_exported_interface_has_or_is_using_private_name_1,
+                            Diagnostics.Type_of_property_0_references_inaccessible_name_1,
                             getNameText(<PropertyDeclaration>container), referencedDeclarationName));
                         return;
                     case SyntaxKind.Parameter:
                         diagnostics.push(createDiagnosticForNode(errorNode,
-                            Diagnostics.Parameter_0_of_exported_function_has_or_is_using_private_name_1,
+                            Diagnostics.Type_of_parameter_0_references_inaccessible_name_1,
                             getNameText(<ParameterDeclaration>container), referencedDeclarationName));
                         return;
                     case SyntaxKind.GetAccessor:
                         diagnostics.push(createDiagnosticForNode(errorNode,
-                            Diagnostics.Return_type_of_public_property_getter_from_exported_class_has_or_is_using_private_name_0,
-                            referencedDeclarationName));
-                        return;
-                    case SyntaxKind.SetAccessor:
-                        diagnostics.push(createDiagnosticForNode(errorNode,
-                            Diagnostics.Parameter_0_of_public_property_setter_from_exported_class_has_or_is_using_private_name_1,
-                            getNameText(<ParameterDeclaration>container), referencedDeclarationName));
+                            Diagnostics.Return_type_of_property_getter_0_references_inaccessible_name_1,
+                            getNameText(<AccessorDeclaration>container), referencedDeclarationName));
                         return;
                     case SyntaxKind.ConstructSignature:
                         diagnostics.push(createDiagnosticForNode(errorNode,
-                            Diagnostics.Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_0,
+                            Diagnostics.Return_type_of_construct_signature_references_inaccessible_name_0,
                             referencedDeclarationName));
                         return;
                     case SyntaxKind.CallSignature:
                         diagnostics.push(createDiagnosticForNode(errorNode,
-                            Diagnostics.Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_name_0,
+                            Diagnostics.Return_type_of_call_signature_references_inaccessible_name_0,
                             referencedDeclarationName));
                         return;
                     case SyntaxKind.IndexSignature:
                         diagnostics.push(createDiagnosticForNode(errorNode,
-                            Diagnostics.Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_name_0,
+                            Diagnostics.Return_type_of_index_signature_references_inaccessible_name_0,
                             referencedDeclarationName));
                         return;
                     case SyntaxKind.MethodDeclaration:
-                        diagnostics.push(createDiagnosticForNode(errorNode,
-                            Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_private_name_0,
-                            referencedDeclarationName));
-                        return;
                     case SyntaxKind.MethodSignature:
                         diagnostics.push(createDiagnosticForNode(errorNode,
-                            Diagnostics.Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0,
-                            referencedDeclarationName));
+                            Diagnostics.Return_type_of_method_0_references_inaccessible_name_1,
+                            getNameText(<MethodDeclaration>container), referencedDeclarationName));
                         return;
                     case SyntaxKind.FunctionDeclaration:
                         diagnostics.push(createDiagnosticForNode(errorNode,
-                            Diagnostics.Return_type_of_exported_function_has_or_is_using_private_name_0,
-                            referencedDeclarationName));
+                            Diagnostics.Return_type_of_function_0_references_inaccessible_name_1,
+                            getNameText(<FunctionDeclaration>container), referencedDeclarationName));
                         return;
                     case SyntaxKind.TypeAliasDeclaration:
                         diagnostics.push(createDiagnosticForNode(errorNode,
-                            Diagnostics.Exported_type_alias_0_has_or_is_using_private_name_1,
+                            Diagnostics.Type_alias_0_references_inaccessible_name_1,
                             (<TypeAliasDeclaration>container).name.text, referencedDeclarationName));
                         return;
                     case SyntaxKind.ExportAssignment:
                         diagnostics.push(createDiagnosticForNode(errorNode,
-                            Diagnostics.Default_export_of_the_module_has_or_is_using_private_name_0,
+                            Diagnostics.Default_export_of_the_module_references_inaccessible_name_0,
                             referencedDeclarationName));
                         return;
                     case SyntaxKind.TypeParameter:
                         diagnostics.push(createDiagnosticForNode(errorNode,
-                            Diagnostics.Type_parameter_0_of_exported_class_has_or_is_using_private_name_1,
+                            Diagnostics.Constraint_of_type_parameter_0_references_inaccessible_name_1,
                             (<TypeParameterDeclaration>container).name.text, referencedDeclarationName));
                         return;
                     case SyntaxKind.ImportEqualsDeclaration:
                         diagnostics.push(createDiagnosticForNode(errorNode,
-                            Diagnostics.Import_declaration_0_is_using_private_name_1,
+                            Diagnostics.Import_declaration_0_references_inaccessible_name_1,
                             (<ImportEqualsDeclaration>container).name.text, referencedDeclarationName));
                         return;
                 }
                 container = container.parent;
             }
+
+            Debug.fail("Could not find container node");
         }
 
         function collectDeclaration(node: Node, errorNode?: Node): void {
diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts
index a0a95d47c8c53..a46ab3ad12e4a 100644
--- a/src/compiler/diagnosticInformationMap.generated.ts
+++ b/src/compiler/diagnosticInformationMap.generated.ts
@@ -424,76 +424,21 @@ namespace ts {
         JSX_element_class_does_not_support_attributes_because_it_does_not_have_a_0_property: { code: 2607, category: DiagnosticCategory.Error, key: "JSX element class does not support attributes because it does not have a '{0}' property" },
         The_global_type_JSX_0_may_not_have_more_than_one_property: { code: 2608, category: DiagnosticCategory.Error, key: "The global type 'JSX.{0}' may not have more than one property" },
         Cannot_emit_namespaced_JSX_elements_in_React: { code: 2650, category: DiagnosticCategory.Error, key: "Cannot emit namespaced JSX elements in React" },
-        Import_declaration_0_is_using_private_name_1: { code: 4000, category: DiagnosticCategory.Error, key: "Import declaration '{0}' is using private name '{1}'." },
-        Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported class has or is using private name '{1}'." },
-        Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4004, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported interface has or is using private name '{1}'." },
-        Type_parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1: { code: 4006, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of constructor signature from exported interface has or is using private name '{1}'." },
-        Type_parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1: { code: 4008, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of call signature from exported interface has or is using private name '{1}'." },
-        Type_parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1: { code: 4010, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of public static method from exported class has or is using private name '{1}'." },
-        Type_parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1: { code: 4012, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of public method from exported class has or is using private name '{1}'." },
-        Type_parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1: { code: 4014, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of method from exported interface has or is using private name '{1}'." },
-        Type_parameter_0_of_exported_function_has_or_is_using_private_name_1: { code: 4016, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported function has or is using private name '{1}'." },
-        Implements_clause_of_exported_class_0_has_or_is_using_private_name_1: { code: 4019, category: DiagnosticCategory.Error, key: "Implements clause of exported class '{0}' has or is using private name '{1}'." },
-        Extends_clause_of_exported_class_0_has_or_is_using_private_name_1: { code: 4020, category: DiagnosticCategory.Error, key: "Extends clause of exported class '{0}' has or is using private name '{1}'." },
-        Extends_clause_of_exported_interface_0_has_or_is_using_private_name_1: { code: 4022, category: DiagnosticCategory.Error, key: "Extends clause of exported interface '{0}' has or is using private name '{1}'." },
-        Exported_variable_0_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: { code: 4023, category: DiagnosticCategory.Error, key: "Exported variable '{0}' has or is using name '{1}' from external module {2} but cannot be named." },
-        Exported_variable_0_has_or_is_using_name_1_from_private_module_2: { code: 4024, category: DiagnosticCategory.Error, key: "Exported variable '{0}' has or is using name '{1}' from private module '{2}'." },
-        Exported_variable_0_has_or_is_using_private_name_1: { code: 4025, category: DiagnosticCategory.Error, key: "Exported variable '{0}' has or is using private name '{1}'." },
-        Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: { code: 4026, category: DiagnosticCategory.Error, key: "Public static property '{0}' of exported class has or is using name '{1}' from external module {2} but cannot be named." },
-        Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 4027, category: DiagnosticCategory.Error, key: "Public static property '{0}' of exported class has or is using name '{1}' from private module '{2}'." },
-        Public_static_property_0_of_exported_class_has_or_is_using_private_name_1: { code: 4028, category: DiagnosticCategory.Error, key: "Public static property '{0}' of exported class has or is using private name '{1}'." },
-        Public_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: { code: 4029, category: DiagnosticCategory.Error, key: "Public property '{0}' of exported class has or is using name '{1}' from external module {2} but cannot be named." },
-        Public_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 4030, category: DiagnosticCategory.Error, key: "Public property '{0}' of exported class has or is using name '{1}' from private module '{2}'." },
-        Public_property_0_of_exported_class_has_or_is_using_private_name_1: { code: 4031, category: DiagnosticCategory.Error, key: "Public property '{0}' of exported class has or is using private name '{1}'." },
-        Property_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2: { code: 4032, category: DiagnosticCategory.Error, key: "Property '{0}' of exported interface has or is using name '{1}' from private module '{2}'." },
-        Property_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4033, category: DiagnosticCategory.Error, key: "Property '{0}' of exported interface has or is using private name '{1}'." },
-        Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 4034, category: DiagnosticCategory.Error, key: "Parameter '{0}' of public static property setter from exported class has or is using name '{1}' from private module '{2}'." },
-        Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_private_name_1: { code: 4035, category: DiagnosticCategory.Error, key: "Parameter '{0}' of public static property setter from exported class has or is using private name '{1}'." },
-        Parameter_0_of_public_property_setter_from_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 4036, category: DiagnosticCategory.Error, key: "Parameter '{0}' of public property setter from exported class has or is using name '{1}' from private module '{2}'." },
-        Parameter_0_of_public_property_setter_from_exported_class_has_or_is_using_private_name_1: { code: 4037, category: DiagnosticCategory.Error, key: "Parameter '{0}' of public property setter from exported class has or is using private name '{1}'." },
-        Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: { code: 4038, category: DiagnosticCategory.Error, key: "Return type of public static property getter from exported class has or is using name '{0}' from external module {1} but cannot be named." },
-        Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_name_0_from_private_module_1: { code: 4039, category: DiagnosticCategory.Error, key: "Return type of public static property getter from exported class has or is using name '{0}' from private module '{1}'." },
-        Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_private_name_0: { code: 4040, category: DiagnosticCategory.Error, key: "Return type of public static property getter from exported class has or is using private name '{0}'." },
-        Return_type_of_public_property_getter_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: { code: 4041, category: DiagnosticCategory.Error, key: "Return type of public property getter from exported class has or is using name '{0}' from external module {1} but cannot be named." },
-        Return_type_of_public_property_getter_from_exported_class_has_or_is_using_name_0_from_private_module_1: { code: 4042, category: DiagnosticCategory.Error, key: "Return type of public property getter from exported class has or is using name '{0}' from private module '{1}'." },
-        Return_type_of_public_property_getter_from_exported_class_has_or_is_using_private_name_0: { code: 4043, category: DiagnosticCategory.Error, key: "Return type of public property getter from exported class has or is using private name '{0}'." },
-        Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1: { code: 4044, category: DiagnosticCategory.Error, key: "Return type of constructor signature from exported interface has or is using name '{0}' from private module '{1}'." },
-        Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_0: { code: 4045, category: DiagnosticCategory.Error, key: "Return type of constructor signature from exported interface has or is using private name '{0}'." },
-        Return_type_of_call_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1: { code: 4046, category: DiagnosticCategory.Error, key: "Return type of call signature from exported interface has or is using name '{0}' from private module '{1}'." },
-        Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_name_0: { code: 4047, category: DiagnosticCategory.Error, key: "Return type of call signature from exported interface has or is using private name '{0}'." },
-        Return_type_of_index_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1: { code: 4048, category: DiagnosticCategory.Error, key: "Return type of index signature from exported interface has or is using name '{0}' from private module '{1}'." },
-        Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_name_0: { code: 4049, category: DiagnosticCategory.Error, key: "Return type of index signature from exported interface has or is using private name '{0}'." },
-        Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: { code: 4050, category: DiagnosticCategory.Error, key: "Return type of public static method from exported class has or is using name '{0}' from external module {1} but cannot be named." },
-        Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_private_module_1: { code: 4051, category: DiagnosticCategory.Error, key: "Return type of public static method from exported class has or is using name '{0}' from private module '{1}'." },
-        Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_name_0: { code: 4052, category: DiagnosticCategory.Error, key: "Return type of public static method from exported class has or is using private name '{0}'." },
-        Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: { code: 4053, category: DiagnosticCategory.Error, key: "Return type of public method from exported class has or is using name '{0}' from external module {1} but cannot be named." },
-        Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_private_module_1: { code: 4054, category: DiagnosticCategory.Error, key: "Return type of public method from exported class has or is using name '{0}' from private module '{1}'." },
-        Return_type_of_public_method_from_exported_class_has_or_is_using_private_name_0: { code: 4055, category: DiagnosticCategory.Error, key: "Return type of public method from exported class has or is using private name '{0}'." },
-        Return_type_of_method_from_exported_interface_has_or_is_using_name_0_from_private_module_1: { code: 4056, category: DiagnosticCategory.Error, key: "Return type of method from exported interface has or is using name '{0}' from private module '{1}'." },
-        Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0: { code: 4057, category: DiagnosticCategory.Error, key: "Return type of method from exported interface has or is using private name '{0}'." },
-        Return_type_of_exported_function_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: { code: 4058, category: DiagnosticCategory.Error, key: "Return type of exported function has or is using name '{0}' from external module {1} but cannot be named." },
-        Return_type_of_exported_function_has_or_is_using_name_0_from_private_module_1: { code: 4059, category: DiagnosticCategory.Error, key: "Return type of exported function has or is using name '{0}' from private module '{1}'." },
-        Return_type_of_exported_function_has_or_is_using_private_name_0: { code: 4060, category: DiagnosticCategory.Error, key: "Return type of exported function has or is using private name '{0}'." },
-        Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: { code: 4061, category: DiagnosticCategory.Error, key: "Parameter '{0}' of constructor from exported class has or is using name '{1}' from external module {2} but cannot be named." },
-        Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 4062, category: DiagnosticCategory.Error, key: "Parameter '{0}' of constructor from exported class has or is using name '{1}' from private module '{2}'." },
-        Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_name_1: { code: 4063, category: DiagnosticCategory.Error, key: "Parameter '{0}' of constructor from exported class has or is using private name '{1}'." },
-        Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2: { code: 4064, category: DiagnosticCategory.Error, key: "Parameter '{0}' of constructor signature from exported interface has or is using name '{1}' from private module '{2}'." },
-        Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1: { code: 4065, category: DiagnosticCategory.Error, key: "Parameter '{0}' of constructor signature from exported interface has or is using private name '{1}'." },
-        Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2: { code: 4066, category: DiagnosticCategory.Error, key: "Parameter '{0}' of call signature from exported interface has or is using name '{1}' from private module '{2}'." },
-        Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1: { code: 4067, category: DiagnosticCategory.Error, key: "Parameter '{0}' of call signature from exported interface has or is using private name '{1}'." },
-        Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: { code: 4068, category: DiagnosticCategory.Error, key: "Parameter '{0}' of public static method from exported class has or is using name '{1}' from external module {2} but cannot be named." },
-        Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 4069, category: DiagnosticCategory.Error, key: "Parameter '{0}' of public static method from exported class has or is using name '{1}' from private module '{2}'." },
-        Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1: { code: 4070, category: DiagnosticCategory.Error, key: "Parameter '{0}' of public static method from exported class has or is using private name '{1}'." },
-        Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: { code: 4071, category: DiagnosticCategory.Error, key: "Parameter '{0}' of public method from exported class has or is using name '{1}' from external module {2} but cannot be named." },
-        Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 4072, category: DiagnosticCategory.Error, key: "Parameter '{0}' of public method from exported class has or is using name '{1}' from private module '{2}'." },
-        Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1: { code: 4073, category: DiagnosticCategory.Error, key: "Parameter '{0}' of public method from exported class has or is using private name '{1}'." },
-        Parameter_0_of_method_from_exported_interface_has_or_is_using_name_1_from_private_module_2: { code: 4074, category: DiagnosticCategory.Error, key: "Parameter '{0}' of method from exported interface has or is using name '{1}' from private module '{2}'." },
-        Parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1: { code: 4075, category: DiagnosticCategory.Error, key: "Parameter '{0}' of method from exported interface has or is using private name '{1}'." },
-        Parameter_0_of_exported_function_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: { code: 4076, category: DiagnosticCategory.Error, key: "Parameter '{0}' of exported function has or is using name '{1}' from external module {2} but cannot be named." },
-        Parameter_0_of_exported_function_has_or_is_using_name_1_from_private_module_2: { code: 4077, category: DiagnosticCategory.Error, key: "Parameter '{0}' of exported function has or is using name '{1}' from private module '{2}'." },
-        Parameter_0_of_exported_function_has_or_is_using_private_name_1: { code: 4078, category: DiagnosticCategory.Error, key: "Parameter '{0}' of exported function has or is using private name '{1}'." },
-        Exported_type_alias_0_has_or_is_using_private_name_1: { code: 4081, category: DiagnosticCategory.Error, key: "Exported type alias '{0}' has or is using private name '{1}'." },
-        Default_export_of_the_module_has_or_is_using_private_name_0: { code: 4082, category: DiagnosticCategory.Error, key: "Default export of the module has or is using private name '{0}'." },
+        Import_declaration_0_references_inaccessible_name_1: { code: 4000, category: DiagnosticCategory.Error, key: "Import declaration '{0}' references inaccessible name '{1}'." },
+        Constraint_of_type_parameter_0_references_inaccessible_name_1: { code: 4002, category: DiagnosticCategory.Error, key: "Constraint of type parameter '{0}' references inaccessible name '{1}'." },
+        Implements_clause_references_inaccessible_name_0: { code: 4019, category: DiagnosticCategory.Error, key: "Implements clause references inaccessible name '{0}'." },
+        Extends_clause_references_inaccessible_name_0: { code: 4020, category: DiagnosticCategory.Error, key: "Extends clause references inaccessible name '{0}'." },
+        Type_of_variable_0_references_inaccessible_name_1: { code: 4025, category: DiagnosticCategory.Error, key: "Type of variable '{0}' references inaccessible name '{1}'." },
+        Type_of_property_0_references_inaccessible_name_1: { code: 4028, category: DiagnosticCategory.Error, key: "Type of property '{0}' references inaccessible name '{1}'." },
+        Type_of_parameter_0_references_inaccessible_name_1: { code: 4028, category: DiagnosticCategory.Error, key: "Type of parameter '{0}' references inaccessible name '{1}'." },
+        Return_type_of_method_0_references_inaccessible_name_1: { code: 4038, category: DiagnosticCategory.Error, key: "Return type of method '{0}' references inaccessible name '{1}'." },
+        Return_type_of_property_getter_0_references_inaccessible_name_1: { code: 4043, category: DiagnosticCategory.Error, key: "Return type of property getter '{0}' references inaccessible name '{1}'." },
+        Return_type_of_construct_signature_references_inaccessible_name_0: { code: 4044, category: DiagnosticCategory.Error, key: "Return type of construct signature references inaccessible name '{0}'." },
+        Return_type_of_call_signature_references_inaccessible_name_0: { code: 4047, category: DiagnosticCategory.Error, key: "Return type of call signature references inaccessible name '{0}'." },
+        Return_type_of_index_signature_references_inaccessible_name_0: { code: 4049, category: DiagnosticCategory.Error, key: "Return type of index signature references inaccessible name '{0}'." },
+        Return_type_of_function_0_references_inaccessible_name_1: { code: 4060, category: DiagnosticCategory.Error, key: "Return type of function '{0}' references inaccessible name '{1}'." },
+        Type_alias_0_references_inaccessible_name_1: { code: 4081, category: DiagnosticCategory.Error, key: "Type alias '{0}' references inaccessible name '{1}'." },
+        Default_export_of_the_module_references_inaccessible_name_0: { code: 4082, category: DiagnosticCategory.Error, key: "Default export of the module references inaccessible name '{0}'." },
         Loop_contains_block_scoped_variable_0_referenced_by_a_function_in_the_loop_This_is_only_supported_in_ECMAScript_6_or_higher: { code: 4091, category: DiagnosticCategory.Error, key: "Loop contains block-scoped variable '{0}' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher." },
         The_current_host_does_not_support_the_0_option: { code: 5001, category: DiagnosticCategory.Error, key: "The current host does not support the '{0}' option." },
         Cannot_find_the_common_subdirectory_path_for_the_input_files: { code: 5009, category: DiagnosticCategory.Error, key: "Cannot find the common subdirectory path for the input files." },
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index acf4e74ae9fc6..ddee3b7f21412 100644
--- a/src/compiler/diagnosticMessages.json
+++ b/src/compiler/diagnosticMessages.json
@@ -1685,290 +1685,73 @@
         "category": "Error",
         "code": 2650
     },
-    "Import declaration '{0}' is using private name '{1}'.": {
+
+    "Import declaration '{0}' references inaccessible name '{1}'.": {
         "category": "Error",
         "code": 4000
     },
-    "Type parameter '{0}' of exported class has or is using private name '{1}'.": {
+    "Constraint of type parameter '{0}' references inaccessible name '{1}'.": {
         "category": "Error",
         "code": 4002
     },
-    "Type parameter '{0}' of exported interface has or is using private name '{1}'.": {
-        "category": "Error",
-        "code": 4004
-    },
-    "Type parameter '{0}' of constructor signature from exported interface has or is using private name '{1}'.": {
-        "category": "Error",
-        "code": 4006
-    },
-    "Type parameter '{0}' of call signature from exported interface has or is using private name '{1}'.": {
-        "category": "Error",
-        "code": 4008
-    },
-    "Type parameter '{0}' of public static method from exported class has or is using private name '{1}'.": {
-        "category": "Error",
-        "code": 4010
-    },
-    "Type parameter '{0}' of public method from exported class has or is using private name '{1}'.": {
-        "category": "Error",
-        "code": 4012
-    },
-    "Type parameter '{0}' of method from exported interface has or is using private name '{1}'.": {
-        "category": "Error",
-        "code": 4014
-    },
-    "Type parameter '{0}' of exported function has or is using private name '{1}'.": {
-        "category": "Error",
-        "code": 4016
-    },
-    "Implements clause of exported class '{0}' has or is using private name '{1}'.": {
+    "Implements clause references inaccessible name '{0}'.": {
         "category": "Error",
         "code": 4019
     },
-    "Extends clause of exported class '{0}' has or is using private name '{1}'.": {
+    "Extends clause references inaccessible name '{0}'.": {
         "category": "Error",
         "code": 4020
     },
-    "Extends clause of exported interface '{0}' has or is using private name '{1}'.": {
-        "category": "Error",
-        "code": 4022
-    },
-    "Exported variable '{0}' has or is using name '{1}' from external module {2} but cannot be named.": {
-        "category": "Error",
-        "code": 4023
-    },
-    "Exported variable '{0}' has or is using name '{1}' from private module '{2}'.": {
-        "category": "Error",
-        "code": 4024
-    },
-    "Exported variable '{0}' has or is using private name '{1}'.": {
+    "Type of variable '{0}' references inaccessible name '{1}'.": {
         "category": "Error",
         "code": 4025
     },
-    "Public static property '{0}' of exported class has or is using name '{1}' from external module {2} but cannot be named.": {
-        "category": "Error",
-        "code": 4026
-    },
-    "Public static property '{0}' of exported class has or is using name '{1}' from private module '{2}'.": {
-        "category": "Error",
-        "code": 4027
-    },
-    "Public static property '{0}' of exported class has or is using private name '{1}'.": {
+    "Type of property '{0}' references inaccessible name '{1}'.": {
         "category": "Error",
         "code": 4028
     },
-    "Public property '{0}' of exported class has or is using name '{1}' from external module {2} but cannot be named.": {
-        "category": "Error",
-        "code": 4029
-    },
-    "Public property '{0}' of exported class has or is using name '{1}' from private module '{2}'.": {
-        "category": "Error",
-        "code": 4030
-    },
-    "Public property '{0}' of exported class has or is using private name '{1}'.": {
+    "Type of parameter '{0}' references inaccessible name '{1}'.": {
         "category": "Error",
-        "code": 4031
-    },
-    "Property '{0}' of exported interface has or is using name '{1}' from private module '{2}'.": {
-        "category": "Error",
-        "code": 4032
-    },
-    "Property '{0}' of exported interface has or is using private name '{1}'.": {
-        "category": "Error",
-        "code": 4033
-    },
-    "Parameter '{0}' of public static property setter from exported class has or is using name '{1}' from private module '{2}'.": {
-        "category": "Error",
-        "code": 4034
-    },
-    "Parameter '{0}' of public static property setter from exported class has or is using private name '{1}'.": {
-        "category": "Error",
-        "code": 4035
-    },
-    "Parameter '{0}' of public property setter from exported class has or is using name '{1}' from private module '{2}'.": {
-        "category": "Error",
-        "code": 4036
-    },
-    "Parameter '{0}' of public property setter from exported class has or is using private name '{1}'.": {
-        "category": "Error",
-        "code": 4037
+        "code": 4028
     },
-    "Return type of public static property getter from exported class has or is using name '{0}' from external module {1} but cannot be named.": {
+    "Return type of method '{0}' references inaccessible name '{1}'.": {
         "category": "Error",
         "code": 4038
     },
-    "Return type of public static property getter from exported class has or is using name '{0}' from private module '{1}'.": {
-        "category": "Error",
-        "code": 4039
-    },
-    "Return type of public static property getter from exported class has or is using private name '{0}'.": {
-        "category": "Error",
-        "code": 4040
-    },
-    "Return type of public property getter from exported class has or is using name '{0}' from external module {1} but cannot be named.": {
-        "category": "Error",
-        "code": 4041
-    },
-    "Return type of public property getter from exported class has or is using name '{0}' from private module '{1}'.": {
-        "category": "Error",
-        "code": 4042
-    },
-    "Return type of public property getter from exported class has or is using private name '{0}'.": {
+    "Return type of property getter '{0}' references inaccessible name '{1}'.": {
         "category": "Error",
         "code": 4043
     },
-    "Return type of constructor signature from exported interface has or is using name '{0}' from private module '{1}'.": {
+    "Return type of construct signature references inaccessible name '{0}'.": {
         "category": "Error",
         "code": 4044
     },
-    "Return type of constructor signature from exported interface has or is using private name '{0}'.": {
-        "category": "Error",
-        "code": 4045
-    },
-    "Return type of call signature from exported interface has or is using name '{0}' from private module '{1}'.": {
-        "category": "Error",
-        "code": 4046
-    },
-    "Return type of call signature from exported interface has or is using private name '{0}'.": {
+    "Return type of call signature references inaccessible name '{0}'.": {
         "category": "Error",
         "code": 4047
     },
-    "Return type of index signature from exported interface has or is using name '{0}' from private module '{1}'.": {
-        "category": "Error",
-        "code": 4048
-    },
-    "Return type of index signature from exported interface has or is using private name '{0}'.": {
+    "Return type of index signature references inaccessible name '{0}'.": {
         "category": "Error",
         "code": 4049
     },
-    "Return type of public static method from exported class has or is using name '{0}' from external module {1} but cannot be named.": {
-        "category": "Error",
-        "code": 4050
-    },
-    "Return type of public static method from exported class has or is using name '{0}' from private module '{1}'.": {
-        "category": "Error",
-        "code": 4051
-    },
-    "Return type of public static method from exported class has or is using private name '{0}'.": {
-        "category": "Error",
-        "code": 4052
-    },
-    "Return type of public method from exported class has or is using name '{0}' from external module {1} but cannot be named.": {
-        "category": "Error",
-        "code": 4053
-    },
-    "Return type of public method from exported class has or is using name '{0}' from private module '{1}'.": {
-        "category": "Error",
-        "code": 4054
-    },
-    "Return type of public method from exported class has or is using private name '{0}'.": {
-        "category": "Error",
-        "code": 4055
-    },
-    "Return type of method from exported interface has or is using name '{0}' from private module '{1}'.": {
-        "category": "Error",
-        "code": 4056
-    },
-    "Return type of method from exported interface has or is using private name '{0}'.": {
-        "category": "Error",
-        "code": 4057
-    },
-    "Return type of exported function has or is using name '{0}' from external module {1} but cannot be named.": {
-        "category": "Error",
-        "code": 4058
-    },
-    "Return type of exported function has or is using name '{0}' from private module '{1}'.": {
-        "category": "Error",
-        "code": 4059
-    },
-    "Return type of exported function has or is using private name '{0}'.": {
+    "Return type of function '{0}' references inaccessible name '{1}'.": {
         "category": "Error",
         "code": 4060
     },
-    "Parameter '{0}' of constructor from exported class has or is using name '{1}' from external module {2} but cannot be named.": {
-        "category": "Error",
-        "code": 4061
-    },
-    "Parameter '{0}' of constructor from exported class has or is using name '{1}' from private module '{2}'.": {
-        "category": "Error",
-        "code": 4062
-    },
-    "Parameter '{0}' of constructor from exported class has or is using private name '{1}'.": {
-        "category": "Error",
-        "code": 4063
-    },
-    "Parameter '{0}' of constructor signature from exported interface has or is using name '{1}' from private module '{2}'.": {
-        "category": "Error",
-        "code": 4064
-    },
-    "Parameter '{0}' of constructor signature from exported interface has or is using private name '{1}'.": {
-        "category": "Error",
-        "code": 4065
-    },
-    "Parameter '{0}' of call signature from exported interface has or is using name '{1}' from private module '{2}'.": {
-        "category": "Error",
-        "code": 4066
-    },
-    "Parameter '{0}' of call signature from exported interface has or is using private name '{1}'.": {
-        "category": "Error",
-        "code": 4067
-    },
-    "Parameter '{0}' of public static method from exported class has or is using name '{1}' from external module {2} but cannot be named.": {
-        "category": "Error",
-        "code": 4068
-    },
-    "Parameter '{0}' of public static method from exported class has or is using name '{1}' from private module '{2}'.": {
-        "category": "Error",
-        "code": 4069
-    },
-    "Parameter '{0}' of public static method from exported class has or is using private name '{1}'.": {
-        "category": "Error",
-        "code": 4070
-    },
-    "Parameter '{0}' of public method from exported class has or is using name '{1}' from external module {2} but cannot be named.": {
-        "category": "Error",
-        "code": 4071
-    },
-    "Parameter '{0}' of public method from exported class has or is using name '{1}' from private module '{2}'.": {
-        "category": "Error",
-        "code": 4072
-    },
-    "Parameter '{0}' of public method from exported class has or is using private name '{1}'.": {
-        "category": "Error",
-        "code": 4073
-    },
-    "Parameter '{0}' of method from exported interface has or is using name '{1}' from private module '{2}'.": {
-        "category": "Error",
-        "code": 4074
-    },
-    "Parameter '{0}' of method from exported interface has or is using private name '{1}'.": {
-        "category": "Error",
-        "code": 4075
-    },
-    "Parameter '{0}' of exported function has or is using name '{1}' from external module {2} but cannot be named.": {
-        "category": "Error",
-        "code": 4076
-    },
-    "Parameter '{0}' of exported function has or is using name '{1}' from private module '{2}'.": {
-        "category": "Error",
-        "code": 4077
-    },
-    "Parameter '{0}' of exported function has or is using private name '{1}'.": {
-        "category": "Error",
-        "code": 4078
-    },
-    "Exported type alias '{0}' has or is using private name '{1}'.": {
+    "Type alias '{0}' references inaccessible name '{1}'.": {
         "category": "Error",
         "code": 4081
     },
-    "Default export of the module has or is using private name '{0}'.": {
+    "Default export of the module references inaccessible name '{0}'.": {
         "category": "Error",
         "code": 4082
     },
+
     "Loop contains block-scoped variable '{0}' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher.": {
         "category": "Error",
         "code": 4091
     },
+
     "The current host does not support the '{0}' option.": {
         "category": "Error",
         "code": 5001
diff --git a/tests/baselines/reference/aliasInaccessibleModule.errors.txt b/tests/baselines/reference/aliasInaccessibleModule.errors.txt
index 3a9c64e50ab46..1f88cca70b5cc 100644
--- a/tests/baselines/reference/aliasInaccessibleModule.errors.txt
+++ b/tests/baselines/reference/aliasInaccessibleModule.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/compiler/aliasInaccessibleModule.ts(4,23): error TS4000: Import declaration 'X' is using private name 'N'.
+tests/cases/compiler/aliasInaccessibleModule.ts(4,23): error TS4000: Import declaration 'X' references inaccessible name 'N'.
 
 
 ==== tests/cases/compiler/aliasInaccessibleModule.ts (1 errors) ====
@@ -7,5 +7,5 @@ tests/cases/compiler/aliasInaccessibleModule.ts(4,23): error TS4000: Import decl
         }
         export import X = N;
                           ~
-!!! error TS4000: Import declaration 'X' is using private name 'N'.
+!!! error TS4000: Import declaration 'X' references inaccessible name 'N'.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/aliasInaccessibleModule2.errors.txt b/tests/baselines/reference/aliasInaccessibleModule2.errors.txt
index 03a37147aba10..709154d3723da 100644
--- a/tests/baselines/reference/aliasInaccessibleModule2.errors.txt
+++ b/tests/baselines/reference/aliasInaccessibleModule2.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/compiler/aliasInaccessibleModule2.ts(7,16): error TS4000: Import declaration 'R' is using private name 'N'.
+tests/cases/compiler/aliasInaccessibleModule2.ts(7,16): error TS4000: Import declaration 'R' references inaccessible name 'N'.
 
 
 ==== tests/cases/compiler/aliasInaccessibleModule2.ts (1 errors) ====
@@ -10,6 +10,6 @@ tests/cases/compiler/aliasInaccessibleModule2.ts(7,16): error TS4000: Import dec
         }
         import R = N;
                    ~
-!!! error TS4000: Import declaration 'R' is using private name 'N'.
+!!! error TS4000: Import declaration 'R' references inaccessible name 'N'.
         export import X = R;
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.errors.txt b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.errors.txt
index b6130864d8b6c..f6550e22fd505 100644
--- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.errors.txt
+++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.errors.txt
@@ -1,13 +1,13 @@
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(16,21): error TS4043: Return type of public property getter from exported class has or is using private name 'private1'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(21,13): error TS4043: Return type of public property getter from exported class has or is using private name 'private1'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(26,25): error TS4037: Parameter 'foo3' of public property setter from exported class has or is using private name 'private1'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(33,25): error TS4037: Parameter 'foo4' of public property setter from exported class has or is using private name 'private1'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(37,21): error TS4043: Return type of public property getter from exported class has or is using private name 'private1'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(72,23): error TS4043: Return type of public property getter from exported class has or is using private name 'm2'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(77,13): error TS4042: Return type of public property getter from exported class has or is using name 'm2.public2' from private module 'm2'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(82,27): error TS4037: Parameter 'foo113' of public property setter from exported class has or is using private name 'm2'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(89,27): error TS4037: Parameter 'foo114' of public property setter from exported class has or is using private name 'm2'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(93,23): error TS4043: Return type of public property getter from exported class has or is using private name 'm2'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(16,21): error TS4043: Return type of property getter 'foo1' references inaccessible name 'private1'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(21,13): error TS4043: Return type of property getter 'foo2' references inaccessible name 'private1'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(26,25): error TS4028: Type of parameter 'param' references inaccessible name 'private1'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(30,13): error TS4043: Return type of property getter 'foo4' references inaccessible name 'private1'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(37,21): error TS4043: Return type of property getter 'foo5' references inaccessible name 'private1'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(72,23): error TS4043: Return type of property getter 'foo111' references inaccessible name 'm2'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(77,13): error TS4043: Return type of property getter 'foo112' references inaccessible name 'm2'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(82,27): error TS4028: Type of parameter 'param' references inaccessible name 'm2'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(86,13): error TS4043: Return type of property getter 'foo114' references inaccessible name 'm2'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(93,23): error TS4043: Return type of property getter 'foo115' references inaccessible name 'm2'.
 
 
 ==== tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts (10 errors) ====
@@ -28,36 +28,36 @@ tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(93,23): e
             // getter with annotation
             get foo1(): private1 {
                         ~~~~~~~~
-!!! error TS4043: Return type of public property getter from exported class has or is using private name 'private1'.
+!!! error TS4043: Return type of property getter 'foo1' references inaccessible name 'private1'.
                 return;
             }
     
             // getter without annotation
             get foo2() {
                 ~~~~
-!!! error TS4043: Return type of public property getter from exported class has or is using private name 'private1'.
+!!! error TS4043: Return type of property getter 'foo2' references inaccessible name 'private1'.
                 return new private1();
             }
     
             // setter with annotation
             set foo3(param: private1) {
                             ~~~~~~~~
-!!! error TS4037: Parameter 'foo3' of public property setter from exported class has or is using private name 'private1'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'private1'.
             }
     
             // Both - getter without annotation, setter with annotation
             get foo4() {
+                ~~~~
+!!! error TS4043: Return type of property getter 'foo4' references inaccessible name 'private1'.
                 return new private1();
             }
             set foo4(param: private1) {
-                            ~~~~~~~~
-!!! error TS4037: Parameter 'foo4' of public property setter from exported class has or is using private name 'private1'.
             }
     
             // Both - with annotation
             get foo5(): private1 {
                         ~~~~~~~~
-!!! error TS4043: Return type of public property getter from exported class has or is using private name 'private1'.
+!!! error TS4043: Return type of property getter 'foo5' references inaccessible name 'private1'.
                 return;
             }
             set foo5(param: private1) {
@@ -94,36 +94,36 @@ tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(93,23): e
             // getter with annotation
             get foo111(): m2.public2 {
                           ~~
-!!! error TS4043: Return type of public property getter from exported class has or is using private name 'm2'.
+!!! error TS4043: Return type of property getter 'foo111' references inaccessible name 'm2'.
                 return;
             }
     
             // getter without annotation
             get foo112() {
                 ~~~~~~
-!!! error TS4042: Return type of public property getter from exported class has or is using name 'm2.public2' from private module 'm2'.
+!!! error TS4043: Return type of property getter 'foo112' references inaccessible name 'm2'.
                 return new m2.public2();
             }
     
             // setter with annotation
             set foo113(param: m2.public2) {
                               ~~
-!!! error TS4037: Parameter 'foo113' of public property setter from exported class has or is using private name 'm2'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'm2'.
             }
     
             // Both - getter without annotation, setter with annotation
             get foo114() {
+                ~~~~~~
+!!! error TS4043: Return type of property getter 'foo114' references inaccessible name 'm2'.
                 return new m2.public2();
             }
             set foo114(param: m2.public2) {
-                              ~~
-!!! error TS4037: Parameter 'foo114' of public property setter from exported class has or is using private name 'm2'.
             }
     
             // Both - with annotation
             get foo115(): m2.public2 {
                           ~~
-!!! error TS4043: Return type of public property getter from exported class has or is using private name 'm2'.
+!!! error TS4043: Return type of property getter 'foo115' references inaccessible name 'm2'.
                 return;
             }
             set foo115(param: m2.public2) {
diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorParameterOfFunction.errors.txt b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorParameterOfFunction.errors.txt
index 7dbe3617de939..62f163d9a04ab 100644
--- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorParameterOfFunction.errors.txt
+++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorParameterOfFunction.errors.txt
@@ -1,7 +1,7 @@
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts(15,34): error TS4078: Parameter 'param' of exported function has or is using private name 'private1'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts(17,26): error TS4078: Parameter 'param' of exported function has or is using private name 'private1'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts(40,35): error TS4078: Parameter 'param' of exported function has or is using private name 'm2'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts(42,28): error TS4077: Parameter 'param' of exported function has or is using name 'm2.public2' from private module 'm2'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts(15,34): error TS4028: Type of parameter 'param' references inaccessible name 'private1'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts(17,26): error TS4028: Type of parameter 'param' references inaccessible name 'private1'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts(40,35): error TS4028: Type of parameter 'param' references inaccessible name 'm2'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts(42,28): error TS4028: Type of parameter 'param' references inaccessible name 'm2'.
 
 
 ==== tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts (4 errors) ====
@@ -21,11 +21,11 @@ tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts
     
         export function foo3(param : private1) {
                                      ~~~~~~~~
-!!! error TS4078: Parameter 'param' of exported function has or is using private name 'private1'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'private1'.
         }
         export function foo4(param = new private1()) {
-                             ~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4078: Parameter 'param' of exported function has or is using private name 'private1'.
+                             ~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'private1'.
         }
     
         function foo11(param: public1) {
@@ -50,11 +50,11 @@ tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts
     
         export function foo113(param: m2.public2) {
                                       ~~
-!!! error TS4078: Parameter 'param' of exported function has or is using private name 'm2'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'm2'.
         }
         export function foo114(param = new m2.public2()) {
-                               ~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4077: Parameter 'param' of exported function has or is using name 'm2.public2' from private module 'm2'.
+                               ~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'm2'.
         }
     }
     
\ No newline at end of file
diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.errors.txt b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.errors.txt
index 449af75bf6153..036cb4e5f6f22 100644
--- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.errors.txt
+++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.errors.txt
@@ -1,7 +1,7 @@
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.ts(17,29): error TS4060: Return type of exported function has or is using private name 'private1'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.ts(20,21): error TS4060: Return type of exported function has or is using private name 'private1'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.ts(50,31): error TS4060: Return type of exported function has or is using private name 'm2'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.ts(53,21): error TS4059: Return type of exported function has or is using name 'm2.public2' from private module 'm2'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.ts(17,29): error TS4060: Return type of function 'foo3' references inaccessible name 'private1'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.ts(20,21): error TS4060: Return type of function 'foo4' references inaccessible name 'private1'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.ts(50,31): error TS4060: Return type of function 'foo113' references inaccessible name 'm2'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.ts(53,21): error TS4060: Return type of function 'foo114' references inaccessible name 'm2'.
 
 
 ==== tests/cases/compiler/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.ts (4 errors) ====
@@ -23,12 +23,12 @@ tests/cases/compiler/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.t
     
         export function foo3(): private1 {
                                 ~~~~~~~~
-!!! error TS4060: Return type of exported function has or is using private name 'private1'.
+!!! error TS4060: Return type of function 'foo3' references inaccessible name 'private1'.
             return;
         }
         export function foo4() {
                         ~~~~
-!!! error TS4060: Return type of exported function has or is using private name 'private1'.
+!!! error TS4060: Return type of function 'foo4' references inaccessible name 'private1'.
             return new private1();
         }
     
@@ -60,12 +60,12 @@ tests/cases/compiler/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.t
     
         export function foo113(): m2.public2 {
                                   ~~
-!!! error TS4060: Return type of exported function has or is using private name 'm2'.
+!!! error TS4060: Return type of function 'foo113' references inaccessible name 'm2'.
             return;
         }
         export function foo114() {
                         ~~~~~~
-!!! error TS4059: Return type of exported function has or is using name 'm2.public2' from private module 'm2'.
+!!! error TS4060: Return type of function 'foo114' references inaccessible name 'm2'.
             return new m2.public2();
         }
     }
diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.errors.txt b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.errors.txt
index a9fd72ae569d6..c9a29fcfde254 100644
--- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.errors.txt
+++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.errors.txt
@@ -1,7 +1,7 @@
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeAlias.ts(10,23): error TS4025: Exported variable 'p' has or is using private name 'W'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeAlias.ts(33,22): error TS4081: Exported type alias 't2' has or is using private name 'private1'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeAlias.ts(36,23): error TS4081: Exported type alias 't12' has or is using private name 'public1'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeAlias.ts(39,24): error TS4081: Exported type alias 't112' has or is using private name 'm3'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeAlias.ts(10,23): error TS4025: Type of variable 'p' references inaccessible name 'W'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeAlias.ts(33,22): error TS4081: Type alias 't2' references inaccessible name 'private1'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeAlias.ts(36,23): error TS4081: Type alias 't12' references inaccessible name 'public1'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeAlias.ts(39,24): error TS4081: Type alias 't112' references inaccessible name 'm3'.
 
 
 ==== tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeAlias.ts (4 errors) ====
@@ -16,7 +16,7 @@ tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeAlias.ts(39,24): e
             export class Window { }
             export var p: W; // Should report error that W is private
                           ~
-!!! error TS4025: Exported variable 'p' has or is using private name 'W'.
+!!! error TS4025: Type of variable 'p' references inaccessible name 'W'.
         }
     }
     
@@ -41,16 +41,16 @@ tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeAlias.ts(39,24): e
         type t1 = private1;
         export type t2 = private1; // error
                          ~~~~~~~~
-!!! error TS4081: Exported type alias 't2' has or is using private name 'private1'.
+!!! error TS4081: Type alias 't2' references inaccessible name 'private1'.
     
         type t11 = public1;
         export type t12 = public1;
                           ~~~~~~~
-!!! error TS4081: Exported type alias 't12' has or is using private name 'public1'.
+!!! error TS4081: Type alias 't12' references inaccessible name 'public1'.
     
         type t111 = m3.public1;
         export type t112 = m3.public1; // error
                            ~~
-!!! error TS4081: Exported type alias 't112' has or is using private name 'm3'.
+!!! error TS4081: Type alias 't112' references inaccessible name 'm3'.
     }
     
\ No newline at end of file
diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeLiteral.errors.txt b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeLiteral.errors.txt
index 8cba0d12464d2..78e65d945d498 100644
--- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeLiteral.errors.txt
+++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeLiteral.errors.txt
@@ -1,21 +1,21 @@
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(11,12): error TS4025: Exported variable 'x' has or is using private name 'private1'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(12,12): error TS4025: Exported variable 'x' has or is using private name 'm2'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(13,13): error TS4025: Exported variable 'x' has or is using private name 'm2'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(14,19): error TS4025: Exported variable 'x' has or is using private name 'private1'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(15,22): error TS4025: Exported variable 'x' has or is using private name 'private1'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(16,22): error TS4025: Exported variable 'x' has or is using private name 'm2'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(18,16): error TS4024: Exported variable 'x2' has or is using name 'm2.public1' from private module 'm2'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(18,16): error TS4025: Exported variable 'x2' has or is using private name 'private1'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(25,16): error TS4024: Exported variable 'x3' has or is using name 'm2.public1' from private module 'm2'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(25,16): error TS4025: Exported variable 'x3' has or is using private name 'private1'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(28,23): error TS4025: Exported variable 'y' has or is using private name 'private1'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(28,36): error TS4025: Exported variable 'y' has or is using private name 'm2'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(29,16): error TS4024: Exported variable 'y2' has or is using name 'm2.public1' from private module 'm2'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(29,16): error TS4025: Exported variable 'y2' has or is using private name 'private1'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(32,27): error TS4025: Exported variable 'z' has or is using private name 'private1'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(32,40): error TS4025: Exported variable 'z' has or is using private name 'm2'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(33,16): error TS4024: Exported variable 'z2' has or is using name 'm2.public1' from private module 'm2'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(33,16): error TS4025: Exported variable 'z2' has or is using private name 'private1'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(11,12): error TS4028: Type of property 'x' references inaccessible name 'private1'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(12,12): error TS4028: Type of property 'y' references inaccessible name 'm2'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(13,13): error TS4047: Return type of call signature references inaccessible name 'm2'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(14,19): error TS4038: Return type of method 'method' references inaccessible name 'private1'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(15,22): error TS4049: Return type of index signature references inaccessible name 'private1'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(16,22): error TS4049: Return type of index signature references inaccessible name 'm2'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(18,16): error TS4025: Type of variable 'x2' references inaccessible name 'm2'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(18,16): error TS4025: Type of variable 'x2' references inaccessible name 'private1'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(25,16): error TS4025: Type of variable 'x3' references inaccessible name 'm2'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(25,16): error TS4025: Type of variable 'x3' references inaccessible name 'private1'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(28,23): error TS4028: Type of parameter 'a' references inaccessible name 'private1'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(28,36): error TS4025: Type of variable 'y' references inaccessible name 'm2'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(29,16): error TS4025: Type of variable 'y2' references inaccessible name 'm2'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(29,16): error TS4025: Type of variable 'y2' references inaccessible name 'private1'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(32,27): error TS4028: Type of parameter 'a' references inaccessible name 'private1'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(32,40): error TS4025: Type of variable 'z' references inaccessible name 'm2'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(33,16): error TS4025: Type of variable 'z2' references inaccessible name 'm2'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(33,16): error TS4025: Type of variable 'z2' references inaccessible name 'private1'.
 
 
 ==== tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts (18 errors) ====
@@ -31,28 +31,28 @@ tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(33,16):
         export var x: {
             x: private1;
                ~~~~~~~~
-!!! error TS4025: Exported variable 'x' has or is using private name 'private1'.
+!!! error TS4028: Type of property 'x' references inaccessible name 'private1'.
             y: m2.public1;
                ~~
-!!! error TS4025: Exported variable 'x' has or is using private name 'm2'.
+!!! error TS4028: Type of property 'y' references inaccessible name 'm2'.
             (): m2.public1[];
                 ~~
-!!! error TS4025: Exported variable 'x' has or is using private name 'm2'.
+!!! error TS4047: Return type of call signature references inaccessible name 'm2'.
             method(): private1;
                       ~~~~~~~~
-!!! error TS4025: Exported variable 'x' has or is using private name 'private1'.
+!!! error TS4038: Return type of method 'method' references inaccessible name 'private1'.
             [n: number]: private1;
                          ~~~~~~~~
-!!! error TS4025: Exported variable 'x' has or is using private name 'private1'.
+!!! error TS4049: Return type of index signature references inaccessible name 'private1'.
             [s: string]: m2.public1;
                          ~~
-!!! error TS4025: Exported variable 'x' has or is using private name 'm2'.
+!!! error TS4049: Return type of index signature references inaccessible name 'm2'.
         };
         export var x2 = {
                    ~~
-!!! error TS4024: Exported variable 'x2' has or is using name 'm2.public1' from private module 'm2'.
+!!! error TS4025: Type of variable 'x2' references inaccessible name 'm2'.
                    ~~
-!!! error TS4025: Exported variable 'x2' has or is using private name 'private1'.
+!!! error TS4025: Type of variable 'x2' references inaccessible name 'private1'.
             x: new private1(),
             y: new m2.public1(),
             method() {
@@ -61,31 +61,31 @@ tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(33,16):
         };
         export var x3 = x;
                    ~~
-!!! error TS4024: Exported variable 'x3' has or is using name 'm2.public1' from private module 'm2'.
+!!! error TS4025: Type of variable 'x3' references inaccessible name 'm2'.
                    ~~
-!!! error TS4025: Exported variable 'x3' has or is using private name 'private1'.
+!!! error TS4025: Type of variable 'x3' references inaccessible name 'private1'.
     
         // Function type
         export var y: (a: private1) => m2.public1;
                           ~~~~~~~~
-!!! error TS4025: Exported variable 'y' has or is using private name 'private1'.
+!!! error TS4028: Type of parameter 'a' references inaccessible name 'private1'.
                                        ~~
-!!! error TS4025: Exported variable 'y' has or is using private name 'm2'.
+!!! error TS4025: Type of variable 'y' references inaccessible name 'm2'.
         export var y2 = y;
                    ~~
-!!! error TS4024: Exported variable 'y2' has or is using name 'm2.public1' from private module 'm2'.
+!!! error TS4025: Type of variable 'y2' references inaccessible name 'm2'.
                    ~~
-!!! error TS4025: Exported variable 'y2' has or is using private name 'private1'.
+!!! error TS4025: Type of variable 'y2' references inaccessible name 'private1'.
     
         // constructor type
         export var z: new (a: private1) => m2.public1;
                               ~~~~~~~~
-!!! error TS4025: Exported variable 'z' has or is using private name 'private1'.
+!!! error TS4028: Type of parameter 'a' references inaccessible name 'private1'.
                                            ~~
-!!! error TS4025: Exported variable 'z' has or is using private name 'm2'.
+!!! error TS4025: Type of variable 'z' references inaccessible name 'm2'.
         export var z2 = z;
                    ~~
-!!! error TS4024: Exported variable 'z2' has or is using name 'm2.public1' from private module 'm2'.
+!!! error TS4025: Type of variable 'z2' references inaccessible name 'm2'.
                    ~~
-!!! error TS4025: Exported variable 'z2' has or is using private name 'private1'.
+!!! error TS4025: Type of variable 'z2' references inaccessible name 'private1'.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorVariableDeclaration.errors.txt b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorVariableDeclaration.errors.txt
index 33771b85dd424..aaaed5350bf78 100644
--- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorVariableDeclaration.errors.txt
+++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorVariableDeclaration.errors.txt
@@ -1,7 +1,7 @@
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorVariableDeclaration.ts(13,19): error TS4025: Exported variable 'k' has or is using private name 'private1'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorVariableDeclaration.ts(14,16): error TS4025: Exported variable 'l' has or is using private name 'private1'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorVariableDeclaration.ts(30,20): error TS4025: Exported variable 'k3' has or is using private name 'm2'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorVariableDeclaration.ts(31,16): error TS4024: Exported variable 'l3' has or is using name 'm2.public2' from private module 'm2'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorVariableDeclaration.ts(13,19): error TS4025: Type of variable 'k' references inaccessible name 'private1'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorVariableDeclaration.ts(14,16): error TS4025: Type of variable 'l' references inaccessible name 'private1'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorVariableDeclaration.ts(30,20): error TS4025: Type of variable 'k3' references inaccessible name 'm2'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorVariableDeclaration.ts(31,16): error TS4025: Type of variable 'l3' references inaccessible name 'm2'.
 
 
 ==== tests/cases/compiler/declFileTypeAnnotationVisibilityErrorVariableDeclaration.ts (4 errors) ====
@@ -19,10 +19,10 @@ tests/cases/compiler/declFileTypeAnnotationVisibilityErrorVariableDeclaration.ts
     
         export var k: private1;
                       ~~~~~~~~
-!!! error TS4025: Exported variable 'k' has or is using private name 'private1'.
+!!! error TS4025: Type of variable 'k' references inaccessible name 'private1'.
         export var l = new private1();
                    ~
-!!! error TS4025: Exported variable 'l' has or is using private name 'private1'.
+!!! error TS4025: Type of variable 'l' references inaccessible name 'private1'.
     
         var x2: public1;
         var y2 = new public1();
@@ -40,9 +40,9 @@ tests/cases/compiler/declFileTypeAnnotationVisibilityErrorVariableDeclaration.ts
     
         export var k3: m2.public2;
                        ~~
-!!! error TS4025: Exported variable 'k3' has or is using private name 'm2'.
+!!! error TS4025: Type of variable 'k3' references inaccessible name 'm2'.
         export var l3 = new m2.public2();
                    ~~
-!!! error TS4024: Exported variable 'l3' has or is using name 'm2.public2' from private module 'm2'.
+!!! error TS4025: Type of variable 'l3' references inaccessible name 'm2'.
     }
     
\ No newline at end of file
diff --git a/tests/baselines/reference/declInput-2.errors.txt b/tests/baselines/reference/declInput-2.errors.txt
index f151f3e712205..6ee7caefdf15f 100644
--- a/tests/baselines/reference/declInput-2.errors.txt
+++ b/tests/baselines/reference/declInput-2.errors.txt
@@ -1,8 +1,8 @@
-tests/cases/compiler/declInput-2.ts(10,21): error TS4031: Public property 'm22' of exported class has or is using private name 'C'.
-tests/cases/compiler/declInput-2.ts(13,21): error TS4031: Public property 'm25' of exported class has or is using private name 'I2'.
-tests/cases/compiler/declInput-2.ts(16,24): error TS4055: Return type of public method from exported class has or is using private name 'I2'.
-tests/cases/compiler/declInput-2.ts(18,23): error TS4073: Parameter 'i' of public method from exported class has or is using private name 'I2'.
-tests/cases/compiler/declInput-2.ts(19,21): error TS4055: Return type of public method from exported class has or is using private name 'C'.
+tests/cases/compiler/declInput-2.ts(10,21): error TS4028: Type of property 'm22' references inaccessible name 'C'.
+tests/cases/compiler/declInput-2.ts(13,21): error TS4028: Type of property 'm25' references inaccessible name 'I2'.
+tests/cases/compiler/declInput-2.ts(16,24): error TS4038: Return type of method 'm252' references inaccessible name 'I2'.
+tests/cases/compiler/declInput-2.ts(18,23): error TS4028: Type of parameter 'i' references inaccessible name 'I2'.
+tests/cases/compiler/declInput-2.ts(19,21): error TS4038: Return type of method 'm3' references inaccessible name 'C'.
 
 
 ==== tests/cases/compiler/declInput-2.ts (5 errors) ====
@@ -17,23 +17,23 @@ tests/cases/compiler/declInput-2.ts(19,21): error TS4055: Return type of public
             public m2: string;
             public m22: C; // don't generate
                         ~
-!!! error TS4031: Public property 'm22' of exported class has or is using private name 'C'.
+!!! error TS4028: Type of property 'm22' references inaccessible name 'C'.
             public m23: E;
             public m24: I1;
             public m25: I2; // don't generate
                         ~~
-!!! error TS4031: Public property 'm25' of exported class has or is using private name 'I2'.
+!!! error TS4028: Type of property 'm25' references inaccessible name 'I2'.
             public m232(): E { return null;}
             public m242(): I1 { return null; }
             public m252(): I2 { return null; } // don't generate
                            ~~
-!!! error TS4055: Return type of public method from exported class has or is using private name 'I2'.
+!!! error TS4038: Return type of method 'm252' references inaccessible name 'I2'.
             public m26(i:I1) {}
             public m262(i:I2) {}
                           ~~
-!!! error TS4073: Parameter 'i' of public method from exported class has or is using private name 'I2'.
+!!! error TS4028: Type of parameter 'i' references inaccessible name 'I2'.
             public m3():C { return new C(); }
                         ~
-!!! error TS4055: Return type of public method from exported class has or is using private name 'C'.
+!!! error TS4038: Return type of method 'm3' references inaccessible name 'C'.
         }
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/declarationEmitDestructuringPrivacyError.errors.txt b/tests/baselines/reference/declarationEmitDestructuringPrivacyError.errors.txt
index e464b96a8bf77..dd9b936e8d510 100644
--- a/tests/baselines/reference/declarationEmitDestructuringPrivacyError.errors.txt
+++ b/tests/baselines/reference/declarationEmitDestructuringPrivacyError.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/compiler/declarationEmitDestructuringPrivacyError.ts(4,20): error TS4025: Exported variable 'y' has or is using private name 'c'.
+tests/cases/compiler/declarationEmitDestructuringPrivacyError.ts(4,20): error TS4025: Type of variable 'y' references inaccessible name 'c'.
 
 
 ==== tests/cases/compiler/declarationEmitDestructuringPrivacyError.ts (1 errors) ====
@@ -7,5 +7,5 @@ tests/cases/compiler/declarationEmitDestructuringPrivacyError.ts(4,20): error TS
         }
         export var [x, y, z] = [10, new c(), 30];
                        ~
-!!! error TS4025: Exported variable 'y' has or is using private name 'c'.
+!!! error TS4025: Type of variable 'y' references inaccessible name 'c'.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/expressionInExtendsClauseWithVisibilityErrors.errors.txt b/tests/baselines/reference/expressionInExtendsClauseWithVisibilityErrors.errors.txt
index ddee65e4cc994..cbaa03a3f1ca5 100644
--- a/tests/baselines/reference/expressionInExtendsClauseWithVisibilityErrors.errors.txt
+++ b/tests/baselines/reference/expressionInExtendsClauseWithVisibilityErrors.errors.txt
@@ -1,5 +1,5 @@
-tests/cases/compiler/expressionInExtendsClauseWithVisibilityErrors.ts(16,30): error TS4020: Extends clause of exported class 'MyClass' has or is using private name 'C'.
-tests/cases/compiler/expressionInExtendsClauseWithVisibilityErrors.ts(16,30): error TS4020: Extends clause of exported class 'MyClass' has or is using private name 'I'.
+tests/cases/compiler/expressionInExtendsClauseWithVisibilityErrors.ts(16,30): error TS4020: Extends clause references inaccessible name 'C'.
+tests/cases/compiler/expressionInExtendsClauseWithVisibilityErrors.ts(16,30): error TS4020: Extends clause references inaccessible name 'I'.
 
 
 ==== tests/cases/compiler/expressionInExtendsClauseWithVisibilityErrors.ts (2 errors) ====
@@ -20,9 +20,9 @@ tests/cases/compiler/expressionInExtendsClauseWithVisibilityErrors.ts(16,30): er
     // Error I is not exported
     export class MyClass extends getClass(2) <string, I> {
                                  ~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4020: Extends clause of exported class 'MyClass' has or is using private name 'C'.
+!!! error TS4020: Extends clause references inaccessible name 'C'.
                                  ~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4020: Extends clause of exported class 'MyClass' has or is using private name 'I'.
+!!! error TS4020: Extends clause references inaccessible name 'I'.
     }
     
     
\ No newline at end of file
diff --git a/tests/baselines/reference/privacyAccessorDeclFile.errors.txt b/tests/baselines/reference/privacyAccessorDeclFile.errors.txt
index debb5808493a7..231acf1c92f70 100644
--- a/tests/baselines/reference/privacyAccessorDeclFile.errors.txt
+++ b/tests/baselines/reference/privacyAccessorDeclFile.errors.txt
@@ -1,42 +1,64 @@
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(253,44): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(259,31): error TS4043: Return type of public property getter from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(265,20): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(271,13): error TS4043: Return type of public property getter from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(361,48): error TS4037: Parameter 'myPublicStaticMethod' of public property setter from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(365,35): error TS4037: Parameter 'myPublicMethod' of public property setter from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(405,44): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(408,31): error TS4043: Return type of public property getter from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(411,20): error TS4039: Return type of public static property getter from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(414,13): error TS4042: Return type of public property getter from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(420,48): error TS4037: Parameter 'myPublicStaticMethod' of public property setter from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(422,35): error TS4037: Parameter 'myPublicMethod' of public property setter from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(9,40): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(15,27): error TS4043: Return type of public property getter from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(21,16): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(27,9): error TS4043: Return type of public property getter from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(117,44): error TS4037: Parameter 'myPublicStaticMethod' of public property setter from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(121,31): error TS4037: Parameter 'myPublicMethod' of public property setter from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(161,40): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(164,27): error TS4043: Return type of public property getter from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(167,16): error TS4039: Return type of public static property getter from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(170,9): error TS4042: Return type of public property getter from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(176,44): error TS4037: Parameter 'myPublicStaticMethod' of public property setter from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(178,31): error TS4037: Parameter 'myPublicMethod' of public property setter from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(211,44): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(217,31): error TS4043: Return type of public property getter from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(223,20): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(229,13): error TS4043: Return type of public property getter from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(319,48): error TS4037: Parameter 'myPublicStaticMethod' of public property setter from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(323,35): error TS4037: Parameter 'myPublicMethod' of public property setter from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(363,44): error TS4040: Return type of public static property getter from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(366,31): error TS4043: Return type of public property getter from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(369,20): error TS4039: Return type of public static property getter from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(372,13): error TS4042: Return type of public property getter from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(378,48): error TS4037: Parameter 'myPublicStaticMethod' of public property setter from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(380,35): error TS4037: Parameter 'myPublicMethod' of public property setter from exported class has or is using private name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(56,48): error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(56,48): error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(62,35): error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(68,24): error TS4043: Return type of property getter 'myPublicStaticMethod1' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(74,17): error TS4043: Return type of property getter 'myPublicMethod1' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(164,52): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(168,39): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(208,48): error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(211,35): error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(223,52): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(225,39): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(253,44): error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(259,31): error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(265,20): error TS4043: Return type of property getter 'myPublicStaticMethod1' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(271,13): error TS4043: Return type of property getter 'myPublicMethod1' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(361,48): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(365,35): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(405,44): error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(408,31): error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(411,20): error TS4043: Return type of property getter 'myPublicStaticMethod1' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(414,13): error TS4043: Return type of property getter 'myPublicMethod1' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(420,48): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(422,35): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(9,40): error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(15,27): error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(21,16): error TS4043: Return type of property getter 'myPublicStaticMethod1' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(27,9): error TS4043: Return type of property getter 'myPublicMethod1' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(117,44): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(121,31): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(161,40): error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(164,27): error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(167,16): error TS4043: Return type of property getter 'myPublicStaticMethod1' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(170,9): error TS4043: Return type of property getter 'myPublicMethod1' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(176,44): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(178,31): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(211,44): error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(217,31): error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(223,20): error TS4043: Return type of property getter 'myPublicStaticMethod1' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(229,13): error TS4043: Return type of property getter 'myPublicMethod1' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(319,48): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(323,35): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(363,44): error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(366,31): error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(369,20): error TS4043: Return type of property getter 'myPublicStaticMethod1' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(372,13): error TS4043: Return type of property getter 'myPublicMethod1' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(378,48): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(380,35): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(414,44): error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(414,44): error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(420,31): error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(426,20): error TS4043: Return type of property getter 'myPublicStaticMethod1' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(432,13): error TS4043: Return type of property getter 'myPublicMethod1' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(522,48): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(526,35): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(566,44): error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(569,31): error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(581,48): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(583,35): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
 
 
-==== tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts (24 errors) ====
+==== tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts (35 errors) ====
     
     class privateClass {
     }
@@ -47,7 +69,7 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(380,35): error TS
     export class publicClassWithWithPrivateGetAccessorTypes {
         static get myPublicStaticMethod(): privateClass { // Error
                                            ~~~~~~~~~~~~
-!!! error TS4040: Return type of public static property getter from exported class has or is using private name 'privateClass'.
+!!! error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateClass'.
             return null;
         }
         private static get myPrivateStaticMethod(): privateClass {
@@ -55,7 +77,7 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(380,35): error TS
         }
         get myPublicMethod(): privateClass { // Error
                               ~~~~~~~~~~~~
-!!! error TS4043: Return type of public property getter from exported class has or is using private name 'privateClass'.
+!!! error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateClass'.
             return null;
         }
         private get myPrivateMethod(): privateClass {
@@ -63,7 +85,7 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(380,35): error TS
         }
         static get myPublicStaticMethod1() { // Error
                    ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4040: Return type of public static property getter from exported class has or is using private name 'privateClass'.
+!!! error TS4043: Return type of property getter 'myPublicStaticMethod1' references inaccessible name 'privateClass'.
             return new privateClass();
         }
         private static get myPrivateStaticMethod1() {
@@ -71,7 +93,7 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(380,35): error TS
         }
         get myPublicMethod1() { // Error
             ~~~~~~~~~~~~~~~
-!!! error TS4043: Return type of public property getter from exported class has or is using private name 'privateClass'.
+!!! error TS4043: Return type of property getter 'myPublicMethod1' references inaccessible name 'privateClass'.
             return new privateClass();
         }
         private get myPrivateMethod1() {
@@ -163,13 +185,13 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(380,35): error TS
     export class publicClassWithWithPrivateSetAccessorTypes {
         static set myPublicStaticMethod(param: privateClass) { // Error
                                                ~~~~~~~~~~~~
-!!! error TS4037: Parameter 'myPublicStaticMethod' of public property setter from exported class has or is using private name 'privateClass'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
         }
         private static set myPrivateStaticMethod(param: privateClass) {
         }
         set myPublicMethod(param: privateClass) { // Error
                                   ~~~~~~~~~~~~
-!!! error TS4037: Parameter 'myPublicMethod' of public property setter from exported class has or is using private name 'privateClass'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
         }
         private set myPrivateMethod(param: privateClass) {
         }
@@ -211,22 +233,22 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(380,35): error TS
     export class publicClassWithPrivateModuleGetAccessorTypes {
         static get myPublicStaticMethod(): privateModule.publicClass { // Error
                                            ~~~~~~~~~~~~~
-!!! error TS4040: Return type of public static property getter from exported class has or is using private name 'privateModule'.
+!!! error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateModule'.
             return null;
         }
         get myPublicMethod(): privateModule.publicClass { // Error
                               ~~~~~~~~~~~~~
-!!! error TS4043: Return type of public property getter from exported class has or is using private name 'privateModule'.
+!!! error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateModule'.
             return null;
         }
         static get myPublicStaticMethod1() { // Error
                    ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4039: Return type of public static property getter from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'.
+!!! error TS4043: Return type of property getter 'myPublicStaticMethod1' references inaccessible name 'privateModule'.
             return new privateModule.publicClass();
         }
         get myPublicMethod1() { // Error
             ~~~~~~~~~~~~~~~
-!!! error TS4042: Return type of public property getter from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'.
+!!! error TS4043: Return type of property getter 'myPublicMethod1' references inaccessible name 'privateModule'.
             return new privateModule.publicClass();
         }
     }
@@ -234,11 +256,11 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(380,35): error TS
     export class publicClassWithPrivateModuleSetAccessorTypes {
         static set myPublicStaticMethod(param: privateModule.publicClass) { // Error
                                                ~~~~~~~~~~~~~
-!!! error TS4037: Parameter 'myPublicStaticMethod' of public property setter from exported class has or is using private name 'privateModule'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
         }
         set myPublicMethod(param: privateModule.publicClass) { // Error
                                   ~~~~~~~~~~~~~
-!!! error TS4037: Parameter 'myPublicMethod' of public property setter from exported class has or is using private name 'privateModule'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
         }
     }
     
@@ -273,7 +295,7 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(380,35): error TS
         export class publicClassWithWithPrivateGetAccessorTypes {
             static get myPublicStaticMethod(): privateClass { // Error
                                                ~~~~~~~~~~~~
-!!! error TS4040: Return type of public static property getter from exported class has or is using private name 'privateClass'.
+!!! error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateClass'.
                 return null;
             }
             private static get myPrivateStaticMethod(): privateClass {
@@ -281,7 +303,7 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(380,35): error TS
             }
             get myPublicMethod(): privateClass { // Error
                                   ~~~~~~~~~~~~
-!!! error TS4043: Return type of public property getter from exported class has or is using private name 'privateClass'.
+!!! error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateClass'.
                 return null;
             }
             private get myPrivateMethod(): privateClass {
@@ -289,7 +311,7 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(380,35): error TS
             }
             static get myPublicStaticMethod1() { // Error
                        ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4040: Return type of public static property getter from exported class has or is using private name 'privateClass'.
+!!! error TS4043: Return type of property getter 'myPublicStaticMethod1' references inaccessible name 'privateClass'.
                 return new privateClass();
             }
             private static get myPrivateStaticMethod1() {
@@ -297,7 +319,7 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(380,35): error TS
             }
             get myPublicMethod1() { // Error
                 ~~~~~~~~~~~~~~~
-!!! error TS4043: Return type of public property getter from exported class has or is using private name 'privateClass'.
+!!! error TS4043: Return type of property getter 'myPublicMethod1' references inaccessible name 'privateClass'.
                 return new privateClass();
             }
             private get myPrivateMethod1() {
@@ -389,13 +411,13 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(380,35): error TS
         export class publicClassWithWithPrivateSetAccessorTypes {
             static set myPublicStaticMethod(param: privateClass) { // Error
                                                    ~~~~~~~~~~~~
-!!! error TS4037: Parameter 'myPublicStaticMethod' of public property setter from exported class has or is using private name 'privateClass'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
             }
             private static set myPrivateStaticMethod(param: privateClass) {
             }
             set myPublicMethod(param: privateClass) { // Error
                                       ~~~~~~~~~~~~
-!!! error TS4037: Parameter 'myPublicMethod' of public property setter from exported class has or is using private name 'privateClass'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
             }
             private set myPrivateMethod(param: privateClass) {
             }
@@ -437,22 +459,22 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(380,35): error TS
         export class publicClassWithPrivateModuleGetAccessorTypes {
             static get myPublicStaticMethod(): privateModule.publicClass { // Error
                                                ~~~~~~~~~~~~~
-!!! error TS4040: Return type of public static property getter from exported class has or is using private name 'privateModule'.
+!!! error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateModule'.
                 return null;
             }
             get myPublicMethod(): privateModule.publicClass { // Error
                                   ~~~~~~~~~~~~~
-!!! error TS4043: Return type of public property getter from exported class has or is using private name 'privateModule'.
+!!! error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateModule'.
                 return null;
             }
             static get myPublicStaticMethod1() { // Error
                        ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4039: Return type of public static property getter from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'.
+!!! error TS4043: Return type of property getter 'myPublicStaticMethod1' references inaccessible name 'privateModule'.
                 return new privateModule.publicClass();
             }
             get myPublicMethod1() { // Error
                 ~~~~~~~~~~~~~~~
-!!! error TS4042: Return type of public property getter from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'.
+!!! error TS4043: Return type of property getter 'myPublicMethod1' references inaccessible name 'privateModule'.
                 return new privateModule.publicClass();
             }
         }
@@ -460,11 +482,11 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(380,35): error TS
         export class publicClassWithPrivateModuleSetAccessorTypes {
             static set myPublicStaticMethod(param: privateModule.publicClass) { // Error
                                                    ~~~~~~~~~~~~~
-!!! error TS4037: Parameter 'myPublicStaticMethod' of public property setter from exported class has or is using private name 'privateModule'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
             }
             set myPublicMethod(param: privateModule.publicClass) { // Error
                                       ~~~~~~~~~~~~~
-!!! error TS4037: Parameter 'myPublicMethod' of public property setter from exported class has or is using private name 'privateModule'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
             }
         }
     
@@ -499,24 +521,34 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(380,35): error TS
         }
         export class publicClassWithWithPrivateGetAccessorTypes {
             static get myPublicStaticMethod(): privateClass { 
+                                               ~~~~~~~~~~~~
+!!! error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateClass'.
+                                               ~~~~~~~~~~~~
+!!! error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateModule'.
                 return null;
             }
             private static get myPrivateStaticMethod(): privateClass {
                 return null;
             }
             get myPublicMethod(): privateClass { 
+                                  ~~~~~~~~~~~~
+!!! error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateClass'.
                 return null;
             }
             private get myPrivateMethod(): privateClass {
                 return null;
             }
             static get myPublicStaticMethod1() { 
+                       ~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4043: Return type of property getter 'myPublicStaticMethod1' references inaccessible name 'privateClass'.
                 return new privateClass();
             }
             private static get myPrivateStaticMethod1() {
                 return new privateClass();
             }
             get myPublicMethod1() { 
+                ~~~~~~~~~~~~~~~
+!!! error TS4043: Return type of property getter 'myPublicMethod1' references inaccessible name 'privateClass'.
                 return new privateClass();
             }
             private get myPrivateMethod1() {
@@ -607,10 +639,14 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(380,35): error TS
     
         export class publicClassWithWithPrivateSetAccessorTypes {
             static set myPublicStaticMethod(param: privateClass) { 
+                                                   ~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
             }
             private static set myPrivateStaticMethod(param: privateClass) {
             }
             set myPublicMethod(param: privateClass) { 
+                                      ~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
             }
             private set myPrivateMethod(param: privateClass) {
             }
@@ -651,9 +687,13 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(380,35): error TS
     
         export class publicClassWithPrivateModuleGetAccessorTypes {
             static get myPublicStaticMethod(): privateModule.publicClass { 
+                                               ~~~~~~~~~~~~~
+!!! error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateModule'.
                 return null;
             }
             get myPublicMethod(): privateModule.publicClass { 
+                                  ~~~~~~~~~~~~~
+!!! error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateModule'.
                 return null;
             }
             static get myPublicStaticMethod1() { 
@@ -666,8 +706,12 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(380,35): error TS
     
         export class publicClassWithPrivateModuleSetAccessorTypes {
             static set myPublicStaticMethod(param: privateModule.publicClass) { 
+                                                   ~~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
             }
             set myPublicMethod(param: privateModule.publicClass) { 
+                                      ~~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
             }
         }
     
@@ -694,7 +738,7 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(380,35): error TS
         }
     }
     
-==== tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts (12 errors) ====
+==== tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts (23 errors) ====
     class publicClassInGlobal {
     }
     
@@ -751,24 +795,34 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(380,35): error TS
             }
             export class publicClassWithWithPrivateGetAccessorTypes {
                 static get myPublicStaticMethod(): privateClass {
+                                                   ~~~~~~~~~~~~
+!!! error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateClass'.
+                                                   ~~~~~~~~~~~~
+!!! error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateModule'.
                     return null;
                 }
                 private static get myPrivateStaticMethod(): privateClass {
                     return null;
                 }
                 get myPublicMethod(): privateClass {
+                                      ~~~~~~~~~~~~
+!!! error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateClass'.
                     return null;
                 }
                 private get myPrivateMethod(): privateClass {
                     return null;
                 }
                 static get myPublicStaticMethod1() {
+                           ~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4043: Return type of property getter 'myPublicStaticMethod1' references inaccessible name 'privateClass'.
                     return new privateClass();
                 }
                 private static get myPrivateStaticMethod1() {
                     return new privateClass();
                 }
                 get myPublicMethod1() {
+                    ~~~~~~~~~~~~~~~
+!!! error TS4043: Return type of property getter 'myPublicMethod1' references inaccessible name 'privateClass'.
                     return new privateClass();
                 }
                 private get myPrivateMethod1() {
@@ -859,10 +913,14 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(380,35): error TS
     
             export class publicClassWithWithPrivateSetAccessorTypes {
                 static set myPublicStaticMethod(param: privateClass) {
+                                                       ~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
                 }
                 private static set myPrivateStaticMethod(param: privateClass) {
                 }
                 set myPublicMethod(param: privateClass) {
+                                          ~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
                 }
                 private set myPrivateMethod(param: privateClass) {
                 }
@@ -903,9 +961,13 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(380,35): error TS
     
             export class publicClassWithPrivateModuleGetAccessorTypes {
                 static get myPublicStaticMethod(): privateModule.publicClass {
+                                                   ~~~~~~~~~~~~~
+!!! error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateModule'.
                     return null;
                 }
                 get myPublicMethod(): privateModule.publicClass {
+                                      ~~~~~~~~~~~~~
+!!! error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateModule'.
                     return null;
                 }
                 static get myPublicStaticMethod1() {
@@ -918,8 +980,12 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(380,35): error TS
     
             export class publicClassWithPrivateModuleSetAccessorTypes {
                 static set myPublicStaticMethod(param: privateModule.publicClass) {
+                                                       ~~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
                 }
                 set myPublicMethod(param: privateModule.publicClass) {
+                                          ~~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
                 }
             }
     
@@ -949,7 +1015,7 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(380,35): error TS
         export class publicClassWithWithPrivateGetAccessorTypes {
             static get myPublicStaticMethod(): privateClass { // Error
                                                ~~~~~~~~~~~~
-!!! error TS4040: Return type of public static property getter from exported class has or is using private name 'privateClass'.
+!!! error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateClass'.
                 return null;
             }
             private static get myPrivateStaticMethod(): privateClass {
@@ -957,7 +1023,7 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(380,35): error TS
             }
             get myPublicMethod(): privateClass { // Error
                                   ~~~~~~~~~~~~
-!!! error TS4043: Return type of public property getter from exported class has or is using private name 'privateClass'.
+!!! error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateClass'.
                 return null;
             }
             private get myPrivateMethod(): privateClass {
@@ -965,7 +1031,7 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(380,35): error TS
             }
             static get myPublicStaticMethod1() { // Error
                        ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4040: Return type of public static property getter from exported class has or is using private name 'privateClass'.
+!!! error TS4043: Return type of property getter 'myPublicStaticMethod1' references inaccessible name 'privateClass'.
                 return new privateClass();
             }
             private static get myPrivateStaticMethod1() {
@@ -973,7 +1039,7 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(380,35): error TS
             }
             get myPublicMethod1() { // Error
                 ~~~~~~~~~~~~~~~
-!!! error TS4043: Return type of public property getter from exported class has or is using private name 'privateClass'.
+!!! error TS4043: Return type of property getter 'myPublicMethod1' references inaccessible name 'privateClass'.
                 return new privateClass();
             }
             private get myPrivateMethod1() {
@@ -1065,13 +1131,13 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(380,35): error TS
         export class publicClassWithWithPrivateSetAccessorTypes {
             static set myPublicStaticMethod(param: privateClass) { // Error
                                                    ~~~~~~~~~~~~
-!!! error TS4037: Parameter 'myPublicStaticMethod' of public property setter from exported class has or is using private name 'privateClass'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
             }
             private static set myPrivateStaticMethod(param: privateClass) {
             }
             set myPublicMethod(param: privateClass) { // Error
                                       ~~~~~~~~~~~~
-!!! error TS4037: Parameter 'myPublicMethod' of public property setter from exported class has or is using private name 'privateClass'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
             }
             private set myPrivateMethod(param: privateClass) {
             }
@@ -1113,22 +1179,22 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(380,35): error TS
         export class publicClassWithPrivateModuleGetAccessorTypes {
             static get myPublicStaticMethod(): privateModule.publicClass { // Error
                                                ~~~~~~~~~~~~~
-!!! error TS4040: Return type of public static property getter from exported class has or is using private name 'privateModule'.
+!!! error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateModule'.
                 return null;
             }
             get myPublicMethod(): privateModule.publicClass { // Error
                                   ~~~~~~~~~~~~~
-!!! error TS4043: Return type of public property getter from exported class has or is using private name 'privateModule'.
+!!! error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateModule'.
                 return null;
             }
             static get myPublicStaticMethod1() { // Error
                        ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4039: Return type of public static property getter from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'.
+!!! error TS4043: Return type of property getter 'myPublicStaticMethod1' references inaccessible name 'privateModule'.
                 return new privateModule.publicClass();
             }
             get myPublicMethod1() { // Error
                 ~~~~~~~~~~~~~~~
-!!! error TS4042: Return type of public property getter from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'.
+!!! error TS4043: Return type of property getter 'myPublicMethod1' references inaccessible name 'privateModule'.
                 return new privateModule.publicClass();
             }
         }
@@ -1136,11 +1202,11 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(380,35): error TS
         export class publicClassWithPrivateModuleSetAccessorTypes {
             static set myPublicStaticMethod(param: privateModule.publicClass) { // Error
                                                    ~~~~~~~~~~~~~
-!!! error TS4037: Parameter 'myPublicStaticMethod' of public property setter from exported class has or is using private name 'privateModule'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
             }
             set myPublicMethod(param: privateModule.publicClass) { // Error
                                       ~~~~~~~~~~~~~
-!!! error TS4037: Parameter 'myPublicMethod' of public property setter from exported class has or is using private name 'privateModule'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
             }
         }
     
diff --git a/tests/baselines/reference/privacyCheckTypeOfFunction.errors.txt b/tests/baselines/reference/privacyCheckTypeOfFunction.errors.txt
index 88801e06dfd97..d453bfdfc8674 100644
--- a/tests/baselines/reference/privacyCheckTypeOfFunction.errors.txt
+++ b/tests/baselines/reference/privacyCheckTypeOfFunction.errors.txt
@@ -1,5 +1,5 @@
-tests/cases/compiler/privacyCheckTypeOfFunction.ts(3,22): error TS4025: Exported variable 'x' has or is using private name 'foo'.
-tests/cases/compiler/privacyCheckTypeOfFunction.ts(4,12): error TS4025: Exported variable 'b' has or is using private name 'foo'.
+tests/cases/compiler/privacyCheckTypeOfFunction.ts(3,22): error TS4025: Type of variable 'x' references inaccessible name 'foo'.
+tests/cases/compiler/privacyCheckTypeOfFunction.ts(4,12): error TS4025: Type of variable 'b' references inaccessible name 'foo'.
 
 
 ==== tests/cases/compiler/privacyCheckTypeOfFunction.ts (2 errors) ====
@@ -7,8 +7,8 @@ tests/cases/compiler/privacyCheckTypeOfFunction.ts(4,12): error TS4025: Exported
     }
     export var x: typeof foo;
                          ~~~
-!!! error TS4025: Exported variable 'x' has or is using private name 'foo'.
+!!! error TS4025: Type of variable 'x' references inaccessible name 'foo'.
     export var b = foo;
                ~
-!!! error TS4025: Exported variable 'b' has or is using private name 'foo'.
+!!! error TS4025: Type of variable 'b' references inaccessible name 'foo'.
     
\ No newline at end of file
diff --git a/tests/baselines/reference/privacyCheckTypeOfInvisibleModuleError.errors.txt b/tests/baselines/reference/privacyCheckTypeOfInvisibleModuleError.errors.txt
index 360555b01875f..6c14517002876 100644
--- a/tests/baselines/reference/privacyCheckTypeOfInvisibleModuleError.errors.txt
+++ b/tests/baselines/reference/privacyCheckTypeOfInvisibleModuleError.errors.txt
@@ -1,5 +1,5 @@
-tests/cases/compiler/privacyCheckTypeOfInvisibleModuleError.ts(3,30): error TS4025: Exported variable 'm' has or is using private name 'Inner'.
-tests/cases/compiler/privacyCheckTypeOfInvisibleModuleError.ts(6,26): error TS4025: Exported variable 'f' has or is using private name 'Inner'.
+tests/cases/compiler/privacyCheckTypeOfInvisibleModuleError.ts(3,30): error TS4025: Type of variable 'm' references inaccessible name 'Inner'.
+tests/cases/compiler/privacyCheckTypeOfInvisibleModuleError.ts(6,26): error TS4025: Type of variable 'f' references inaccessible name 'Inner'.
 
 
 ==== tests/cases/compiler/privacyCheckTypeOfInvisibleModuleError.ts (2 errors) ====
@@ -7,11 +7,11 @@ tests/cases/compiler/privacyCheckTypeOfInvisibleModuleError.ts(6,26): error TS40
         module Inner {
             export var m: typeof Inner;
                                  ~~~~~
-!!! error TS4025: Exported variable 'm' has or is using private name 'Inner'.
+!!! error TS4025: Type of variable 'm' references inaccessible name 'Inner'.
         }
     
         export var f: typeof Inner;
                              ~~~~~
-!!! error TS4025: Exported variable 'f' has or is using private name 'Inner'.
+!!! error TS4025: Type of variable 'f' references inaccessible name 'Inner'.
     }
     
\ No newline at end of file
diff --git a/tests/baselines/reference/privacyCheckTypeOfInvisibleModuleNoError.errors.txt b/tests/baselines/reference/privacyCheckTypeOfInvisibleModuleNoError.errors.txt
index bbc8954cff10c..033268fa62edd 100644
--- a/tests/baselines/reference/privacyCheckTypeOfInvisibleModuleNoError.errors.txt
+++ b/tests/baselines/reference/privacyCheckTypeOfInvisibleModuleNoError.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/compiler/privacyCheckTypeOfInvisibleModuleNoError.ts(6,26): error TS4025: Exported variable 'f' has or is using private name 'Inner'.
+tests/cases/compiler/privacyCheckTypeOfInvisibleModuleNoError.ts(6,26): error TS4025: Type of variable 'f' references inaccessible name 'Inner'.
 
 
 ==== tests/cases/compiler/privacyCheckTypeOfInvisibleModuleNoError.ts (1 errors) ====
@@ -9,6 +9,6 @@ tests/cases/compiler/privacyCheckTypeOfInvisibleModuleNoError.ts(6,26): error TS
     
         export var f: typeof Inner; // Since we dont unwind inner any more, it is error here
                              ~~~~~
-!!! error TS4025: Exported variable 'f' has or is using private name 'Inner'.
+!!! error TS4025: Type of variable 'f' references inaccessible name 'Inner'.
     }
     
\ No newline at end of file
diff --git a/tests/baselines/reference/privacyClassExtendsClauseDeclFile.errors.txt b/tests/baselines/reference/privacyClassExtendsClauseDeclFile.errors.txt
index f3c21baed3ce9..dbc7a94ac7853 100644
--- a/tests/baselines/reference/privacyClassExtendsClauseDeclFile.errors.txt
+++ b/tests/baselines/reference/privacyClassExtendsClauseDeclFile.errors.txt
@@ -1,11 +1,14 @@
-tests/cases/compiler/privacyClassExtendsClauseDeclFile_GlobalFile.ts(16,67): error TS4020: Extends clause of exported class 'publicClassExtendingPrivateClassInModule' has or is using private name 'privateClassInPublicModule'.
-tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(17,67): error TS4020: Extends clause of exported class 'publicClassExtendingPrivateClassInModule' has or is using private name 'privateClassInPublicModule'.
-tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(22,69): error TS4020: Extends clause of exported class 'publicClassExtendingFromPrivateModuleClass' has or is using private name 'privateModule'.
-tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(64,55): error TS4020: Extends clause of exported class 'publicClassExtendingPrivateClass' has or is using private name 'privateClass'.
-tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(69,65): error TS4020: Extends clause of exported class 'publicClassExtendingFromPrivateModuleClass' has or is using private name 'privateModule'.
+tests/cases/compiler/privacyClassExtendsClauseDeclFile_GlobalFile.ts(16,67): error TS4020: Extends clause references inaccessible name 'privateClassInPublicModule'.
+tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(17,67): error TS4020: Extends clause references inaccessible name 'privateClassInPublicModule'.
+tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(22,69): error TS4020: Extends clause references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(41,67): error TS4020: Extends clause references inaccessible name 'privateClassInPrivateModule'.
+tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(41,67): error TS4020: Extends clause references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(46,69): error TS4020: Extends clause references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(64,55): error TS4020: Extends clause references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(69,65): error TS4020: Extends clause references inaccessible name 'privateModule'.
 
 
-==== tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts (4 errors) ====
+==== tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts (7 errors) ====
     
     export module publicModule {
         export class publicClassInPublicModule {
@@ -24,14 +27,14 @@ tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(69,65):
         }
         export class publicClassExtendingPrivateClassInModule extends privateClassInPublicModule { // Should error
                                                                       ~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4020: Extends clause of exported class 'publicClassExtendingPrivateClassInModule' has or is using private name 'privateClassInPublicModule'.
+!!! error TS4020: Extends clause references inaccessible name 'privateClassInPublicModule'.
         }
     
         class privateClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule {
         }
         export class publicClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule { // Should error
                                                                         ~~~~~~~~~~~~~
-!!! error TS4020: Extends clause of exported class 'publicClassExtendingFromPrivateModuleClass' has or is using private name 'privateModule'.
+!!! error TS4020: Extends clause references inaccessible name 'privateModule'.
         }
     }
     
@@ -51,11 +54,17 @@ tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(69,65):
         export class publicClassExtendingPublicClassInModule extends publicClassInPrivateModule {
         }
         export class publicClassExtendingPrivateClassInModule extends privateClassInPrivateModule { 
+                                                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4020: Extends clause references inaccessible name 'privateClassInPrivateModule'.
+                                                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4020: Extends clause references inaccessible name 'privateModule'.
         }
     
         class privateClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule {
         }
         export class publicClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule {
+                                                                        ~~~~~~~~~~~~~
+!!! error TS4020: Extends clause references inaccessible name 'privateModule'.
         }
     }
     
@@ -75,14 +84,14 @@ tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(69,65):
     }
     export class publicClassExtendingPrivateClass extends privateClass { // Should error
                                                           ~~~~~~~~~~~~
-!!! error TS4020: Extends clause of exported class 'publicClassExtendingPrivateClass' has or is using private name 'privateClass'.
+!!! error TS4020: Extends clause references inaccessible name 'privateClass'.
     }
     
     class privateClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule {
     }
     export class publicClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule { // Should error
                                                                     ~~~~~~~~~~~~~
-!!! error TS4020: Extends clause of exported class 'publicClassExtendingFromPrivateModuleClass' has or is using private name 'privateModule'.
+!!! error TS4020: Extends clause references inaccessible name 'privateModule'.
     }
     
 ==== tests/cases/compiler/privacyClassExtendsClauseDeclFile_GlobalFile.ts (1 errors) ====
@@ -103,7 +112,7 @@ tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(69,65):
         }
         export class publicClassExtendingPrivateClassInModule extends privateClassInPublicModule { // Should error
                                                                       ~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4020: Extends clause of exported class 'publicClassExtendingPrivateClassInModule' has or is using private name 'privateClassInPublicModule'.
+!!! error TS4020: Extends clause references inaccessible name 'privateClassInPublicModule'.
         }
     }
     class publicClassInGlobal {
diff --git a/tests/baselines/reference/privacyClassImplementsClauseDeclFile.errors.txt b/tests/baselines/reference/privacyClassImplementsClauseDeclFile.errors.txt
index 2681ee0e20e4f..4e8355aba0187 100644
--- a/tests/baselines/reference/privacyClassImplementsClauseDeclFile.errors.txt
+++ b/tests/baselines/reference/privacyClassImplementsClauseDeclFile.errors.txt
@@ -1,12 +1,15 @@
-tests/cases/compiler/privacyClassImplementsClauseDeclFile_GlobalFile.ts(14,77): error TS4019: Implements clause of exported class 'publicClassImplementingPrivateInterfaceInModule' has or is using private name 'privateInterfaceInPublicModule'.
-tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(15,77): error TS4019: Implements clause of exported class 'publicClassImplementingPrivateInterfaceInModule' has or is using private name 'privateInterfaceInPublicModule'.
-tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(20,79): error TS4019: Implements clause of exported class 'publicClassImplementingFromPrivateModuleInterface' has or is using private name 'privateModule'.
-tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(23,78): error TS4019: Implements clause of exported class 'publicClassImplementingPrivateAndPublicInterface' has or is using private name 'privateInterfaceInPublicModule'.
-tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(63,65): error TS4019: Implements clause of exported class 'publicClassImplementingPrivateInterface' has or is using private name 'privateInterface'.
-tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(68,75): error TS4019: Implements clause of exported class 'publicClassImplementingFromPrivateModuleInterface' has or is using private name 'privateModule'.
+tests/cases/compiler/privacyClassImplementsClauseDeclFile_GlobalFile.ts(14,77): error TS4019: Implements clause references inaccessible name 'privateInterfaceInPublicModule'.
+tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(15,77): error TS4019: Implements clause references inaccessible name 'privateInterfaceInPublicModule'.
+tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(20,79): error TS4019: Implements clause references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(23,78): error TS4019: Implements clause references inaccessible name 'privateInterfaceInPublicModule'.
+tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(41,77): error TS4019: Implements clause references inaccessible name 'privateInterfaceInPrivateModule'.
+tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(41,77): error TS4019: Implements clause references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(46,79): error TS4019: Implements clause references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(63,65): error TS4019: Implements clause references inaccessible name 'privateInterface'.
+tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(68,75): error TS4019: Implements clause references inaccessible name 'privateModule'.
 
 
-==== tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts (5 errors) ====
+==== tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts (8 errors) ====
     
     export module publicModule {
         export interface publicInterfaceInPublicModule {
@@ -23,19 +26,19 @@ tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(68,7
         }
         export class publicClassImplementingPrivateInterfaceInModule implements privateInterfaceInPublicModule { // Should error
                                                                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4019: Implements clause of exported class 'publicClassImplementingPrivateInterfaceInModule' has or is using private name 'privateInterfaceInPublicModule'.
+!!! error TS4019: Implements clause references inaccessible name 'privateInterfaceInPublicModule'.
         }
     
         class privateClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule {
         }
         export class publicClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule { // Should error
                                                                                   ~~~~~~~~~~~~~
-!!! error TS4019: Implements clause of exported class 'publicClassImplementingFromPrivateModuleInterface' has or is using private name 'privateModule'.
+!!! error TS4019: Implements clause references inaccessible name 'privateModule'.
         }
     
         export class publicClassImplementingPrivateAndPublicInterface implements privateInterfaceInPublicModule, publicInterfaceInPublicModule { // Should error
                                                                                  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4019: Implements clause of exported class 'publicClassImplementingPrivateAndPublicInterface' has or is using private name 'privateInterfaceInPublicModule'.
+!!! error TS4019: Implements clause references inaccessible name 'privateInterfaceInPublicModule'.
         }
     }
     
@@ -54,11 +57,17 @@ tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(68,7
         export class publicClassImplementingPublicInterfaceInModule implements publicInterfaceInPrivateModule {
         }
         export class publicClassImplementingPrivateInterfaceInModule implements privateInterfaceInPrivateModule { 
+                                                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4019: Implements clause references inaccessible name 'privateInterfaceInPrivateModule'.
+                                                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4019: Implements clause references inaccessible name 'privateModule'.
         }
     
         class privateClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule {
         }
         export class publicClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule {
+                                                                                  ~~~~~~~~~~~~~
+!!! error TS4019: Implements clause references inaccessible name 'privateModule'.
         }
     }
     
@@ -77,14 +86,14 @@ tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(68,7
     }
     export class publicClassImplementingPrivateInterface implements privateInterface { // Should error
                                                                     ~~~~~~~~~~~~~~~~
-!!! error TS4019: Implements clause of exported class 'publicClassImplementingPrivateInterface' has or is using private name 'privateInterface'.
+!!! error TS4019: Implements clause references inaccessible name 'privateInterface'.
     }
     
     class privateClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule {
     }
     export class publicClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule { // Should error
                                                                               ~~~~~~~~~~~~~
-!!! error TS4019: Implements clause of exported class 'publicClassImplementingFromPrivateModuleInterface' has or is using private name 'privateModule'.
+!!! error TS4019: Implements clause references inaccessible name 'privateModule'.
     }
     
 ==== tests/cases/compiler/privacyClassImplementsClauseDeclFile_GlobalFile.ts (1 errors) ====
@@ -103,7 +112,7 @@ tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(68,7
         }
         export class publicClassImplementingPrivateInterfaceInModule implements privateInterfaceInPublicModule { // Should error
                                                                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4019: Implements clause of exported class 'publicClassImplementingPrivateInterfaceInModule' has or is using private name 'privateInterfaceInPublicModule'.
+!!! error TS4019: Implements clause references inaccessible name 'privateInterfaceInPublicModule'.
         }
     }
     interface publicInterfaceInGlobal {
diff --git a/tests/baselines/reference/privacyFunctionParameterDeclFile.errors.txt b/tests/baselines/reference/privacyFunctionParameterDeclFile.errors.txt
index 0e88e08e645ae..56312953a5763 100644
--- a/tests/baselines/reference/privacyFunctionParameterDeclFile.errors.txt
+++ b/tests/baselines/reference/privacyFunctionParameterDeclFile.errors.txt
@@ -1,66 +1,108 @@
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(164,21): error TS4065: Parameter 'param' of constructor signature from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(165,17): error TS4067: Parameter 'param' of call signature from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(166,25): error TS4075: Parameter 'param' of method from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(188,44): error TS4070: Parameter 'param' of public static method from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(192,31): error TS4073: Parameter 'param' of public method from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(196,28): error TS4063: Parameter 'param' of constructor from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(196,58): error TS4063: Parameter 'param1' of constructor from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(196,87): error TS4063: Parameter 'param2' of constructor from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(239,67): error TS4078: Parameter 'param' of exported function has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(248,82): error TS4078: Parameter 'param' of exported function has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(254,21): error TS4065: Parameter 'param' of constructor signature from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(255,17): error TS4067: Parameter 'param' of call signature from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(256,25): error TS4075: Parameter 'param' of method from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(259,44): error TS4070: Parameter 'param' of public static method from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(261,31): error TS4073: Parameter 'param' of public method from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(263,28): error TS4063: Parameter 'param' of constructor from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(263,71): error TS4063: Parameter 'param1' of constructor from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(263,113): error TS4063: Parameter 'param2' of constructor from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(266,74): error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(268,89): error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(9,17): error TS4065: Parameter 'param' of constructor signature from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(10,13): error TS4067: Parameter 'param' of call signature from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(11,21): error TS4075: Parameter 'param' of method from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(33,40): error TS4070: Parameter 'param' of public static method from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(37,27): error TS4073: Parameter 'param' of public method from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(41,24): error TS4063: Parameter 'param' of constructor from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(41,54): error TS4063: Parameter 'param1' of constructor from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(41,83): error TS4063: Parameter 'param2' of constructor from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(84,63): error TS4078: Parameter 'param' of exported function has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(93,78): error TS4078: Parameter 'param' of exported function has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(99,17): error TS4065: Parameter 'param' of constructor signature from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(100,13): error TS4067: Parameter 'param' of call signature from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(101,21): error TS4075: Parameter 'param' of method from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(104,40): error TS4070: Parameter 'param' of public static method from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(106,27): error TS4073: Parameter 'param' of public method from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(108,24): error TS4063: Parameter 'param' of constructor from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(108,67): error TS4063: Parameter 'param1' of constructor from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(108,109): error TS4063: Parameter 'param2' of constructor from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(111,70): error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(113,85): error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(141,21): error TS4065: Parameter 'param' of constructor signature from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(142,17): error TS4067: Parameter 'param' of call signature from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(143,25): error TS4075: Parameter 'param' of method from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(165,44): error TS4070: Parameter 'param' of public static method from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(169,31): error TS4073: Parameter 'param' of public method from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(173,28): error TS4063: Parameter 'param' of constructor from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(173,58): error TS4063: Parameter 'param1' of constructor from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(173,87): error TS4063: Parameter 'param2' of constructor from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(216,67): error TS4078: Parameter 'param' of exported function has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(225,82): error TS4078: Parameter 'param' of exported function has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(231,21): error TS4065: Parameter 'param' of constructor signature from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(232,17): error TS4067: Parameter 'param' of call signature from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(233,25): error TS4075: Parameter 'param' of method from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(236,44): error TS4070: Parameter 'param' of public static method from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(238,31): error TS4073: Parameter 'param' of public method from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(240,28): error TS4063: Parameter 'param' of constructor from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(240,71): error TS4063: Parameter 'param1' of constructor from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(240,113): error TS4063: Parameter 'param2' of constructor from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(243,74): error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(245,89): error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(39,25): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(39,25): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(40,21): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(41,29): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(63,48): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(67,35): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(71,32): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(71,62): error TS4028: Type of parameter 'param1' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(71,91): error TS4028: Type of parameter 'param2' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(114,71): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(123,86): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(129,25): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(130,21): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(131,29): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(134,48): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(136,35): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(138,32): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(138,75): error TS4028: Type of parameter 'param1' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(138,117): error TS4028: Type of parameter 'param2' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(141,78): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(143,93): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(164,21): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(165,17): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(166,25): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(188,44): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(192,31): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(196,28): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(196,58): error TS4028: Type of parameter 'param1' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(196,87): error TS4028: Type of parameter 'param2' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(239,67): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(248,82): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(254,21): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(255,17): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(256,25): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(259,44): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(261,31): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(263,28): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(263,71): error TS4028: Type of parameter 'param1' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(263,113): error TS4028: Type of parameter 'param2' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(266,74): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(268,89): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(9,17): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(10,13): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(11,21): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(33,40): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(37,27): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(41,24): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(41,54): error TS4028: Type of parameter 'param1' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(41,83): error TS4028: Type of parameter 'param2' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(84,63): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(93,78): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(99,17): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(100,13): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(101,21): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(104,40): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(106,27): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(108,24): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(108,67): error TS4028: Type of parameter 'param1' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(108,109): error TS4028: Type of parameter 'param2' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(111,70): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(113,85): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(141,21): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(142,17): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(143,25): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(165,44): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(169,31): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(173,28): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(173,58): error TS4028: Type of parameter 'param1' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(173,87): error TS4028: Type of parameter 'param2' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(216,67): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(225,82): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(231,21): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(232,17): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(233,25): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(236,44): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(238,31): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(240,28): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(240,71): error TS4028: Type of parameter 'param1' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(240,113): error TS4028: Type of parameter 'param2' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(243,74): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(245,89): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(274,21): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(274,21): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(275,17): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(276,25): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(298,44): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(302,31): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(306,28): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(306,58): error TS4028: Type of parameter 'param1' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(306,87): error TS4028: Type of parameter 'param2' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(349,67): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(358,82): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(364,21): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(365,17): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(366,25): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(369,44): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(371,31): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(373,28): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(373,71): error TS4028: Type of parameter 'param1' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(373,113): error TS4028: Type of parameter 'param2' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(376,74): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
 
 
-==== tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts (40 errors) ====
+==== tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts (61 errors) ====
     
     class privateClass {
     }
@@ -71,13 +113,13 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(245,89):
     export interface publicInterfaceWithPrivateParmeterTypes {
         new (param: privateClass): publicClass; // Error
                     ~~~~~~~~~~~~
-!!! error TS4065: Parameter 'param' of constructor signature from exported interface has or is using private name 'privateClass'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
         (param: privateClass): publicClass; // Error
                 ~~~~~~~~~~~~
-!!! error TS4067: Parameter 'param' of call signature from exported interface has or is using private name 'privateClass'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
         myMethod(param: privateClass): void; // Error
                         ~~~~~~~~~~~~
-!!! error TS4075: Parameter 'param' of method from exported interface has or is using private name 'privateClass'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
     }
     
     export interface publicInterfaceWithPublicParmeterTypes {
@@ -101,23 +143,23 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(245,89):
     export class publicClassWithWithPrivateParmeterTypes {
         static myPublicStaticMethod(param: privateClass) { // Error
                                            ~~~~~~~~~~~~
-!!! error TS4070: Parameter 'param' of public static method from exported class has or is using private name 'privateClass'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
         }
         private static myPrivateStaticMethod(param: privateClass) {
         }
         myPublicMethod(param: privateClass) { // Error
                               ~~~~~~~~~~~~
-!!! error TS4073: Parameter 'param' of public method from exported class has or is using private name 'privateClass'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
         }
         private myPrivateMethod(param: privateClass) {
         }
         constructor(param: privateClass, private param1: privateClass, public param2: privateClass) { // Error
                            ~~~~~~~~~~~~
-!!! error TS4063: Parameter 'param' of constructor from exported class has or is using private name 'privateClass'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
                                                          ~~~~~~~~~~~~
-!!! error TS4063: Parameter 'param1' of constructor from exported class has or is using private name 'privateClass'.
+!!! error TS4028: Type of parameter 'param1' references inaccessible name 'privateClass'.
                                                                                       ~~~~~~~~~~~~
-!!! error TS4063: Parameter 'param2' of constructor from exported class has or is using private name 'privateClass'.
+!!! error TS4028: Type of parameter 'param2' references inaccessible name 'privateClass'.
         }
     }
     
@@ -162,7 +204,7 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(245,89):
     
     export function publicFunctionWithPrivateParmeterTypes(param: privateClass) { // Error
                                                                   ~~~~~~~~~~~~
-!!! error TS4078: Parameter 'param' of exported function has or is using private name 'privateClass'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
     }
     export function publicFunctionWithPublicParmeterTypes(param: publicClass) {
     }
@@ -173,7 +215,7 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(245,89):
     
     export declare function publicAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void; // Error
                                                                                  ~~~~~~~~~~~~
-!!! error TS4078: Parameter 'param' of exported function has or is using private name 'privateClass'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
     export declare function publicAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
     declare function privateAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void;
     declare function privateAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
@@ -181,39 +223,39 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(245,89):
     export interface publicInterfaceWithPrivateModuleParameterTypes {
         new (param: privateModule.publicClass): publicClass; // Error
                     ~~~~~~~~~~~~~
-!!! error TS4065: Parameter 'param' of constructor signature from exported interface has or is using private name 'privateModule'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
         (param: privateModule.publicClass): publicClass; // Error
                 ~~~~~~~~~~~~~
-!!! error TS4067: Parameter 'param' of call signature from exported interface has or is using private name 'privateModule'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
         myMethod(param: privateModule.publicClass): void; // Error
                         ~~~~~~~~~~~~~
-!!! error TS4075: Parameter 'param' of method from exported interface has or is using private name 'privateModule'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
     }
     export class publicClassWithPrivateModuleParameterTypes {
         static myPublicStaticMethod(param: privateModule.publicClass) { // Error
                                            ~~~~~~~~~~~~~
-!!! error TS4070: Parameter 'param' of public static method from exported class has or is using private name 'privateModule'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
         }
         myPublicMethod(param: privateModule.publicClass) { // Error
                               ~~~~~~~~~~~~~
-!!! error TS4073: Parameter 'param' of public method from exported class has or is using private name 'privateModule'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
         }
         constructor(param: privateModule.publicClass, private param1: privateModule.publicClass, public param2: privateModule.publicClass) { // Error
                            ~~~~~~~~~~~~~
-!!! error TS4063: Parameter 'param' of constructor from exported class has or is using private name 'privateModule'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
                                                                       ~~~~~~~~~~~~~
-!!! error TS4063: Parameter 'param1' of constructor from exported class has or is using private name 'privateModule'.
+!!! error TS4028: Type of parameter 'param1' references inaccessible name 'privateModule'.
                                                                                                                 ~~~~~~~~~~~~~
-!!! error TS4063: Parameter 'param2' of constructor from exported class has or is using private name 'privateModule'.
+!!! error TS4028: Type of parameter 'param2' references inaccessible name 'privateModule'.
         }
     }
     export function publicFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass) { // Error
                                                                          ~~~~~~~~~~~~~
-!!! error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
     }
     export declare function publicAmbientFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass): void; // Error
                                                                                         ~~~~~~~~~~~~~
-!!! error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
     
     interface privateInterfaceWithPrivateModuleParameterTypes {
         new (param: privateModule.publicClass): publicClass;
@@ -243,13 +285,13 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(245,89):
         export interface publicInterfaceWithPrivateParmeterTypes {
             new (param: privateClass): publicClass; // Error
                         ~~~~~~~~~~~~
-!!! error TS4065: Parameter 'param' of constructor signature from exported interface has or is using private name 'privateClass'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
             (param: privateClass): publicClass; // Error
                     ~~~~~~~~~~~~
-!!! error TS4067: Parameter 'param' of call signature from exported interface has or is using private name 'privateClass'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
             myMethod(param: privateClass): void; // Error
                             ~~~~~~~~~~~~
-!!! error TS4075: Parameter 'param' of method from exported interface has or is using private name 'privateClass'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
         }
     
         export interface publicInterfaceWithPublicParmeterTypes {
@@ -273,23 +315,23 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(245,89):
         export class publicClassWithWithPrivateParmeterTypes {
             static myPublicStaticMethod(param: privateClass) { // Error
                                                ~~~~~~~~~~~~
-!!! error TS4070: Parameter 'param' of public static method from exported class has or is using private name 'privateClass'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
             }
             private static myPrivateStaticMethod(param: privateClass) {
             }
             myPublicMethod(param: privateClass) { // Error
                                   ~~~~~~~~~~~~
-!!! error TS4073: Parameter 'param' of public method from exported class has or is using private name 'privateClass'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
             }
             private myPrivateMethod(param: privateClass) {
             }
             constructor(param: privateClass, private param1: privateClass, public param2: privateClass) { // Error
                                ~~~~~~~~~~~~
-!!! error TS4063: Parameter 'param' of constructor from exported class has or is using private name 'privateClass'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
                                                              ~~~~~~~~~~~~
-!!! error TS4063: Parameter 'param1' of constructor from exported class has or is using private name 'privateClass'.
+!!! error TS4028: Type of parameter 'param1' references inaccessible name 'privateClass'.
                                                                                           ~~~~~~~~~~~~
-!!! error TS4063: Parameter 'param2' of constructor from exported class has or is using private name 'privateClass'.
+!!! error TS4028: Type of parameter 'param2' references inaccessible name 'privateClass'.
             }
         }
     
@@ -334,7 +376,7 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(245,89):
     
         export function publicFunctionWithPrivateParmeterTypes(param: privateClass) { // Error
                                                                       ~~~~~~~~~~~~
-!!! error TS4078: Parameter 'param' of exported function has or is using private name 'privateClass'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
         }
         export function publicFunctionWithPublicParmeterTypes(param: publicClass) {
         }
@@ -345,7 +387,7 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(245,89):
     
         export declare function publicAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void; // Error
                                                                                      ~~~~~~~~~~~~
-!!! error TS4078: Parameter 'param' of exported function has or is using private name 'privateClass'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
         export declare function publicAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
         declare function privateAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void;
         declare function privateAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
@@ -353,39 +395,39 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(245,89):
         export interface publicInterfaceWithPrivateModuleParameterTypes {
             new (param: privateModule.publicClass): publicClass; // Error
                         ~~~~~~~~~~~~~
-!!! error TS4065: Parameter 'param' of constructor signature from exported interface has or is using private name 'privateModule'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
             (param: privateModule.publicClass): publicClass; // Error
                     ~~~~~~~~~~~~~
-!!! error TS4067: Parameter 'param' of call signature from exported interface has or is using private name 'privateModule'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
             myMethod(param: privateModule.publicClass): void; // Error
                             ~~~~~~~~~~~~~
-!!! error TS4075: Parameter 'param' of method from exported interface has or is using private name 'privateModule'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
         }
         export class publicClassWithPrivateModuleParameterTypes {
             static myPublicStaticMethod(param: privateModule.publicClass) { // Error
                                                ~~~~~~~~~~~~~
-!!! error TS4070: Parameter 'param' of public static method from exported class has or is using private name 'privateModule'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
             }
             myPublicMethod(param: privateModule.publicClass) { // Error
                                   ~~~~~~~~~~~~~
-!!! error TS4073: Parameter 'param' of public method from exported class has or is using private name 'privateModule'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
             }
             constructor(param: privateModule.publicClass, private param1: privateModule.publicClass, public param2: privateModule.publicClass) { // Error
                                ~~~~~~~~~~~~~
-!!! error TS4063: Parameter 'param' of constructor from exported class has or is using private name 'privateModule'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
                                                                           ~~~~~~~~~~~~~
-!!! error TS4063: Parameter 'param1' of constructor from exported class has or is using private name 'privateModule'.
+!!! error TS4028: Type of parameter 'param1' references inaccessible name 'privateModule'.
                                                                                                                     ~~~~~~~~~~~~~
-!!! error TS4063: Parameter 'param2' of constructor from exported class has or is using private name 'privateModule'.
+!!! error TS4028: Type of parameter 'param2' references inaccessible name 'privateModule'.
             }
         }
         export function publicFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass) { // Error
                                                                              ~~~~~~~~~~~~~
-!!! error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
         }
         export declare function publicAmbientFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass): void; // Error
                                                                                             ~~~~~~~~~~~~~
-!!! error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
     
         interface privateInterfaceWithPrivateModuleParameterTypes {
             new (param: privateModule.publicClass): publicClass;
@@ -415,8 +457,16 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(245,89):
     
         export interface publicInterfaceWithPrivateParmeterTypes {
             new (param: privateClass): publicClass;
+                        ~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+                        ~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
             (param: privateClass): publicClass;
+                    ~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
             myMethod(param: privateClass): void;
+                            ~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
         }
     
         export interface publicInterfaceWithPublicParmeterTypes {
@@ -439,14 +489,24 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(245,89):
     
         export class publicClassWithWithPrivateParmeterTypes {
             static myPublicStaticMethod(param: privateClass) {
+                                               ~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
             }
             private static myPrivateStaticMethod(param: privateClass) {
             }
             myPublicMethod(param: privateClass) {
+                                  ~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
             }
             private myPrivateMethod(param: privateClass) {
             }
             constructor(param: privateClass, private param1: privateClass, public param2: privateClass) {
+                               ~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+                                                             ~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param1' references inaccessible name 'privateClass'.
+                                                                                          ~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param2' references inaccessible name 'privateClass'.
             }
         }
     
@@ -490,6 +550,8 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(245,89):
         }
     
         export function publicFunctionWithPrivateParmeterTypes(param: privateClass) {
+                                                                      ~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
         }
         export function publicFunctionWithPublicParmeterTypes(param: publicClass) {
         }
@@ -499,26 +561,48 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(245,89):
         }
     
         export declare function publicAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void;
+                                                                                     ~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
         export declare function publicAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
         declare function privateAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void;
         declare function privateAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
     
         export interface publicInterfaceWithPrivateModuleParameterTypes {
             new (param: privateModule.publicClass): publicClass;
+                        ~~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
             (param: privateModule.publicClass): publicClass;
+                    ~~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
             myMethod(param: privateModule.publicClass): void;
+                            ~~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
         }
         export class publicClassWithPrivateModuleParameterTypes {
             static myPublicStaticMethod(param: privateModule.publicClass) {
+                                               ~~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
             }
             myPublicMethod(param: privateModule.publicClass) {
+                                  ~~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
             }
             constructor(param: privateModule.publicClass, private param1: privateModule.publicClass, public param2: privateModule.publicClass) {
+                               ~~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+                                                                          ~~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param1' references inaccessible name 'privateModule'.
+                                                                                                                    ~~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param2' references inaccessible name 'privateModule'.
             }
         }
         export function publicFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass) {
+                                                                             ~~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
         }
         export declare function publicAmbientFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass): void;
+                                                                                            ~~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
     
         interface privateInterfaceWithPrivateModuleParameterTypes {
             new (param: privateModule.publicClass): publicClass;
@@ -538,7 +622,7 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(245,89):
         declare function privateAmbientFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass): void;
     }
     
-==== tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts (20 errors) ====
+==== tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts (41 errors) ====
     class publicClassInGlobal {
     }
     interface publicInterfaceWithPublicParmeterTypesInGlobal {
@@ -578,8 +662,16 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(245,89):
     
             export interface publicInterfaceWithPrivateParmeterTypes {
                 new (param: privateClass): publicClass;
+                            ~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+                            ~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
                 (param: privateClass): publicClass;
+                        ~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
                 myMethod(param: privateClass): void;
+                                ~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
             }
     
             export interface publicInterfaceWithPublicParmeterTypes {
@@ -602,14 +694,24 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(245,89):
     
             export class publicClassWithWithPrivateParmeterTypes {
                 static myPublicStaticMethod(param: privateClass) {
+                                                   ~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
                 }
                 private static myPrivateStaticMethod(param: privateClass) {
                 }
                 myPublicMethod(param: privateClass) {
+                                      ~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
                 }
                 private myPrivateMethod(param: privateClass) {
                 }
                 constructor(param: privateClass, private param1: privateClass, public param2: privateClass) {
+                                   ~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+                                                                 ~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param1' references inaccessible name 'privateClass'.
+                                                                                              ~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param2' references inaccessible name 'privateClass'.
                 }
             }
     
@@ -653,6 +755,8 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(245,89):
             }
     
             export function publicFunctionWithPrivateParmeterTypes(param: privateClass) {
+                                                                          ~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
             }
             export function publicFunctionWithPublicParmeterTypes(param: publicClass) {
             }
@@ -662,26 +766,48 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(245,89):
             }
     
             export declare function publicAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void;
+                                                                                         ~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
             export declare function publicAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
             declare function privateAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void;
             declare function privateAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
     
             export interface publicInterfaceWithPrivateModuleParameterTypes {
                 new (param: privateModule.publicClass): publicClass;
+                            ~~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
                 (param: privateModule.publicClass): publicClass;
+                        ~~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
                 myMethod(param: privateModule.publicClass): void;
+                                ~~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
             }
             export class publicClassWithPrivateModuleParameterTypes {
                 static myPublicStaticMethod(param: privateModule.publicClass) {
+                                                   ~~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
                 }
                 myPublicMethod(param: privateModule.publicClass) {
+                                      ~~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
                 }
                 constructor(param: privateModule.publicClass, private param1: privateModule.publicClass, public param2: privateModule.publicClass) {
+                                   ~~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+                                                                              ~~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param1' references inaccessible name 'privateModule'.
+                                                                                                                        ~~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param2' references inaccessible name 'privateModule'.
                 }
             }
             export function publicFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass) {
+                                                                                 ~~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
             }
             export declare function publicAmbientFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass): void;
+                                                                                                ~~~~~~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
     
             interface privateInterfaceWithPrivateModuleParameterTypes {
                 new (param: privateModule.publicClass): publicClass;
@@ -704,13 +830,13 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(245,89):
         export interface publicInterfaceWithPrivateParmeterTypes {
             new (param: privateClass): publicClass; // Error
                         ~~~~~~~~~~~~
-!!! error TS4065: Parameter 'param' of constructor signature from exported interface has or is using private name 'privateClass'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
             (param: privateClass): publicClass; // Error
                     ~~~~~~~~~~~~
-!!! error TS4067: Parameter 'param' of call signature from exported interface has or is using private name 'privateClass'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
             myMethod(param: privateClass): void; // Error
                             ~~~~~~~~~~~~
-!!! error TS4075: Parameter 'param' of method from exported interface has or is using private name 'privateClass'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
         }
     
         export interface publicInterfaceWithPublicParmeterTypes {
@@ -734,23 +860,23 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(245,89):
         export class publicClassWithWithPrivateParmeterTypes {
             static myPublicStaticMethod(param: privateClass) { // Error
                                                ~~~~~~~~~~~~
-!!! error TS4070: Parameter 'param' of public static method from exported class has or is using private name 'privateClass'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
             }
             private static myPrivateStaticMethod(param: privateClass) {
             }
             myPublicMethod(param: privateClass) { // Error
                                   ~~~~~~~~~~~~
-!!! error TS4073: Parameter 'param' of public method from exported class has or is using private name 'privateClass'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
             }
             private myPrivateMethod(param: privateClass) {
             }
             constructor(param: privateClass, private param1: privateClass, public param2: privateClass) { // Error
                                ~~~~~~~~~~~~
-!!! error TS4063: Parameter 'param' of constructor from exported class has or is using private name 'privateClass'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
                                                              ~~~~~~~~~~~~
-!!! error TS4063: Parameter 'param1' of constructor from exported class has or is using private name 'privateClass'.
+!!! error TS4028: Type of parameter 'param1' references inaccessible name 'privateClass'.
                                                                                           ~~~~~~~~~~~~
-!!! error TS4063: Parameter 'param2' of constructor from exported class has or is using private name 'privateClass'.
+!!! error TS4028: Type of parameter 'param2' references inaccessible name 'privateClass'.
             }
         }
     
@@ -795,7 +921,7 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(245,89):
     
         export function publicFunctionWithPrivateParmeterTypes(param: privateClass) { // Error
                                                                       ~~~~~~~~~~~~
-!!! error TS4078: Parameter 'param' of exported function has or is using private name 'privateClass'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
         }
         export function publicFunctionWithPublicParmeterTypes(param: publicClass) {
         }
@@ -806,7 +932,7 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(245,89):
     
         export declare function publicAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void; // Error
                                                                                      ~~~~~~~~~~~~
-!!! error TS4078: Parameter 'param' of exported function has or is using private name 'privateClass'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
         export declare function publicAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
         declare function privateAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void;
         declare function privateAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
@@ -814,39 +940,39 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(245,89):
         export interface publicInterfaceWithPrivateModuleParameterTypes {
             new (param: privateModule.publicClass): publicClass; // Error
                         ~~~~~~~~~~~~~
-!!! error TS4065: Parameter 'param' of constructor signature from exported interface has or is using private name 'privateModule'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
             (param: privateModule.publicClass): publicClass; // Error
                     ~~~~~~~~~~~~~
-!!! error TS4067: Parameter 'param' of call signature from exported interface has or is using private name 'privateModule'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
             myMethod(param: privateModule.publicClass): void; // Error
                             ~~~~~~~~~~~~~
-!!! error TS4075: Parameter 'param' of method from exported interface has or is using private name 'privateModule'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
         }
         export class publicClassWithPrivateModuleParameterTypes {
             static myPublicStaticMethod(param: privateModule.publicClass) { // Error
                                                ~~~~~~~~~~~~~
-!!! error TS4070: Parameter 'param' of public static method from exported class has or is using private name 'privateModule'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
             }
             myPublicMethod(param: privateModule.publicClass) { // Error
                                   ~~~~~~~~~~~~~
-!!! error TS4073: Parameter 'param' of public method from exported class has or is using private name 'privateModule'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
             }
             constructor(param: privateModule.publicClass, private param1: privateModule.publicClass, public param2: privateModule.publicClass) { // Error
                                ~~~~~~~~~~~~~
-!!! error TS4063: Parameter 'param' of constructor from exported class has or is using private name 'privateModule'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
                                                                           ~~~~~~~~~~~~~
-!!! error TS4063: Parameter 'param1' of constructor from exported class has or is using private name 'privateModule'.
+!!! error TS4028: Type of parameter 'param1' references inaccessible name 'privateModule'.
                                                                                                                     ~~~~~~~~~~~~~
-!!! error TS4063: Parameter 'param2' of constructor from exported class has or is using private name 'privateModule'.
+!!! error TS4028: Type of parameter 'param2' references inaccessible name 'privateModule'.
             }
         }
         export function publicFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass) { // Error
                                                                              ~~~~~~~~~~~~~
-!!! error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
         }
         export declare function publicAmbientFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass): void; // Error
                                                                                             ~~~~~~~~~~~~~
-!!! error TS4078: Parameter 'param' of exported function has or is using private name 'privateModule'.
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
     
         interface privateInterfaceWithPrivateModuleParameterTypes {
             new (param: privateModule.publicClass): publicClass;
diff --git a/tests/baselines/reference/privacyFunctionReturnTypeDeclFile.errors.txt b/tests/baselines/reference/privacyFunctionReturnTypeDeclFile.errors.txt
index 0156c7241f778..d5d5132c61c89 100644
--- a/tests/baselines/reference/privacyFunctionReturnTypeDeclFile.errors.txt
+++ b/tests/baselines/reference/privacyFunctionReturnTypeDeclFile.errors.txt
@@ -1,72 +1,112 @@
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(281,17): error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(282,13): error TS4047: Return type of call signature from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(283,22): error TS4049: Return type of index signature from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(284,21): error TS4057: Return type of method from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(309,40): error TS4052: Return type of public static method from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(315,27): error TS4055: Return type of public method from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(321,16): error TS4052: Return type of public static method from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(327,9): error TS4055: Return type of public method from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(416,63): error TS4060: Return type of exported function has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(428,21): error TS4060: Return type of exported function has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(441,78): error TS4060: Return type of exported function has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(447,17): error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(448,13): error TS4047: Return type of call signature from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(449,22): error TS4049: Return type of index signature from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(450,21): error TS4057: Return type of method from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(453,40): error TS4052: Return type of public static method from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(456,27): error TS4055: Return type of public method from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(459,16): error TS4051: Return type of public static method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(462,9): error TS4054: Return type of public method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(466,70): error TS4060: Return type of exported function has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(469,21): error TS4059: Return type of exported function has or is using name 'privateModule.publicClass' from private module 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(472,85): error TS4060: Return type of exported function has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(9,13): error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(10,9): error TS4047: Return type of call signature from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(11,18): error TS4049: Return type of index signature from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(12,17): error TS4057: Return type of method from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(37,36): error TS4052: Return type of public static method from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(43,23): error TS4055: Return type of public method from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(49,12): error TS4052: Return type of public static method from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(55,5): error TS4055: Return type of public method from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(144,59): error TS4060: Return type of exported function has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(156,17): error TS4060: Return type of exported function has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(169,74): error TS4060: Return type of exported function has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(175,13): error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(176,9): error TS4047: Return type of call signature from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(177,18): error TS4049: Return type of index signature from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(178,17): error TS4057: Return type of method from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(181,36): error TS4052: Return type of public static method from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(184,23): error TS4055: Return type of public method from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(187,12): error TS4051: Return type of public static method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(190,5): error TS4054: Return type of public method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(194,66): error TS4060: Return type of exported function has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(197,17): error TS4059: Return type of exported function has or is using name 'privateModule.publicClass' from private module 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(200,81): error TS4060: Return type of exported function has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(238,17): error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(239,13): error TS4047: Return type of call signature from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(240,22): error TS4049: Return type of index signature from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(241,21): error TS4057: Return type of method from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(266,40): error TS4052: Return type of public static method from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(272,27): error TS4055: Return type of public method from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(278,16): error TS4052: Return type of public static method from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(284,9): error TS4055: Return type of public method from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(373,63): error TS4060: Return type of exported function has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(385,21): error TS4060: Return type of exported function has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(398,78): error TS4060: Return type of exported function has or is using private name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(404,17): error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(405,13): error TS4047: Return type of call signature from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(406,22): error TS4049: Return type of index signature from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(407,21): error TS4057: Return type of method from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(410,40): error TS4052: Return type of public static method from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(413,27): error TS4055: Return type of public method from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(416,16): error TS4051: Return type of public static method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(419,9): error TS4054: Return type of public method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(423,70): error TS4060: Return type of exported function has or is using private name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(426,21): error TS4059: Return type of exported function has or is using name 'privateModule.publicClass' from private module 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85): error TS4060: Return type of exported function has or is using private name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(58,21): error TS4044: Return type of construct signature references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(58,21): error TS4044: Return type of construct signature references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(59,17): error TS4047: Return type of call signature references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(60,26): error TS4049: Return type of index signature references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(61,25): error TS4038: Return type of method 'myMethod' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(86,44): error TS4038: Return type of method 'myPublicStaticMethod' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(92,31): error TS4038: Return type of method 'myPublicMethod' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(98,20): error TS4038: Return type of method 'myPublicStaticMethod1' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(104,13): error TS4038: Return type of method 'myPublicMethod1' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(193,67): error TS4060: Return type of function 'publicFunctionWithPrivateParmeterTypes' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(205,25): error TS4060: Return type of function 'publicFunctionWithPrivateParmeterTypes1' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(218,82): error TS4060: Return type of function 'publicAmbientFunctionWithPrivateParmeterTypes' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(224,21): error TS4044: Return type of construct signature references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(225,17): error TS4047: Return type of call signature references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(226,26): error TS4049: Return type of index signature references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(227,25): error TS4038: Return type of method 'myMethod' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(230,44): error TS4038: Return type of method 'myPublicStaticMethod' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(233,31): error TS4038: Return type of method 'myPublicMethod' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(243,74): error TS4060: Return type of function 'publicFunctionWithPrivateModuleParameterTypes' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(249,89): error TS4060: Return type of function 'publicAmbientFunctionWithPrivateModuleParameterTypes' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(281,17): error TS4044: Return type of construct signature references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(282,13): error TS4047: Return type of call signature references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(283,22): error TS4049: Return type of index signature references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(284,21): error TS4038: Return type of method 'myMethod' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(309,40): error TS4038: Return type of method 'myPublicStaticMethod' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(315,27): error TS4038: Return type of method 'myPublicMethod' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(321,16): error TS4038: Return type of method 'myPublicStaticMethod1' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(327,9): error TS4038: Return type of method 'myPublicMethod1' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(416,63): error TS4060: Return type of function 'publicFunctionWithPrivateParmeterTypes' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(428,21): error TS4060: Return type of function 'publicFunctionWithPrivateParmeterTypes1' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(441,78): error TS4060: Return type of function 'publicAmbientFunctionWithPrivateParmeterTypes' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(447,17): error TS4044: Return type of construct signature references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(448,13): error TS4047: Return type of call signature references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(449,22): error TS4049: Return type of index signature references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(450,21): error TS4038: Return type of method 'myMethod' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(453,40): error TS4038: Return type of method 'myPublicStaticMethod' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(456,27): error TS4038: Return type of method 'myPublicMethod' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(459,16): error TS4038: Return type of method 'myPublicStaticMethod1' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(462,9): error TS4038: Return type of method 'myPublicMethod1' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(466,70): error TS4060: Return type of function 'publicFunctionWithPrivateModuleParameterTypes' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(469,21): error TS4060: Return type of function 'publicFunctionWithPrivateModuleParameterTypes1' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(472,85): error TS4060: Return type of function 'publicAmbientFunctionWithPrivateModuleParameterTypes' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(9,13): error TS4044: Return type of construct signature references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(10,9): error TS4047: Return type of call signature references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(11,18): error TS4049: Return type of index signature references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(12,17): error TS4038: Return type of method 'myMethod' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(37,36): error TS4038: Return type of method 'myPublicStaticMethod' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(43,23): error TS4038: Return type of method 'myPublicMethod' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(49,12): error TS4038: Return type of method 'myPublicStaticMethod1' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(55,5): error TS4038: Return type of method 'myPublicMethod1' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(144,59): error TS4060: Return type of function 'publicFunctionWithPrivateParmeterTypes' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(156,17): error TS4060: Return type of function 'publicFunctionWithPrivateParmeterTypes1' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(169,74): error TS4060: Return type of function 'publicAmbientFunctionWithPrivateParmeterTypes' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(175,13): error TS4044: Return type of construct signature references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(176,9): error TS4047: Return type of call signature references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(177,18): error TS4049: Return type of index signature references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(178,17): error TS4038: Return type of method 'myMethod' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(181,36): error TS4038: Return type of method 'myPublicStaticMethod' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(184,23): error TS4038: Return type of method 'myPublicMethod' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(187,12): error TS4038: Return type of method 'myPublicStaticMethod1' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(190,5): error TS4038: Return type of method 'myPublicMethod1' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(194,66): error TS4060: Return type of function 'publicFunctionWithPrivateModuleParameterTypes' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(197,17): error TS4060: Return type of function 'publicFunctionWithPrivateModuleParameterTypes1' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(200,81): error TS4060: Return type of function 'publicAmbientFunctionWithPrivateModuleParameterTypes' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(238,17): error TS4044: Return type of construct signature references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(239,13): error TS4047: Return type of call signature references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(240,22): error TS4049: Return type of index signature references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(241,21): error TS4038: Return type of method 'myMethod' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(266,40): error TS4038: Return type of method 'myPublicStaticMethod' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(272,27): error TS4038: Return type of method 'myPublicMethod' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(278,16): error TS4038: Return type of method 'myPublicStaticMethod1' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(284,9): error TS4038: Return type of method 'myPublicMethod1' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(373,63): error TS4060: Return type of function 'publicFunctionWithPrivateParmeterTypes' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(385,21): error TS4060: Return type of function 'publicFunctionWithPrivateParmeterTypes1' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(398,78): error TS4060: Return type of function 'publicAmbientFunctionWithPrivateParmeterTypes' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(404,17): error TS4044: Return type of construct signature references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(405,13): error TS4047: Return type of call signature references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(406,22): error TS4049: Return type of index signature references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(407,21): error TS4038: Return type of method 'myMethod' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(410,40): error TS4038: Return type of method 'myPublicStaticMethod' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(413,27): error TS4038: Return type of method 'myPublicMethod' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(416,16): error TS4038: Return type of method 'myPublicStaticMethod1' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(419,9): error TS4038: Return type of method 'myPublicMethod1' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(423,70): error TS4060: Return type of function 'publicFunctionWithPrivateModuleParameterTypes' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(426,21): error TS4060: Return type of function 'publicFunctionWithPrivateModuleParameterTypes1' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85): error TS4060: Return type of function 'publicAmbientFunctionWithPrivateModuleParameterTypes' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(468,17): error TS4044: Return type of construct signature references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(468,17): error TS4044: Return type of construct signature references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(469,13): error TS4047: Return type of call signature references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(470,22): error TS4049: Return type of index signature references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(471,21): error TS4038: Return type of method 'myMethod' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(496,40): error TS4038: Return type of method 'myPublicStaticMethod' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(502,27): error TS4038: Return type of method 'myPublicMethod' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(508,16): error TS4038: Return type of method 'myPublicStaticMethod1' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(514,9): error TS4038: Return type of method 'myPublicMethod1' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(603,63): error TS4060: Return type of function 'publicFunctionWithPrivateParmeterTypes' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(615,21): error TS4060: Return type of function 'publicFunctionWithPrivateParmeterTypes1' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(628,78): error TS4060: Return type of function 'publicAmbientFunctionWithPrivateParmeterTypes' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(634,17): error TS4044: Return type of construct signature references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(635,13): error TS4047: Return type of call signature references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(636,22): error TS4049: Return type of index signature references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(637,21): error TS4038: Return type of method 'myMethod' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(640,40): error TS4038: Return type of method 'myPublicStaticMethod' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(643,27): error TS4038: Return type of method 'myPublicMethod' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(653,70): error TS4060: Return type of function 'publicFunctionWithPrivateModuleParameterTypes' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(659,85): error TS4060: Return type of function 'publicAmbientFunctionWithPrivateModuleParameterTypes' references inaccessible name 'privateModule'.
 
 
-==== tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts (44 errors) ====
+==== tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts (64 errors) ====
     
     class privateClass {
     }
@@ -77,16 +117,16 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
     export interface publicInterfaceWithPrivateParmeterTypes {
         new (): privateClass; // Error
                 ~~~~~~~~~~~~
-!!! error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateClass'.
+!!! error TS4044: Return type of construct signature references inaccessible name 'privateClass'.
         (): privateClass; // Error
             ~~~~~~~~~~~~
-!!! error TS4047: Return type of call signature from exported interface has or is using private name 'privateClass'.
+!!! error TS4047: Return type of call signature references inaccessible name 'privateClass'.
         [x: number]: privateClass; // Error
                      ~~~~~~~~~~~~
-!!! error TS4049: Return type of index signature from exported interface has or is using private name 'privateClass'.
+!!! error TS4049: Return type of index signature references inaccessible name 'privateClass'.
         myMethod(): privateClass; // Error
                     ~~~~~~~~~~~~
-!!! error TS4057: Return type of method from exported interface has or is using private name 'privateClass'.
+!!! error TS4038: Return type of method 'myMethod' references inaccessible name 'privateClass'.
     }
     
     export interface publicInterfaceWithPublicParmeterTypes {
@@ -113,7 +153,7 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
     export class publicClassWithWithPrivateParmeterTypes {
         static myPublicStaticMethod(): privateClass { // Error
                                        ~~~~~~~~~~~~
-!!! error TS4052: Return type of public static method from exported class has or is using private name 'privateClass'.
+!!! error TS4038: Return type of method 'myPublicStaticMethod' references inaccessible name 'privateClass'.
             return null;
         }
         private static myPrivateStaticMethod(): privateClass {
@@ -121,7 +161,7 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
         }
         myPublicMethod(): privateClass { // Error
                           ~~~~~~~~~~~~
-!!! error TS4055: Return type of public method from exported class has or is using private name 'privateClass'.
+!!! error TS4038: Return type of method 'myPublicMethod' references inaccessible name 'privateClass'.
             return null;
         }
         private myPrivateMethod(): privateClass {
@@ -129,7 +169,7 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
         }
         static myPublicStaticMethod1() { // Error
                ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4052: Return type of public static method from exported class has or is using private name 'privateClass'.
+!!! error TS4038: Return type of method 'myPublicStaticMethod1' references inaccessible name 'privateClass'.
             return new privateClass();
         }
         private static myPrivateStaticMethod1() {
@@ -137,7 +177,7 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
         }
         myPublicMethod1() { // Error
         ~~~~~~~~~~~~~~~
-!!! error TS4055: Return type of public method from exported class has or is using private name 'privateClass'.
+!!! error TS4038: Return type of method 'myPublicMethod1' references inaccessible name 'privateClass'.
             return new privateClass();
         }
         private myPrivateMethod1() {
@@ -228,7 +268,7 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
     
     export function publicFunctionWithPrivateParmeterTypes(): privateClass { // Error
                                                               ~~~~~~~~~~~~
-!!! error TS4060: Return type of exported function has or is using private name 'privateClass'.
+!!! error TS4060: Return type of function 'publicFunctionWithPrivateParmeterTypes' references inaccessible name 'privateClass'.
         return null;
     }
     export function publicFunctionWithPublicParmeterTypes(): publicClass {
@@ -242,7 +282,7 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
     }
     export function publicFunctionWithPrivateParmeterTypes1() { // Error
                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4060: Return type of exported function has or is using private name 'privateClass'.
+!!! error TS4060: Return type of function 'publicFunctionWithPrivateParmeterTypes1' references inaccessible name 'privateClass'.
         return new privateClass();
     }
     export function publicFunctionWithPublicParmeterTypes1() {
@@ -257,7 +297,7 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
     
     export declare function publicAmbientFunctionWithPrivateParmeterTypes(): privateClass; // Error
                                                                              ~~~~~~~~~~~~
-!!! error TS4060: Return type of exported function has or is using private name 'privateClass'.
+!!! error TS4060: Return type of function 'publicAmbientFunctionWithPrivateParmeterTypes' references inaccessible name 'privateClass'.
     export declare function publicAmbientFunctionWithPublicParmeterTypes(): publicClass;
     declare function privateAmbientFunctionWithPrivateParmeterTypes(): privateClass;
     declare function privateAmbientFunctionWithPublicParmeterTypes(): publicClass;
@@ -265,52 +305,52 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
     export interface publicInterfaceWithPrivateModuleParameterTypes {
         new (): privateModule.publicClass; // Error
                 ~~~~~~~~~~~~~
-!!! error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateModule'.
+!!! error TS4044: Return type of construct signature references inaccessible name 'privateModule'.
         (): privateModule.publicClass; // Error
             ~~~~~~~~~~~~~
-!!! error TS4047: Return type of call signature from exported interface has or is using private name 'privateModule'.
+!!! error TS4047: Return type of call signature references inaccessible name 'privateModule'.
         [x: number]: privateModule.publicClass // Error
                      ~~~~~~~~~~~~~
-!!! error TS4049: Return type of index signature from exported interface has or is using private name 'privateModule'.
+!!! error TS4049: Return type of index signature references inaccessible name 'privateModule'.
         myMethod(): privateModule.publicClass; // Error
                     ~~~~~~~~~~~~~
-!!! error TS4057: Return type of method from exported interface has or is using private name 'privateModule'.
+!!! error TS4038: Return type of method 'myMethod' references inaccessible name 'privateModule'.
     }
     export class publicClassWithPrivateModuleParameterTypes {
         static myPublicStaticMethod(): privateModule.publicClass { // Error
                                        ~~~~~~~~~~~~~
-!!! error TS4052: Return type of public static method from exported class has or is using private name 'privateModule'.
+!!! error TS4038: Return type of method 'myPublicStaticMethod' references inaccessible name 'privateModule'.
             return null;
         }
         myPublicMethod(): privateModule.publicClass { // Error
                           ~~~~~~~~~~~~~
-!!! error TS4055: Return type of public method from exported class has or is using private name 'privateModule'.
+!!! error TS4038: Return type of method 'myPublicMethod' references inaccessible name 'privateModule'.
             return null;
         }
         static myPublicStaticMethod1() { // Error
                ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4051: Return type of public static method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'.
+!!! error TS4038: Return type of method 'myPublicStaticMethod1' references inaccessible name 'privateModule'.
             return new privateModule.publicClass();
         }
         myPublicMethod1() { // Error
         ~~~~~~~~~~~~~~~
-!!! error TS4054: Return type of public method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'.
+!!! error TS4038: Return type of method 'myPublicMethod1' references inaccessible name 'privateModule'.
             return new privateModule.publicClass();
         }
     }
     export function publicFunctionWithPrivateModuleParameterTypes(): privateModule.publicClass { // Error
                                                                      ~~~~~~~~~~~~~
-!!! error TS4060: Return type of exported function has or is using private name 'privateModule'.
+!!! error TS4060: Return type of function 'publicFunctionWithPrivateModuleParameterTypes' references inaccessible name 'privateModule'.
         return null;
     }
     export function publicFunctionWithPrivateModuleParameterTypes1() { // Error
                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4059: Return type of exported function has or is using name 'privateModule.publicClass' from private module 'privateModule'.
+!!! error TS4060: Return type of function 'publicFunctionWithPrivateModuleParameterTypes1' references inaccessible name 'privateModule'.
         return new privateModule.publicClass();
     }
     export declare function publicAmbientFunctionWithPrivateModuleParameterTypes(): privateModule.publicClass; // Error
                                                                                     ~~~~~~~~~~~~~
-!!! error TS4060: Return type of exported function has or is using private name 'privateModule'.
+!!! error TS4060: Return type of function 'publicAmbientFunctionWithPrivateModuleParameterTypes' references inaccessible name 'privateModule'.
     
     interface privateInterfaceWithPrivateModuleParameterTypes {
         new (): privateModule.publicClass; 
@@ -350,16 +390,16 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
         export interface publicInterfaceWithPrivateParmeterTypes {
             new (): privateClass; // Error
                     ~~~~~~~~~~~~
-!!! error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateClass'.
+!!! error TS4044: Return type of construct signature references inaccessible name 'privateClass'.
             (): privateClass; // Error
                 ~~~~~~~~~~~~
-!!! error TS4047: Return type of call signature from exported interface has or is using private name 'privateClass'.
+!!! error TS4047: Return type of call signature references inaccessible name 'privateClass'.
             [x: number]: privateClass; // Error
                          ~~~~~~~~~~~~
-!!! error TS4049: Return type of index signature from exported interface has or is using private name 'privateClass'.
+!!! error TS4049: Return type of index signature references inaccessible name 'privateClass'.
             myMethod(): privateClass; // Error
                         ~~~~~~~~~~~~
-!!! error TS4057: Return type of method from exported interface has or is using private name 'privateClass'.
+!!! error TS4038: Return type of method 'myMethod' references inaccessible name 'privateClass'.
         }
     
         export interface publicInterfaceWithPublicParmeterTypes {
@@ -386,7 +426,7 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
         export class publicClassWithWithPrivateParmeterTypes {
             static myPublicStaticMethod(): privateClass { // Error
                                            ~~~~~~~~~~~~
-!!! error TS4052: Return type of public static method from exported class has or is using private name 'privateClass'.
+!!! error TS4038: Return type of method 'myPublicStaticMethod' references inaccessible name 'privateClass'.
                 return null;
             }
             private static myPrivateStaticMethod(): privateClass {
@@ -394,7 +434,7 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
             }
             myPublicMethod(): privateClass { // Error
                               ~~~~~~~~~~~~
-!!! error TS4055: Return type of public method from exported class has or is using private name 'privateClass'.
+!!! error TS4038: Return type of method 'myPublicMethod' references inaccessible name 'privateClass'.
                 return null;
             }
             private myPrivateMethod(): privateClass {
@@ -402,7 +442,7 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
             }
             static myPublicStaticMethod1() { // Error
                    ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4052: Return type of public static method from exported class has or is using private name 'privateClass'.
+!!! error TS4038: Return type of method 'myPublicStaticMethod1' references inaccessible name 'privateClass'.
                 return new privateClass();
             }
             private static myPrivateStaticMethod1() {
@@ -410,7 +450,7 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
             }
             myPublicMethod1() { // Error
             ~~~~~~~~~~~~~~~
-!!! error TS4055: Return type of public method from exported class has or is using private name 'privateClass'.
+!!! error TS4038: Return type of method 'myPublicMethod1' references inaccessible name 'privateClass'.
                 return new privateClass();
             }
             private myPrivateMethod1() {
@@ -501,7 +541,7 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
     
         export function publicFunctionWithPrivateParmeterTypes(): privateClass { // Error
                                                                   ~~~~~~~~~~~~
-!!! error TS4060: Return type of exported function has or is using private name 'privateClass'.
+!!! error TS4060: Return type of function 'publicFunctionWithPrivateParmeterTypes' references inaccessible name 'privateClass'.
             return null;
         }
         export function publicFunctionWithPublicParmeterTypes(): publicClass {
@@ -515,7 +555,7 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
         }
         export function publicFunctionWithPrivateParmeterTypes1() { // Error
                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4060: Return type of exported function has or is using private name 'privateClass'.
+!!! error TS4060: Return type of function 'publicFunctionWithPrivateParmeterTypes1' references inaccessible name 'privateClass'.
             return new privateClass();
         }
         export function publicFunctionWithPublicParmeterTypes1() {
@@ -530,7 +570,7 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
     
         export declare function publicAmbientFunctionWithPrivateParmeterTypes(): privateClass; // Error
                                                                                  ~~~~~~~~~~~~
-!!! error TS4060: Return type of exported function has or is using private name 'privateClass'.
+!!! error TS4060: Return type of function 'publicAmbientFunctionWithPrivateParmeterTypes' references inaccessible name 'privateClass'.
         export declare function publicAmbientFunctionWithPublicParmeterTypes(): publicClass;
         declare function privateAmbientFunctionWithPrivateParmeterTypes(): privateClass;
         declare function privateAmbientFunctionWithPublicParmeterTypes(): publicClass;
@@ -538,52 +578,52 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
         export interface publicInterfaceWithPrivateModuleParameterTypes {
             new (): privateModule.publicClass; // Error
                     ~~~~~~~~~~~~~
-!!! error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateModule'.
+!!! error TS4044: Return type of construct signature references inaccessible name 'privateModule'.
             (): privateModule.publicClass; // Error
                 ~~~~~~~~~~~~~
-!!! error TS4047: Return type of call signature from exported interface has or is using private name 'privateModule'.
+!!! error TS4047: Return type of call signature references inaccessible name 'privateModule'.
             [x: number]: privateModule.publicClass; // Error
                          ~~~~~~~~~~~~~
-!!! error TS4049: Return type of index signature from exported interface has or is using private name 'privateModule'.
+!!! error TS4049: Return type of index signature references inaccessible name 'privateModule'.
             myMethod(): privateModule.publicClass; // Error
                         ~~~~~~~~~~~~~
-!!! error TS4057: Return type of method from exported interface has or is using private name 'privateModule'.
+!!! error TS4038: Return type of method 'myMethod' references inaccessible name 'privateModule'.
         }
         export class publicClassWithPrivateModuleParameterTypes {
             static myPublicStaticMethod(): privateModule.publicClass { // Error
                                            ~~~~~~~~~~~~~
-!!! error TS4052: Return type of public static method from exported class has or is using private name 'privateModule'.
+!!! error TS4038: Return type of method 'myPublicStaticMethod' references inaccessible name 'privateModule'.
                 return null;
             }
             myPublicMethod(): privateModule.publicClass { // Error
                               ~~~~~~~~~~~~~
-!!! error TS4055: Return type of public method from exported class has or is using private name 'privateModule'.
+!!! error TS4038: Return type of method 'myPublicMethod' references inaccessible name 'privateModule'.
                 return null;
             }
             static myPublicStaticMethod1() { // Error
                    ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4051: Return type of public static method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'.
+!!! error TS4038: Return type of method 'myPublicStaticMethod1' references inaccessible name 'privateModule'.
                 return new privateModule.publicClass();
             }
             myPublicMethod1() { // Error
             ~~~~~~~~~~~~~~~
-!!! error TS4054: Return type of public method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'.
+!!! error TS4038: Return type of method 'myPublicMethod1' references inaccessible name 'privateModule'.
                 return new privateModule.publicClass();
             }
         }
         export function publicFunctionWithPrivateModuleParameterTypes(): privateModule.publicClass { // Error
                                                                          ~~~~~~~~~~~~~
-!!! error TS4060: Return type of exported function has or is using private name 'privateModule'.
+!!! error TS4060: Return type of function 'publicFunctionWithPrivateModuleParameterTypes' references inaccessible name 'privateModule'.
             return null;
         }
         export function publicFunctionWithPrivateModuleParameterTypes1() { // Error
                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4059: Return type of exported function has or is using name 'privateModule.publicClass' from private module 'privateModule'.
+!!! error TS4060: Return type of function 'publicFunctionWithPrivateModuleParameterTypes1' references inaccessible name 'privateModule'.
             return new privateModule.publicClass();
         }
         export declare function publicAmbientFunctionWithPrivateModuleParameterTypes(): privateModule.publicClass; // Error
                                                                                         ~~~~~~~~~~~~~
-!!! error TS4060: Return type of exported function has or is using private name 'privateModule'.
+!!! error TS4060: Return type of function 'publicAmbientFunctionWithPrivateModuleParameterTypes' references inaccessible name 'privateModule'.
     
         interface privateInterfaceWithPrivateModuleParameterTypes {
             new (): privateModule.publicClass;
@@ -623,9 +663,19 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
     
         export interface publicInterfaceWithPrivateParmeterTypes {
             new (): privateClass; 
+                    ~~~~~~~~~~~~
+!!! error TS4044: Return type of construct signature references inaccessible name 'privateClass'.
+                    ~~~~~~~~~~~~
+!!! error TS4044: Return type of construct signature references inaccessible name 'privateModule'.
             (): privateClass; 
+                ~~~~~~~~~~~~
+!!! error TS4047: Return type of call signature references inaccessible name 'privateClass'.
             [x: number]: privateClass; 
+                         ~~~~~~~~~~~~
+!!! error TS4049: Return type of index signature references inaccessible name 'privateClass'.
             myMethod(): privateClass; 
+                        ~~~~~~~~~~~~
+!!! error TS4038: Return type of method 'myMethod' references inaccessible name 'privateClass'.
         }
     
         export interface publicInterfaceWithPublicParmeterTypes {
@@ -651,24 +701,32 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
     
         export class publicClassWithWithPrivateParmeterTypes {
             static myPublicStaticMethod(): privateClass { 
+                                           ~~~~~~~~~~~~
+!!! error TS4038: Return type of method 'myPublicStaticMethod' references inaccessible name 'privateClass'.
                 return null;
             }
             private static myPrivateStaticMethod(): privateClass {
                 return null;
             }
             myPublicMethod(): privateClass { 
+                              ~~~~~~~~~~~~
+!!! error TS4038: Return type of method 'myPublicMethod' references inaccessible name 'privateClass'.
                 return null;
             }
             private myPrivateMethod(): privateClass {
                 return null;
             }
             static myPublicStaticMethod1() { 
+                   ~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4038: Return type of method 'myPublicStaticMethod1' references inaccessible name 'privateClass'.
                 return new privateClass();
             }
             private static myPrivateStaticMethod1() {
                 return new privateClass();
             }
             myPublicMethod1() { 
+            ~~~~~~~~~~~~~~~
+!!! error TS4038: Return type of method 'myPublicMethod1' references inaccessible name 'privateClass'.
                 return new privateClass();
             }
             private myPrivateMethod1() {
@@ -758,6 +816,8 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
         }
     
         export function publicFunctionWithPrivateParmeterTypes(): privateClass { 
+                                                                  ~~~~~~~~~~~~
+!!! error TS4060: Return type of function 'publicFunctionWithPrivateParmeterTypes' references inaccessible name 'privateClass'.
             return null;
         }
         export function publicFunctionWithPublicParmeterTypes(): publicClass {
@@ -770,6 +830,8 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
             return null;
         }
         export function publicFunctionWithPrivateParmeterTypes1() { 
+                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4060: Return type of function 'publicFunctionWithPrivateParmeterTypes1' references inaccessible name 'privateClass'.
             return new privateClass();
         }
         export function publicFunctionWithPublicParmeterTypes1() {
@@ -783,21 +845,35 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
         }
     
         export declare function publicAmbientFunctionWithPrivateParmeterTypes(): privateClass; 
+                                                                                 ~~~~~~~~~~~~
+!!! error TS4060: Return type of function 'publicAmbientFunctionWithPrivateParmeterTypes' references inaccessible name 'privateClass'.
         export declare function publicAmbientFunctionWithPublicParmeterTypes(): publicClass;
         declare function privateAmbientFunctionWithPrivateParmeterTypes(): privateClass;
         declare function privateAmbientFunctionWithPublicParmeterTypes(): publicClass;
     
         export interface publicInterfaceWithPrivateModuleParameterTypes {
             new (): privateModule.publicClass;
+                    ~~~~~~~~~~~~~
+!!! error TS4044: Return type of construct signature references inaccessible name 'privateModule'.
             (): privateModule.publicClass;
+                ~~~~~~~~~~~~~
+!!! error TS4047: Return type of call signature references inaccessible name 'privateModule'.
             [x: number]: privateModule.publicClass;
+                         ~~~~~~~~~~~~~
+!!! error TS4049: Return type of index signature references inaccessible name 'privateModule'.
             myMethod(): privateModule.publicClass;
+                        ~~~~~~~~~~~~~
+!!! error TS4038: Return type of method 'myMethod' references inaccessible name 'privateModule'.
         }
         export class publicClassWithPrivateModuleParameterTypes {
             static myPublicStaticMethod(): privateModule.publicClass { 
+                                           ~~~~~~~~~~~~~
+!!! error TS4038: Return type of method 'myPublicStaticMethod' references inaccessible name 'privateModule'.
                 return null;
             }
             myPublicMethod(): privateModule.publicClass { 
+                              ~~~~~~~~~~~~~
+!!! error TS4038: Return type of method 'myPublicMethod' references inaccessible name 'privateModule'.
                 return null;
             }
             static myPublicStaticMethod1() { 
@@ -808,12 +884,16 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
             }
         }
         export function publicFunctionWithPrivateModuleParameterTypes(): privateModule.publicClass { 
+                                                                         ~~~~~~~~~~~~~
+!!! error TS4060: Return type of function 'publicFunctionWithPrivateModuleParameterTypes' references inaccessible name 'privateModule'.
             return null;
         }
         export function publicFunctionWithPrivateModuleParameterTypes1() { 
             return new privateModule.publicClass();
         }
         export declare function publicAmbientFunctionWithPrivateModuleParameterTypes(): privateModule.publicClass; 
+                                                                                        ~~~~~~~~~~~~~
+!!! error TS4060: Return type of function 'publicAmbientFunctionWithPrivateModuleParameterTypes' references inaccessible name 'privateModule'.
     
         interface privateInterfaceWithPrivateModuleParameterTypes {
             new (): privateModule.publicClass;
@@ -844,7 +924,7 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
         declare function privateAmbientFunctionWithPrivateModuleParameterTypes(): privateModule.publicClass; 
     }
     
-==== tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts (22 errors) ====
+==== tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts (42 errors) ====
     class publicClassInGlobal {
     }
     interface publicInterfaceWithPublicParmeterTypesInGlobal {
@@ -903,9 +983,19 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
     
             export interface publicInterfaceWithPrivateParmeterTypes {
                 new (): privateClass;
+                        ~~~~~~~~~~~~
+!!! error TS4044: Return type of construct signature references inaccessible name 'privateClass'.
+                        ~~~~~~~~~~~~
+!!! error TS4044: Return type of construct signature references inaccessible name 'privateModule'.
                 (): privateClass;
+                    ~~~~~~~~~~~~
+!!! error TS4047: Return type of call signature references inaccessible name 'privateClass'.
                 [x: number]: privateClass;
+                             ~~~~~~~~~~~~
+!!! error TS4049: Return type of index signature references inaccessible name 'privateClass'.
                 myMethod(): privateClass;
+                            ~~~~~~~~~~~~
+!!! error TS4038: Return type of method 'myMethod' references inaccessible name 'privateClass'.
             }
     
             export interface publicInterfaceWithPublicParmeterTypes {
@@ -931,24 +1021,32 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
     
             export class publicClassWithWithPrivateParmeterTypes {
                 static myPublicStaticMethod(): privateClass {
+                                               ~~~~~~~~~~~~
+!!! error TS4038: Return type of method 'myPublicStaticMethod' references inaccessible name 'privateClass'.
                     return null;
                 }
                 private static myPrivateStaticMethod(): privateClass {
                     return null;
                 }
                 myPublicMethod(): privateClass {
+                                  ~~~~~~~~~~~~
+!!! error TS4038: Return type of method 'myPublicMethod' references inaccessible name 'privateClass'.
                     return null;
                 }
                 private myPrivateMethod(): privateClass {
                     return null;
                 }
                 static myPublicStaticMethod1() {
+                       ~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4038: Return type of method 'myPublicStaticMethod1' references inaccessible name 'privateClass'.
                     return new privateClass();
                 }
                 private static myPrivateStaticMethod1() {
                     return new privateClass();
                 }
                 myPublicMethod1() {
+                ~~~~~~~~~~~~~~~
+!!! error TS4038: Return type of method 'myPublicMethod1' references inaccessible name 'privateClass'.
                     return new privateClass();
                 }
                 private myPrivateMethod1() {
@@ -1038,6 +1136,8 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
             }
     
             export function publicFunctionWithPrivateParmeterTypes(): privateClass {
+                                                                      ~~~~~~~~~~~~
+!!! error TS4060: Return type of function 'publicFunctionWithPrivateParmeterTypes' references inaccessible name 'privateClass'.
                 return null;
             }
             export function publicFunctionWithPublicParmeterTypes(): publicClass {
@@ -1050,6 +1150,8 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
                 return null;
             }
             export function publicFunctionWithPrivateParmeterTypes1() {
+                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4060: Return type of function 'publicFunctionWithPrivateParmeterTypes1' references inaccessible name 'privateClass'.
                 return new privateClass();
             }
             export function publicFunctionWithPublicParmeterTypes1() {
@@ -1063,21 +1165,35 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
             }
     
             export declare function publicAmbientFunctionWithPrivateParmeterTypes(): privateClass;
+                                                                                     ~~~~~~~~~~~~
+!!! error TS4060: Return type of function 'publicAmbientFunctionWithPrivateParmeterTypes' references inaccessible name 'privateClass'.
             export declare function publicAmbientFunctionWithPublicParmeterTypes(): publicClass;
             declare function privateAmbientFunctionWithPrivateParmeterTypes(): privateClass;
             declare function privateAmbientFunctionWithPublicParmeterTypes(): publicClass;
     
             export interface publicInterfaceWithPrivateModuleParameterTypes {
                 new (): privateModule.publicClass;
+                        ~~~~~~~~~~~~~
+!!! error TS4044: Return type of construct signature references inaccessible name 'privateModule'.
                 (): privateModule.publicClass;
+                    ~~~~~~~~~~~~~
+!!! error TS4047: Return type of call signature references inaccessible name 'privateModule'.
                 [x: number]: privateModule.publicClass;
+                             ~~~~~~~~~~~~~
+!!! error TS4049: Return type of index signature references inaccessible name 'privateModule'.
                 myMethod(): privateModule.publicClass;
+                            ~~~~~~~~~~~~~
+!!! error TS4038: Return type of method 'myMethod' references inaccessible name 'privateModule'.
             }
             export class publicClassWithPrivateModuleParameterTypes {
                 static myPublicStaticMethod(): privateModule.publicClass {
+                                               ~~~~~~~~~~~~~
+!!! error TS4038: Return type of method 'myPublicStaticMethod' references inaccessible name 'privateModule'.
                     return null;
                 }
                 myPublicMethod(): privateModule.publicClass {
+                                  ~~~~~~~~~~~~~
+!!! error TS4038: Return type of method 'myPublicMethod' references inaccessible name 'privateModule'.
                     return null;
                 }
                 static myPublicStaticMethod1() {
@@ -1088,12 +1204,16 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
                 }
             }
             export function publicFunctionWithPrivateModuleParameterTypes(): privateModule.publicClass {
+                                                                             ~~~~~~~~~~~~~
+!!! error TS4060: Return type of function 'publicFunctionWithPrivateModuleParameterTypes' references inaccessible name 'privateModule'.
                 return null;
             }
             export function publicFunctionWithPrivateModuleParameterTypes1() {
                 return new privateModule.publicClass();
             }
             export declare function publicAmbientFunctionWithPrivateModuleParameterTypes(): privateModule.publicClass;
+                                                                                            ~~~~~~~~~~~~~
+!!! error TS4060: Return type of function 'publicAmbientFunctionWithPrivateModuleParameterTypes' references inaccessible name 'privateModule'.
     
             interface privateInterfaceWithPrivateModuleParameterTypes {
                 new (): privateModule.publicClass;
@@ -1127,16 +1247,16 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
         export interface publicInterfaceWithPrivateParmeterTypes {
             new (): privateClass; // Error
                     ~~~~~~~~~~~~
-!!! error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateClass'.
+!!! error TS4044: Return type of construct signature references inaccessible name 'privateClass'.
             (): privateClass; // Error
                 ~~~~~~~~~~~~
-!!! error TS4047: Return type of call signature from exported interface has or is using private name 'privateClass'.
+!!! error TS4047: Return type of call signature references inaccessible name 'privateClass'.
             [x: number]: privateClass; // Error
                          ~~~~~~~~~~~~
-!!! error TS4049: Return type of index signature from exported interface has or is using private name 'privateClass'.
+!!! error TS4049: Return type of index signature references inaccessible name 'privateClass'.
             myMethod(): privateClass; // Error
                         ~~~~~~~~~~~~
-!!! error TS4057: Return type of method from exported interface has or is using private name 'privateClass'.
+!!! error TS4038: Return type of method 'myMethod' references inaccessible name 'privateClass'.
         }
     
         export interface publicInterfaceWithPublicParmeterTypes {
@@ -1163,7 +1283,7 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
         export class publicClassWithWithPrivateParmeterTypes {
             static myPublicStaticMethod(): privateClass { // Error
                                            ~~~~~~~~~~~~
-!!! error TS4052: Return type of public static method from exported class has or is using private name 'privateClass'.
+!!! error TS4038: Return type of method 'myPublicStaticMethod' references inaccessible name 'privateClass'.
                 return null;
             }
             private static myPrivateStaticMethod(): privateClass {
@@ -1171,7 +1291,7 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
             }
             myPublicMethod(): privateClass { // Error
                               ~~~~~~~~~~~~
-!!! error TS4055: Return type of public method from exported class has or is using private name 'privateClass'.
+!!! error TS4038: Return type of method 'myPublicMethod' references inaccessible name 'privateClass'.
                 return null;
             }
             private myPrivateMethod(): privateClass {
@@ -1179,7 +1299,7 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
             }
             static myPublicStaticMethod1() { // Error
                    ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4052: Return type of public static method from exported class has or is using private name 'privateClass'.
+!!! error TS4038: Return type of method 'myPublicStaticMethod1' references inaccessible name 'privateClass'.
                 return new privateClass();
             }
             private static myPrivateStaticMethod1() {
@@ -1187,7 +1307,7 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
             }
             myPublicMethod1() { // Error
             ~~~~~~~~~~~~~~~
-!!! error TS4055: Return type of public method from exported class has or is using private name 'privateClass'.
+!!! error TS4038: Return type of method 'myPublicMethod1' references inaccessible name 'privateClass'.
                 return new privateClass();
             }
             private myPrivateMethod1() {
@@ -1278,7 +1398,7 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
     
         export function publicFunctionWithPrivateParmeterTypes(): privateClass { // Error
                                                                   ~~~~~~~~~~~~
-!!! error TS4060: Return type of exported function has or is using private name 'privateClass'.
+!!! error TS4060: Return type of function 'publicFunctionWithPrivateParmeterTypes' references inaccessible name 'privateClass'.
             return null;
         }
         export function publicFunctionWithPublicParmeterTypes(): publicClass {
@@ -1292,7 +1412,7 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
         }
         export function publicFunctionWithPrivateParmeterTypes1() { // Error
                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4060: Return type of exported function has or is using private name 'privateClass'.
+!!! error TS4060: Return type of function 'publicFunctionWithPrivateParmeterTypes1' references inaccessible name 'privateClass'.
             return new privateClass();
         }
         export function publicFunctionWithPublicParmeterTypes1() {
@@ -1307,7 +1427,7 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
     
         export declare function publicAmbientFunctionWithPrivateParmeterTypes(): privateClass; // Error
                                                                                  ~~~~~~~~~~~~
-!!! error TS4060: Return type of exported function has or is using private name 'privateClass'.
+!!! error TS4060: Return type of function 'publicAmbientFunctionWithPrivateParmeterTypes' references inaccessible name 'privateClass'.
         export declare function publicAmbientFunctionWithPublicParmeterTypes(): publicClass;
         declare function privateAmbientFunctionWithPrivateParmeterTypes(): privateClass;
         declare function privateAmbientFunctionWithPublicParmeterTypes(): publicClass;
@@ -1315,52 +1435,52 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85)
         export interface publicInterfaceWithPrivateModuleParameterTypes {
             new (): privateModule.publicClass; // Error
                     ~~~~~~~~~~~~~
-!!! error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateModule'.
+!!! error TS4044: Return type of construct signature references inaccessible name 'privateModule'.
             (): privateModule.publicClass; // Error
                 ~~~~~~~~~~~~~
-!!! error TS4047: Return type of call signature from exported interface has or is using private name 'privateModule'.
+!!! error TS4047: Return type of call signature references inaccessible name 'privateModule'.
             [x: number]: privateModule.publicClass; // Error
                          ~~~~~~~~~~~~~
-!!! error TS4049: Return type of index signature from exported interface has or is using private name 'privateModule'.
+!!! error TS4049: Return type of index signature references inaccessible name 'privateModule'.
             myMethod(): privateModule.publicClass; // Error
                         ~~~~~~~~~~~~~
-!!! error TS4057: Return type of method from exported interface has or is using private name 'privateModule'.
+!!! error TS4038: Return type of method 'myMethod' references inaccessible name 'privateModule'.
         }
         export class publicClassWithPrivateModuleParameterTypes {
             static myPublicStaticMethod(): privateModule.publicClass { // Error
                                            ~~~~~~~~~~~~~
-!!! error TS4052: Return type of public static method from exported class has or is using private name 'privateModule'.
+!!! error TS4038: Return type of method 'myPublicStaticMethod' references inaccessible name 'privateModule'.
                 return null;
             }
             myPublicMethod(): privateModule.publicClass { // Error
                               ~~~~~~~~~~~~~
-!!! error TS4055: Return type of public method from exported class has or is using private name 'privateModule'.
+!!! error TS4038: Return type of method 'myPublicMethod' references inaccessible name 'privateModule'.
                 return null;
             }
             static myPublicStaticMethod1() { // Error
                    ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4051: Return type of public static method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'.
+!!! error TS4038: Return type of method 'myPublicStaticMethod1' references inaccessible name 'privateModule'.
                 return new privateModule.publicClass();
             }
             myPublicMethod1() { // Error
             ~~~~~~~~~~~~~~~
-!!! error TS4054: Return type of public method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'.
+!!! error TS4038: Return type of method 'myPublicMethod1' references inaccessible name 'privateModule'.
                 return new privateModule.publicClass();
             }
         }
         export function publicFunctionWithPrivateModuleParameterTypes(): privateModule.publicClass { // Error
                                                                          ~~~~~~~~~~~~~
-!!! error TS4060: Return type of exported function has or is using private name 'privateModule'.
+!!! error TS4060: Return type of function 'publicFunctionWithPrivateModuleParameterTypes' references inaccessible name 'privateModule'.
             return null;
         }
         export function publicFunctionWithPrivateModuleParameterTypes1() { // Error
                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4059: Return type of exported function has or is using name 'privateModule.publicClass' from private module 'privateModule'.
+!!! error TS4060: Return type of function 'publicFunctionWithPrivateModuleParameterTypes1' references inaccessible name 'privateModule'.
             return new privateModule.publicClass();
         }
         export declare function publicAmbientFunctionWithPrivateModuleParameterTypes(): privateModule.publicClass; // Error
                                                                                         ~~~~~~~~~~~~~
-!!! error TS4060: Return type of exported function has or is using private name 'privateModule'.
+!!! error TS4060: Return type of function 'publicAmbientFunctionWithPrivateModuleParameterTypes' references inaccessible name 'privateModule'.
     
         interface privateInterfaceWithPrivateModuleParameterTypes {
             new (): privateModule.publicClass;
diff --git a/tests/baselines/reference/privacyGloImport.errors.txt b/tests/baselines/reference/privacyGloImport.errors.txt
index 933af3315a7af..e7410fa03397d 100644
--- a/tests/baselines/reference/privacyGloImport.errors.txt
+++ b/tests/baselines/reference/privacyGloImport.errors.txt
@@ -1,5 +1,5 @@
-tests/cases/compiler/privacyGloImport.ts(49,29): error TS4000: Import declaration 'm1_im2_private' is using private name 'm1_M2_private'.
-tests/cases/compiler/privacyGloImport.ts(80,35): error TS4000: Import declaration 'm1_im2_public' is using private name 'm1_M2_private'.
+tests/cases/compiler/privacyGloImport.ts(49,29): error TS4000: Import declaration 'm1_im2_private' references inaccessible name 'm1_M2_private'.
+tests/cases/compiler/privacyGloImport.ts(80,35): error TS4000: Import declaration 'm1_im2_public' references inaccessible name 'm1_M2_private'.
 
 
 ==== tests/cases/compiler/privacyGloImport.ts (2 errors) ====
@@ -53,7 +53,7 @@ tests/cases/compiler/privacyGloImport.ts(80,35): error TS4000: Import declaratio
     
         import m1_im2_private = m1_M2_private;
                                 ~~~~~~~~~~~~~
-!!! error TS4000: Import declaration 'm1_im2_private' is using private name 'm1_M2_private'.
+!!! error TS4000: Import declaration 'm1_im2_private' references inaccessible name 'm1_M2_private'.
         export var m1_im2_private_v1_public = m1_im2_private.c1;
         export var m1_im2_private_v2_public = new m1_im2_private.c1();
         export var m1_im2_private_v3_public = m1_im2_private.f1;
@@ -86,7 +86,7 @@ tests/cases/compiler/privacyGloImport.ts(80,35): error TS4000: Import declaratio
         export import m1_im1_public = m1_M1_public;
         export import m1_im2_public = m1_M2_private;
                                       ~~~~~~~~~~~~~
-!!! error TS4000: Import declaration 'm1_im2_public' is using private name 'm1_M2_private'.
+!!! error TS4000: Import declaration 'm1_im2_public' references inaccessible name 'm1_M2_private'.
         //export import m1_im3_public = require("m1_M3_public");
         //export import m1_im4_public = require("m1_M4_private");
     }
diff --git a/tests/baselines/reference/privacyGloImportParseErrors.errors.txt b/tests/baselines/reference/privacyGloImportParseErrors.errors.txt
index d6d24ebcb308b..a97ebf37b3be3 100644
--- a/tests/baselines/reference/privacyGloImportParseErrors.errors.txt
+++ b/tests/baselines/reference/privacyGloImportParseErrors.errors.txt
@@ -1,11 +1,11 @@
 tests/cases/compiler/privacyGloImportParseErrors.ts(22,27): error TS2435: Ambient modules cannot be nested in other modules.
 tests/cases/compiler/privacyGloImportParseErrors.ts(30,20): error TS2435: Ambient modules cannot be nested in other modules.
-tests/cases/compiler/privacyGloImportParseErrors.ts(49,29): error TS4000: Import declaration 'm1_im2_private' is using private name 'm1_M2_private'.
+tests/cases/compiler/privacyGloImportParseErrors.ts(49,29): error TS4000: Import declaration 'm1_im2_private' references inaccessible name 'm1_M2_private'.
 tests/cases/compiler/privacyGloImportParseErrors.ts(59,37): error TS1147: Import declarations in a namespace cannot reference a module.
 tests/cases/compiler/privacyGloImportParseErrors.ts(59,37): error TS2307: Cannot find module 'm1_M3_public'.
 tests/cases/compiler/privacyGloImportParseErrors.ts(69,37): error TS1147: Import declarations in a namespace cannot reference a module.
 tests/cases/compiler/privacyGloImportParseErrors.ts(69,37): error TS2307: Cannot find module 'm1_M4_private'.
-tests/cases/compiler/privacyGloImportParseErrors.ts(80,35): error TS4000: Import declaration 'm1_im2_public' is using private name 'm1_M2_private'.
+tests/cases/compiler/privacyGloImportParseErrors.ts(80,35): error TS4000: Import declaration 'm1_im2_public' references inaccessible name 'm1_M2_private'.
 tests/cases/compiler/privacyGloImportParseErrors.ts(81,43): error TS1147: Import declarations in a namespace cannot reference a module.
 tests/cases/compiler/privacyGloImportParseErrors.ts(82,43): error TS1147: Import declarations in a namespace cannot reference a module.
 tests/cases/compiler/privacyGloImportParseErrors.ts(121,38): error TS1147: Import declarations in a namespace cannot reference a module.
@@ -73,7 +73,7 @@ tests/cases/compiler/privacyGloImportParseErrors.ts(149,29): error TS1147: Impor
     
         import m1_im2_private = m1_M2_private;
                                 ~~~~~~~~~~~~~
-!!! error TS4000: Import declaration 'm1_im2_private' is using private name 'm1_M2_private'.
+!!! error TS4000: Import declaration 'm1_im2_private' references inaccessible name 'm1_M2_private'.
         export var m1_im2_private_v1_public = m1_im2_private.c1;
         export var m1_im2_private_v2_public = new m1_im2_private.c1();
         export var m1_im2_private_v3_public = m1_im2_private.f1;
@@ -114,7 +114,7 @@ tests/cases/compiler/privacyGloImportParseErrors.ts(149,29): error TS1147: Impor
         export import m1_im1_public = m1_M1_public;
         export import m1_im2_public = m1_M2_private;
                                       ~~~~~~~~~~~~~
-!!! error TS4000: Import declaration 'm1_im2_public' is using private name 'm1_M2_private'.
+!!! error TS4000: Import declaration 'm1_im2_public' references inaccessible name 'm1_M2_private'.
         export import m1_im3_public = require("m1_M3_public");
                                               ~~~~~~~~~~~~~~
 !!! error TS1147: Import declarations in a namespace cannot reference a module.
diff --git a/tests/baselines/reference/privacyImport.errors.txt b/tests/baselines/reference/privacyImport.errors.txt
index d5cb61d99b5f4..a5d2dfd1cd6bf 100644
--- a/tests/baselines/reference/privacyImport.errors.txt
+++ b/tests/baselines/reference/privacyImport.errors.txt
@@ -1,5 +1,5 @@
-tests/cases/compiler/privacyImport.ts(49,29): error TS4000: Import declaration 'm1_im2_private' is using private name 'm1_M2_private'.
-tests/cases/compiler/privacyImport.ts(80,35): error TS4000: Import declaration 'm1_im2_public' is using private name 'm1_M2_private'.
+tests/cases/compiler/privacyImport.ts(49,29): error TS4000: Import declaration 'm1_im2_private' references inaccessible name 'm1_M2_private'.
+tests/cases/compiler/privacyImport.ts(80,35): error TS4000: Import declaration 'm1_im2_public' references inaccessible name 'm1_M2_private'.
 
 
 ==== tests/cases/compiler/privacyImport.ts (2 errors) ====
@@ -53,7 +53,7 @@ tests/cases/compiler/privacyImport.ts(80,35): error TS4000: Import declaration '
     
         import m1_im2_private = m1_M2_private;
                                 ~~~~~~~~~~~~~
-!!! error TS4000: Import declaration 'm1_im2_private' is using private name 'm1_M2_private'.
+!!! error TS4000: Import declaration 'm1_im2_private' references inaccessible name 'm1_M2_private'.
         export var m1_im2_private_v1_public = m1_im2_private.c1;
         export var m1_im2_private_v2_public = new m1_im2_private.c1();
         export var m1_im2_private_v3_public = m1_im2_private.f1;
@@ -86,7 +86,7 @@ tests/cases/compiler/privacyImport.ts(80,35): error TS4000: Import declaration '
         export import m1_im1_public = m1_M1_public;
         export import m1_im2_public = m1_M2_private;
                                       ~~~~~~~~~~~~~
-!!! error TS4000: Import declaration 'm1_im2_public' is using private name 'm1_M2_private'.
+!!! error TS4000: Import declaration 'm1_im2_public' references inaccessible name 'm1_M2_private'.
         //export import m1_im3_public = require("m1_M3_public");
         //export import m1_im4_public = require("m1_M4_private");
     }
diff --git a/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.errors.txt b/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.errors.txt
index 41c53ffd19b43..1535070e17622 100644
--- a/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.errors.txt
+++ b/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.errors.txt
@@ -1,12 +1,15 @@
-tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts(14,82): error TS4022: Extends clause of exported interface 'publicInterfaceImplementingPrivateInterfaceInModule' has or is using private name 'privateInterfaceInPublicModule'.
-tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(15,82): error TS4022: Extends clause of exported interface 'publicInterfaceImplementingPrivateInterfaceInModule' has or is using private name 'privateInterfaceInPublicModule'.
-tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(20,84): error TS4022: Extends clause of exported interface 'publicInterfaceImplementingFromPrivateModuleInterface' has or is using private name 'privateModule'.
-tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(23,83): error TS4022: Extends clause of exported interface 'publicInterfaceImplementingPrivateAndPublicInterface' has or is using private name 'privateInterfaceInPublicModule'.
-tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(63,70): error TS4022: Extends clause of exported interface 'publicInterfaceImplementingPrivateInterface' has or is using private name 'privateInterface'.
-tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(68,80): error TS4022: Extends clause of exported interface 'publicInterfaceImplementingFromPrivateModuleInterface' has or is using private name 'privateModule'.
+tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts(14,82): error TS4020: Extends clause references inaccessible name 'privateInterfaceInPublicModule'.
+tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(15,82): error TS4020: Extends clause references inaccessible name 'privateInterfaceInPublicModule'.
+tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(20,84): error TS4020: Extends clause references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(23,83): error TS4020: Extends clause references inaccessible name 'privateInterfaceInPublicModule'.
+tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(41,82): error TS4020: Extends clause references inaccessible name 'privateInterfaceInPrivateModule'.
+tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(41,82): error TS4020: Extends clause references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(46,84): error TS4020: Extends clause references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(63,70): error TS4020: Extends clause references inaccessible name 'privateInterface'.
+tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(68,80): error TS4020: Extends clause references inaccessible name 'privateModule'.
 
 
-==== tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts (5 errors) ====
+==== tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts (8 errors) ====
     
     export module publicModule {
         export interface publicInterfaceInPublicModule {
@@ -23,19 +26,19 @@ tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(68,
         }
         export interface publicInterfaceImplementingPrivateInterfaceInModule extends privateInterfaceInPublicModule { // Should error
                                                                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4022: Extends clause of exported interface 'publicInterfaceImplementingPrivateInterfaceInModule' has or is using private name 'privateInterfaceInPublicModule'.
+!!! error TS4020: Extends clause references inaccessible name 'privateInterfaceInPublicModule'.
         }
     
         interface privateInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule {
         }
         export interface publicInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule { // Should error
                                                                                        ~~~~~~~~~~~~~
-!!! error TS4022: Extends clause of exported interface 'publicInterfaceImplementingFromPrivateModuleInterface' has or is using private name 'privateModule'.
+!!! error TS4020: Extends clause references inaccessible name 'privateModule'.
         }
     
         export interface publicInterfaceImplementingPrivateAndPublicInterface extends privateInterfaceInPublicModule, publicInterfaceInPublicModule { // Should error
                                                                                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4022: Extends clause of exported interface 'publicInterfaceImplementingPrivateAndPublicInterface' has or is using private name 'privateInterfaceInPublicModule'.
+!!! error TS4020: Extends clause references inaccessible name 'privateInterfaceInPublicModule'.
         }
     }
     
@@ -54,11 +57,17 @@ tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(68,
         export interface publicInterfaceImplementingPublicInterfaceInModule extends publicInterfaceInPrivateModule {
         }
         export interface publicInterfaceImplementingPrivateInterfaceInModule extends privateInterfaceInPrivateModule {
+                                                                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4020: Extends clause references inaccessible name 'privateInterfaceInPrivateModule'.
+                                                                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4020: Extends clause references inaccessible name 'privateModule'.
         }
     
         interface privateInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule {
         }
         export interface publicInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule {
+                                                                                       ~~~~~~~~~~~~~
+!!! error TS4020: Extends clause references inaccessible name 'privateModule'.
         }
     }
     
@@ -77,14 +86,14 @@ tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(68,
     }
     export interface publicInterfaceImplementingPrivateInterface extends privateInterface { // Should error
                                                                          ~~~~~~~~~~~~~~~~
-!!! error TS4022: Extends clause of exported interface 'publicInterfaceImplementingPrivateInterface' has or is using private name 'privateInterface'.
+!!! error TS4020: Extends clause references inaccessible name 'privateInterface'.
     }
     
     interface privateInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule {
     }
     export interface publicInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule { // Should error
                                                                                    ~~~~~~~~~~~~~
-!!! error TS4022: Extends clause of exported interface 'publicInterfaceImplementingFromPrivateModuleInterface' has or is using private name 'privateModule'.
+!!! error TS4020: Extends clause references inaccessible name 'privateModule'.
     }
     
 ==== tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts (1 errors) ====
@@ -103,7 +112,7 @@ tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(68,
         }
         export interface publicInterfaceImplementingPrivateInterfaceInModule extends privateInterfaceInPublicModule { // Should error
                                                                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4022: Extends clause of exported interface 'publicInterfaceImplementingPrivateInterfaceInModule' has or is using private name 'privateInterfaceInPublicModule'.
+!!! error TS4020: Extends clause references inaccessible name 'privateInterfaceInPublicModule'.
         }
     }
     interface publicInterfaceInGlobal {
diff --git a/tests/baselines/reference/privacyLocalInternalReferenceImportWithExport.errors.txt b/tests/baselines/reference/privacyLocalInternalReferenceImportWithExport.errors.txt
index 45dbc77e7a0a3..d307f6499ce6d 100644
--- a/tests/baselines/reference/privacyLocalInternalReferenceImportWithExport.errors.txt
+++ b/tests/baselines/reference/privacyLocalInternalReferenceImportWithExport.errors.txt
@@ -1,10 +1,10 @@
-tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts(51,41): error TS4000: Import declaration 'im_public_c_private' is using private name 'm_private'.
-tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts(52,41): error TS4000: Import declaration 'im_public_e_private' is using private name 'm_private'.
-tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts(53,41): error TS4000: Import declaration 'im_public_f_private' is using private name 'm_private'.
-tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts(54,41): error TS4000: Import declaration 'im_public_v_private' is using private name 'm_private'.
-tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts(55,41): error TS4000: Import declaration 'im_public_i_private' is using private name 'm_private'.
-tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts(56,42): error TS4000: Import declaration 'im_public_mi_private' is using private name 'm_private'.
-tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts(57,42): error TS4000: Import declaration 'im_public_mu_private' is using private name 'm_private'.
+tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts(51,41): error TS4000: Import declaration 'im_public_c_private' references inaccessible name 'm_private'.
+tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts(52,41): error TS4000: Import declaration 'im_public_e_private' references inaccessible name 'm_private'.
+tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts(53,41): error TS4000: Import declaration 'im_public_f_private' references inaccessible name 'm_private'.
+tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts(54,41): error TS4000: Import declaration 'im_public_v_private' references inaccessible name 'm_private'.
+tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts(55,41): error TS4000: Import declaration 'im_public_i_private' references inaccessible name 'm_private'.
+tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts(56,42): error TS4000: Import declaration 'im_public_mi_private' references inaccessible name 'm_private'.
+tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts(57,42): error TS4000: Import declaration 'im_public_mu_private' references inaccessible name 'm_private'.
 
 
 ==== tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts (7 errors) ====
@@ -59,26 +59,26 @@ tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts(57,42): er
     export module import_public {
         // Privacy errors - importing private elements
         export import im_public_c_private = m_private.c_private;
-                                            ~~~~~~~~~
-!!! error TS4000: Import declaration 'im_public_c_private' is using private name 'm_private'.
+                                            ~~~~~~~~~~~~~~~~~~~
+!!! error TS4000: Import declaration 'im_public_c_private' references inaccessible name 'm_private'.
         export import im_public_e_private = m_private.e_private;
-                                            ~~~~~~~~~
-!!! error TS4000: Import declaration 'im_public_e_private' is using private name 'm_private'.
+                                            ~~~~~~~~~~~~~~~~~~~
+!!! error TS4000: Import declaration 'im_public_e_private' references inaccessible name 'm_private'.
         export import im_public_f_private = m_private.f_private;
-                                            ~~~~~~~~~
-!!! error TS4000: Import declaration 'im_public_f_private' is using private name 'm_private'.
+                                            ~~~~~~~~~~~~~~~~~~~
+!!! error TS4000: Import declaration 'im_public_f_private' references inaccessible name 'm_private'.
         export import im_public_v_private = m_private.v_private;
-                                            ~~~~~~~~~
-!!! error TS4000: Import declaration 'im_public_v_private' is using private name 'm_private'.
+                                            ~~~~~~~~~~~~~~~~~~~
+!!! error TS4000: Import declaration 'im_public_v_private' references inaccessible name 'm_private'.
         export import im_public_i_private = m_private.i_private;
-                                            ~~~~~~~~~
-!!! error TS4000: Import declaration 'im_public_i_private' is using private name 'm_private'.
+                                            ~~~~~~~~~~~~~~~~~~~
+!!! error TS4000: Import declaration 'im_public_i_private' references inaccessible name 'm_private'.
         export import im_public_mi_private = m_private.mi_private;
-                                             ~~~~~~~~~
-!!! error TS4000: Import declaration 'im_public_mi_private' is using private name 'm_private'.
+                                             ~~~~~~~~~~~~~~~~~~~~
+!!! error TS4000: Import declaration 'im_public_mi_private' references inaccessible name 'm_private'.
         export import im_public_mu_private = m_private.mu_private;
-                                             ~~~~~~~~~
-!!! error TS4000: Import declaration 'im_public_mu_private' is using private name 'm_private'.
+                                             ~~~~~~~~~~~~~~~~~~~~
+!!! error TS4000: Import declaration 'im_public_mu_private' references inaccessible name 'm_private'.
     
         // Usage of privacy error imports
         var privateUse_im_public_c_private = new im_public_c_private();
diff --git a/tests/baselines/reference/privacyLocalInternalReferenceImportWithoutExport.errors.txt b/tests/baselines/reference/privacyLocalInternalReferenceImportWithoutExport.errors.txt
index 12fd1927660fc..4f014edd553dc 100644
--- a/tests/baselines/reference/privacyLocalInternalReferenceImportWithoutExport.errors.txt
+++ b/tests/baselines/reference/privacyLocalInternalReferenceImportWithoutExport.errors.txt
@@ -1,8 +1,8 @@
-tests/cases/compiler/privacyLocalInternalReferenceImportWithoutExport.ts(51,35): error TS4000: Import declaration 'im_private_c_private' is using private name 'm_private'.
-tests/cases/compiler/privacyLocalInternalReferenceImportWithoutExport.ts(52,35): error TS4000: Import declaration 'im_private_e_private' is using private name 'm_private'.
-tests/cases/compiler/privacyLocalInternalReferenceImportWithoutExport.ts(55,35): error TS4000: Import declaration 'im_private_i_private' is using private name 'm_private'.
-tests/cases/compiler/privacyLocalInternalReferenceImportWithoutExport.ts(56,36): error TS4000: Import declaration 'im_private_mi_private' is using private name 'm_private'.
-tests/cases/compiler/privacyLocalInternalReferenceImportWithoutExport.ts(57,36): error TS4000: Import declaration 'im_private_mu_private' is using private name 'm_private'.
+tests/cases/compiler/privacyLocalInternalReferenceImportWithoutExport.ts(51,35): error TS4000: Import declaration 'im_private_c_private' references inaccessible name 'm_private'.
+tests/cases/compiler/privacyLocalInternalReferenceImportWithoutExport.ts(52,35): error TS4000: Import declaration 'im_private_e_private' references inaccessible name 'm_private'.
+tests/cases/compiler/privacyLocalInternalReferenceImportWithoutExport.ts(55,35): error TS4000: Import declaration 'im_private_i_private' references inaccessible name 'm_private'.
+tests/cases/compiler/privacyLocalInternalReferenceImportWithoutExport.ts(56,36): error TS4000: Import declaration 'im_private_mi_private' references inaccessible name 'm_private'.
+tests/cases/compiler/privacyLocalInternalReferenceImportWithoutExport.ts(57,36): error TS4000: Import declaration 'im_private_mu_private' references inaccessible name 'm_private'.
 
 
 ==== tests/cases/compiler/privacyLocalInternalReferenceImportWithoutExport.ts (5 errors) ====
@@ -57,22 +57,22 @@ tests/cases/compiler/privacyLocalInternalReferenceImportWithoutExport.ts(57,36):
     export module import_public {
         // No Privacy errors - importing private elements
         import im_private_c_private = m_private.c_private;
-                                      ~~~~~~~~~
-!!! error TS4000: Import declaration 'im_private_c_private' is using private name 'm_private'.
+                                      ~~~~~~~~~~~~~~~~~~~
+!!! error TS4000: Import declaration 'im_private_c_private' references inaccessible name 'm_private'.
         import im_private_e_private = m_private.e_private;
-                                      ~~~~~~~~~
-!!! error TS4000: Import declaration 'im_private_e_private' is using private name 'm_private'.
+                                      ~~~~~~~~~~~~~~~~~~~
+!!! error TS4000: Import declaration 'im_private_e_private' references inaccessible name 'm_private'.
         import im_private_f_private = m_private.f_private;
         import im_private_v_private = m_private.v_private;
         import im_private_i_private = m_private.i_private;
-                                      ~~~~~~~~~
-!!! error TS4000: Import declaration 'im_private_i_private' is using private name 'm_private'.
+                                      ~~~~~~~~~~~~~~~~~~~
+!!! error TS4000: Import declaration 'im_private_i_private' references inaccessible name 'm_private'.
         import im_private_mi_private = m_private.mi_private;
-                                       ~~~~~~~~~
-!!! error TS4000: Import declaration 'im_private_mi_private' is using private name 'm_private'.
+                                       ~~~~~~~~~~~~~~~~~~~~
+!!! error TS4000: Import declaration 'im_private_mi_private' references inaccessible name 'm_private'.
         import im_private_mu_private = m_private.mu_private;
-                                       ~~~~~~~~~
-!!! error TS4000: Import declaration 'im_private_mu_private' is using private name 'm_private'.
+                                       ~~~~~~~~~~~~~~~~~~~~
+!!! error TS4000: Import declaration 'im_private_mu_private' references inaccessible name 'm_private'.
     
         // Usage of above decls
         var privateUse_im_private_c_private = new im_private_c_private();
diff --git a/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithExport.errors.txt b/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithExport.errors.txt
index d3715af1d5493..c082fe2b1c49a 100644
--- a/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithExport.errors.txt
+++ b/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithExport.errors.txt
@@ -1,10 +1,10 @@
-tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts(50,37): error TS4000: Import declaration 'im_public_c_private' is using private name 'm_private'.
-tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts(51,37): error TS4000: Import declaration 'im_public_e_private' is using private name 'm_private'.
-tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts(52,37): error TS4000: Import declaration 'im_public_f_private' is using private name 'm_private'.
-tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts(53,37): error TS4000: Import declaration 'im_public_v_private' is using private name 'm_private'.
-tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts(54,37): error TS4000: Import declaration 'im_public_i_private' is using private name 'm_private'.
-tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts(55,38): error TS4000: Import declaration 'im_public_mi_private' is using private name 'm_private'.
-tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts(56,38): error TS4000: Import declaration 'im_public_mu_private' is using private name 'm_private'.
+tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts(50,37): error TS4000: Import declaration 'im_public_c_private' references inaccessible name 'm_private'.
+tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts(51,37): error TS4000: Import declaration 'im_public_e_private' references inaccessible name 'm_private'.
+tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts(52,37): error TS4000: Import declaration 'im_public_f_private' references inaccessible name 'm_private'.
+tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts(53,37): error TS4000: Import declaration 'im_public_v_private' references inaccessible name 'm_private'.
+tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts(54,37): error TS4000: Import declaration 'im_public_i_private' references inaccessible name 'm_private'.
+tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts(55,38): error TS4000: Import declaration 'im_public_mi_private' references inaccessible name 'm_private'.
+tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts(56,38): error TS4000: Import declaration 'im_public_mu_private' references inaccessible name 'm_private'.
 
 
 ==== tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts (7 errors) ====
@@ -58,26 +58,26 @@ tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts(56,38):
     
     // Privacy errors - importing private elements
     export import im_public_c_private = m_private.c_private;
-                                        ~~~~~~~~~
-!!! error TS4000: Import declaration 'im_public_c_private' is using private name 'm_private'.
+                                        ~~~~~~~~~~~~~~~~~~~
+!!! error TS4000: Import declaration 'im_public_c_private' references inaccessible name 'm_private'.
     export import im_public_e_private = m_private.e_private;
-                                        ~~~~~~~~~
-!!! error TS4000: Import declaration 'im_public_e_private' is using private name 'm_private'.
+                                        ~~~~~~~~~~~~~~~~~~~
+!!! error TS4000: Import declaration 'im_public_e_private' references inaccessible name 'm_private'.
     export import im_public_f_private = m_private.f_private;
-                                        ~~~~~~~~~
-!!! error TS4000: Import declaration 'im_public_f_private' is using private name 'm_private'.
+                                        ~~~~~~~~~~~~~~~~~~~
+!!! error TS4000: Import declaration 'im_public_f_private' references inaccessible name 'm_private'.
     export import im_public_v_private = m_private.v_private;
-                                        ~~~~~~~~~
-!!! error TS4000: Import declaration 'im_public_v_private' is using private name 'm_private'.
+                                        ~~~~~~~~~~~~~~~~~~~
+!!! error TS4000: Import declaration 'im_public_v_private' references inaccessible name 'm_private'.
     export import im_public_i_private = m_private.i_private;
-                                        ~~~~~~~~~
-!!! error TS4000: Import declaration 'im_public_i_private' is using private name 'm_private'.
+                                        ~~~~~~~~~~~~~~~~~~~
+!!! error TS4000: Import declaration 'im_public_i_private' references inaccessible name 'm_private'.
     export import im_public_mi_private = m_private.mi_private;
-                                         ~~~~~~~~~
-!!! error TS4000: Import declaration 'im_public_mi_private' is using private name 'm_private'.
+                                         ~~~~~~~~~~~~~~~~~~~~
+!!! error TS4000: Import declaration 'im_public_mi_private' references inaccessible name 'm_private'.
     export import im_public_mu_private = m_private.mu_private;
-                                         ~~~~~~~~~
-!!! error TS4000: Import declaration 'im_public_mu_private' is using private name 'm_private'.
+                                         ~~~~~~~~~~~~~~~~~~~~
+!!! error TS4000: Import declaration 'im_public_mu_private' references inaccessible name 'm_private'.
     
     // Usage of privacy error imports
     var privateUse_im_public_c_private = new im_public_c_private();
diff --git a/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithoutExport.errors.txt b/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithoutExport.errors.txt
index 1fbf8f7bac94b..4a8cc701dda47 100644
--- a/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithoutExport.errors.txt
+++ b/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithoutExport.errors.txt
@@ -1,8 +1,8 @@
-tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(51,31): error TS4000: Import declaration 'im_private_c_private' is using private name 'm_private'.
-tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(52,31): error TS4000: Import declaration 'im_private_e_private' is using private name 'm_private'.
-tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(55,31): error TS4000: Import declaration 'im_private_i_private' is using private name 'm_private'.
-tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(56,32): error TS4000: Import declaration 'im_private_mi_private' is using private name 'm_private'.
-tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(57,32): error TS4000: Import declaration 'im_private_mu_private' is using private name 'm_private'.
+tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(51,31): error TS4000: Import declaration 'im_private_c_private' references inaccessible name 'm_private'.
+tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(52,31): error TS4000: Import declaration 'im_private_e_private' references inaccessible name 'm_private'.
+tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(55,31): error TS4000: Import declaration 'im_private_i_private' references inaccessible name 'm_private'.
+tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(56,32): error TS4000: Import declaration 'im_private_mi_private' references inaccessible name 'm_private'.
+tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(57,32): error TS4000: Import declaration 'im_private_mu_private' references inaccessible name 'm_private'.
 
 
 ==== tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts (5 errors) ====
@@ -57,22 +57,22 @@ tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(57,3
     
     // No Privacy errors - importing private elements
     import im_private_c_private = m_private.c_private;
-                                  ~~~~~~~~~
-!!! error TS4000: Import declaration 'im_private_c_private' is using private name 'm_private'.
+                                  ~~~~~~~~~~~~~~~~~~~
+!!! error TS4000: Import declaration 'im_private_c_private' references inaccessible name 'm_private'.
     import im_private_e_private = m_private.e_private;
-                                  ~~~~~~~~~
-!!! error TS4000: Import declaration 'im_private_e_private' is using private name 'm_private'.
+                                  ~~~~~~~~~~~~~~~~~~~
+!!! error TS4000: Import declaration 'im_private_e_private' references inaccessible name 'm_private'.
     import im_private_f_private = m_private.f_private;
     import im_private_v_private = m_private.v_private;
     import im_private_i_private = m_private.i_private;
-                                  ~~~~~~~~~
-!!! error TS4000: Import declaration 'im_private_i_private' is using private name 'm_private'.
+                                  ~~~~~~~~~~~~~~~~~~~
+!!! error TS4000: Import declaration 'im_private_i_private' references inaccessible name 'm_private'.
     import im_private_mi_private = m_private.mi_private;
-                                   ~~~~~~~~~
-!!! error TS4000: Import declaration 'im_private_mi_private' is using private name 'm_private'.
+                                   ~~~~~~~~~~~~~~~~~~~~
+!!! error TS4000: Import declaration 'im_private_mi_private' references inaccessible name 'm_private'.
     import im_private_mu_private = m_private.mu_private;
-                                   ~~~~~~~~~
-!!! error TS4000: Import declaration 'im_private_mu_private' is using private name 'm_private'.
+                                   ~~~~~~~~~~~~~~~~~~~~
+!!! error TS4000: Import declaration 'im_private_mu_private' references inaccessible name 'm_private'.
     
     // Usage of above decls
     var privateUse_im_private_c_private = new im_private_c_private();
diff --git a/tests/baselines/reference/privacyTypeParameterOfFunctionDeclFile.errors.txt b/tests/baselines/reference/privacyTypeParameterOfFunctionDeclFile.errors.txt
index 663025ee72286..3eb26acdd0551 100644
--- a/tests/baselines/reference/privacyTypeParameterOfFunctionDeclFile.errors.txt
+++ b/tests/baselines/reference/privacyTypeParameterOfFunctionDeclFile.errors.txt
@@ -1,42 +1,52 @@
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(8,20): error TS4006: Type parameter 'T' of constructor signature from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(8,37): error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(9,16): error TS4008: Type parameter 'T' of call signature from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(9,33): error TS4047: Return type of call signature from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(10,24): error TS4014: Type parameter 'T' of method from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(10,41): error TS4057: Return type of method from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(32,43): error TS4010: Type parameter 'T' of public static method from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(36,30): error TS4012: Type parameter 'T' of public method from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(75,67): error TS4016: Type parameter 'T' of exported function has or is using private name 'privateClass'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(127,20): error TS4006: Type parameter 'T' of constructor signature from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(127,50): error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(128,16): error TS4008: Type parameter 'T' of call signature from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(128,46): error TS4047: Return type of call signature from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(129,24): error TS4014: Type parameter 'T' of method from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(129,54): error TS4057: Return type of method from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(132,43): error TS4010: Type parameter 'T' of public static method from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(134,30): error TS4012: Type parameter 'T' of public method from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(137,74): error TS4016: Type parameter 'T' of exported function has or is using private name 'privateModule'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(164,24): error TS4006: Type parameter 'T' of constructor signature from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(164,41): error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(165,20): error TS4008: Type parameter 'T' of call signature from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(165,37): error TS4047: Return type of call signature from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(166,28): error TS4014: Type parameter 'T' of method from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(166,45): error TS4057: Return type of method from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(188,47): error TS4010: Type parameter 'T' of public static method from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(192,34): error TS4012: Type parameter 'T' of public method from exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(231,71): error TS4016: Type parameter 'T' of exported function has or is using private name 'privateClass'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(283,24): error TS4006: Type parameter 'T' of constructor signature from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(283,54): error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(284,20): error TS4008: Type parameter 'T' of call signature from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(284,50): error TS4047: Return type of call signature from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(285,28): error TS4014: Type parameter 'T' of method from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(285,58): error TS4057: Return type of method from exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(288,47): error TS4010: Type parameter 'T' of public static method from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(290,34): error TS4012: Type parameter 'T' of public method from exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(293,78): error TS4016: Type parameter 'T' of exported function has or is using private name 'privateModule'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(8,20): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(8,37): error TS4044: Return type of construct signature references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(9,16): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(9,33): error TS4047: Return type of call signature references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(10,24): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(10,41): error TS4038: Return type of method 'myMethod' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(32,43): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(36,30): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(75,67): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(127,20): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(127,50): error TS4044: Return type of construct signature references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(128,16): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(128,46): error TS4047: Return type of call signature references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(129,24): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(129,54): error TS4038: Return type of method 'myMethod' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(132,43): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(134,30): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(137,74): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(164,24): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(164,41): error TS4044: Return type of construct signature references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(165,20): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(165,37): error TS4047: Return type of call signature references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(166,28): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(166,45): error TS4038: Return type of method 'myMethod' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(188,47): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(192,34): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(231,71): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(283,24): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(283,54): error TS4044: Return type of construct signature references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(284,20): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(284,50): error TS4047: Return type of call signature references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(285,28): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(285,58): error TS4038: Return type of method 'myMethod' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(288,47): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(290,34): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(293,78): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(321,24): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(321,24): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(321,41): error TS4044: Return type of construct signature references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(322,20): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(322,37): error TS4047: Return type of call signature references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(323,28): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(323,45): error TS4038: Return type of method 'myMethod' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(345,47): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(349,34): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(388,71): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
 
 
-==== tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts (36 errors) ====
+==== tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts (46 errors) ====
     class privateClass {
     }
     
@@ -46,19 +56,19 @@ tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(293,78): error TS
     export interface publicInterfaceWithPrivateTypeParameters {
         new <T extends privateClass>(): privateClass;  // Error
                        ~~~~~~~~~~~~
-!!! error TS4006: Type parameter 'T' of constructor signature from exported interface has or is using private name 'privateClass'.
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
                                         ~~~~~~~~~~~~
-!!! error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateClass'.
+!!! error TS4044: Return type of construct signature references inaccessible name 'privateClass'.
         <T extends privateClass>(): privateClass;  // Error
                    ~~~~~~~~~~~~
-!!! error TS4008: Type parameter 'T' of call signature from exported interface has or is using private name 'privateClass'.
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
                                     ~~~~~~~~~~~~
-!!! error TS4047: Return type of call signature from exported interface has or is using private name 'privateClass'.
+!!! error TS4047: Return type of call signature references inaccessible name 'privateClass'.
         myMethod<T extends privateClass>(): privateClass;  // Error
                            ~~~~~~~~~~~~
-!!! error TS4014: Type parameter 'T' of method from exported interface has or is using private name 'privateClass'.
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
                                             ~~~~~~~~~~~~
-!!! error TS4057: Return type of method from exported interface has or is using private name 'privateClass'.
+!!! error TS4038: Return type of method 'myMethod' references inaccessible name 'privateClass'.
     }
     
     export interface publicInterfaceWithPublicTypeParameters {
@@ -82,13 +92,13 @@ tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(293,78): error TS
     export class publicClassWithWithPrivateTypeParameters {
         static myPublicStaticMethod<T extends privateClass>() {  // Error
                                               ~~~~~~~~~~~~
-!!! error TS4010: Type parameter 'T' of public static method from exported class has or is using private name 'privateClass'.
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
         }
         private static myPrivateStaticMethod<T extends privateClass>() {
         }
         myPublicMethod<T extends privateClass>() {  // Error
                                  ~~~~~~~~~~~~
-!!! error TS4012: Type parameter 'T' of public method from exported class has or is using private name 'privateClass'.
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
         }
         private myPrivateMethod<T extends privateClass>() {
         }
@@ -129,7 +139,7 @@ tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(293,78): error TS
     
     export function publicFunctionWithPrivateTypeParameters<T extends privateClass>() {  // Error
                                                                       ~~~~~~~~~~~~
-!!! error TS4016: Type parameter 'T' of exported function has or is using private name 'privateClass'.
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
     }
     
     export function publicFunctionWithPublicTypeParameters<T extends publicClass>() {
@@ -183,33 +193,33 @@ tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(293,78): error TS
     export interface publicInterfaceWithPrivatModuleTypeParameters {
         new <T extends privateModule.publicClass>(): privateModule.publicClass;  // Error
                        ~~~~~~~~~~~~~
-!!! error TS4006: Type parameter 'T' of constructor signature from exported interface has or is using private name 'privateModule'.
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
                                                      ~~~~~~~~~~~~~
-!!! error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateModule'.
+!!! error TS4044: Return type of construct signature references inaccessible name 'privateModule'.
         <T extends privateModule.publicClass>(): privateModule.publicClass;  // Error
                    ~~~~~~~~~~~~~
-!!! error TS4008: Type parameter 'T' of call signature from exported interface has or is using private name 'privateModule'.
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
                                                  ~~~~~~~~~~~~~
-!!! error TS4047: Return type of call signature from exported interface has or is using private name 'privateModule'.
+!!! error TS4047: Return type of call signature references inaccessible name 'privateModule'.
         myMethod<T extends privateModule.publicClass>(): privateModule.publicClass;  // Error
                            ~~~~~~~~~~~~~
-!!! error TS4014: Type parameter 'T' of method from exported interface has or is using private name 'privateModule'.
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
                                                          ~~~~~~~~~~~~~
-!!! error TS4057: Return type of method from exported interface has or is using private name 'privateModule'.
+!!! error TS4038: Return type of method 'myMethod' references inaccessible name 'privateModule'.
     }
     export class publicClassWithWithPrivateModuleTypeParameters {
         static myPublicStaticMethod<T extends privateModule.publicClass>() {  // Error
                                               ~~~~~~~~~~~~~
-!!! error TS4010: Type parameter 'T' of public static method from exported class has or is using private name 'privateModule'.
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
         }
         myPublicMethod<T extends privateModule.publicClass>() {  // Error
                                  ~~~~~~~~~~~~~
-!!! error TS4012: Type parameter 'T' of public method from exported class has or is using private name 'privateModule'.
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
         }
     }
     export function publicFunctionWithPrivateMopduleTypeParameters<T extends privateModule.publicClass>() {  // Error
                                                                              ~~~~~~~~~~~~~
-!!! error TS4016: Type parameter 'T' of exported function has or is using private name 'privateModule'.
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
     }
     
     
@@ -238,19 +248,19 @@ tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(293,78): error TS
         export interface publicInterfaceWithPrivateTypeParameters {
             new <T extends privateClass>(): privateClass;  // Error
                            ~~~~~~~~~~~~
-!!! error TS4006: Type parameter 'T' of constructor signature from exported interface has or is using private name 'privateClass'.
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
                                             ~~~~~~~~~~~~
-!!! error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateClass'.
+!!! error TS4044: Return type of construct signature references inaccessible name 'privateClass'.
             <T extends privateClass>(): privateClass;  // Error
                        ~~~~~~~~~~~~
-!!! error TS4008: Type parameter 'T' of call signature from exported interface has or is using private name 'privateClass'.
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
                                         ~~~~~~~~~~~~
-!!! error TS4047: Return type of call signature from exported interface has or is using private name 'privateClass'.
+!!! error TS4047: Return type of call signature references inaccessible name 'privateClass'.
             myMethod<T extends privateClass>(): privateClass;  // Error
                                ~~~~~~~~~~~~
-!!! error TS4014: Type parameter 'T' of method from exported interface has or is using private name 'privateClass'.
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
                                                 ~~~~~~~~~~~~
-!!! error TS4057: Return type of method from exported interface has or is using private name 'privateClass'.
+!!! error TS4038: Return type of method 'myMethod' references inaccessible name 'privateClass'.
         }
     
         export interface publicInterfaceWithPublicTypeParameters {
@@ -274,13 +284,13 @@ tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(293,78): error TS
         export class publicClassWithWithPrivateTypeParameters {
             static myPublicStaticMethod<T extends privateClass>() {  // Error
                                                   ~~~~~~~~~~~~
-!!! error TS4010: Type parameter 'T' of public static method from exported class has or is using private name 'privateClass'.
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
             }
             private static myPrivateStaticMethod<T extends privateClass>() {
             }
             myPublicMethod<T extends privateClass>() {  // Error
                                      ~~~~~~~~~~~~
-!!! error TS4012: Type parameter 'T' of public method from exported class has or is using private name 'privateClass'.
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
             }
             private myPrivateMethod<T extends privateClass>() {
             }
@@ -321,7 +331,7 @@ tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(293,78): error TS
     
         export function publicFunctionWithPrivateTypeParameters<T extends privateClass>() {  // Error
                                                                           ~~~~~~~~~~~~
-!!! error TS4016: Type parameter 'T' of exported function has or is using private name 'privateClass'.
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
         }
     
         export function publicFunctionWithPublicTypeParameters<T extends publicClass>() {
@@ -375,33 +385,33 @@ tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(293,78): error TS
         export interface publicInterfaceWithPrivatModuleTypeParameters {
             new <T extends privateModule.publicClass>(): privateModule.publicClass;  // Error
                            ~~~~~~~~~~~~~
-!!! error TS4006: Type parameter 'T' of constructor signature from exported interface has or is using private name 'privateModule'.
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
                                                          ~~~~~~~~~~~~~
-!!! error TS4045: Return type of constructor signature from exported interface has or is using private name 'privateModule'.
+!!! error TS4044: Return type of construct signature references inaccessible name 'privateModule'.
             <T extends privateModule.publicClass>(): privateModule.publicClass;  // Error
                        ~~~~~~~~~~~~~
-!!! error TS4008: Type parameter 'T' of call signature from exported interface has or is using private name 'privateModule'.
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
                                                      ~~~~~~~~~~~~~
-!!! error TS4047: Return type of call signature from exported interface has or is using private name 'privateModule'.
+!!! error TS4047: Return type of call signature references inaccessible name 'privateModule'.
             myMethod<T extends privateModule.publicClass>(): privateModule.publicClass;  // Error
                                ~~~~~~~~~~~~~
-!!! error TS4014: Type parameter 'T' of method from exported interface has or is using private name 'privateModule'.
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
                                                              ~~~~~~~~~~~~~
-!!! error TS4057: Return type of method from exported interface has or is using private name 'privateModule'.
+!!! error TS4038: Return type of method 'myMethod' references inaccessible name 'privateModule'.
         }
         export class publicClassWithWithPrivateModuleTypeParameters {
             static myPublicStaticMethod<T extends privateModule.publicClass>() {  // Error
                                                   ~~~~~~~~~~~~~
-!!! error TS4010: Type parameter 'T' of public static method from exported class has or is using private name 'privateModule'.
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
             }
             myPublicMethod<T extends privateModule.publicClass>() {  // Error
                                      ~~~~~~~~~~~~~
-!!! error TS4012: Type parameter 'T' of public method from exported class has or is using private name 'privateModule'.
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
             }
         }
         export function publicFunctionWithPrivateMopduleTypeParameters<T extends privateModule.publicClass>() {  // Error
                                                                                  ~~~~~~~~~~~~~
-!!! error TS4016: Type parameter 'T' of exported function has or is using private name 'privateModule'.
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
         }
     
     
@@ -430,8 +440,22 @@ tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(293,78): error TS
     
         export interface publicInterfaceWithPrivateTypeParameters {
             new <T extends privateClass>(): privateClass; 
+                           ~~~~~~~~~~~~
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
+                           ~~~~~~~~~~~~
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
+                                            ~~~~~~~~~~~~
+!!! error TS4044: Return type of construct signature references inaccessible name 'privateClass'.
             <T extends privateClass>(): privateClass;
+                       ~~~~~~~~~~~~
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
+                                        ~~~~~~~~~~~~
+!!! error TS4047: Return type of call signature references inaccessible name 'privateClass'.
             myMethod<T extends privateClass>(): privateClass; 
+                               ~~~~~~~~~~~~
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
+                                                ~~~~~~~~~~~~
+!!! error TS4038: Return type of method 'myMethod' references inaccessible name 'privateClass'.
         }
     
         export interface publicInterfaceWithPublicTypeParameters {
@@ -454,10 +478,14 @@ tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(293,78): error TS
     
         export class publicClassWithWithPrivateTypeParameters {
             static myPublicStaticMethod<T extends privateClass>() { 
+                                                  ~~~~~~~~~~~~
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
             }
             private static myPrivateStaticMethod<T extends privateClass>() {
             }
             myPublicMethod<T extends privateClass>() {  
+                                     ~~~~~~~~~~~~
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
             }
             private myPrivateMethod<T extends privateClass>() {
             }
@@ -497,6 +525,8 @@ tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(293,78): error TS
         }
     
         export function publicFunctionWithPrivateTypeParameters<T extends privateClass>() { 
+                                                                          ~~~~~~~~~~~~
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
         }
     
         export function publicFunctionWithPublicTypeParameters<T extends publicClass>() {
diff --git a/tests/baselines/reference/privacyTypeParametersOfClassDeclFile.errors.txt b/tests/baselines/reference/privacyTypeParametersOfClassDeclFile.errors.txt
index a6ae0fdcc0148..18c4769381be0 100644
--- a/tests/baselines/reference/privacyTypeParametersOfClassDeclFile.errors.txt
+++ b/tests/baselines/reference/privacyTypeParametersOfClassDeclFile.errors.txt
@@ -1,10 +1,12 @@
-tests/cases/compiler/privacyTypeParametersOfClassDeclFile.ts(7,61): error TS4002: Type parameter 'T' of exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyTypeParametersOfClassDeclFile.ts(43,71): error TS4002: Type parameter 'T' of exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyTypeParametersOfClassDeclFile.ts(62,65): error TS4002: Type parameter 'T' of exported class has or is using private name 'privateClassInPublicModule'.
-tests/cases/compiler/privacyTypeParametersOfClassDeclFile.ts(98,75): error TS4002: Type parameter 'T' of exported class has or is using private name 'privateModule'.
+tests/cases/compiler/privacyTypeParametersOfClassDeclFile.ts(7,61): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyTypeParametersOfClassDeclFile.ts(43,71): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyTypeParametersOfClassDeclFile.ts(62,65): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClassInPublicModule'.
+tests/cases/compiler/privacyTypeParametersOfClassDeclFile.ts(98,75): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyTypeParametersOfClassDeclFile.ts(118,65): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClassInPrivateModule'.
+tests/cases/compiler/privacyTypeParametersOfClassDeclFile.ts(118,65): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
 
 
-==== tests/cases/compiler/privacyTypeParametersOfClassDeclFile.ts (4 errors) ====
+==== tests/cases/compiler/privacyTypeParametersOfClassDeclFile.ts (6 errors) ====
     class privateClass {
     }
     
@@ -13,7 +15,7 @@ tests/cases/compiler/privacyTypeParametersOfClassDeclFile.ts(98,75): error TS400
     
     export class publicClassWithPrivateTypeParameters<T extends privateClass> { // Error
                                                                 ~~~~~~~~~~~~
-!!! error TS4002: Type parameter 'T' of exported class has or is using private name 'privateClass'.
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
         myMethod(val: T): T {
             return val;
         }
@@ -51,7 +53,7 @@ tests/cases/compiler/privacyTypeParametersOfClassDeclFile.ts(98,75): error TS400
     
     export class publicClassWithTypeParametersFromPrivateModule<T extends privateModule.publicClassInPrivateModule> { // Error
                                                                           ~~~~~~~~~~~~~
-!!! error TS4002: Type parameter 'T' of exported class has or is using private name 'privateModule'.
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
         myMethod(val: T): T {
             return val;
         }
@@ -72,7 +74,7 @@ tests/cases/compiler/privacyTypeParametersOfClassDeclFile.ts(98,75): error TS400
     
         export class publicClassWithPrivateTypeParameters<T extends privateClassInPublicModule> { // Error
                                                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4002: Type parameter 'T' of exported class has or is using private name 'privateClassInPublicModule'.
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClassInPublicModule'.
             myMethod(val: T): T {
                 return val;
             }
@@ -110,7 +112,7 @@ tests/cases/compiler/privacyTypeParametersOfClassDeclFile.ts(98,75): error TS400
     
         export class publicClassWithTypeParametersFromPrivateModule<T extends privateModule.publicClassInPrivateModule> { // Error
                                                                               ~~~~~~~~~~~~~
-!!! error TS4002: Type parameter 'T' of exported class has or is using private name 'privateModule'.
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
             myMethod(val: T): T {
                 return val;
             }
@@ -131,6 +133,10 @@ tests/cases/compiler/privacyTypeParametersOfClassDeclFile.ts(98,75): error TS400
         }
     
         export class publicClassWithPrivateTypeParameters<T extends privateClassInPrivateModule> {
+                                                                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClassInPrivateModule'.
+                                                                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
             myMethod(val: T): T {
                 return val;
             }
diff --git a/tests/baselines/reference/privacyTypeParametersOfInterfaceDeclFile.errors.txt b/tests/baselines/reference/privacyTypeParametersOfInterfaceDeclFile.errors.txt
index eb6bb3ea73421..ad66dbef91ca9 100644
--- a/tests/baselines/reference/privacyTypeParametersOfInterfaceDeclFile.errors.txt
+++ b/tests/baselines/reference/privacyTypeParametersOfInterfaceDeclFile.errors.txt
@@ -1,26 +1,37 @@
-tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(13,69): error TS4004: Type parameter 'T' of exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(16,18): error TS4057: Return type of method from exported interface has or is using private name 'privateClassT'.
-tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(16,32): error TS4057: Return type of method from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(17,18): error TS4057: Return type of method from exported interface has or is using private name 'privateClassT'.
-tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(18,31): error TS4057: Return type of method from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(25,18): error TS4057: Return type of method from exported interface has or is using private name 'privateClassT'.
-tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(25,32): error TS4057: Return type of method from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(26,18): error TS4057: Return type of method from exported interface has or is using private name 'privateClassT'.
-tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(27,31): error TS4057: Return type of method from exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(60,85): error TS4004: Type parameter 'T' of exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(79,73): error TS4004: Type parameter 'T' of exported interface has or is using private name 'privateClassInPublicModule'.
-tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(82,22): error TS4057: Return type of method from exported interface has or is using private name 'privateClassInPublicModuleT'.
-tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(82,50): error TS4057: Return type of method from exported interface has or is using private name 'privateClassInPublicModule'.
-tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(83,22): error TS4057: Return type of method from exported interface has or is using private name 'privateClassInPublicModuleT'.
-tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(84,49): error TS4057: Return type of method from exported interface has or is using private name 'privateClassInPublicModule'.
-tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(91,22): error TS4057: Return type of method from exported interface has or is using private name 'privateClassInPublicModuleT'.
-tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(91,50): error TS4057: Return type of method from exported interface has or is using private name 'privateClassInPublicModule'.
-tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(92,22): error TS4057: Return type of method from exported interface has or is using private name 'privateClassInPublicModuleT'.
-tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(93,49): error TS4057: Return type of method from exported interface has or is using private name 'privateClassInPublicModule'.
-tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(125,89): error TS4004: Type parameter 'T' of exported interface has or is using private name 'privateModule'.
+tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(13,69): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(16,18): error TS4038: Return type of method 'myMethod1' references inaccessible name 'privateClassT'.
+tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(16,32): error TS4038: Return type of method 'myMethod1' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(17,18): error TS4038: Return type of method 'myMethod2' references inaccessible name 'privateClassT'.
+tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(18,31): error TS4038: Return type of method 'myMethod3' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(25,18): error TS4038: Return type of method 'myMethod1' references inaccessible name 'privateClassT'.
+tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(25,32): error TS4038: Return type of method 'myMethod1' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(26,18): error TS4038: Return type of method 'myMethod2' references inaccessible name 'privateClassT'.
+tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(27,31): error TS4038: Return type of method 'myMethod3' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(60,85): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(79,73): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClassInPublicModule'.
+tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(82,22): error TS4038: Return type of method 'myMethod1' references inaccessible name 'privateClassInPublicModuleT'.
+tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(82,50): error TS4038: Return type of method 'myMethod1' references inaccessible name 'privateClassInPublicModule'.
+tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(83,22): error TS4038: Return type of method 'myMethod2' references inaccessible name 'privateClassInPublicModuleT'.
+tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(84,49): error TS4038: Return type of method 'myMethod3' references inaccessible name 'privateClassInPublicModule'.
+tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(91,22): error TS4038: Return type of method 'myMethod1' references inaccessible name 'privateClassInPublicModuleT'.
+tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(91,50): error TS4038: Return type of method 'myMethod1' references inaccessible name 'privateClassInPublicModule'.
+tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(92,22): error TS4038: Return type of method 'myMethod2' references inaccessible name 'privateClassInPublicModuleT'.
+tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(93,49): error TS4038: Return type of method 'myMethod3' references inaccessible name 'privateClassInPublicModule'.
+tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(125,89): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(145,73): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClassInPrivateModule'.
+tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(145,73): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(148,22): error TS4038: Return type of method 'myMethod1' references inaccessible name 'privateClassInPrivateModuleT'.
+tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(148,22): error TS4038: Return type of method 'myMethod1' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(148,51): error TS4038: Return type of method 'myMethod1' references inaccessible name 'privateClassInPrivateModule'.
+tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(149,22): error TS4038: Return type of method 'myMethod2' references inaccessible name 'privateClassInPrivateModuleT'.
+tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(150,50): error TS4038: Return type of method 'myMethod3' references inaccessible name 'privateClassInPrivateModule'.
+tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(157,22): error TS4038: Return type of method 'myMethod1' references inaccessible name 'privateClassInPrivateModuleT'.
+tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(157,51): error TS4038: Return type of method 'myMethod1' references inaccessible name 'privateClassInPrivateModule'.
+tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(158,22): error TS4038: Return type of method 'myMethod2' references inaccessible name 'privateClassInPrivateModuleT'.
+tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(159,50): error TS4038: Return type of method 'myMethod3' references inaccessible name 'privateClassInPrivateModule'.
 
 
-==== tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts (20 errors) ====
+==== tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts (31 errors) ====
     class privateClass {
     }
     
@@ -35,20 +46,20 @@ tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(125,89): error
     
     export interface publicInterfaceWithPrivateTypeParameters<T extends privateClass> { // Error
                                                                         ~~~~~~~~~~~~
-!!! error TS4004: Type parameter 'T' of exported interface has or is using private name 'privateClass'.
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
         myMethod(val: T): T;
         myMethod0(): publicClassT<T>;
         myMethod1(): privateClassT<privateClass>; 
                      ~~~~~~~~~~~~~
-!!! error TS4057: Return type of method from exported interface has or is using private name 'privateClassT'.
+!!! error TS4038: Return type of method 'myMethod1' references inaccessible name 'privateClassT'.
                                    ~~~~~~~~~~~~
-!!! error TS4057: Return type of method from exported interface has or is using private name 'privateClass'.
+!!! error TS4038: Return type of method 'myMethod1' references inaccessible name 'privateClass'.
         myMethod2(): privateClassT<publicClass>;
                      ~~~~~~~~~~~~~
-!!! error TS4057: Return type of method from exported interface has or is using private name 'privateClassT'.
+!!! error TS4038: Return type of method 'myMethod2' references inaccessible name 'privateClassT'.
         myMethod3(): publicClassT<privateClass>;
                                   ~~~~~~~~~~~~
-!!! error TS4057: Return type of method from exported interface has or is using private name 'privateClass'.
+!!! error TS4038: Return type of method 'myMethod3' references inaccessible name 'privateClass'.
         myMethod4(): publicClassT<publicClass>; 
     }
     
@@ -57,15 +68,15 @@ tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(125,89): error
         myMethod0(): publicClassT<T>
         myMethod1(): privateClassT<privateClass>;
                      ~~~~~~~~~~~~~
-!!! error TS4057: Return type of method from exported interface has or is using private name 'privateClassT'.
+!!! error TS4038: Return type of method 'myMethod1' references inaccessible name 'privateClassT'.
                                    ~~~~~~~~~~~~
-!!! error TS4057: Return type of method from exported interface has or is using private name 'privateClass'.
+!!! error TS4038: Return type of method 'myMethod1' references inaccessible name 'privateClass'.
         myMethod2(): privateClassT<publicClass>;
                      ~~~~~~~~~~~~~
-!!! error TS4057: Return type of method from exported interface has or is using private name 'privateClassT'.
+!!! error TS4038: Return type of method 'myMethod2' references inaccessible name 'privateClassT'.
         myMethod3(): publicClassT<privateClass>;
                                   ~~~~~~~~~~~~
-!!! error TS4057: Return type of method from exported interface has or is using private name 'privateClass'.
+!!! error TS4038: Return type of method 'myMethod3' references inaccessible name 'privateClass'.
         myMethod4(): publicClassT<publicClass>;
     }
     
@@ -100,7 +111,7 @@ tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(125,89): error
     
     export interface publicInterfaceWithPrivateModuleTypeParameterConstraints<T extends privateModule.publicClassInPrivateModule> { // Error
                                                                                         ~~~~~~~~~~~~~
-!!! error TS4004: Type parameter 'T' of exported interface has or is using private name 'privateModule'.
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
     }
     
     interface privateInterfaceWithPrivateModuleTypeParameterConstraints<T extends privateModule.publicClassInPrivateModule> { // Error
@@ -121,20 +132,20 @@ tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(125,89): error
     
         export interface publicInterfaceWithPrivateTypeParameters<T extends privateClassInPublicModule> { // Error
                                                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4004: Type parameter 'T' of exported interface has or is using private name 'privateClassInPublicModule'.
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClassInPublicModule'.
             myMethod(val: T): T;
             myMethod0(): publicClassInPublicModuleT<T>;
             myMethod1(): privateClassInPublicModuleT<privateClassInPublicModule>;
                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4057: Return type of method from exported interface has or is using private name 'privateClassInPublicModuleT'.
+!!! error TS4038: Return type of method 'myMethod1' references inaccessible name 'privateClassInPublicModuleT'.
                                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4057: Return type of method from exported interface has or is using private name 'privateClassInPublicModule'.
+!!! error TS4038: Return type of method 'myMethod1' references inaccessible name 'privateClassInPublicModule'.
             myMethod2(): privateClassInPublicModuleT<publicClassInPublicModule>;
                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4057: Return type of method from exported interface has or is using private name 'privateClassInPublicModuleT'.
+!!! error TS4038: Return type of method 'myMethod2' references inaccessible name 'privateClassInPublicModuleT'.
             myMethod3(): publicClassInPublicModuleT<privateClassInPublicModule>;
                                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4057: Return type of method from exported interface has or is using private name 'privateClassInPublicModule'.
+!!! error TS4038: Return type of method 'myMethod3' references inaccessible name 'privateClassInPublicModule'.
             myMethod4(): publicClassInPublicModuleT<publicClassInPublicModule>;
         }
     
@@ -143,15 +154,15 @@ tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(125,89): error
             myMethod0(): publicClassInPublicModuleT<T>
             myMethod1(): privateClassInPublicModuleT<privateClassInPublicModule>;
                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4057: Return type of method from exported interface has or is using private name 'privateClassInPublicModuleT'.
+!!! error TS4038: Return type of method 'myMethod1' references inaccessible name 'privateClassInPublicModuleT'.
                                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4057: Return type of method from exported interface has or is using private name 'privateClassInPublicModule'.
+!!! error TS4038: Return type of method 'myMethod1' references inaccessible name 'privateClassInPublicModule'.
             myMethod2(): privateClassInPublicModuleT<publicClassInPublicModule>;
                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4057: Return type of method from exported interface has or is using private name 'privateClassInPublicModuleT'.
+!!! error TS4038: Return type of method 'myMethod2' references inaccessible name 'privateClassInPublicModuleT'.
             myMethod3(): publicClassInPublicModuleT<privateClassInPublicModule>;
                                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4057: Return type of method from exported interface has or is using private name 'privateClassInPublicModule'.
+!!! error TS4038: Return type of method 'myMethod3' references inaccessible name 'privateClassInPublicModule'.
             myMethod4(): publicClassInPublicModuleT<publicClassInPublicModule>;
         }
     
@@ -185,7 +196,7 @@ tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(125,89): error
     
         export interface publicInterfaceWithPrivateModuleTypeParameterConstraints<T extends privateModule.publicClassInPrivateModule> { // Error
                                                                                             ~~~~~~~~~~~~~
-!!! error TS4004: Type parameter 'T' of exported interface has or is using private name 'privateModule'.
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
         }
     
         interface privateInterfaceWithPrivateModuleTypeParameterConstraints<T extends privateModule.publicClassInPrivateModule> { // Error
@@ -206,11 +217,25 @@ tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(125,89): error
         }
     
         export interface publicInterfaceWithPrivateTypeParameters<T extends privateClassInPrivateModule> {
+                                                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClassInPrivateModule'.
+                                                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
             myMethod(val: T): T;
             myMethod0(): publicClassInPrivateModuleT<T>;
             myMethod1(): privateClassInPrivateModuleT<privateClassInPrivateModule>;
+                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4038: Return type of method 'myMethod1' references inaccessible name 'privateClassInPrivateModuleT'.
+                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4038: Return type of method 'myMethod1' references inaccessible name 'privateModule'.
+                                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4038: Return type of method 'myMethod1' references inaccessible name 'privateClassInPrivateModule'.
             myMethod2(): privateClassInPrivateModuleT<publicClassInPrivateModule>;
+                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4038: Return type of method 'myMethod2' references inaccessible name 'privateClassInPrivateModuleT'.
             myMethod3(): publicClassInPrivateModuleT<privateClassInPrivateModule>;
+                                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4038: Return type of method 'myMethod3' references inaccessible name 'privateClassInPrivateModule'.
             myMethod4(): publicClassInPrivateModuleT<publicClassInPrivateModule>;
         }
     
@@ -218,8 +243,16 @@ tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(125,89): error
             myMethod(val: T): T;
             myMethod0(): publicClassInPrivateModuleT<T>
             myMethod1(): privateClassInPrivateModuleT<privateClassInPrivateModule>;
+                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4038: Return type of method 'myMethod1' references inaccessible name 'privateClassInPrivateModuleT'.
+                                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4038: Return type of method 'myMethod1' references inaccessible name 'privateClassInPrivateModule'.
             myMethod2(): privateClassInPrivateModuleT<publicClassInPrivateModule>;
+                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4038: Return type of method 'myMethod2' references inaccessible name 'privateClassInPrivateModuleT'.
             myMethod3(): publicClassInPrivateModuleT<privateClassInPrivateModule>;
+                                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4038: Return type of method 'myMethod3' references inaccessible name 'privateClassInPrivateModule'.
             myMethod4(): publicClassInPrivateModuleT<publicClassInPrivateModule>;
         }
     
diff --git a/tests/baselines/reference/privacyVarDeclFile.errors.txt b/tests/baselines/reference/privacyVarDeclFile.errors.txt
index 6ae5373e0c7f7..89d167cfcf8a7 100644
--- a/tests/baselines/reference/privacyVarDeclFile.errors.txt
+++ b/tests/baselines/reference/privacyVarDeclFile.errors.txt
@@ -1,36 +1,58 @@
-tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(105,21): error TS4033: Property 'myProperty' of exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(121,40): error TS4028: Public static property 'myPublicStaticProperty' of exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(123,27): error TS4031: Public property 'myPublicProperty' of exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(148,51): error TS4025: Exported variable 'publicVarWithPrivatePropertyTypes' has or is using private name 'privateClass'.
-tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(153,66): error TS4025: Exported variable 'publicAmbientVarWithPrivatePropertyTypes' has or is using private name 'privateClass'.
-tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(159,21): error TS4033: Property 'myProperty' of exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(162,40): error TS4028: Public static property 'myPublicStaticProperty' of exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(163,27): error TS4031: Public property 'myPublicProperty' of exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(165,57): error TS4025: Exported variable 'publicVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'.
-tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(166,72): error TS4025: Exported variable 'publicAmbientVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'.
-tests/cases/compiler/privacyVarDeclFile_externalModule.ts(9,17): error TS4033: Property 'myProperty' of exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyVarDeclFile_externalModule.ts(25,36): error TS4028: Public static property 'myPublicStaticProperty' of exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyVarDeclFile_externalModule.ts(27,23): error TS4031: Public property 'myPublicProperty' of exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyVarDeclFile_externalModule.ts(52,47): error TS4025: Exported variable 'publicVarWithPrivatePropertyTypes' has or is using private name 'privateClass'.
-tests/cases/compiler/privacyVarDeclFile_externalModule.ts(57,62): error TS4025: Exported variable 'publicAmbientVarWithPrivatePropertyTypes' has or is using private name 'privateClass'.
-tests/cases/compiler/privacyVarDeclFile_externalModule.ts(63,17): error TS4033: Property 'myProperty' of exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyVarDeclFile_externalModule.ts(66,36): error TS4028: Public static property 'myPublicStaticProperty' of exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyVarDeclFile_externalModule.ts(67,23): error TS4031: Public property 'myPublicProperty' of exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyVarDeclFile_externalModule.ts(69,53): error TS4025: Exported variable 'publicVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'.
-tests/cases/compiler/privacyVarDeclFile_externalModule.ts(70,68): error TS4025: Exported variable 'publicAmbientVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'.
-tests/cases/compiler/privacyVarDeclFile_externalModule.ts(90,21): error TS4033: Property 'myProperty' of exported interface has or is using private name 'privateClass'.
-tests/cases/compiler/privacyVarDeclFile_externalModule.ts(106,40): error TS4028: Public static property 'myPublicStaticProperty' of exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyVarDeclFile_externalModule.ts(108,27): error TS4031: Public property 'myPublicProperty' of exported class has or is using private name 'privateClass'.
-tests/cases/compiler/privacyVarDeclFile_externalModule.ts(133,51): error TS4025: Exported variable 'publicVarWithPrivatePropertyTypes' has or is using private name 'privateClass'.
-tests/cases/compiler/privacyVarDeclFile_externalModule.ts(138,66): error TS4025: Exported variable 'publicAmbientVarWithPrivatePropertyTypes' has or is using private name 'privateClass'.
-tests/cases/compiler/privacyVarDeclFile_externalModule.ts(144,21): error TS4033: Property 'myProperty' of exported interface has or is using private name 'privateModule'.
-tests/cases/compiler/privacyVarDeclFile_externalModule.ts(147,40): error TS4028: Public static property 'myPublicStaticProperty' of exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyVarDeclFile_externalModule.ts(148,27): error TS4031: Public property 'myPublicProperty' of exported class has or is using private name 'privateModule'.
-tests/cases/compiler/privacyVarDeclFile_externalModule.ts(150,57): error TS4025: Exported variable 'publicVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'.
-tests/cases/compiler/privacyVarDeclFile_externalModule.ts(151,72): error TS4025: Exported variable 'publicAmbientVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'.
+tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(30,25): error TS4028: Type of property 'myProperty' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(30,25): error TS4028: Type of property 'myProperty' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(46,44): error TS4028: Type of property 'myPublicStaticProperty' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(48,31): error TS4028: Type of property 'myPublicProperty' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(73,55): error TS4025: Type of variable 'publicVarWithPrivatePropertyTypes' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(78,70): error TS4025: Type of variable 'publicAmbientVarWithPrivatePropertyTypes' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(84,25): error TS4028: Type of property 'myProperty' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(87,44): error TS4028: Type of property 'myPublicStaticProperty' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(88,31): error TS4028: Type of property 'myPublicProperty' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(90,61): error TS4025: Type of variable 'publicVarWithPrivateModulePropertyTypes' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(91,76): error TS4025: Type of variable 'publicAmbientVarWithPrivateModulePropertyTypes' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(105,21): error TS4028: Type of property 'myProperty' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(121,40): error TS4028: Type of property 'myPublicStaticProperty' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(123,27): error TS4028: Type of property 'myPublicProperty' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(148,51): error TS4025: Type of variable 'publicVarWithPrivatePropertyTypes' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(153,66): error TS4025: Type of variable 'publicAmbientVarWithPrivatePropertyTypes' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(159,21): error TS4028: Type of property 'myProperty' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(162,40): error TS4028: Type of property 'myPublicStaticProperty' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(163,27): error TS4028: Type of property 'myPublicProperty' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(165,57): error TS4025: Type of variable 'publicVarWithPrivateModulePropertyTypes' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(166,72): error TS4025: Type of variable 'publicAmbientVarWithPrivateModulePropertyTypes' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyVarDeclFile_externalModule.ts(9,17): error TS4028: Type of property 'myProperty' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyVarDeclFile_externalModule.ts(25,36): error TS4028: Type of property 'myPublicStaticProperty' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyVarDeclFile_externalModule.ts(27,23): error TS4028: Type of property 'myPublicProperty' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyVarDeclFile_externalModule.ts(52,47): error TS4025: Type of variable 'publicVarWithPrivatePropertyTypes' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyVarDeclFile_externalModule.ts(57,62): error TS4025: Type of variable 'publicAmbientVarWithPrivatePropertyTypes' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyVarDeclFile_externalModule.ts(63,17): error TS4028: Type of property 'myProperty' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyVarDeclFile_externalModule.ts(66,36): error TS4028: Type of property 'myPublicStaticProperty' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyVarDeclFile_externalModule.ts(67,23): error TS4028: Type of property 'myPublicProperty' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyVarDeclFile_externalModule.ts(69,53): error TS4025: Type of variable 'publicVarWithPrivateModulePropertyTypes' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyVarDeclFile_externalModule.ts(70,68): error TS4025: Type of variable 'publicAmbientVarWithPrivateModulePropertyTypes' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyVarDeclFile_externalModule.ts(90,21): error TS4028: Type of property 'myProperty' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyVarDeclFile_externalModule.ts(106,40): error TS4028: Type of property 'myPublicStaticProperty' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyVarDeclFile_externalModule.ts(108,27): error TS4028: Type of property 'myPublicProperty' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyVarDeclFile_externalModule.ts(133,51): error TS4025: Type of variable 'publicVarWithPrivatePropertyTypes' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyVarDeclFile_externalModule.ts(138,66): error TS4025: Type of variable 'publicAmbientVarWithPrivatePropertyTypes' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyVarDeclFile_externalModule.ts(144,21): error TS4028: Type of property 'myProperty' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyVarDeclFile_externalModule.ts(147,40): error TS4028: Type of property 'myPublicStaticProperty' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyVarDeclFile_externalModule.ts(148,27): error TS4028: Type of property 'myPublicProperty' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyVarDeclFile_externalModule.ts(150,57): error TS4025: Type of variable 'publicVarWithPrivateModulePropertyTypes' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyVarDeclFile_externalModule.ts(151,72): error TS4025: Type of variable 'publicAmbientVarWithPrivateModulePropertyTypes' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyVarDeclFile_externalModule.ts(172,21): error TS4028: Type of property 'myProperty' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyVarDeclFile_externalModule.ts(172,21): error TS4028: Type of property 'myProperty' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyVarDeclFile_externalModule.ts(188,40): error TS4028: Type of property 'myPublicStaticProperty' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyVarDeclFile_externalModule.ts(190,27): error TS4028: Type of property 'myPublicProperty' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyVarDeclFile_externalModule.ts(215,51): error TS4025: Type of variable 'publicVarWithPrivatePropertyTypes' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyVarDeclFile_externalModule.ts(220,66): error TS4025: Type of variable 'publicAmbientVarWithPrivatePropertyTypes' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyVarDeclFile_externalModule.ts(226,21): error TS4028: Type of property 'myProperty' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyVarDeclFile_externalModule.ts(229,40): error TS4028: Type of property 'myPublicStaticProperty' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyVarDeclFile_externalModule.ts(230,27): error TS4028: Type of property 'myPublicProperty' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyVarDeclFile_externalModule.ts(232,57): error TS4025: Type of variable 'publicVarWithPrivateModulePropertyTypes' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyVarDeclFile_externalModule.ts(233,72): error TS4025: Type of variable 'publicAmbientVarWithPrivateModulePropertyTypes' references inaccessible name 'privateModule'.
 
 
-==== tests/cases/compiler/privacyVarDeclFile_externalModule.ts (20 errors) ====
+==== tests/cases/compiler/privacyVarDeclFile_externalModule.ts (31 errors) ====
     
     class privateClass {
     }
@@ -41,7 +63,7 @@ tests/cases/compiler/privacyVarDeclFile_externalModule.ts(151,72): error TS4025:
     export interface publicInterfaceWithPrivatePropertyTypes {
         myProperty: privateClass;  // Error
                     ~~~~~~~~~~~~
-!!! error TS4033: Property 'myProperty' of exported interface has or is using private name 'privateClass'.
+!!! error TS4028: Type of property 'myProperty' references inaccessible name 'privateClass'.
     }
     
     export interface publicInterfaceWithPublicPropertyTypes {
@@ -59,11 +81,11 @@ tests/cases/compiler/privacyVarDeclFile_externalModule.ts(151,72): error TS4025:
     export class publicClassWithWithPrivatePropertyTypes {
         static myPublicStaticProperty: privateClass; // Error
                                        ~~~~~~~~~~~~
-!!! error TS4028: Public static property 'myPublicStaticProperty' of exported class has or is using private name 'privateClass'.
+!!! error TS4028: Type of property 'myPublicStaticProperty' references inaccessible name 'privateClass'.
         private static myPrivateStaticProperty: privateClass;
         myPublicProperty: privateClass; // Error
                           ~~~~~~~~~~~~
-!!! error TS4031: Public property 'myPublicProperty' of exported class has or is using private name 'privateClass'.
+!!! error TS4028: Type of property 'myPublicProperty' references inaccessible name 'privateClass'.
         private myPrivateProperty: privateClass;
     }
     
@@ -90,14 +112,14 @@ tests/cases/compiler/privacyVarDeclFile_externalModule.ts(151,72): error TS4025:
     
     export var publicVarWithPrivatePropertyTypes: privateClass; // Error
                                                   ~~~~~~~~~~~~
-!!! error TS4025: Exported variable 'publicVarWithPrivatePropertyTypes' has or is using private name 'privateClass'.
+!!! error TS4025: Type of variable 'publicVarWithPrivatePropertyTypes' references inaccessible name 'privateClass'.
     export var publicVarWithPublicPropertyTypes: publicClass;
     var privateVarWithPrivatePropertyTypes: privateClass;
     var privateVarWithPublicPropertyTypes: publicClass;
     
     export declare var publicAmbientVarWithPrivatePropertyTypes: privateClass; // Error
                                                                  ~~~~~~~~~~~~
-!!! error TS4025: Exported variable 'publicAmbientVarWithPrivatePropertyTypes' has or is using private name 'privateClass'.
+!!! error TS4025: Type of variable 'publicAmbientVarWithPrivatePropertyTypes' references inaccessible name 'privateClass'.
     export declare var publicAmbientVarWithPublicPropertyTypes: publicClass;
     declare var privateAmbientVarWithPrivatePropertyTypes: privateClass;
     declare var privateAmbientVarWithPublicPropertyTypes: publicClass;
@@ -105,22 +127,22 @@ tests/cases/compiler/privacyVarDeclFile_externalModule.ts(151,72): error TS4025:
     export interface publicInterfaceWithPrivateModulePropertyTypes {
         myProperty: privateModule.publicClass; // Error
                     ~~~~~~~~~~~~~
-!!! error TS4033: Property 'myProperty' of exported interface has or is using private name 'privateModule'.
+!!! error TS4028: Type of property 'myProperty' references inaccessible name 'privateModule'.
     }
     export class publicClassWithPrivateModulePropertyTypes {
         static myPublicStaticProperty: privateModule.publicClass; // Error
                                        ~~~~~~~~~~~~~
-!!! error TS4028: Public static property 'myPublicStaticProperty' of exported class has or is using private name 'privateModule'.
+!!! error TS4028: Type of property 'myPublicStaticProperty' references inaccessible name 'privateModule'.
         myPublicProperty: privateModule.publicClass; // Error
                           ~~~~~~~~~~~~~
-!!! error TS4031: Public property 'myPublicProperty' of exported class has or is using private name 'privateModule'.
+!!! error TS4028: Type of property 'myPublicProperty' references inaccessible name 'privateModule'.
     }
     export var publicVarWithPrivateModulePropertyTypes: privateModule.publicClass; // Error
                                                         ~~~~~~~~~~~~~
-!!! error TS4025: Exported variable 'publicVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'.
+!!! error TS4025: Type of variable 'publicVarWithPrivateModulePropertyTypes' references inaccessible name 'privateModule'.
     export declare var publicAmbientVarWithPrivateModulePropertyTypes: privateModule.publicClass; // Error
                                                                        ~~~~~~~~~~~~~
-!!! error TS4025: Exported variable 'publicAmbientVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'.
+!!! error TS4025: Type of variable 'publicAmbientVarWithPrivateModulePropertyTypes' references inaccessible name 'privateModule'.
     
     interface privateInterfaceWithPrivateModulePropertyTypes {
         myProperty: privateModule.publicClass;
@@ -142,7 +164,7 @@ tests/cases/compiler/privacyVarDeclFile_externalModule.ts(151,72): error TS4025:
         export interface publicInterfaceWithPrivatePropertyTypes {
             myProperty: privateClass;  // Error
                         ~~~~~~~~~~~~
-!!! error TS4033: Property 'myProperty' of exported interface has or is using private name 'privateClass'.
+!!! error TS4028: Type of property 'myProperty' references inaccessible name 'privateClass'.
         }
     
         export interface publicInterfaceWithPublicPropertyTypes {
@@ -160,11 +182,11 @@ tests/cases/compiler/privacyVarDeclFile_externalModule.ts(151,72): error TS4025:
         export class publicClassWithWithPrivatePropertyTypes {
             static myPublicStaticProperty: privateClass; // Error
                                            ~~~~~~~~~~~~
-!!! error TS4028: Public static property 'myPublicStaticProperty' of exported class has or is using private name 'privateClass'.
+!!! error TS4028: Type of property 'myPublicStaticProperty' references inaccessible name 'privateClass'.
             private static myPrivateStaticProperty: privateClass;
             myPublicProperty: privateClass; // Error
                               ~~~~~~~~~~~~
-!!! error TS4031: Public property 'myPublicProperty' of exported class has or is using private name 'privateClass'.
+!!! error TS4028: Type of property 'myPublicProperty' references inaccessible name 'privateClass'.
             private myPrivateProperty: privateClass;
         }
     
@@ -191,14 +213,14 @@ tests/cases/compiler/privacyVarDeclFile_externalModule.ts(151,72): error TS4025:
     
         export var publicVarWithPrivatePropertyTypes: privateClass; // Error
                                                       ~~~~~~~~~~~~
-!!! error TS4025: Exported variable 'publicVarWithPrivatePropertyTypes' has or is using private name 'privateClass'.
+!!! error TS4025: Type of variable 'publicVarWithPrivatePropertyTypes' references inaccessible name 'privateClass'.
         export var publicVarWithPublicPropertyTypes: publicClass;
         var privateVarWithPrivatePropertyTypes: privateClass;
         var privateVarWithPublicPropertyTypes: publicClass;
     
         export declare var publicAmbientVarWithPrivatePropertyTypes: privateClass; // Error
                                                                      ~~~~~~~~~~~~
-!!! error TS4025: Exported variable 'publicAmbientVarWithPrivatePropertyTypes' has or is using private name 'privateClass'.
+!!! error TS4025: Type of variable 'publicAmbientVarWithPrivatePropertyTypes' references inaccessible name 'privateClass'.
         export declare var publicAmbientVarWithPublicPropertyTypes: publicClass;
         declare var privateAmbientVarWithPrivatePropertyTypes: privateClass;
         declare var privateAmbientVarWithPublicPropertyTypes: publicClass;
@@ -206,22 +228,22 @@ tests/cases/compiler/privacyVarDeclFile_externalModule.ts(151,72): error TS4025:
         export interface publicInterfaceWithPrivateModulePropertyTypes {
             myProperty: privateModule.publicClass; // Error
                         ~~~~~~~~~~~~~
-!!! error TS4033: Property 'myProperty' of exported interface has or is using private name 'privateModule'.
+!!! error TS4028: Type of property 'myProperty' references inaccessible name 'privateModule'.
         }
         export class publicClassWithPrivateModulePropertyTypes {
             static myPublicStaticProperty: privateModule.publicClass; // Error
                                            ~~~~~~~~~~~~~
-!!! error TS4028: Public static property 'myPublicStaticProperty' of exported class has or is using private name 'privateModule'.
+!!! error TS4028: Type of property 'myPublicStaticProperty' references inaccessible name 'privateModule'.
             myPublicProperty: privateModule.publicClass; // Error
                               ~~~~~~~~~~~~~
-!!! error TS4031: Public property 'myPublicProperty' of exported class has or is using private name 'privateModule'.
+!!! error TS4028: Type of property 'myPublicProperty' references inaccessible name 'privateModule'.
         }
         export var publicVarWithPrivateModulePropertyTypes: privateModule.publicClass; // Error
                                                             ~~~~~~~~~~~~~
-!!! error TS4025: Exported variable 'publicVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'.
+!!! error TS4025: Type of variable 'publicVarWithPrivateModulePropertyTypes' references inaccessible name 'privateModule'.
         export declare var publicAmbientVarWithPrivateModulePropertyTypes: privateModule.publicClass; // Error
                                                                            ~~~~~~~~~~~~~
-!!! error TS4025: Exported variable 'publicAmbientVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'.
+!!! error TS4025: Type of variable 'publicAmbientVarWithPrivateModulePropertyTypes' references inaccessible name 'privateModule'.
     
         interface privateInterfaceWithPrivateModulePropertyTypes {
             myProperty: privateModule.publicClass;
@@ -243,6 +265,10 @@ tests/cases/compiler/privacyVarDeclFile_externalModule.ts(151,72): error TS4025:
     
         export interface publicInterfaceWithPrivatePropertyTypes {
             myProperty: privateClass;  
+                        ~~~~~~~~~~~~
+!!! error TS4028: Type of property 'myProperty' references inaccessible name 'privateClass'.
+                        ~~~~~~~~~~~~
+!!! error TS4028: Type of property 'myProperty' references inaccessible name 'privateModule'.
         }
     
         export interface publicInterfaceWithPublicPropertyTypes {
@@ -259,8 +285,12 @@ tests/cases/compiler/privacyVarDeclFile_externalModule.ts(151,72): error TS4025:
     
         export class publicClassWithWithPrivatePropertyTypes {
             static myPublicStaticProperty: privateClass; 
+                                           ~~~~~~~~~~~~
+!!! error TS4028: Type of property 'myPublicStaticProperty' references inaccessible name 'privateClass'.
             private static myPrivateStaticProperty: privateClass;
             myPublicProperty: privateClass; 
+                              ~~~~~~~~~~~~
+!!! error TS4028: Type of property 'myPublicProperty' references inaccessible name 'privateClass'.
             private myPrivateProperty: privateClass;
         }
     
@@ -286,24 +316,38 @@ tests/cases/compiler/privacyVarDeclFile_externalModule.ts(151,72): error TS4025:
         }
     
         export var publicVarWithPrivatePropertyTypes: privateClass; 
+                                                      ~~~~~~~~~~~~
+!!! error TS4025: Type of variable 'publicVarWithPrivatePropertyTypes' references inaccessible name 'privateClass'.
         export var publicVarWithPublicPropertyTypes: publicClass;
         var privateVarWithPrivatePropertyTypes: privateClass;
         var privateVarWithPublicPropertyTypes: publicClass;
     
         export declare var publicAmbientVarWithPrivatePropertyTypes: privateClass; 
+                                                                     ~~~~~~~~~~~~
+!!! error TS4025: Type of variable 'publicAmbientVarWithPrivatePropertyTypes' references inaccessible name 'privateClass'.
         export declare var publicAmbientVarWithPublicPropertyTypes: publicClass;
         declare var privateAmbientVarWithPrivatePropertyTypes: privateClass;
         declare var privateAmbientVarWithPublicPropertyTypes: publicClass;
     
         export interface publicInterfaceWithPrivateModulePropertyTypes {
             myProperty: privateModule.publicClass; 
+                        ~~~~~~~~~~~~~
+!!! error TS4028: Type of property 'myProperty' references inaccessible name 'privateModule'.
         }
         export class publicClassWithPrivateModulePropertyTypes {
             static myPublicStaticProperty: privateModule.publicClass; 
+                                           ~~~~~~~~~~~~~
+!!! error TS4028: Type of property 'myPublicStaticProperty' references inaccessible name 'privateModule'.
             myPublicProperty: privateModule.publicClass; 
+                              ~~~~~~~~~~~~~
+!!! error TS4028: Type of property 'myPublicProperty' references inaccessible name 'privateModule'.
         }
         export var publicVarWithPrivateModulePropertyTypes: privateModule.publicClass; 
+                                                            ~~~~~~~~~~~~~
+!!! error TS4025: Type of variable 'publicVarWithPrivateModulePropertyTypes' references inaccessible name 'privateModule'.
         export declare var publicAmbientVarWithPrivateModulePropertyTypes: privateModule.publicClass;
+                                                                           ~~~~~~~~~~~~~
+!!! error TS4025: Type of variable 'publicAmbientVarWithPrivateModulePropertyTypes' references inaccessible name 'privateModule'.
     
         interface privateInterfaceWithPrivateModulePropertyTypes {
             myProperty: privateModule.publicClass;
@@ -316,7 +360,7 @@ tests/cases/compiler/privacyVarDeclFile_externalModule.ts(151,72): error TS4025:
         declare var privateAmbientVarWithPrivateModulePropertyTypes: privateModule.publicClass;
     }
     
-==== tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts (10 errors) ====
+==== tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts (21 errors) ====
     class publicClassInGlobal {
     }
     interface publicInterfaceWithPublicPropertyTypesInGlobal {
@@ -347,6 +391,10 @@ tests/cases/compiler/privacyVarDeclFile_externalModule.ts(151,72): error TS4025:
     
             export interface publicInterfaceWithPrivatePropertyTypes {
                 myProperty: privateClass;
+                            ~~~~~~~~~~~~
+!!! error TS4028: Type of property 'myProperty' references inaccessible name 'privateClass'.
+                            ~~~~~~~~~~~~
+!!! error TS4028: Type of property 'myProperty' references inaccessible name 'privateModule'.
             }
     
             export interface publicInterfaceWithPublicPropertyTypes {
@@ -363,8 +411,12 @@ tests/cases/compiler/privacyVarDeclFile_externalModule.ts(151,72): error TS4025:
     
             export class publicClassWithWithPrivatePropertyTypes {
                 static myPublicStaticProperty: privateClass;
+                                               ~~~~~~~~~~~~
+!!! error TS4028: Type of property 'myPublicStaticProperty' references inaccessible name 'privateClass'.
                 private static myPrivateStaticProperty: privateClass;
                 myPublicProperty: privateClass;
+                                  ~~~~~~~~~~~~
+!!! error TS4028: Type of property 'myPublicProperty' references inaccessible name 'privateClass'.
                 private myPrivateProperty: privateClass;
             }
     
@@ -390,24 +442,38 @@ tests/cases/compiler/privacyVarDeclFile_externalModule.ts(151,72): error TS4025:
             }
     
             export var publicVarWithPrivatePropertyTypes: privateClass;
+                                                          ~~~~~~~~~~~~
+!!! error TS4025: Type of variable 'publicVarWithPrivatePropertyTypes' references inaccessible name 'privateClass'.
             export var publicVarWithPublicPropertyTypes: publicClass;
             var privateVarWithPrivatePropertyTypes: privateClass;
             var privateVarWithPublicPropertyTypes: publicClass;
     
             export declare var publicAmbientVarWithPrivatePropertyTypes: privateClass;
+                                                                         ~~~~~~~~~~~~
+!!! error TS4025: Type of variable 'publicAmbientVarWithPrivatePropertyTypes' references inaccessible name 'privateClass'.
             export declare var publicAmbientVarWithPublicPropertyTypes: publicClass;
             declare var privateAmbientVarWithPrivatePropertyTypes: privateClass;
             declare var privateAmbientVarWithPublicPropertyTypes: publicClass;
     
             export interface publicInterfaceWithPrivateModulePropertyTypes {
                 myProperty: privateModule.publicClass;
+                            ~~~~~~~~~~~~~
+!!! error TS4028: Type of property 'myProperty' references inaccessible name 'privateModule'.
             }
             export class publicClassWithPrivateModulePropertyTypes {
                 static myPublicStaticProperty: privateModule.publicClass;
+                                               ~~~~~~~~~~~~~
+!!! error TS4028: Type of property 'myPublicStaticProperty' references inaccessible name 'privateModule'.
                 myPublicProperty: privateModule.publicClass;
+                                  ~~~~~~~~~~~~~
+!!! error TS4028: Type of property 'myPublicProperty' references inaccessible name 'privateModule'.
             }
             export var publicVarWithPrivateModulePropertyTypes: privateModule.publicClass;
+                                                                ~~~~~~~~~~~~~
+!!! error TS4025: Type of variable 'publicVarWithPrivateModulePropertyTypes' references inaccessible name 'privateModule'.
             export declare var publicAmbientVarWithPrivateModulePropertyTypes: privateModule.publicClass;
+                                                                               ~~~~~~~~~~~~~
+!!! error TS4025: Type of variable 'publicAmbientVarWithPrivateModulePropertyTypes' references inaccessible name 'privateModule'.
     
             interface privateInterfaceWithPrivateModulePropertyTypes {
                 myProperty: privateModule.publicClass;
@@ -423,7 +489,7 @@ tests/cases/compiler/privacyVarDeclFile_externalModule.ts(151,72): error TS4025:
         export interface publicInterfaceWithPrivatePropertyTypes {
             myProperty: privateClass;  // Error
                         ~~~~~~~~~~~~
-!!! error TS4033: Property 'myProperty' of exported interface has or is using private name 'privateClass'.
+!!! error TS4028: Type of property 'myProperty' references inaccessible name 'privateClass'.
         }
     
         export interface publicInterfaceWithPublicPropertyTypes {
@@ -441,11 +507,11 @@ tests/cases/compiler/privacyVarDeclFile_externalModule.ts(151,72): error TS4025:
         export class publicClassWithWithPrivatePropertyTypes {
             static myPublicStaticProperty: privateClass; // Error
                                            ~~~~~~~~~~~~
-!!! error TS4028: Public static property 'myPublicStaticProperty' of exported class has or is using private name 'privateClass'.
+!!! error TS4028: Type of property 'myPublicStaticProperty' references inaccessible name 'privateClass'.
             private static myPrivateStaticProperty: privateClass;
             myPublicProperty: privateClass; // Error
                               ~~~~~~~~~~~~
-!!! error TS4031: Public property 'myPublicProperty' of exported class has or is using private name 'privateClass'.
+!!! error TS4028: Type of property 'myPublicProperty' references inaccessible name 'privateClass'.
             private myPrivateProperty: privateClass;
         }
     
@@ -472,14 +538,14 @@ tests/cases/compiler/privacyVarDeclFile_externalModule.ts(151,72): error TS4025:
     
         export var publicVarWithPrivatePropertyTypes: privateClass; // Error
                                                       ~~~~~~~~~~~~
-!!! error TS4025: Exported variable 'publicVarWithPrivatePropertyTypes' has or is using private name 'privateClass'.
+!!! error TS4025: Type of variable 'publicVarWithPrivatePropertyTypes' references inaccessible name 'privateClass'.
         export var publicVarWithPublicPropertyTypes: publicClass;
         var privateVarWithPrivatePropertyTypes: privateClass;
         var privateVarWithPublicPropertyTypes: publicClass;
     
         export declare var publicAmbientVarWithPrivatePropertyTypes: privateClass; // Error
                                                                      ~~~~~~~~~~~~
-!!! error TS4025: Exported variable 'publicAmbientVarWithPrivatePropertyTypes' has or is using private name 'privateClass'.
+!!! error TS4025: Type of variable 'publicAmbientVarWithPrivatePropertyTypes' references inaccessible name 'privateClass'.
         export declare var publicAmbientVarWithPublicPropertyTypes: publicClass;
         declare var privateAmbientVarWithPrivatePropertyTypes: privateClass;
         declare var privateAmbientVarWithPublicPropertyTypes: publicClass;
@@ -487,22 +553,22 @@ tests/cases/compiler/privacyVarDeclFile_externalModule.ts(151,72): error TS4025:
         export interface publicInterfaceWithPrivateModulePropertyTypes {
             myProperty: privateModule.publicClass; // Error
                         ~~~~~~~~~~~~~
-!!! error TS4033: Property 'myProperty' of exported interface has or is using private name 'privateModule'.
+!!! error TS4028: Type of property 'myProperty' references inaccessible name 'privateModule'.
         }
         export class publicClassWithPrivateModulePropertyTypes {
             static myPublicStaticProperty: privateModule.publicClass; // Error
                                            ~~~~~~~~~~~~~
-!!! error TS4028: Public static property 'myPublicStaticProperty' of exported class has or is using private name 'privateModule'.
+!!! error TS4028: Type of property 'myPublicStaticProperty' references inaccessible name 'privateModule'.
             myPublicProperty: privateModule.publicClass; // Error
                               ~~~~~~~~~~~~~
-!!! error TS4031: Public property 'myPublicProperty' of exported class has or is using private name 'privateModule'.
+!!! error TS4028: Type of property 'myPublicProperty' references inaccessible name 'privateModule'.
         }
         export var publicVarWithPrivateModulePropertyTypes: privateModule.publicClass; // Error
                                                             ~~~~~~~~~~~~~
-!!! error TS4025: Exported variable 'publicVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'.
+!!! error TS4025: Type of variable 'publicVarWithPrivateModulePropertyTypes' references inaccessible name 'privateModule'.
         export declare var publicAmbientVarWithPrivateModulePropertyTypes: privateModule.publicClass; // Error
                                                                            ~~~~~~~~~~~~~
-!!! error TS4025: Exported variable 'publicAmbientVarWithPrivateModulePropertyTypes' has or is using private name 'privateModule'.
+!!! error TS4025: Type of variable 'publicAmbientVarWithPrivateModulePropertyTypes' references inaccessible name 'privateModule'.
     
         interface privateInterfaceWithPrivateModulePropertyTypes {
             myProperty: privateModule.publicClass;
diff --git a/tests/baselines/reference/symbolDeclarationEmit12.errors.txt b/tests/baselines/reference/symbolDeclarationEmit12.errors.txt
index cdc712f698d06..d7f739dc905ea 100644
--- a/tests/baselines/reference/symbolDeclarationEmit12.errors.txt
+++ b/tests/baselines/reference/symbolDeclarationEmit12.errors.txt
@@ -1,10 +1,10 @@
-tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts(4,28): error TS4031: Public property '[Symbol.iterator]' of exported class has or is using private name 'I'.
+tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts(4,28): error TS4028: Type of property '[Symbol.iterator]' references inaccessible name 'I'.
 tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts(5,9): error TS2300: Duplicate identifier '[Symbol.toPrimitive]'.
-tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts(5,33): error TS4073: Parameter 'x' of public method from exported class has or is using private name 'I'.
-tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts(6,40): error TS4055: Return type of public method from exported class has or is using private name 'I'.
+tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts(5,33): error TS4028: Type of parameter 'x' references inaccessible name 'I'.
+tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts(6,40): error TS4038: Return type of method '[Symbol.isConcatSpreadable]' references inaccessible name 'I'.
 tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts(9,13): error TS2300: Duplicate identifier '[Symbol.toPrimitive]'.
 tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts(10,13): error TS2300: Duplicate identifier '[Symbol.toPrimitive]'.
-tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts(10,37): error TS4037: Parameter '[Symbol.toPrimitive]' of public property setter from exported class has or is using private name 'I'.
+tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts(10,37): error TS4028: Type of parameter 'x' references inaccessible name 'I'.
 
 
 ==== tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts (7 errors) ====
@@ -13,15 +13,15 @@ tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts(10,37): error TS4
         export class C {
             [Symbol.iterator]: I;
                                ~
-!!! error TS4031: Public property '[Symbol.iterator]' of exported class has or is using private name 'I'.
+!!! error TS4028: Type of property '[Symbol.iterator]' references inaccessible name 'I'.
             [Symbol.toPrimitive](x: I) { }
             ~~~~~~~~~~~~~~~~~~~~
 !!! error TS2300: Duplicate identifier '[Symbol.toPrimitive]'.
                                     ~
-!!! error TS4073: Parameter 'x' of public method from exported class has or is using private name 'I'.
+!!! error TS4028: Type of parameter 'x' references inaccessible name 'I'.
             [Symbol.isConcatSpreadable](): I {
                                            ~
-!!! error TS4055: Return type of public method from exported class has or is using private name 'I'.
+!!! error TS4038: Return type of method '[Symbol.isConcatSpreadable]' references inaccessible name 'I'.
                 return undefined
             }
             get [Symbol.toPrimitive]() { return undefined; }
@@ -31,6 +31,6 @@ tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts(10,37): error TS4
                 ~~~~~~~~~~~~~~~~~~~~
 !!! error TS2300: Duplicate identifier '[Symbol.toPrimitive]'.
                                         ~
-!!! error TS4037: Parameter '[Symbol.toPrimitive]' of public property setter from exported class has or is using private name 'I'.
+!!! error TS4028: Type of parameter 'x' references inaccessible name 'I'.
         }
     }
\ No newline at end of file

From 8209348ab4a1fbb1382208046ea7e3a138b536f5 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Tue, 14 Jul 2015 15:12:13 -0700
Subject: [PATCH 37/57] Accept baseline change

---
 tests/baselines/reference/intrinsics.errors.txt |  5 +----
 tests/baselines/reference/intrinsics.js         | 10 ++++++++++
 2 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/tests/baselines/reference/intrinsics.errors.txt b/tests/baselines/reference/intrinsics.errors.txt
index 342b84e02b995..e9529d4b9f0eb 100644
--- a/tests/baselines/reference/intrinsics.errors.txt
+++ b/tests/baselines/reference/intrinsics.errors.txt
@@ -1,15 +1,12 @@
 tests/cases/compiler/intrinsics.ts(2,21): error TS2304: Cannot find name 'hasOwnProperty'.
-tests/cases/compiler/intrinsics.ts(2,21): error TS4025: Exported variable 'hasOwnProperty' has or is using private name 'hasOwnProperty'.
 tests/cases/compiler/intrinsics.ts(11,1): error TS2304: Cannot find name '__proto__'.
 
 
-==== tests/cases/compiler/intrinsics.ts (3 errors) ====
+==== tests/cases/compiler/intrinsics.ts (2 errors) ====
     
     var hasOwnProperty: hasOwnProperty; // Error
                         ~~~~~~~~~~~~~~
 !!! error TS2304: Cannot find name 'hasOwnProperty'.
-                        ~~~~~~~~~~~~~~
-!!! error TS4025: Exported variable 'hasOwnProperty' has or is using private name 'hasOwnProperty'.
     
     module m1 {
         export var __proto__;
diff --git a/tests/baselines/reference/intrinsics.js b/tests/baselines/reference/intrinsics.js
index 736ffa020fa2b..675e10c01d3ac 100644
--- a/tests/baselines/reference/intrinsics.js
+++ b/tests/baselines/reference/intrinsics.js
@@ -33,3 +33,13 @@ var Foo = (function () {
     return Foo;
 })();
 var foo;
+
+
+//// [intrinsics.d.ts]
+declare var hasOwnProperty: hasOwnProperty;
+declare module m1 {
+    var __proto__: any;
+}
+declare class Foo<__proto__> {
+}
+declare var foo: (__proto__: number) => void;

From d18b82978911510a47781b4d82d1746a5b66d7cf Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Tue, 14 Jul 2015 19:35:07 -0700
Subject: [PATCH 38/57] Accept baseline

---
 ...TypeAnnotationVisibilityErrorAccessors.errors.txt | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.errors.txt b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.errors.txt
index f6550e22fd505..ff5a6429a802f 100644
--- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.errors.txt
+++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.errors.txt
@@ -1,12 +1,12 @@
 tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(16,21): error TS4043: Return type of property getter 'foo1' references inaccessible name 'private1'.
 tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(21,13): error TS4043: Return type of property getter 'foo2' references inaccessible name 'private1'.
 tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(26,25): error TS4028: Type of parameter 'param' references inaccessible name 'private1'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(30,13): error TS4043: Return type of property getter 'foo4' references inaccessible name 'private1'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(33,25): error TS4028: Type of parameter 'param' references inaccessible name 'private1'.
 tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(37,21): error TS4043: Return type of property getter 'foo5' references inaccessible name 'private1'.
 tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(72,23): error TS4043: Return type of property getter 'foo111' references inaccessible name 'm2'.
 tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(77,13): error TS4043: Return type of property getter 'foo112' references inaccessible name 'm2'.
 tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(82,27): error TS4028: Type of parameter 'param' references inaccessible name 'm2'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(86,13): error TS4043: Return type of property getter 'foo114' references inaccessible name 'm2'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(89,27): error TS4028: Type of parameter 'param' references inaccessible name 'm2'.
 tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(93,23): error TS4043: Return type of property getter 'foo115' references inaccessible name 'm2'.
 
 
@@ -47,11 +47,11 @@ tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(93,23): e
     
             // Both - getter without annotation, setter with annotation
             get foo4() {
-                ~~~~
-!!! error TS4043: Return type of property getter 'foo4' references inaccessible name 'private1'.
                 return new private1();
             }
             set foo4(param: private1) {
+                            ~~~~~~~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'private1'.
             }
     
             // Both - with annotation
@@ -113,11 +113,11 @@ tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(93,23): e
     
             // Both - getter without annotation, setter with annotation
             get foo114() {
-                ~~~~~~
-!!! error TS4043: Return type of property getter 'foo114' references inaccessible name 'm2'.
                 return new m2.public2();
             }
             set foo114(param: m2.public2) {
+                              ~~
+!!! error TS4028: Type of parameter 'param' references inaccessible name 'm2'.
             }
     
             // Both - with annotation

From d47caa268611999fd6498e6af6c711cc2abe75bb Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Thu, 16 Jul 2015 11:10:17 -0700
Subject: [PATCH 39/57] Handel inaccisible symbol errors

---
 src/compiler/checker.ts                       |   5 +
 src/compiler/declarationEmitter.ts            |  54 ++
 .../diagnosticInformationMap.generated.ts     |   8 +-
 src/compiler/diagnosticMessages.json          |  27 +-
 src/compiler/types.ts                         |   5 +-
 src/compiler/utilities.ts                     |   3 +-
 src/services/utilities.ts                     |   3 +-
 ...otationVisibilityErrorAccessors.errors.txt |  16 +-
 ...ibilityErrorParameterOfFunction.errors.txt |  16 +-
 ...ationVisibilityErrorTypeLiteral.errors.txt |   8 +-
 .../reference/declInput-2.errors.txt          |   4 +-
 .../privacyAccessorDeclFile.errors.txt        |  80 +--
 ...ivacyCannotNameAccessorDeclFile.errors.txt |  32 +-
 .../privacyCannotNameAccessorDeclFile.symbols | 319 ------------
 ...vacyCannotNameAccessorDeclFile2.errors.txt |  29 ++
 .../privacyCannotNameAccessorDeclFile2.js     |  46 ++
 ...rivacyCannotNameVarTypeDeclFile.errors.txt |  64 +--
 .../privacyCannotNameVarTypeDeclFile.symbols  | 315 ------------
 ...CannotNameParameterTypeDeclFile.errors.txt | 144 +++---
 ...ionCannotNameParameterTypeDeclFile.symbols | 483 ------------------
 ...ionCannotNameReturnTypeDeclFile.errors.txt |  48 +-
 ...nctionCannotNameReturnTypeDeclFile.symbols | 386 --------------
 ...rivacyFunctionParameterDeclFile.errors.txt | 408 +++++++--------
 .../symbolDeclarationEmit12.errors.txt        |   8 +-
 .../privacyCannotNameAccessorDeclFile2.ts     |  24 +
 25 files changed, 612 insertions(+), 1923 deletions(-)
 delete mode 100644 tests/baselines/reference/privacyCannotNameAccessorDeclFile.symbols
 create mode 100644 tests/baselines/reference/privacyCannotNameAccessorDeclFile2.errors.txt
 create mode 100644 tests/baselines/reference/privacyCannotNameAccessorDeclFile2.js
 delete mode 100644 tests/baselines/reference/privacyCannotNameVarTypeDeclFile.symbols
 delete mode 100644 tests/baselines/reference/privacyFunctionCannotNameParameterTypeDeclFile.symbols
 delete mode 100644 tests/baselines/reference/privacyFunctionCannotNameReturnTypeDeclFile.symbols
 create mode 100644 tests/cases/compiler/privacyCannotNameAccessorDeclFile2.ts

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index cef4f048f2106..b168161f4d959 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -1567,6 +1567,11 @@ namespace ts {
                             }
                         }
                         else {
+
+                            if (!parentSymbol) {
+                                writer.trackInaccesibleSymbol(symbol);
+                            }
+
                             // If we didn't find accessible symbol chain for this symbol, break if this is external module
                             if (!parentSymbol && ts.forEach(symbol.declarations, hasExternalModuleSymbol)) {
                                 return;
diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index aa29ab393a10b..ebd68b789c6fa 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -128,6 +128,7 @@ namespace ts {
         function createNewTextWriterWithSymbolWriter(): EmitTextWriterWithSymbolWriter {
             let writer = <EmitTextWriterWithSymbolWriter>createTextWriter(newLine);
             writer.trackSymbol = trackSymbol;
+            writer.trackInaccesibleSymbol = trackInaccesibleSymbol;
             writer.writeKeyword = writer.write;
             writer.writeOperator = writer.write;
             writer.writePunctuation = writer.write;
@@ -154,6 +155,12 @@ namespace ts {
             }
         }
 
+        function trackInaccesibleSymbol(symbol: Symbol): void {
+            if (currentErrorNode) {
+                reportUnamedDeclarationMessage(currentErrorNode);
+            }
+        }
+
         function emitTypeOfDeclaration(declaration: AccessorDeclaration | VariableLikeDeclaration, type: TypeNode) {
             write(": ");
             if (type) {
@@ -1525,6 +1532,53 @@ namespace ts {
             Debug.fail("Could not find container node");
         }
 
+        function reportUnamedDeclarationMessage(errorNode: Node): void {
+            reportedDeclarationError = true;
+            let container = errorNode;
+
+            while (container) {
+                switch (container.kind) {
+                    case SyntaxKind.BindingElement:
+                    case SyntaxKind.VariableDeclaration:
+                        diagnostics.push(createDiagnosticForNode(errorNode,
+                            Diagnostics.Name_of_inferred_type_of_variable_0_could_not_be_written_Consider_adding_an_explicit_type_annotation,
+                            getNameText(<VariableDeclaration>container)));
+                        return;
+                    case SyntaxKind.PropertySignature:
+                    case SyntaxKind.PropertyDeclaration:
+                    case SyntaxKind.SetAccessor:
+                    case SyntaxKind.GetAccessor:
+                        diagnostics.push(createDiagnosticForNode(errorNode,
+                            Diagnostics.Name_of_inferred_type_of_property_0_could_not_be_written_Consider_adding_an_explicit_type_annotation,
+                            getNameText(<PropertyDeclaration>container)));
+                        return;
+                    case SyntaxKind.Parameter:
+                        diagnostics.push(createDiagnosticForNode(errorNode,
+                            Diagnostics.Name_of_inferred_type_of_parameter_0_could_not_be_written_Consider_adding_an_explicit_type_annotation,
+                            getNameText(<ParameterDeclaration>container)));
+                        return;
+                    case SyntaxKind.MethodDeclaration:
+                    case SyntaxKind.MethodSignature:
+                        diagnostics.push(createDiagnosticForNode(errorNode,
+                            Diagnostics.Name_of_inferred_return_type_of_method_0_could_not_be_written_Consider_adding_an_explicit_type_annotation,
+                            getNameText(<MethodDeclaration>container)));
+                        return;
+                    case SyntaxKind.FunctionDeclaration:
+                        diagnostics.push(createDiagnosticForNode(errorNode,
+                            Diagnostics.Name_of_inferred_return_type_of_function_0_could_not_be_written_Consider_adding_an_explicit_type_annotation,
+                            getNameText(<FunctionDeclaration>container)));
+                        return;
+                    case SyntaxKind.ExportAssignment:
+                        diagnostics.push(createDiagnosticForNode(errorNode,
+                            Diagnostics.Name_of_inferred_type_of_default_export_could_not_be_written_Consider_exporting_a_declaration_instead));
+                        return;
+                }
+                container = container.parent;
+            }
+
+            Debug.fail("Could not find container node");
+        }
+
         function collectDeclaration(node: Node, errorNode?: Node): void {
             if (node.kind === SyntaxKind.TypeParameter || node.kind === SyntaxKind.Parameter) {
                 return;
diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts
index a46ab3ad12e4a..4c451afc2066b 100644
--- a/src/compiler/diagnosticInformationMap.generated.ts
+++ b/src/compiler/diagnosticInformationMap.generated.ts
@@ -429,16 +429,22 @@ namespace ts {
         Implements_clause_references_inaccessible_name_0: { code: 4019, category: DiagnosticCategory.Error, key: "Implements clause references inaccessible name '{0}'." },
         Extends_clause_references_inaccessible_name_0: { code: 4020, category: DiagnosticCategory.Error, key: "Extends clause references inaccessible name '{0}'." },
         Type_of_variable_0_references_inaccessible_name_1: { code: 4025, category: DiagnosticCategory.Error, key: "Type of variable '{0}' references inaccessible name '{1}'." },
+        Name_of_inferred_type_of_variable_0_could_not_be_written_Consider_adding_an_explicit_type_annotation: { code: 4026, category: DiagnosticCategory.Error, key: "Name of inferred type of variable '{0}' could not be written. Consider adding an explicit type annotation." },
         Type_of_property_0_references_inaccessible_name_1: { code: 4028, category: DiagnosticCategory.Error, key: "Type of property '{0}' references inaccessible name '{1}'." },
-        Type_of_parameter_0_references_inaccessible_name_1: { code: 4028, category: DiagnosticCategory.Error, key: "Type of parameter '{0}' references inaccessible name '{1}'." },
+        Name_of_inferred_type_of_property_0_could_not_be_written_Consider_adding_an_explicit_type_annotation: { code: 4029, category: DiagnosticCategory.Error, key: "Name of inferred type of property '{0}' could not be written. Consider adding an explicit type annotation." },
+        Type_of_parameter_0_references_inaccessible_name_1: { code: 4030, category: DiagnosticCategory.Error, key: "Type of parameter '{0}' references inaccessible name '{1}'." },
+        Name_of_inferred_type_of_parameter_0_could_not_be_written_Consider_adding_an_explicit_type_annotation: { code: 4031, category: DiagnosticCategory.Error, key: "Name of inferred type of parameter '{0}' could not be written. Consider adding an explicit type annotation." },
         Return_type_of_method_0_references_inaccessible_name_1: { code: 4038, category: DiagnosticCategory.Error, key: "Return type of method '{0}' references inaccessible name '{1}'." },
+        Name_of_inferred_return_type_of_method_0_could_not_be_written_Consider_adding_an_explicit_type_annotation: { code: 4039, category: DiagnosticCategory.Error, key: "Name of inferred return type of method '{0}' could not be written. Consider adding an explicit type annotation." },
         Return_type_of_property_getter_0_references_inaccessible_name_1: { code: 4043, category: DiagnosticCategory.Error, key: "Return type of property getter '{0}' references inaccessible name '{1}'." },
         Return_type_of_construct_signature_references_inaccessible_name_0: { code: 4044, category: DiagnosticCategory.Error, key: "Return type of construct signature references inaccessible name '{0}'." },
         Return_type_of_call_signature_references_inaccessible_name_0: { code: 4047, category: DiagnosticCategory.Error, key: "Return type of call signature references inaccessible name '{0}'." },
         Return_type_of_index_signature_references_inaccessible_name_0: { code: 4049, category: DiagnosticCategory.Error, key: "Return type of index signature references inaccessible name '{0}'." },
         Return_type_of_function_0_references_inaccessible_name_1: { code: 4060, category: DiagnosticCategory.Error, key: "Return type of function '{0}' references inaccessible name '{1}'." },
+        Name_of_inferred_return_type_of_function_0_could_not_be_written_Consider_adding_an_explicit_type_annotation: { code: 4061, category: DiagnosticCategory.Error, key: "Name of inferred return type of function '{0}' could not be written. Consider adding an explicit type annotation." },
         Type_alias_0_references_inaccessible_name_1: { code: 4081, category: DiagnosticCategory.Error, key: "Type alias '{0}' references inaccessible name '{1}'." },
         Default_export_of_the_module_references_inaccessible_name_0: { code: 4082, category: DiagnosticCategory.Error, key: "Default export of the module references inaccessible name '{0}'." },
+        Name_of_inferred_type_of_default_export_could_not_be_written_Consider_exporting_a_declaration_instead: { code: 4083, category: DiagnosticCategory.Error, key: "Name of inferred type of default export could not be written. Consider exporting a declaration instead." },
         Loop_contains_block_scoped_variable_0_referenced_by_a_function_in_the_loop_This_is_only_supported_in_ECMAScript_6_or_higher: { code: 4091, category: DiagnosticCategory.Error, key: "Loop contains block-scoped variable '{0}' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher." },
         The_current_host_does_not_support_the_0_option: { code: 5001, category: DiagnosticCategory.Error, key: "The current host does not support the '{0}' option." },
         Cannot_find_the_common_subdirectory_path_for_the_input_files: { code: 5009, category: DiagnosticCategory.Error, key: "Cannot find the common subdirectory path for the input files." },
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index ddee3b7f21412..db2798362c3ab 100644
--- a/src/compiler/diagnosticMessages.json
+++ b/src/compiler/diagnosticMessages.json
@@ -1706,18 +1706,34 @@
         "category": "Error",
         "code": 4025
     },
+    "Name of inferred type of variable '{0}' could not be written. Consider adding an explicit type annotation.": {
+        "category": "Error",
+        "code": 4026
+    },
     "Type of property '{0}' references inaccessible name '{1}'.": {
         "category": "Error",
         "code": 4028
     },
+    "Name of inferred type of property '{0}' could not be written. Consider adding an explicit type annotation.": {
+        "category": "Error",
+        "code": 4029
+    },
     "Type of parameter '{0}' references inaccessible name '{1}'.": {
         "category": "Error",
-        "code": 4028
+        "code": 4030
+    },
+    "Name of inferred type of parameter '{0}' could not be written. Consider adding an explicit type annotation.": {
+        "category": "Error",
+        "code": 4031
     },
     "Return type of method '{0}' references inaccessible name '{1}'.": {
         "category": "Error",
         "code": 4038
     },
+    "Name of inferred return type of method '{0}' could not be written. Consider adding an explicit type annotation.": {
+        "category": "Error",
+        "code": 4039
+    },
     "Return type of property getter '{0}' references inaccessible name '{1}'.": {
         "category": "Error",
         "code": 4043
@@ -1738,6 +1754,10 @@
         "category": "Error",
         "code": 4060
     },
+    "Name of inferred return type of function '{0}' could not be written. Consider adding an explicit type annotation.": {
+        "category": "Error",
+        "code": 4061
+    },
     "Type alias '{0}' references inaccessible name '{1}'.": {
         "category": "Error",
         "code": 4081
@@ -1746,6 +1766,11 @@
         "category": "Error",
         "code": 4082
     },
+    "Name of inferred type of default export could not be written. Consider exporting a declaration instead.": {
+        "category": "Error",
+        "code": 4083
+    },
+
 
     "Loop contains block-scoped variable '{0}' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher.": {
         "category": "Error",
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 138726ccc5d62..5c45d6d4fb9d6 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -1471,6 +1471,7 @@ namespace ts {
         // declaration emitter to help determine if it should patch up the final declaration file
         // with import statements it previously saw (but chose not to emit).
         trackSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): void;
+        trackInaccesibleSymbol(symbol: Symbol): void;
     }
 
     export const enum TypeFormatFlags {
@@ -1786,10 +1787,10 @@ namespace ts {
         StringLike = String | StringLiteral,
         NumberLike = Number | Enum,
         ObjectType = Class | Interface | Reference | Tuple | Anonymous,
-        UnionOrIntersection = Union | Intersection,
+        UnionOrIntersection = Union | Intersection,
         StructuredType = ObjectType | Union | Intersection,
         /* @internal */
-        RequiresWidening = ContainsUndefinedOrNull | ContainsObjectLiteral
+        RequiresWidening = ContainsUndefinedOrNull | ContainsObjectLiteral
     }
 
     // Properties common to all types
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index 5174589cdcf3b..1d8555b34bb3d 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -64,7 +64,8 @@ namespace ts {
                 increaseIndent: () => { },
                 decreaseIndent: () => { },
                 clear: () => str = "",
-                trackSymbol: () => { }
+                trackSymbol: () => { },
+                trackInaccesibleSymbol: () => { }
             };
         }
 
diff --git a/src/services/utilities.ts b/src/services/utilities.ts
index 5f8859c815e1f..c3e55b2bff63b 100644
--- a/src/services/utilities.ts
+++ b/src/services/utilities.ts
@@ -528,7 +528,8 @@ namespace ts {
             increaseIndent: () => { indent++; },
             decreaseIndent: () => { indent--; },
             clear: resetWriter,
-            trackSymbol: () => { }
+            trackSymbol: () => { },
+            trackInaccesibleSymbol: () => { }
         };
 
         function writeIndent() {
diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.errors.txt b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.errors.txt
index ff5a6429a802f..8101b25f1a0ee 100644
--- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.errors.txt
+++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.errors.txt
@@ -1,12 +1,12 @@
 tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(16,21): error TS4043: Return type of property getter 'foo1' references inaccessible name 'private1'.
 tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(21,13): error TS4043: Return type of property getter 'foo2' references inaccessible name 'private1'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(26,25): error TS4028: Type of parameter 'param' references inaccessible name 'private1'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(33,25): error TS4028: Type of parameter 'param' references inaccessible name 'private1'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(26,25): error TS4030: Type of parameter 'param' references inaccessible name 'private1'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(33,25): error TS4030: Type of parameter 'param' references inaccessible name 'private1'.
 tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(37,21): error TS4043: Return type of property getter 'foo5' references inaccessible name 'private1'.
 tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(72,23): error TS4043: Return type of property getter 'foo111' references inaccessible name 'm2'.
 tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(77,13): error TS4043: Return type of property getter 'foo112' references inaccessible name 'm2'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(82,27): error TS4028: Type of parameter 'param' references inaccessible name 'm2'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(89,27): error TS4028: Type of parameter 'param' references inaccessible name 'm2'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(82,27): error TS4030: Type of parameter 'param' references inaccessible name 'm2'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(89,27): error TS4030: Type of parameter 'param' references inaccessible name 'm2'.
 tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(93,23): error TS4043: Return type of property getter 'foo115' references inaccessible name 'm2'.
 
 
@@ -42,7 +42,7 @@ tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(93,23): e
             // setter with annotation
             set foo3(param: private1) {
                             ~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'private1'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'private1'.
             }
     
             // Both - getter without annotation, setter with annotation
@@ -51,7 +51,7 @@ tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(93,23): e
             }
             set foo4(param: private1) {
                             ~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'private1'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'private1'.
             }
     
             // Both - with annotation
@@ -108,7 +108,7 @@ tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(93,23): e
             // setter with annotation
             set foo113(param: m2.public2) {
                               ~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'm2'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'm2'.
             }
     
             // Both - getter without annotation, setter with annotation
@@ -117,7 +117,7 @@ tests/cases/compiler/declFileTypeAnnotationVisibilityErrorAccessors.ts(93,23): e
             }
             set foo114(param: m2.public2) {
                               ~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'm2'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'm2'.
             }
     
             // Both - with annotation
diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorParameterOfFunction.errors.txt b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorParameterOfFunction.errors.txt
index 62f163d9a04ab..eb7553fdf377c 100644
--- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorParameterOfFunction.errors.txt
+++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorParameterOfFunction.errors.txt
@@ -1,7 +1,7 @@
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts(15,34): error TS4028: Type of parameter 'param' references inaccessible name 'private1'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts(17,26): error TS4028: Type of parameter 'param' references inaccessible name 'private1'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts(40,35): error TS4028: Type of parameter 'param' references inaccessible name 'm2'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts(42,28): error TS4028: Type of parameter 'param' references inaccessible name 'm2'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts(15,34): error TS4030: Type of parameter 'param' references inaccessible name 'private1'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts(17,26): error TS4030: Type of parameter 'param' references inaccessible name 'private1'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts(40,35): error TS4030: Type of parameter 'param' references inaccessible name 'm2'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts(42,28): error TS4030: Type of parameter 'param' references inaccessible name 'm2'.
 
 
 ==== tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts (4 errors) ====
@@ -21,11 +21,11 @@ tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts
     
         export function foo3(param : private1) {
                                      ~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'private1'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'private1'.
         }
         export function foo4(param = new private1()) {
                              ~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'private1'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'private1'.
         }
     
         function foo11(param: public1) {
@@ -50,11 +50,11 @@ tests/cases/compiler/declFileTypeAnnotationVisibilityErrorParameterOfFunction.ts
     
         export function foo113(param: m2.public2) {
                                       ~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'm2'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'm2'.
         }
         export function foo114(param = new m2.public2()) {
                                ~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'm2'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'm2'.
         }
     }
     
\ No newline at end of file
diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeLiteral.errors.txt b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeLiteral.errors.txt
index 78e65d945d498..a46adfc2914dc 100644
--- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeLiteral.errors.txt
+++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeLiteral.errors.txt
@@ -8,11 +8,11 @@ tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(18,16):
 tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(18,16): error TS4025: Type of variable 'x2' references inaccessible name 'private1'.
 tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(25,16): error TS4025: Type of variable 'x3' references inaccessible name 'm2'.
 tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(25,16): error TS4025: Type of variable 'x3' references inaccessible name 'private1'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(28,23): error TS4028: Type of parameter 'a' references inaccessible name 'private1'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(28,23): error TS4030: Type of parameter 'a' references inaccessible name 'private1'.
 tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(28,36): error TS4025: Type of variable 'y' references inaccessible name 'm2'.
 tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(29,16): error TS4025: Type of variable 'y2' references inaccessible name 'm2'.
 tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(29,16): error TS4025: Type of variable 'y2' references inaccessible name 'private1'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(32,27): error TS4028: Type of parameter 'a' references inaccessible name 'private1'.
+tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(32,27): error TS4030: Type of parameter 'a' references inaccessible name 'private1'.
 tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(32,40): error TS4025: Type of variable 'z' references inaccessible name 'm2'.
 tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(33,16): error TS4025: Type of variable 'z2' references inaccessible name 'm2'.
 tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(33,16): error TS4025: Type of variable 'z2' references inaccessible name 'private1'.
@@ -68,7 +68,7 @@ tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(33,16):
         // Function type
         export var y: (a: private1) => m2.public1;
                           ~~~~~~~~
-!!! error TS4028: Type of parameter 'a' references inaccessible name 'private1'.
+!!! error TS4030: Type of parameter 'a' references inaccessible name 'private1'.
                                        ~~
 !!! error TS4025: Type of variable 'y' references inaccessible name 'm2'.
         export var y2 = y;
@@ -80,7 +80,7 @@ tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(33,16):
         // constructor type
         export var z: new (a: private1) => m2.public1;
                               ~~~~~~~~
-!!! error TS4028: Type of parameter 'a' references inaccessible name 'private1'.
+!!! error TS4030: Type of parameter 'a' references inaccessible name 'private1'.
                                            ~~
 !!! error TS4025: Type of variable 'z' references inaccessible name 'm2'.
         export var z2 = z;
diff --git a/tests/baselines/reference/declInput-2.errors.txt b/tests/baselines/reference/declInput-2.errors.txt
index 6ee7caefdf15f..37f8b581a5de2 100644
--- a/tests/baselines/reference/declInput-2.errors.txt
+++ b/tests/baselines/reference/declInput-2.errors.txt
@@ -1,7 +1,7 @@
 tests/cases/compiler/declInput-2.ts(10,21): error TS4028: Type of property 'm22' references inaccessible name 'C'.
 tests/cases/compiler/declInput-2.ts(13,21): error TS4028: Type of property 'm25' references inaccessible name 'I2'.
 tests/cases/compiler/declInput-2.ts(16,24): error TS4038: Return type of method 'm252' references inaccessible name 'I2'.
-tests/cases/compiler/declInput-2.ts(18,23): error TS4028: Type of parameter 'i' references inaccessible name 'I2'.
+tests/cases/compiler/declInput-2.ts(18,23): error TS4030: Type of parameter 'i' references inaccessible name 'I2'.
 tests/cases/compiler/declInput-2.ts(19,21): error TS4038: Return type of method 'm3' references inaccessible name 'C'.
 
 
@@ -31,7 +31,7 @@ tests/cases/compiler/declInput-2.ts(19,21): error TS4038: Return type of method
             public m26(i:I1) {}
             public m262(i:I2) {}
                           ~~
-!!! error TS4028: Type of parameter 'i' references inaccessible name 'I2'.
+!!! error TS4030: Type of parameter 'i' references inaccessible name 'I2'.
             public m3():C { return new C(); }
                         ~
 !!! error TS4038: Return type of method 'm3' references inaccessible name 'C'.
diff --git a/tests/baselines/reference/privacyAccessorDeclFile.errors.txt b/tests/baselines/reference/privacyAccessorDeclFile.errors.txt
index 231acf1c92f70..1f0df4faf6a1c 100644
--- a/tests/baselines/reference/privacyAccessorDeclFile.errors.txt
+++ b/tests/baselines/reference/privacyAccessorDeclFile.errors.txt
@@ -3,59 +3,59 @@ tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(56,48): error TS4043:
 tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(62,35): error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateClass'.
 tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(68,24): error TS4043: Return type of property getter 'myPublicStaticMethod1' references inaccessible name 'privateClass'.
 tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(74,17): error TS4043: Return type of property getter 'myPublicMethod1' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(164,52): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(168,39): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(164,52): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(168,39): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
 tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(208,48): error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateModule'.
 tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(211,35): error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(223,52): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(225,39): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(223,52): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(225,39): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
 tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(253,44): error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateClass'.
 tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(259,31): error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateClass'.
 tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(265,20): error TS4043: Return type of property getter 'myPublicStaticMethod1' references inaccessible name 'privateClass'.
 tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(271,13): error TS4043: Return type of property getter 'myPublicMethod1' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(361,48): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(365,35): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(361,48): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(365,35): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
 tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(405,44): error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateModule'.
 tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(408,31): error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateModule'.
 tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(411,20): error TS4043: Return type of property getter 'myPublicStaticMethod1' references inaccessible name 'privateModule'.
 tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(414,13): error TS4043: Return type of property getter 'myPublicMethod1' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(420,48): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(422,35): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(420,48): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(422,35): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
 tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(9,40): error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateClass'.
 tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(15,27): error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateClass'.
 tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(21,16): error TS4043: Return type of property getter 'myPublicStaticMethod1' references inaccessible name 'privateClass'.
 tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(27,9): error TS4043: Return type of property getter 'myPublicMethod1' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(117,44): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(121,31): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(117,44): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(121,31): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
 tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(161,40): error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateModule'.
 tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(164,27): error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateModule'.
 tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(167,16): error TS4043: Return type of property getter 'myPublicStaticMethod1' references inaccessible name 'privateModule'.
 tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(170,9): error TS4043: Return type of property getter 'myPublicMethod1' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(176,44): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(178,31): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(176,44): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(178,31): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
 tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(211,44): error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateClass'.
 tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(217,31): error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateClass'.
 tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(223,20): error TS4043: Return type of property getter 'myPublicStaticMethod1' references inaccessible name 'privateClass'.
 tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(229,13): error TS4043: Return type of property getter 'myPublicMethod1' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(319,48): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(323,35): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(319,48): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(323,35): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
 tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(363,44): error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateModule'.
 tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(366,31): error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateModule'.
 tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(369,20): error TS4043: Return type of property getter 'myPublicStaticMethod1' references inaccessible name 'privateModule'.
 tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(372,13): error TS4043: Return type of property getter 'myPublicMethod1' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(378,48): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(380,35): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(378,48): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(380,35): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
 tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(414,44): error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateClass'.
 tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(414,44): error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateModule'.
 tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(420,31): error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateClass'.
 tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(426,20): error TS4043: Return type of property getter 'myPublicStaticMethod1' references inaccessible name 'privateClass'.
 tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(432,13): error TS4043: Return type of property getter 'myPublicMethod1' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(522,48): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(526,35): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(522,48): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(526,35): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
 tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(566,44): error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateModule'.
 tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(569,31): error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(581,48): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(583,35): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(581,48): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(583,35): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
 
 
 ==== tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts (35 errors) ====
@@ -185,13 +185,13 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(583,35): error TS
     export class publicClassWithWithPrivateSetAccessorTypes {
         static set myPublicStaticMethod(param: privateClass) { // Error
                                                ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
         }
         private static set myPrivateStaticMethod(param: privateClass) {
         }
         set myPublicMethod(param: privateClass) { // Error
                                   ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
         }
         private set myPrivateMethod(param: privateClass) {
         }
@@ -256,11 +256,11 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(583,35): error TS
     export class publicClassWithPrivateModuleSetAccessorTypes {
         static set myPublicStaticMethod(param: privateModule.publicClass) { // Error
                                                ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
         }
         set myPublicMethod(param: privateModule.publicClass) { // Error
                                   ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
         }
     }
     
@@ -411,13 +411,13 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(583,35): error TS
         export class publicClassWithWithPrivateSetAccessorTypes {
             static set myPublicStaticMethod(param: privateClass) { // Error
                                                    ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
             }
             private static set myPrivateStaticMethod(param: privateClass) {
             }
             set myPublicMethod(param: privateClass) { // Error
                                       ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
             }
             private set myPrivateMethod(param: privateClass) {
             }
@@ -482,11 +482,11 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(583,35): error TS
         export class publicClassWithPrivateModuleSetAccessorTypes {
             static set myPublicStaticMethod(param: privateModule.publicClass) { // Error
                                                    ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
             }
             set myPublicMethod(param: privateModule.publicClass) { // Error
                                       ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
             }
         }
     
@@ -640,13 +640,13 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(583,35): error TS
         export class publicClassWithWithPrivateSetAccessorTypes {
             static set myPublicStaticMethod(param: privateClass) { 
                                                    ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
             }
             private static set myPrivateStaticMethod(param: privateClass) {
             }
             set myPublicMethod(param: privateClass) { 
                                       ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
             }
             private set myPrivateMethod(param: privateClass) {
             }
@@ -707,11 +707,11 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(583,35): error TS
         export class publicClassWithPrivateModuleSetAccessorTypes {
             static set myPublicStaticMethod(param: privateModule.publicClass) { 
                                                    ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
             }
             set myPublicMethod(param: privateModule.publicClass) { 
                                       ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
             }
         }
     
@@ -914,13 +914,13 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(583,35): error TS
             export class publicClassWithWithPrivateSetAccessorTypes {
                 static set myPublicStaticMethod(param: privateClass) {
                                                        ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
                 }
                 private static set myPrivateStaticMethod(param: privateClass) {
                 }
                 set myPublicMethod(param: privateClass) {
                                           ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
                 }
                 private set myPrivateMethod(param: privateClass) {
                 }
@@ -981,11 +981,11 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(583,35): error TS
             export class publicClassWithPrivateModuleSetAccessorTypes {
                 static set myPublicStaticMethod(param: privateModule.publicClass) {
                                                        ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
                 }
                 set myPublicMethod(param: privateModule.publicClass) {
                                           ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
                 }
             }
     
@@ -1131,13 +1131,13 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(583,35): error TS
         export class publicClassWithWithPrivateSetAccessorTypes {
             static set myPublicStaticMethod(param: privateClass) { // Error
                                                    ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
             }
             private static set myPrivateStaticMethod(param: privateClass) {
             }
             set myPublicMethod(param: privateClass) { // Error
                                       ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
             }
             private set myPrivateMethod(param: privateClass) {
             }
@@ -1202,11 +1202,11 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(583,35): error TS
         export class publicClassWithPrivateModuleSetAccessorTypes {
             static set myPublicStaticMethod(param: privateModule.publicClass) { // Error
                                                    ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
             }
             set myPublicMethod(param: privateModule.publicClass) { // Error
                                       ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
             }
         }
     
diff --git a/tests/baselines/reference/privacyCannotNameAccessorDeclFile.errors.txt b/tests/baselines/reference/privacyCannotNameAccessorDeclFile.errors.txt
index 578baa694fd89..8dddba70167db 100644
--- a/tests/baselines/reference/privacyCannotNameAccessorDeclFile.errors.txt
+++ b/tests/baselines/reference/privacyCannotNameAccessorDeclFile.errors.txt
@@ -1,11 +1,11 @@
-tests/cases/compiler/privacyCannotNameAccessorDeclFile_consumer.ts(3,16): error TS4038: Return type of public static property getter from exported class has or is using name 'Widget1' from external module "tests/cases/compiler/privacyCannotNameAccessorDeclFile_Widgets" but cannot be named.
-tests/cases/compiler/privacyCannotNameAccessorDeclFile_consumer.ts(9,9): error TS4041: Return type of public property getter from exported class has or is using name 'Widget1' from external module "tests/cases/compiler/privacyCannotNameAccessorDeclFile_Widgets" but cannot be named.
-tests/cases/compiler/privacyCannotNameAccessorDeclFile_consumer.ts(15,16): error TS4038: Return type of public static property getter from exported class has or is using name 'Widget3' from external module "GlobalWidgets" but cannot be named.
-tests/cases/compiler/privacyCannotNameAccessorDeclFile_consumer.ts(21,9): error TS4041: Return type of public property getter from exported class has or is using name 'Widget3' from external module "GlobalWidgets" but cannot be named.
-tests/cases/compiler/privacyCannotNameAccessorDeclFile_consumer.ts(57,16): error TS4038: Return type of public static property getter from exported class has or is using name 'SpecializedWidget.Widget2' from external module "tests/cases/compiler/privacyCannotNameAccessorDeclFile_Widgets" but cannot be named.
-tests/cases/compiler/privacyCannotNameAccessorDeclFile_consumer.ts(60,9): error TS4041: Return type of public property getter from exported class has or is using name 'SpecializedWidget.Widget2' from external module "tests/cases/compiler/privacyCannotNameAccessorDeclFile_Widgets" but cannot be named.
-tests/cases/compiler/privacyCannotNameAccessorDeclFile_consumer.ts(63,16): error TS4038: Return type of public static property getter from exported class has or is using name 'SpecializedGlobalWidget.Widget4' from external module "GlobalWidgets" but cannot be named.
-tests/cases/compiler/privacyCannotNameAccessorDeclFile_consumer.ts(66,9): error TS4041: Return type of public property getter from exported class has or is using name 'SpecializedGlobalWidget.Widget4' from external module "GlobalWidgets" but cannot be named.
+tests/cases/compiler/privacyCannotNameAccessorDeclFile_consumer.ts(3,16): error TS4029: Name of inferred type of property 'myPublicStaticMethod' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyCannotNameAccessorDeclFile_consumer.ts(9,9): error TS4029: Name of inferred type of property 'myPublicMethod' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyCannotNameAccessorDeclFile_consumer.ts(15,16): error TS4029: Name of inferred type of property 'myPublicStaticMethod1' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyCannotNameAccessorDeclFile_consumer.ts(21,9): error TS4029: Name of inferred type of property 'myPublicMethod1' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyCannotNameAccessorDeclFile_consumer.ts(57,16): error TS4029: Name of inferred type of property 'myPublicStaticMethod' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyCannotNameAccessorDeclFile_consumer.ts(60,9): error TS4029: Name of inferred type of property 'myPublicMethod' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyCannotNameAccessorDeclFile_consumer.ts(63,16): error TS4029: Name of inferred type of property 'myPublicStaticMethod1' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyCannotNameAccessorDeclFile_consumer.ts(66,9): error TS4029: Name of inferred type of property 'myPublicMethod1' could not be written. Consider adding an explicit type annotation.
 
 
 ==== tests/cases/compiler/privacyCannotNameAccessorDeclFile_consumer.ts (8 errors) ====
@@ -13,7 +13,7 @@ tests/cases/compiler/privacyCannotNameAccessorDeclFile_consumer.ts(66,9): error
     export class publicClassWithWithPrivateGetAccessorTypes {
         static get myPublicStaticMethod() { // Error
                    ~~~~~~~~~~~~~~~~~~~~
-!!! error TS4038: Return type of public static property getter from exported class has or is using name 'Widget1' from external module "tests/cases/compiler/privacyCannotNameAccessorDeclFile_Widgets" but cannot be named.
+!!! error TS4029: Name of inferred type of property 'myPublicStaticMethod' could not be written. Consider adding an explicit type annotation.
             return exporter.createExportedWidget1();
         }
         private static get myPrivateStaticMethod() {
@@ -21,7 +21,7 @@ tests/cases/compiler/privacyCannotNameAccessorDeclFile_consumer.ts(66,9): error
         }
         get myPublicMethod() { // Error
             ~~~~~~~~~~~~~~
-!!! error TS4041: Return type of public property getter from exported class has or is using name 'Widget1' from external module "tests/cases/compiler/privacyCannotNameAccessorDeclFile_Widgets" but cannot be named.
+!!! error TS4029: Name of inferred type of property 'myPublicMethod' could not be written. Consider adding an explicit type annotation.
             return exporter.createExportedWidget1();
         }
         private get myPrivateMethod() {
@@ -29,7 +29,7 @@ tests/cases/compiler/privacyCannotNameAccessorDeclFile_consumer.ts(66,9): error
         }
         static get myPublicStaticMethod1() { // Error
                    ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4038: Return type of public static property getter from exported class has or is using name 'Widget3' from external module "GlobalWidgets" but cannot be named.
+!!! error TS4029: Name of inferred type of property 'myPublicStaticMethod1' could not be written. Consider adding an explicit type annotation.
             return exporter.createExportedWidget3();
         }
         private static get myPrivateStaticMethod1() {
@@ -37,7 +37,7 @@ tests/cases/compiler/privacyCannotNameAccessorDeclFile_consumer.ts(66,9): error
         }
         get myPublicMethod1() { // Error
             ~~~~~~~~~~~~~~~
-!!! error TS4041: Return type of public property getter from exported class has or is using name 'Widget3' from external module "GlobalWidgets" but cannot be named.
+!!! error TS4029: Name of inferred type of property 'myPublicMethod1' could not be written. Consider adding an explicit type annotation.
             return exporter.createExportedWidget3();
         }
         private get myPrivateMethod1() {
@@ -75,22 +75,22 @@ tests/cases/compiler/privacyCannotNameAccessorDeclFile_consumer.ts(66,9): error
     export class publicClassWithPrivateModuleGetAccessorTypes {
         static get myPublicStaticMethod() { // Error
                    ~~~~~~~~~~~~~~~~~~~~
-!!! error TS4038: Return type of public static property getter from exported class has or is using name 'SpecializedWidget.Widget2' from external module "tests/cases/compiler/privacyCannotNameAccessorDeclFile_Widgets" but cannot be named.
+!!! error TS4029: Name of inferred type of property 'myPublicStaticMethod' could not be written. Consider adding an explicit type annotation.
             return exporter.createExportedWidget2();
         }
         get myPublicMethod() { // Error
             ~~~~~~~~~~~~~~
-!!! error TS4041: Return type of public property getter from exported class has or is using name 'SpecializedWidget.Widget2' from external module "tests/cases/compiler/privacyCannotNameAccessorDeclFile_Widgets" but cannot be named.
+!!! error TS4029: Name of inferred type of property 'myPublicMethod' could not be written. Consider adding an explicit type annotation.
             return exporter.createExportedWidget2();
         }
         static get myPublicStaticMethod1() { // Error
                    ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4038: Return type of public static property getter from exported class has or is using name 'SpecializedGlobalWidget.Widget4' from external module "GlobalWidgets" but cannot be named.
+!!! error TS4029: Name of inferred type of property 'myPublicStaticMethod1' could not be written. Consider adding an explicit type annotation.
             return exporter.createExportedWidget4();
         }
         get myPublicMethod1() { // Error
             ~~~~~~~~~~~~~~~
-!!! error TS4041: Return type of public property getter from exported class has or is using name 'SpecializedGlobalWidget.Widget4' from external module "GlobalWidgets" but cannot be named.
+!!! error TS4029: Name of inferred type of property 'myPublicMethod1' could not be written. Consider adding an explicit type annotation.
             return exporter.createExportedWidget4();
         }
     }
diff --git a/tests/baselines/reference/privacyCannotNameAccessorDeclFile.symbols b/tests/baselines/reference/privacyCannotNameAccessorDeclFile.symbols
deleted file mode 100644
index b705d92652f05..0000000000000
--- a/tests/baselines/reference/privacyCannotNameAccessorDeclFile.symbols
+++ /dev/null
@@ -1,319 +0,0 @@
-=== tests/cases/compiler/privacyCannotNameAccessorDeclFile_consumer.ts ===
-import exporter = require("privacyCannotNameAccessorDeclFile_exporter");
->exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
-
-export class publicClassWithWithPrivateGetAccessorTypes {
->publicClassWithWithPrivateGetAccessorTypes : Symbol(publicClassWithWithPrivateGetAccessorTypes, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 72))
-
-    static get myPublicStaticMethod() { // Error
->myPublicStaticMethod : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 1, 57))
-
-        return exporter.createExportedWidget1();
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 2, 43))
-    }
-    private static get myPrivateStaticMethod() {
->myPrivateStaticMethod : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 4, 5))
-
-        return exporter.createExportedWidget1();
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 2, 43))
-    }
-    get myPublicMethod() { // Error
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 7, 5))
-
-        return exporter.createExportedWidget1();
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 2, 43))
-    }
-    private get myPrivateMethod() {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 10, 5))
-
-        return exporter.createExportedWidget1();
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 2, 43))
-    }
-    static get myPublicStaticMethod1() { // Error
->myPublicStaticMethod1 : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod1, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 13, 5))
-
-        return exporter.createExportedWidget3();
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 8, 1))
-    }
-    private static get myPrivateStaticMethod1() {
->myPrivateStaticMethod1 : Symbol(publicClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 16, 5))
-
-        return exporter.createExportedWidget3();
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 8, 1))
-    }
-    get myPublicMethod1() { // Error
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 19, 5))
-
-        return exporter.createExportedWidget3();
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 8, 1))
-    }
-    private get myPrivateMethod1() {
->myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 22, 5))
-
-        return exporter.createExportedWidget3();
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 8, 1))
-    }
-}
-
-class privateClassWithWithPrivateGetAccessorTypes {
->privateClassWithWithPrivateGetAccessorTypes : Symbol(privateClassWithWithPrivateGetAccessorTypes, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 26, 1))
-
-    static get myPublicStaticMethod() { 
->myPublicStaticMethod : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 28, 51))
-
-        return exporter.createExportedWidget1();
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 2, 43))
-    }
-    private static get myPrivateStaticMethod() {
->myPrivateStaticMethod : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 31, 5))
-
-        return exporter.createExportedWidget1();
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 2, 43))
-    }
-    get myPublicMethod() { 
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 34, 5))
-
-        return exporter.createExportedWidget1();
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 2, 43))
-    }
-    private get myPrivateMethod() {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 37, 5))
-
-        return exporter.createExportedWidget1();
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 2, 43))
-    }
-    static get myPublicStaticMethod1() { 
->myPublicStaticMethod1 : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPublicStaticMethod1, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 40, 5))
-
-        return exporter.createExportedWidget3();
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 8, 1))
-    }
-    private static get myPrivateStaticMethod1() {
->myPrivateStaticMethod1 : Symbol(privateClassWithWithPrivateGetAccessorTypes.myPrivateStaticMethod1, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 43, 5))
-
-        return exporter.createExportedWidget3();
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 8, 1))
-    }
-    get myPublicMethod1() { 
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 46, 5))
-
-        return exporter.createExportedWidget3();
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 8, 1))
-    }
-    private get myPrivateMethod1() {
->myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 49, 5))
-
-        return exporter.createExportedWidget3();
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 8, 1))
-    }
-}
-
-export class publicClassWithPrivateModuleGetAccessorTypes {
->publicClassWithPrivateModuleGetAccessorTypes : Symbol(publicClassWithPrivateModuleGetAccessorTypes, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 53, 1))
-
-    static get myPublicStaticMethod() { // Error
->myPublicStaticMethod : Symbol(publicClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 55, 59))
-
-        return exporter.createExportedWidget2();
->exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 5, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
->createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 5, 1))
-    }
-    get myPublicMethod() { // Error
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 58, 5))
-
-        return exporter.createExportedWidget2();
->exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 5, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
->createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 5, 1))
-    }
-    static get myPublicStaticMethod1() { // Error
->myPublicStaticMethod1 : Symbol(publicClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod1, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 61, 5))
-
-        return exporter.createExportedWidget4();
->exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 11, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
->createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 11, 1))
-    }
-    get myPublicMethod1() { // Error
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 64, 5))
-
-        return exporter.createExportedWidget4();
->exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 11, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
->createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 11, 1))
-    }
-}
-
-class privateClassWithPrivateModuleGetAccessorTypes {
->privateClassWithPrivateModuleGetAccessorTypes : Symbol(privateClassWithPrivateModuleGetAccessorTypes, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 68, 1))
-
-    static get myPublicStaticMethod() { 
->myPublicStaticMethod : Symbol(privateClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 70, 53))
-
-        return exporter.createExportedWidget2();
->exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 5, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
->createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 5, 1))
-    }
-    get myPublicMethod() { 
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 73, 5))
-
-        return exporter.createExportedWidget2();
->exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 5, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
->createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 5, 1))
-    }
-    static get myPublicStaticMethod1() { 
->myPublicStaticMethod1 : Symbol(privateClassWithPrivateModuleGetAccessorTypes.myPublicStaticMethod1, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 76, 5))
-
-        return exporter.createExportedWidget4();
->exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 11, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
->createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 11, 1))
-    }
-    get myPublicMethod1() { 
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 79, 5))
-
-        return exporter.createExportedWidget4();
->exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 11, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameAccessorDeclFile_consumer.ts, 0, 0))
->createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 11, 1))
-    }
-}
-=== tests/cases/compiler/privacyCannotNameAccessorDeclFile_GlobalWidgets.ts ===
-
-declare module "GlobalWidgets" {
-    export class Widget3 {
->Widget3 : Symbol(Widget3, Decl(privacyCannotNameAccessorDeclFile_GlobalWidgets.ts, 1, 32))
-
-        name: string;
->name : Symbol(name, Decl(privacyCannotNameAccessorDeclFile_GlobalWidgets.ts, 2, 26))
-    }
-    export function createWidget3(): Widget3;
->createWidget3 : Symbol(createWidget3, Decl(privacyCannotNameAccessorDeclFile_GlobalWidgets.ts, 4, 5))
->Widget3 : Symbol(Widget3, Decl(privacyCannotNameAccessorDeclFile_GlobalWidgets.ts, 1, 32))
-
-    export module SpecializedGlobalWidget {
->SpecializedGlobalWidget : Symbol(SpecializedGlobalWidget, Decl(privacyCannotNameAccessorDeclFile_GlobalWidgets.ts, 5, 45))
-
-        export class Widget4 {
->Widget4 : Symbol(Widget4, Decl(privacyCannotNameAccessorDeclFile_GlobalWidgets.ts, 7, 43))
-
-            name: string;
->name : Symbol(name, Decl(privacyCannotNameAccessorDeclFile_GlobalWidgets.ts, 8, 30))
-        }
-        function createWidget4(): Widget4;
->createWidget4 : Symbol(createWidget4, Decl(privacyCannotNameAccessorDeclFile_GlobalWidgets.ts, 10, 9))
->Widget4 : Symbol(Widget4, Decl(privacyCannotNameAccessorDeclFile_GlobalWidgets.ts, 7, 43))
-    }
-}
-
-=== tests/cases/compiler/privacyCannotNameAccessorDeclFile_Widgets.ts ===
-export class Widget1 {
->Widget1 : Symbol(Widget1, Decl(privacyCannotNameAccessorDeclFile_Widgets.ts, 0, 0))
-
-    name = 'one';
->name : Symbol(name, Decl(privacyCannotNameAccessorDeclFile_Widgets.ts, 0, 22))
-}
-export function createWidget1() {
->createWidget1 : Symbol(createWidget1, Decl(privacyCannotNameAccessorDeclFile_Widgets.ts, 2, 1))
-
-    return new Widget1();
->Widget1 : Symbol(Widget1, Decl(privacyCannotNameAccessorDeclFile_Widgets.ts, 0, 0))
-}
-
-export module SpecializedWidget {
->SpecializedWidget : Symbol(SpecializedWidget, Decl(privacyCannotNameAccessorDeclFile_Widgets.ts, 5, 1))
-
-    export class Widget2 {
->Widget2 : Symbol(Widget2, Decl(privacyCannotNameAccessorDeclFile_Widgets.ts, 7, 33))
-
-        name = 'one';
->name : Symbol(name, Decl(privacyCannotNameAccessorDeclFile_Widgets.ts, 8, 26))
-    }
-    export function createWidget2() {
->createWidget2 : Symbol(createWidget2, Decl(privacyCannotNameAccessorDeclFile_Widgets.ts, 10, 5))
-
-        return new Widget2();
->Widget2 : Symbol(Widget2, Decl(privacyCannotNameAccessorDeclFile_Widgets.ts, 7, 33))
-    }
-}
-
-=== tests/cases/compiler/privacyCannotNameAccessorDeclFile_exporter.ts ===
-///<reference path='privacyCannotNameAccessorDeclFile_GlobalWidgets.ts'/>
-import Widgets = require("privacyCannotNameAccessorDeclFile_Widgets");
->Widgets : Symbol(Widgets, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 0, 0))
-
-import Widgets1 = require("GlobalWidgets");
->Widgets1 : Symbol(Widgets1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 1, 70))
-
-export function createExportedWidget1() {
->createExportedWidget1 : Symbol(createExportedWidget1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 2, 43))
-
-    return Widgets.createWidget1();
->Widgets.createWidget1 : Symbol(Widgets.createWidget1, Decl(privacyCannotNameAccessorDeclFile_Widgets.ts, 2, 1))
->Widgets : Symbol(Widgets, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 0, 0))
->createWidget1 : Symbol(Widgets.createWidget1, Decl(privacyCannotNameAccessorDeclFile_Widgets.ts, 2, 1))
-}
-export function createExportedWidget2() {
->createExportedWidget2 : Symbol(createExportedWidget2, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 5, 1))
-
-    return Widgets.SpecializedWidget.createWidget2();
->Widgets.SpecializedWidget.createWidget2 : Symbol(Widgets.SpecializedWidget.createWidget2, Decl(privacyCannotNameAccessorDeclFile_Widgets.ts, 10, 5))
->Widgets.SpecializedWidget : Symbol(Widgets.SpecializedWidget, Decl(privacyCannotNameAccessorDeclFile_Widgets.ts, 5, 1))
->Widgets : Symbol(Widgets, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 0, 0))
->SpecializedWidget : Symbol(Widgets.SpecializedWidget, Decl(privacyCannotNameAccessorDeclFile_Widgets.ts, 5, 1))
->createWidget2 : Symbol(Widgets.SpecializedWidget.createWidget2, Decl(privacyCannotNameAccessorDeclFile_Widgets.ts, 10, 5))
-}
-export function createExportedWidget3() {
->createExportedWidget3 : Symbol(createExportedWidget3, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 8, 1))
-
-    return Widgets1.createWidget3();
->Widgets1.createWidget3 : Symbol(Widgets1.createWidget3, Decl(privacyCannotNameAccessorDeclFile_GlobalWidgets.ts, 4, 5))
->Widgets1 : Symbol(Widgets1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 1, 70))
->createWidget3 : Symbol(Widgets1.createWidget3, Decl(privacyCannotNameAccessorDeclFile_GlobalWidgets.ts, 4, 5))
-}
-export function createExportedWidget4() {
->createExportedWidget4 : Symbol(createExportedWidget4, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 11, 1))
-
-    return Widgets1.SpecializedGlobalWidget.createWidget4();
->Widgets1.SpecializedGlobalWidget.createWidget4 : Symbol(Widgets1.SpecializedGlobalWidget.createWidget4, Decl(privacyCannotNameAccessorDeclFile_GlobalWidgets.ts, 10, 9))
->Widgets1.SpecializedGlobalWidget : Symbol(Widgets1.SpecializedGlobalWidget, Decl(privacyCannotNameAccessorDeclFile_GlobalWidgets.ts, 5, 45))
->Widgets1 : Symbol(Widgets1, Decl(privacyCannotNameAccessorDeclFile_exporter.ts, 1, 70))
->SpecializedGlobalWidget : Symbol(Widgets1.SpecializedGlobalWidget, Decl(privacyCannotNameAccessorDeclFile_GlobalWidgets.ts, 5, 45))
->createWidget4 : Symbol(Widgets1.SpecializedGlobalWidget.createWidget4, Decl(privacyCannotNameAccessorDeclFile_GlobalWidgets.ts, 10, 9))
-}
-
diff --git a/tests/baselines/reference/privacyCannotNameAccessorDeclFile2.errors.txt b/tests/baselines/reference/privacyCannotNameAccessorDeclFile2.errors.txt
new file mode 100644
index 0000000000000..24b8813056778
--- /dev/null
+++ b/tests/baselines/reference/privacyCannotNameAccessorDeclFile2.errors.txt
@@ -0,0 +1,29 @@
+tests/cases/compiler/privacyCannotNameAccessorDeclFile2.ts(19,21): error TS4061: Name of inferred return type of function 'getIlocally' could not be written. Consider adding an explicit type annotation.
+
+
+==== tests/cases/compiler/privacyCannotNameAccessorDeclFile2.ts (1 errors) ====
+    
+    namespace M {
+        export interface I { }
+    }
+    
+    namespace N {
+        export function getI(): M.I {
+            return undefined
+        }
+    }
+    
+    namespace O {
+        // shadow M with a local namespace declaration
+        export namespace M {
+            export var x = 0;
+        }
+    
+        // Error, return type cannot be named
+        export function getIlocally() {
+                        ~~~~~~~~~~~
+!!! error TS4061: Name of inferred return type of function 'getIlocally' could not be written. Consider adding an explicit type annotation.
+            return N.getI();
+        }
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/privacyCannotNameAccessorDeclFile2.js b/tests/baselines/reference/privacyCannotNameAccessorDeclFile2.js
new file mode 100644
index 0000000000000..168bd068aed18
--- /dev/null
+++ b/tests/baselines/reference/privacyCannotNameAccessorDeclFile2.js
@@ -0,0 +1,46 @@
+//// [privacyCannotNameAccessorDeclFile2.ts]
+
+namespace M {
+    export interface I { }
+}
+
+namespace N {
+    export function getI(): M.I {
+        return undefined
+    }
+}
+
+namespace O {
+    // shadow M with a local namespace declaration
+    export namespace M {
+        export var x = 0;
+    }
+
+    // Error, return type cannot be named
+    export function getIlocally() {
+        return N.getI();
+    }
+}
+
+
+//// [privacyCannotNameAccessorDeclFile2.js]
+var N;
+(function (N) {
+    function getI() {
+        return undefined;
+    }
+    N.getI = getI;
+})(N || (N = {}));
+var O;
+(function (O) {
+    // shadow M with a local namespace declaration
+    var M;
+    (function (M) {
+        M.x = 0;
+    })(M = O.M || (O.M = {}));
+    // Error, return type cannot be named
+    function getIlocally() {
+        return N.getI();
+    }
+    O.getIlocally = getIlocally;
+})(O || (O = {}));
diff --git a/tests/baselines/reference/privacyCannotNameVarTypeDeclFile.errors.txt b/tests/baselines/reference/privacyCannotNameVarTypeDeclFile.errors.txt
index 7f155f0e45410..7a82ebaf4382c 100644
--- a/tests/baselines/reference/privacyCannotNameVarTypeDeclFile.errors.txt
+++ b/tests/baselines/reference/privacyCannotNameVarTypeDeclFile.errors.txt
@@ -1,36 +1,36 @@
-tests/cases/compiler/privacyCannotNameVarTypeDeclFile_consumer.ts(3,5): error TS4026: Public static property 'myPublicStaticProperty' of exported class has or is using name 'Widget1' from external module "tests/cases/compiler/privacyCannotNameVarTypeDeclFile_Widgets" but cannot be named.
-tests/cases/compiler/privacyCannotNameVarTypeDeclFile_consumer.ts(5,5): error TS4029: Public property 'myPublicProperty' of exported class has or is using name 'Widget1' from external module "tests/cases/compiler/privacyCannotNameVarTypeDeclFile_Widgets" but cannot be named.
-tests/cases/compiler/privacyCannotNameVarTypeDeclFile_consumer.ts(8,5): error TS4026: Public static property 'myPublicStaticProperty1' of exported class has or is using name 'Widget3' from external module "GlobalWidgets" but cannot be named.
-tests/cases/compiler/privacyCannotNameVarTypeDeclFile_consumer.ts(10,5): error TS4029: Public property 'myPublicProperty1' of exported class has or is using name 'Widget3' from external module "GlobalWidgets" but cannot be named.
-tests/cases/compiler/privacyCannotNameVarTypeDeclFile_consumer.ts(26,12): error TS4023: Exported variable 'publicVarWithPrivatePropertyTypes' has or is using name 'Widget1' from external module "tests/cases/compiler/privacyCannotNameVarTypeDeclFile_Widgets" but cannot be named.
-tests/cases/compiler/privacyCannotNameVarTypeDeclFile_consumer.ts(28,12): error TS4023: Exported variable 'publicVarWithPrivatePropertyTypes1' has or is using name 'Widget3' from external module "GlobalWidgets" but cannot be named.
-tests/cases/compiler/privacyCannotNameVarTypeDeclFile_consumer.ts(32,5): error TS4026: Public static property 'myPublicStaticProperty' of exported class has or is using name 'SpecializedWidget.Widget2' from external module "tests/cases/compiler/privacyCannotNameVarTypeDeclFile_Widgets" but cannot be named.
-tests/cases/compiler/privacyCannotNameVarTypeDeclFile_consumer.ts(33,5): error TS4029: Public property 'myPublicProperty' of exported class has or is using name 'SpecializedWidget.Widget2' from external module "tests/cases/compiler/privacyCannotNameVarTypeDeclFile_Widgets" but cannot be named.
-tests/cases/compiler/privacyCannotNameVarTypeDeclFile_consumer.ts(34,5): error TS4026: Public static property 'myPublicStaticProperty1' of exported class has or is using name 'SpecializedGlobalWidget.Widget4' from external module "GlobalWidgets" but cannot be named.
-tests/cases/compiler/privacyCannotNameVarTypeDeclFile_consumer.ts(35,5): error TS4029: Public property 'myPublicProperty1' of exported class has or is using name 'SpecializedGlobalWidget.Widget4' from external module "GlobalWidgets" but cannot be named.
-tests/cases/compiler/privacyCannotNameVarTypeDeclFile_consumer.ts(37,12): error TS4023: Exported variable 'publicVarWithPrivateModulePropertyTypes' has or is using name 'SpecializedWidget.Widget2' from external module "tests/cases/compiler/privacyCannotNameVarTypeDeclFile_Widgets" but cannot be named.
-tests/cases/compiler/privacyCannotNameVarTypeDeclFile_consumer.ts(38,12): error TS4023: Exported variable 'publicVarWithPrivateModulePropertyTypes1' has or is using name 'SpecializedGlobalWidget.Widget4' from external module "GlobalWidgets" but cannot be named.
+tests/cases/compiler/privacyCannotNameVarTypeDeclFile_consumer.ts(3,12): error TS4029: Name of inferred type of property 'myPublicStaticProperty' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyCannotNameVarTypeDeclFile_consumer.ts(5,5): error TS4029: Name of inferred type of property 'myPublicProperty' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyCannotNameVarTypeDeclFile_consumer.ts(8,12): error TS4029: Name of inferred type of property 'myPublicStaticProperty1' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyCannotNameVarTypeDeclFile_consumer.ts(10,5): error TS4029: Name of inferred type of property 'myPublicProperty1' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyCannotNameVarTypeDeclFile_consumer.ts(26,12): error TS4026: Name of inferred type of variable 'publicVarWithPrivatePropertyTypes' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyCannotNameVarTypeDeclFile_consumer.ts(28,12): error TS4026: Name of inferred type of variable 'publicVarWithPrivatePropertyTypes1' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyCannotNameVarTypeDeclFile_consumer.ts(32,12): error TS4029: Name of inferred type of property 'myPublicStaticProperty' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyCannotNameVarTypeDeclFile_consumer.ts(33,5): error TS4029: Name of inferred type of property 'myPublicProperty' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyCannotNameVarTypeDeclFile_consumer.ts(34,12): error TS4029: Name of inferred type of property 'myPublicStaticProperty1' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyCannotNameVarTypeDeclFile_consumer.ts(35,5): error TS4029: Name of inferred type of property 'myPublicProperty1' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyCannotNameVarTypeDeclFile_consumer.ts(37,12): error TS4026: Name of inferred type of variable 'publicVarWithPrivateModulePropertyTypes' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyCannotNameVarTypeDeclFile_consumer.ts(38,12): error TS4026: Name of inferred type of variable 'publicVarWithPrivateModulePropertyTypes1' could not be written. Consider adding an explicit type annotation.
 
 
 ==== tests/cases/compiler/privacyCannotNameVarTypeDeclFile_consumer.ts (12 errors) ====
     import exporter = require("privacyCannotNameVarTypeDeclFile_exporter");
     export class publicClassWithWithPrivatePropertyTypes {
         static myPublicStaticProperty = exporter.createExportedWidget1(); // Error
-        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4026: Public static property 'myPublicStaticProperty' of exported class has or is using name 'Widget1' from external module "tests/cases/compiler/privacyCannotNameVarTypeDeclFile_Widgets" but cannot be named.
+               ~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4029: Name of inferred type of property 'myPublicStaticProperty' could not be written. Consider adding an explicit type annotation.
         private static myPrivateStaticProperty = exporter.createExportedWidget1();
         myPublicProperty = exporter.createExportedWidget1(); // Error
-        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4029: Public property 'myPublicProperty' of exported class has or is using name 'Widget1' from external module "tests/cases/compiler/privacyCannotNameVarTypeDeclFile_Widgets" but cannot be named.
+        ~~~~~~~~~~~~~~~~
+!!! error TS4029: Name of inferred type of property 'myPublicProperty' could not be written. Consider adding an explicit type annotation.
         private myPrivateProperty = exporter.createExportedWidget1();
     
         static myPublicStaticProperty1 = exporter.createExportedWidget3(); // Error
-        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4026: Public static property 'myPublicStaticProperty1' of exported class has or is using name 'Widget3' from external module "GlobalWidgets" but cannot be named.
+               ~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4029: Name of inferred type of property 'myPublicStaticProperty1' could not be written. Consider adding an explicit type annotation.
         private static myPrivateStaticProperty1 = exporter.createExportedWidget3();
         myPublicProperty1 = exporter.createExportedWidget3(); // Error
-        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4029: Public property 'myPublicProperty1' of exported class has or is using name 'Widget3' from external module "GlobalWidgets" but cannot be named.
+        ~~~~~~~~~~~~~~~~~
+!!! error TS4029: Name of inferred type of property 'myPublicProperty1' could not be written. Consider adding an explicit type annotation.
         private myPrivateProperty1 = exporter.createExportedWidget3();
     }
     
@@ -48,33 +48,33 @@ tests/cases/compiler/privacyCannotNameVarTypeDeclFile_consumer.ts(38,12): error
     
     export var publicVarWithPrivatePropertyTypes= exporter.createExportedWidget1(); // Error
                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4023: Exported variable 'publicVarWithPrivatePropertyTypes' has or is using name 'Widget1' from external module "tests/cases/compiler/privacyCannotNameVarTypeDeclFile_Widgets" but cannot be named.
+!!! error TS4026: Name of inferred type of variable 'publicVarWithPrivatePropertyTypes' could not be written. Consider adding an explicit type annotation.
     var privateVarWithPrivatePropertyTypes= exporter.createExportedWidget1();
     export var publicVarWithPrivatePropertyTypes1 = exporter.createExportedWidget3(); // Error
                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4023: Exported variable 'publicVarWithPrivatePropertyTypes1' has or is using name 'Widget3' from external module "GlobalWidgets" but cannot be named.
+!!! error TS4026: Name of inferred type of variable 'publicVarWithPrivatePropertyTypes1' could not be written. Consider adding an explicit type annotation.
     var privateVarWithPrivatePropertyTypes1 = exporter.createExportedWidget3();
     
     export class publicClassWithPrivateModulePropertyTypes {
         static myPublicStaticProperty= exporter.createExportedWidget2(); // Error
-        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4026: Public static property 'myPublicStaticProperty' of exported class has or is using name 'SpecializedWidget.Widget2' from external module "tests/cases/compiler/privacyCannotNameVarTypeDeclFile_Widgets" but cannot be named.
+               ~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4029: Name of inferred type of property 'myPublicStaticProperty' could not be written. Consider adding an explicit type annotation.
         myPublicProperty = exporter.createExportedWidget2(); // Error
-        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4029: Public property 'myPublicProperty' of exported class has or is using name 'SpecializedWidget.Widget2' from external module "tests/cases/compiler/privacyCannotNameVarTypeDeclFile_Widgets" but cannot be named.
+        ~~~~~~~~~~~~~~~~
+!!! error TS4029: Name of inferred type of property 'myPublicProperty' could not be written. Consider adding an explicit type annotation.
         static myPublicStaticProperty1 = exporter.createExportedWidget4(); // Error
-        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4026: Public static property 'myPublicStaticProperty1' of exported class has or is using name 'SpecializedGlobalWidget.Widget4' from external module "GlobalWidgets" but cannot be named.
+               ~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4029: Name of inferred type of property 'myPublicStaticProperty1' could not be written. Consider adding an explicit type annotation.
         myPublicProperty1 = exporter.createExportedWidget4(); // Error
-        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4029: Public property 'myPublicProperty1' of exported class has or is using name 'SpecializedGlobalWidget.Widget4' from external module "GlobalWidgets" but cannot be named.
+        ~~~~~~~~~~~~~~~~~
+!!! error TS4029: Name of inferred type of property 'myPublicProperty1' could not be written. Consider adding an explicit type annotation.
     }
     export var publicVarWithPrivateModulePropertyTypes= exporter.createExportedWidget2(); // Error
                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4023: Exported variable 'publicVarWithPrivateModulePropertyTypes' has or is using name 'SpecializedWidget.Widget2' from external module "tests/cases/compiler/privacyCannotNameVarTypeDeclFile_Widgets" but cannot be named.
+!!! error TS4026: Name of inferred type of variable 'publicVarWithPrivateModulePropertyTypes' could not be written. Consider adding an explicit type annotation.
     export var publicVarWithPrivateModulePropertyTypes1 = exporter.createExportedWidget4(); // Error
                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4023: Exported variable 'publicVarWithPrivateModulePropertyTypes1' has or is using name 'SpecializedGlobalWidget.Widget4' from external module "GlobalWidgets" but cannot be named.
+!!! error TS4026: Name of inferred type of variable 'publicVarWithPrivateModulePropertyTypes1' could not be written. Consider adding an explicit type annotation.
     
     class privateClassWithPrivateModulePropertyTypes {
         static myPublicStaticProperty= exporter.createExportedWidget2();
diff --git a/tests/baselines/reference/privacyCannotNameVarTypeDeclFile.symbols b/tests/baselines/reference/privacyCannotNameVarTypeDeclFile.symbols
deleted file mode 100644
index 416e44c4ddccb..0000000000000
--- a/tests/baselines/reference/privacyCannotNameVarTypeDeclFile.symbols
+++ /dev/null
@@ -1,315 +0,0 @@
-=== tests/cases/compiler/privacyCannotNameVarTypeDeclFile_consumer.ts ===
-import exporter = require("privacyCannotNameVarTypeDeclFile_exporter");
->exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
-
-export class publicClassWithWithPrivatePropertyTypes {
->publicClassWithWithPrivatePropertyTypes : Symbol(publicClassWithWithPrivatePropertyTypes, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 71))
-
-    static myPublicStaticProperty = exporter.createExportedWidget1(); // Error
->myPublicStaticProperty : Symbol(publicClassWithWithPrivatePropertyTypes.myPublicStaticProperty, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 1, 54))
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
-
-    private static myPrivateStaticProperty = exporter.createExportedWidget1();
->myPrivateStaticProperty : Symbol(publicClassWithWithPrivatePropertyTypes.myPrivateStaticProperty, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 2, 69))
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
-
-    myPublicProperty = exporter.createExportedWidget1(); // Error
->myPublicProperty : Symbol(myPublicProperty, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 3, 78))
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
-
-    private myPrivateProperty = exporter.createExportedWidget1();
->myPrivateProperty : Symbol(myPrivateProperty, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 4, 56))
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
-
-    static myPublicStaticProperty1 = exporter.createExportedWidget3(); // Error
->myPublicStaticProperty1 : Symbol(publicClassWithWithPrivatePropertyTypes.myPublicStaticProperty1, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 5, 65))
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
-
-    private static myPrivateStaticProperty1 = exporter.createExportedWidget3();
->myPrivateStaticProperty1 : Symbol(publicClassWithWithPrivatePropertyTypes.myPrivateStaticProperty1, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 7, 70))
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
-
-    myPublicProperty1 = exporter.createExportedWidget3(); // Error
->myPublicProperty1 : Symbol(myPublicProperty1, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 8, 79))
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
-
-    private myPrivateProperty1 = exporter.createExportedWidget3();
->myPrivateProperty1 : Symbol(myPrivateProperty1, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 9, 57))
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
-}
-
-class privateClassWithWithPrivatePropertyTypes {
->privateClassWithWithPrivatePropertyTypes : Symbol(privateClassWithWithPrivatePropertyTypes, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 11, 1))
-
-    static myPublicStaticProperty = exporter.createExportedWidget1(); 
->myPublicStaticProperty : Symbol(privateClassWithWithPrivatePropertyTypes.myPublicStaticProperty, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 13, 48))
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
-
-    private static myPrivateStaticProperty = exporter.createExportedWidget1();
->myPrivateStaticProperty : Symbol(privateClassWithWithPrivatePropertyTypes.myPrivateStaticProperty, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 14, 69))
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
-
-    myPublicProperty = exporter.createExportedWidget1(); 
->myPublicProperty : Symbol(myPublicProperty, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 15, 78))
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
-
-    private myPrivateProperty = exporter.createExportedWidget1();
->myPrivateProperty : Symbol(myPrivateProperty, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 16, 56))
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
-
-    static myPublicStaticProperty1 = exporter.createExportedWidget3(); 
->myPublicStaticProperty1 : Symbol(privateClassWithWithPrivatePropertyTypes.myPublicStaticProperty1, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 17, 65))
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
-
-    private static myPrivateStaticProperty1 = exporter.createExportedWidget3();
->myPrivateStaticProperty1 : Symbol(privateClassWithWithPrivatePropertyTypes.myPrivateStaticProperty1, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 19, 70))
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
-
-    myPublicProperty1 = exporter.createExportedWidget3(); 
->myPublicProperty1 : Symbol(myPublicProperty1, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 20, 79))
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
-
-    private myPrivateProperty1 = exporter.createExportedWidget3();
->myPrivateProperty1 : Symbol(myPrivateProperty1, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 21, 57))
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
-}
-
-export var publicVarWithPrivatePropertyTypes= exporter.createExportedWidget1(); // Error
->publicVarWithPrivatePropertyTypes : Symbol(publicVarWithPrivatePropertyTypes, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 25, 10))
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
-
-var privateVarWithPrivatePropertyTypes= exporter.createExportedWidget1();
->privateVarWithPrivatePropertyTypes : Symbol(privateVarWithPrivatePropertyTypes, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 26, 3))
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
-
-export var publicVarWithPrivatePropertyTypes1 = exporter.createExportedWidget3(); // Error
->publicVarWithPrivatePropertyTypes1 : Symbol(publicVarWithPrivatePropertyTypes1, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 27, 10))
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
-
-var privateVarWithPrivatePropertyTypes1 = exporter.createExportedWidget3();
->privateVarWithPrivatePropertyTypes1 : Symbol(privateVarWithPrivatePropertyTypes1, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 28, 3))
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
-
-export class publicClassWithPrivateModulePropertyTypes {
->publicClassWithPrivateModulePropertyTypes : Symbol(publicClassWithPrivateModulePropertyTypes, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 28, 75))
-
-    static myPublicStaticProperty= exporter.createExportedWidget2(); // Error
->myPublicStaticProperty : Symbol(publicClassWithPrivateModulePropertyTypes.myPublicStaticProperty, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 30, 56))
->exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 5, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 5, 1))
-
-    myPublicProperty = exporter.createExportedWidget2(); // Error
->myPublicProperty : Symbol(myPublicProperty, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 31, 68))
->exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 5, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 5, 1))
-
-    static myPublicStaticProperty1 = exporter.createExportedWidget4(); // Error
->myPublicStaticProperty1 : Symbol(publicClassWithPrivateModulePropertyTypes.myPublicStaticProperty1, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 32, 56))
->exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 11, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 11, 1))
-
-    myPublicProperty1 = exporter.createExportedWidget4(); // Error
->myPublicProperty1 : Symbol(myPublicProperty1, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 33, 70))
->exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 11, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 11, 1))
-}
-export var publicVarWithPrivateModulePropertyTypes= exporter.createExportedWidget2(); // Error
->publicVarWithPrivateModulePropertyTypes : Symbol(publicVarWithPrivateModulePropertyTypes, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 36, 10))
->exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 5, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 5, 1))
-
-export var publicVarWithPrivateModulePropertyTypes1 = exporter.createExportedWidget4(); // Error
->publicVarWithPrivateModulePropertyTypes1 : Symbol(publicVarWithPrivateModulePropertyTypes1, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 37, 10))
->exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 11, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 11, 1))
-
-class privateClassWithPrivateModulePropertyTypes {
->privateClassWithPrivateModulePropertyTypes : Symbol(privateClassWithPrivateModulePropertyTypes, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 37, 87))
-
-    static myPublicStaticProperty= exporter.createExportedWidget2();
->myPublicStaticProperty : Symbol(privateClassWithPrivateModulePropertyTypes.myPublicStaticProperty, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 39, 50))
->exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 5, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 5, 1))
-
-    myPublicProperty= exporter.createExportedWidget2();
->myPublicProperty : Symbol(myPublicProperty, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 40, 68))
->exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 5, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 5, 1))
-
-    static myPublicStaticProperty1 = exporter.createExportedWidget4();
->myPublicStaticProperty1 : Symbol(privateClassWithPrivateModulePropertyTypes.myPublicStaticProperty1, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 41, 55))
->exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 11, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 11, 1))
-
-    myPublicProperty1 = exporter.createExportedWidget4();
->myPublicProperty1 : Symbol(myPublicProperty1, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 42, 70))
->exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 11, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 11, 1))
-}
-var privateVarWithPrivateModulePropertyTypes= exporter.createExportedWidget2();
->privateVarWithPrivateModulePropertyTypes : Symbol(privateVarWithPrivateModulePropertyTypes, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 45, 3))
->exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 5, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 5, 1))
-
-var privateVarWithPrivateModulePropertyTypes1 = exporter.createExportedWidget4();
->privateVarWithPrivateModulePropertyTypes1 : Symbol(privateVarWithPrivateModulePropertyTypes1, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 46, 3))
->exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 11, 1))
->exporter : Symbol(exporter, Decl(privacyCannotNameVarTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 11, 1))
-
-=== tests/cases/compiler/privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts ===
-
-
-declare module "GlobalWidgets" {
-    export class Widget3 {
->Widget3 : Symbol(Widget3, Decl(privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts, 2, 32))
-
-        name: string;
->name : Symbol(name, Decl(privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts, 3, 26))
-    }
-    export function createWidget3(): Widget3;
->createWidget3 : Symbol(createWidget3, Decl(privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts, 5, 5))
->Widget3 : Symbol(Widget3, Decl(privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts, 2, 32))
-
-    export module SpecializedGlobalWidget {
->SpecializedGlobalWidget : Symbol(SpecializedGlobalWidget, Decl(privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts, 6, 45))
-
-        export class Widget4 {
->Widget4 : Symbol(Widget4, Decl(privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts, 8, 43))
-
-            name: string;
->name : Symbol(name, Decl(privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts, 9, 30))
-        }
-        function createWidget4(): Widget4;
->createWidget4 : Symbol(createWidget4, Decl(privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts, 11, 9))
->Widget4 : Symbol(Widget4, Decl(privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts, 8, 43))
-    }
-}
-
-=== tests/cases/compiler/privacyCannotNameVarTypeDeclFile_Widgets.ts ===
-export class Widget1 {
->Widget1 : Symbol(Widget1, Decl(privacyCannotNameVarTypeDeclFile_Widgets.ts, 0, 0))
-
-    name = 'one';
->name : Symbol(name, Decl(privacyCannotNameVarTypeDeclFile_Widgets.ts, 0, 22))
-}
-export function createWidget1() {
->createWidget1 : Symbol(createWidget1, Decl(privacyCannotNameVarTypeDeclFile_Widgets.ts, 2, 1))
-
-    return new Widget1();
->Widget1 : Symbol(Widget1, Decl(privacyCannotNameVarTypeDeclFile_Widgets.ts, 0, 0))
-}
-
-export module SpecializedWidget {
->SpecializedWidget : Symbol(SpecializedWidget, Decl(privacyCannotNameVarTypeDeclFile_Widgets.ts, 5, 1))
-
-    export class Widget2 {
->Widget2 : Symbol(Widget2, Decl(privacyCannotNameVarTypeDeclFile_Widgets.ts, 7, 33))
-
-        name = 'one';
->name : Symbol(name, Decl(privacyCannotNameVarTypeDeclFile_Widgets.ts, 8, 26))
-    }
-    export function createWidget2() {
->createWidget2 : Symbol(createWidget2, Decl(privacyCannotNameVarTypeDeclFile_Widgets.ts, 10, 5))
-
-        return new Widget2();
->Widget2 : Symbol(Widget2, Decl(privacyCannotNameVarTypeDeclFile_Widgets.ts, 7, 33))
-    }
-}
-
-=== tests/cases/compiler/privacyCannotNameVarTypeDeclFile_exporter.ts ===
-///<reference path='privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts'/>
-import Widgets = require("privacyCannotNameVarTypeDeclFile_Widgets");
->Widgets : Symbol(Widgets, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 0, 0))
-
-import Widgets1 = require("GlobalWidgets");
->Widgets1 : Symbol(Widgets1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 1, 69))
-
-export function createExportedWidget1() {
->createExportedWidget1 : Symbol(createExportedWidget1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 2, 43))
-
-    return Widgets.createWidget1();
->Widgets.createWidget1 : Symbol(Widgets.createWidget1, Decl(privacyCannotNameVarTypeDeclFile_Widgets.ts, 2, 1))
->Widgets : Symbol(Widgets, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 0, 0))
->createWidget1 : Symbol(Widgets.createWidget1, Decl(privacyCannotNameVarTypeDeclFile_Widgets.ts, 2, 1))
-}
-export function createExportedWidget2() {
->createExportedWidget2 : Symbol(createExportedWidget2, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 5, 1))
-
-    return Widgets.SpecializedWidget.createWidget2();
->Widgets.SpecializedWidget.createWidget2 : Symbol(Widgets.SpecializedWidget.createWidget2, Decl(privacyCannotNameVarTypeDeclFile_Widgets.ts, 10, 5))
->Widgets.SpecializedWidget : Symbol(Widgets.SpecializedWidget, Decl(privacyCannotNameVarTypeDeclFile_Widgets.ts, 5, 1))
->Widgets : Symbol(Widgets, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 0, 0))
->SpecializedWidget : Symbol(Widgets.SpecializedWidget, Decl(privacyCannotNameVarTypeDeclFile_Widgets.ts, 5, 1))
->createWidget2 : Symbol(Widgets.SpecializedWidget.createWidget2, Decl(privacyCannotNameVarTypeDeclFile_Widgets.ts, 10, 5))
-}
-export function createExportedWidget3() {
->createExportedWidget3 : Symbol(createExportedWidget3, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 8, 1))
-
-    return Widgets1.createWidget3();
->Widgets1.createWidget3 : Symbol(Widgets1.createWidget3, Decl(privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts, 5, 5))
->Widgets1 : Symbol(Widgets1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 1, 69))
->createWidget3 : Symbol(Widgets1.createWidget3, Decl(privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts, 5, 5))
-}
-export function createExportedWidget4() {
->createExportedWidget4 : Symbol(createExportedWidget4, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 11, 1))
-
-    return Widgets1.SpecializedGlobalWidget.createWidget4();
->Widgets1.SpecializedGlobalWidget.createWidget4 : Symbol(Widgets1.SpecializedGlobalWidget.createWidget4, Decl(privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts, 11, 9))
->Widgets1.SpecializedGlobalWidget : Symbol(Widgets1.SpecializedGlobalWidget, Decl(privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts, 6, 45))
->Widgets1 : Symbol(Widgets1, Decl(privacyCannotNameVarTypeDeclFile_exporter.ts, 1, 69))
->SpecializedGlobalWidget : Symbol(Widgets1.SpecializedGlobalWidget, Decl(privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts, 6, 45))
->createWidget4 : Symbol(Widgets1.SpecializedGlobalWidget.createWidget4, Decl(privacyCannotNameVarTypeDeclFile_GlobalWidgets.ts, 11, 9))
-}
-
diff --git a/tests/baselines/reference/privacyFunctionCannotNameParameterTypeDeclFile.errors.txt b/tests/baselines/reference/privacyFunctionCannotNameParameterTypeDeclFile.errors.txt
index 1e221ccd70ae1..c33951dfdd87b 100644
--- a/tests/baselines/reference/privacyFunctionCannotNameParameterTypeDeclFile.errors.txt
+++ b/tests/baselines/reference/privacyFunctionCannotNameParameterTypeDeclFile.errors.txt
@@ -1,73 +1,73 @@
-tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(3,33): error TS4068: Parameter 'param' of public static method from exported class has or is using name 'Widget1' from external module "tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_Widgets" but cannot be named.
-tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(7,20): error TS4071: Parameter 'param' of public method from exported class has or is using name 'Widget1' from external module "tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_Widgets" but cannot be named.
-tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(11,17): error TS4061: Parameter 'param' of constructor from exported class has or is using name 'Widget1' from external module "tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_Widgets" but cannot be named.
-tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(11,59): error TS4061: Parameter 'param1' of constructor from exported class has or is using name 'Widget1' from external module "tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_Widgets" but cannot be named.
-tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(11,110): error TS4061: Parameter 'param2' of constructor from exported class has or is using name 'Widget1' from external module "tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_Widgets" but cannot be named.
-tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(15,33): error TS4068: Parameter 'param' of public static method from exported class has or is using name 'Widget3' from external module "GlobalWidgets" but cannot be named.
-tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(19,20): error TS4071: Parameter 'param' of public method from exported class has or is using name 'Widget3' from external module "GlobalWidgets" but cannot be named.
-tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(23,17): error TS4061: Parameter 'param' of constructor from exported class has or is using name 'Widget3' from external module "GlobalWidgets" but cannot be named.
-tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(23,59): error TS4061: Parameter 'param1' of constructor from exported class has or is using name 'Widget3' from external module "GlobalWidgets" but cannot be named.
-tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(23,110): error TS4061: Parameter 'param2' of constructor from exported class has or is using name 'Widget3' from external module "GlobalWidgets" but cannot be named.
-tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(52,56): error TS4076: Parameter 'param' of exported function has or is using name 'Widget1' from external module "tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_Widgets" but cannot be named.
-tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(56,57): error TS4076: Parameter 'param' of exported function has or is using name 'Widget3' from external module "GlobalWidgets" but cannot be named.
-tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(63,33): error TS4068: Parameter 'param' of public static method from exported class has or is using name 'SpecializedWidget.Widget2' from external module "tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_Widgets" but cannot be named.
-tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(65,20): error TS4071: Parameter 'param' of public method from exported class has or is using name 'SpecializedWidget.Widget2' from external module "tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_Widgets" but cannot be named.
-tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(67,17): error TS4061: Parameter 'param' of constructor from exported class has or is using name 'SpecializedWidget.Widget2' from external module "tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_Widgets" but cannot be named.
-tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(67,58): error TS4061: Parameter 'param1' of constructor from exported class has or is using name 'SpecializedWidget.Widget2' from external module "tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_Widgets" but cannot be named.
-tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(67,108): error TS4061: Parameter 'param2' of constructor from exported class has or is using name 'SpecializedWidget.Widget2' from external module "tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_Widgets" but cannot be named.
-tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(71,33): error TS4068: Parameter 'param' of public static method from exported class has or is using name 'SpecializedGlobalWidget.Widget4' from external module "GlobalWidgets" but cannot be named.
-tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(73,20): error TS4071: Parameter 'param' of public method from exported class has or is using name 'SpecializedGlobalWidget.Widget4' from external module "GlobalWidgets" but cannot be named.
-tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(75,17): error TS4061: Parameter 'param' of constructor from exported class has or is using name 'SpecializedGlobalWidget.Widget4' from external module "GlobalWidgets" but cannot be named.
-tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(75,58): error TS4061: Parameter 'param1' of constructor from exported class has or is using name 'SpecializedGlobalWidget.Widget4' from external module "GlobalWidgets" but cannot be named.
-tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(75,108): error TS4061: Parameter 'param2' of constructor from exported class has or is using name 'SpecializedGlobalWidget.Widget4' from external module "GlobalWidgets" but cannot be named.
-tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(78,63): error TS4076: Parameter 'param' of exported function has or is using name 'SpecializedWidget.Widget2' from external module "tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_Widgets" but cannot be named.
-tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(80,64): error TS4076: Parameter 'param' of exported function has or is using name 'SpecializedGlobalWidget.Widget4' from external module "GlobalWidgets" but cannot be named.
+tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(3,33): error TS4031: Name of inferred type of parameter 'param' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(7,20): error TS4031: Name of inferred type of parameter 'param' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(11,17): error TS4031: Name of inferred type of parameter 'param' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(11,67): error TS4031: Name of inferred type of parameter 'param1' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(11,117): error TS4031: Name of inferred type of parameter 'param2' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(15,33): error TS4031: Name of inferred type of parameter 'param' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(19,20): error TS4031: Name of inferred type of parameter 'param' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(23,17): error TS4031: Name of inferred type of parameter 'param' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(23,67): error TS4031: Name of inferred type of parameter 'param1' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(23,117): error TS4031: Name of inferred type of parameter 'param2' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(52,56): error TS4031: Name of inferred type of parameter 'param' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(56,57): error TS4031: Name of inferred type of parameter 'param' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(63,33): error TS4031: Name of inferred type of parameter 'param' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(65,20): error TS4031: Name of inferred type of parameter 'param' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(67,17): error TS4031: Name of inferred type of parameter 'param' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(67,66): error TS4031: Name of inferred type of parameter 'param1' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(67,115): error TS4031: Name of inferred type of parameter 'param2' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(71,33): error TS4031: Name of inferred type of parameter 'param' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(73,20): error TS4031: Name of inferred type of parameter 'param' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(75,17): error TS4031: Name of inferred type of parameter 'param' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(75,66): error TS4031: Name of inferred type of parameter 'param1' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(75,115): error TS4031: Name of inferred type of parameter 'param2' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(78,63): error TS4031: Name of inferred type of parameter 'param' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(80,64): error TS4031: Name of inferred type of parameter 'param' could not be written. Consider adding an explicit type annotation.
 
 
 ==== tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts (24 errors) ====
     import exporter = require("privacyFunctionCannotNameParameterTypeDeclFile_exporter");
     export class publicClassWithWithPrivateParmeterTypes {
         static myPublicStaticMethod(param = exporter.createExportedWidget1()) { // Error
-                                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4068: Parameter 'param' of public static method from exported class has or is using name 'Widget1' from external module "tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_Widgets" but cannot be named.
+                                    ~~~~~
+!!! error TS4031: Name of inferred type of parameter 'param' could not be written. Consider adding an explicit type annotation.
         }
         private static myPrivateStaticMethod(param = exporter.createExportedWidget1()) {
         }
         myPublicMethod(param  = exporter.createExportedWidget1()) { // Error
-                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4071: Parameter 'param' of public method from exported class has or is using name 'Widget1' from external module "tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_Widgets" but cannot be named.
+                       ~~~~~
+!!! error TS4031: Name of inferred type of parameter 'param' could not be written. Consider adding an explicit type annotation.
         }
         private myPrivateMethod(param = exporter.createExportedWidget1()) {
         }
         constructor(param = exporter.createExportedWidget1(), private param1 = exporter.createExportedWidget1(), public param2 = exporter.createExportedWidget1()) { // Error
-                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4061: Parameter 'param' of constructor from exported class has or is using name 'Widget1' from external module "tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_Widgets" but cannot be named.
-                                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4061: Parameter 'param1' of constructor from exported class has or is using name 'Widget1' from external module "tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_Widgets" but cannot be named.
-                                                                                                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4061: Parameter 'param2' of constructor from exported class has or is using name 'Widget1' from external module "tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_Widgets" but cannot be named.
+                    ~~~~~
+!!! error TS4031: Name of inferred type of parameter 'param' could not be written. Consider adding an explicit type annotation.
+                                                                      ~~~~~~
+!!! error TS4031: Name of inferred type of parameter 'param1' could not be written. Consider adding an explicit type annotation.
+                                                                                                                        ~~~~~~
+!!! error TS4031: Name of inferred type of parameter 'param2' could not be written. Consider adding an explicit type annotation.
         }
     }
     export class publicClassWithWithPrivateParmeterTypes1 {
         static myPublicStaticMethod(param = exporter.createExportedWidget3()) { // Error
-                                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4068: Parameter 'param' of public static method from exported class has or is using name 'Widget3' from external module "GlobalWidgets" but cannot be named.
+                                    ~~~~~
+!!! error TS4031: Name of inferred type of parameter 'param' could not be written. Consider adding an explicit type annotation.
         }
         private static myPrivateStaticMethod(param = exporter.createExportedWidget3()) {
         }
         myPublicMethod(param  = exporter.createExportedWidget3()) { // Error
-                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4071: Parameter 'param' of public method from exported class has or is using name 'Widget3' from external module "GlobalWidgets" but cannot be named.
+                       ~~~~~
+!!! error TS4031: Name of inferred type of parameter 'param' could not be written. Consider adding an explicit type annotation.
         }
         private myPrivateMethod(param = exporter.createExportedWidget3()) {
         }
         constructor(param = exporter.createExportedWidget3(), private param1 = exporter.createExportedWidget3(), public param2 = exporter.createExportedWidget3()) { // Error
-                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4061: Parameter 'param' of constructor from exported class has or is using name 'Widget3' from external module "GlobalWidgets" but cannot be named.
-                                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4061: Parameter 'param1' of constructor from exported class has or is using name 'Widget3' from external module "GlobalWidgets" but cannot be named.
-                                                                                                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4061: Parameter 'param2' of constructor from exported class has or is using name 'Widget3' from external module "GlobalWidgets" but cannot be named.
+                    ~~~~~
+!!! error TS4031: Name of inferred type of parameter 'param' could not be written. Consider adding an explicit type annotation.
+                                                                      ~~~~~~
+!!! error TS4031: Name of inferred type of parameter 'param1' could not be written. Consider adding an explicit type annotation.
+                                                                                                                        ~~~~~~
+!!! error TS4031: Name of inferred type of parameter 'param2' could not be written. Consider adding an explicit type annotation.
         }
     }
     
@@ -97,14 +97,14 @@ tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(
     }
     
     export function publicFunctionWithPrivateParmeterTypes(param = exporter.createExportedWidget1()) { // Error
-                                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4076: Parameter 'param' of exported function has or is using name 'Widget1' from external module "tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_Widgets" but cannot be named.
+                                                           ~~~~~
+!!! error TS4031: Name of inferred type of parameter 'param' could not be written. Consider adding an explicit type annotation.
     }
     function privateFunctionWithPrivateParmeterTypes(param = exporter.createExportedWidget1()) {
     }
     export function publicFunctionWithPrivateParmeterTypes1(param = exporter.createExportedWidget3()) { // Error
-                                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4076: Parameter 'param' of exported function has or is using name 'Widget3' from external module "GlobalWidgets" but cannot be named.
+                                                            ~~~~~
+!!! error TS4031: Name of inferred type of parameter 'param' could not be written. Consider adding an explicit type annotation.
     }
     function privateFunctionWithPrivateParmeterTypes1(param = exporter.createExportedWidget3()) {
     }
@@ -112,47 +112,47 @@ tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts(
     
     export class publicClassWithPrivateModuleParameterTypes {
         static myPublicStaticMethod(param= exporter.createExportedWidget2()) { // Error
-                                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4068: Parameter 'param' of public static method from exported class has or is using name 'SpecializedWidget.Widget2' from external module "tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_Widgets" but cannot be named.
+                                    ~~~~~
+!!! error TS4031: Name of inferred type of parameter 'param' could not be written. Consider adding an explicit type annotation.
         }
         myPublicMethod(param= exporter.createExportedWidget2()) { // Error
-                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4071: Parameter 'param' of public method from exported class has or is using name 'SpecializedWidget.Widget2' from external module "tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_Widgets" but cannot be named.
+                       ~~~~~
+!!! error TS4031: Name of inferred type of parameter 'param' could not be written. Consider adding an explicit type annotation.
         }
         constructor(param= exporter.createExportedWidget2(), private param1= exporter.createExportedWidget2(), public param2= exporter.createExportedWidget2()) { // Error
-                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4061: Parameter 'param' of constructor from exported class has or is using name 'SpecializedWidget.Widget2' from external module "tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_Widgets" but cannot be named.
-                                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4061: Parameter 'param1' of constructor from exported class has or is using name 'SpecializedWidget.Widget2' from external module "tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_Widgets" but cannot be named.
-                                                                                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4061: Parameter 'param2' of constructor from exported class has or is using name 'SpecializedWidget.Widget2' from external module "tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_Widgets" but cannot be named.
+                    ~~~~~
+!!! error TS4031: Name of inferred type of parameter 'param' could not be written. Consider adding an explicit type annotation.
+                                                                     ~~~~~~
+!!! error TS4031: Name of inferred type of parameter 'param1' could not be written. Consider adding an explicit type annotation.
+                                                                                                                      ~~~~~~
+!!! error TS4031: Name of inferred type of parameter 'param2' could not be written. Consider adding an explicit type annotation.
         }
     }
     export class publicClassWithPrivateModuleParameterTypes2 {
         static myPublicStaticMethod(param= exporter.createExportedWidget4()) { // Error
-                                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4068: Parameter 'param' of public static method from exported class has or is using name 'SpecializedGlobalWidget.Widget4' from external module "GlobalWidgets" but cannot be named.
+                                    ~~~~~
+!!! error TS4031: Name of inferred type of parameter 'param' could not be written. Consider adding an explicit type annotation.
         }
         myPublicMethod(param= exporter.createExportedWidget4()) { // Error
-                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4071: Parameter 'param' of public method from exported class has or is using name 'SpecializedGlobalWidget.Widget4' from external module "GlobalWidgets" but cannot be named.
+                       ~~~~~
+!!! error TS4031: Name of inferred type of parameter 'param' could not be written. Consider adding an explicit type annotation.
         }
         constructor(param= exporter.createExportedWidget4(), private param1= exporter.createExportedWidget4(), public param2= exporter.createExportedWidget4()) { // Error
-                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4061: Parameter 'param' of constructor from exported class has or is using name 'SpecializedGlobalWidget.Widget4' from external module "GlobalWidgets" but cannot be named.
-                                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4061: Parameter 'param1' of constructor from exported class has or is using name 'SpecializedGlobalWidget.Widget4' from external module "GlobalWidgets" but cannot be named.
-                                                                                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4061: Parameter 'param2' of constructor from exported class has or is using name 'SpecializedGlobalWidget.Widget4' from external module "GlobalWidgets" but cannot be named.
+                    ~~~~~
+!!! error TS4031: Name of inferred type of parameter 'param' could not be written. Consider adding an explicit type annotation.
+                                                                     ~~~~~~
+!!! error TS4031: Name of inferred type of parameter 'param1' could not be written. Consider adding an explicit type annotation.
+                                                                                                                      ~~~~~~
+!!! error TS4031: Name of inferred type of parameter 'param2' could not be written. Consider adding an explicit type annotation.
         }
     }
     export function publicFunctionWithPrivateModuleParameterTypes(param= exporter.createExportedWidget2()) { // Error
-                                                                  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4076: Parameter 'param' of exported function has or is using name 'SpecializedWidget.Widget2' from external module "tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_Widgets" but cannot be named.
+                                                                  ~~~~~
+!!! error TS4031: Name of inferred type of parameter 'param' could not be written. Consider adding an explicit type annotation.
     }
     export function publicFunctionWithPrivateModuleParameterTypes1(param= exporter.createExportedWidget4()) { // Error
-                                                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4076: Parameter 'param' of exported function has or is using name 'SpecializedGlobalWidget.Widget4' from external module "GlobalWidgets" but cannot be named.
+                                                                   ~~~~~
+!!! error TS4031: Name of inferred type of parameter 'param' could not be written. Consider adding an explicit type annotation.
     }
     
     
diff --git a/tests/baselines/reference/privacyFunctionCannotNameParameterTypeDeclFile.symbols b/tests/baselines/reference/privacyFunctionCannotNameParameterTypeDeclFile.symbols
deleted file mode 100644
index ea5ddf28d8099..0000000000000
--- a/tests/baselines/reference/privacyFunctionCannotNameParameterTypeDeclFile.symbols
+++ /dev/null
@@ -1,483 +0,0 @@
-=== tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts ===
-import exporter = require("privacyFunctionCannotNameParameterTypeDeclFile_exporter");
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
-
-export class publicClassWithWithPrivateParmeterTypes {
->publicClassWithWithPrivateParmeterTypes : Symbol(publicClassWithWithPrivateParmeterTypes, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 85))
-
-    static myPublicStaticMethod(param = exporter.createExportedWidget1()) { // Error
->myPublicStaticMethod : Symbol(publicClassWithWithPrivateParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 1, 54))
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 2, 32))
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
-    }
-    private static myPrivateStaticMethod(param = exporter.createExportedWidget1()) {
->myPrivateStaticMethod : Symbol(publicClassWithWithPrivateParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 3, 5))
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 4, 41))
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
-    }
-    myPublicMethod(param  = exporter.createExportedWidget1()) { // Error
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 5, 5))
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 6, 19))
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
-    }
-    private myPrivateMethod(param = exporter.createExportedWidget1()) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 7, 5))
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 8, 28))
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
-    }
-    constructor(param = exporter.createExportedWidget1(), private param1 = exporter.createExportedWidget1(), public param2 = exporter.createExportedWidget1()) { // Error
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 10, 16))
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
->param1 : Symbol(param1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 10, 57))
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
->param2 : Symbol(param2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 10, 108))
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
-    }
-}
-export class publicClassWithWithPrivateParmeterTypes1 {
->publicClassWithWithPrivateParmeterTypes1 : Symbol(publicClassWithWithPrivateParmeterTypes1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 12, 1))
-
-    static myPublicStaticMethod(param = exporter.createExportedWidget3()) { // Error
->myPublicStaticMethod : Symbol(publicClassWithWithPrivateParmeterTypes1.myPublicStaticMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 13, 55))
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 14, 32))
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
-    }
-    private static myPrivateStaticMethod(param = exporter.createExportedWidget3()) {
->myPrivateStaticMethod : Symbol(publicClassWithWithPrivateParmeterTypes1.myPrivateStaticMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 15, 5))
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 16, 41))
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
-    }
-    myPublicMethod(param  = exporter.createExportedWidget3()) { // Error
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 17, 5))
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 18, 19))
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
-    }
-    private myPrivateMethod(param = exporter.createExportedWidget3()) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 19, 5))
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 20, 28))
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
-    }
-    constructor(param = exporter.createExportedWidget3(), private param1 = exporter.createExportedWidget3(), public param2 = exporter.createExportedWidget3()) { // Error
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 22, 16))
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
->param1 : Symbol(param1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 22, 57))
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
->param2 : Symbol(param2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 22, 108))
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
-    }
-}
-
-class privateClassWithWithPrivateParmeterTypes {
->privateClassWithWithPrivateParmeterTypes : Symbol(privateClassWithWithPrivateParmeterTypes, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 24, 1))
-
-    static myPublicStaticMethod(param = exporter.createExportedWidget1()) {
->myPublicStaticMethod : Symbol(privateClassWithWithPrivateParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 26, 48))
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 27, 32))
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
-    }
-    private static myPrivateStaticMethod(param = exporter.createExportedWidget1()) {
->myPrivateStaticMethod : Symbol(privateClassWithWithPrivateParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 28, 5))
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 29, 41))
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
-    }
-    myPublicMethod(param  = exporter.createExportedWidget1()) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 30, 5))
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 31, 19))
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
-    }
-    private myPrivateMethod(param = exporter.createExportedWidget1()) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 32, 5))
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 33, 28))
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
-    }
-    constructor(param = exporter.createExportedWidget1(), private param1 = exporter.createExportedWidget1(), public param2 = exporter.createExportedWidget1()) {
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 35, 16))
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
->param1 : Symbol(param1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 35, 57))
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
->param2 : Symbol(param2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 35, 108))
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
-    }
-}
-class privateClassWithWithPrivateParmeterTypes2 {
->privateClassWithWithPrivateParmeterTypes2 : Symbol(privateClassWithWithPrivateParmeterTypes2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 37, 1))
-
-    static myPublicStaticMethod(param = exporter.createExportedWidget3()) {
->myPublicStaticMethod : Symbol(privateClassWithWithPrivateParmeterTypes2.myPublicStaticMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 38, 49))
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 39, 32))
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
-    }
-    private static myPrivateStaticMethod(param = exporter.createExportedWidget3()) {
->myPrivateStaticMethod : Symbol(privateClassWithWithPrivateParmeterTypes2.myPrivateStaticMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 40, 5))
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 41, 41))
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
-    }
-    myPublicMethod(param  = exporter.createExportedWidget3()) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 42, 5))
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 43, 19))
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
-    }
-    private myPrivateMethod(param = exporter.createExportedWidget3()) {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 44, 5))
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 45, 28))
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
-    }
-    constructor(param = exporter.createExportedWidget3(), private param1 = exporter.createExportedWidget3(), public param2 = exporter.createExportedWidget3()) {
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 47, 16))
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
->param1 : Symbol(param1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 47, 57))
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
->param2 : Symbol(param2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 47, 108))
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
-    }
-}
-
-export function publicFunctionWithPrivateParmeterTypes(param = exporter.createExportedWidget1()) { // Error
->publicFunctionWithPrivateParmeterTypes : Symbol(publicFunctionWithPrivateParmeterTypes, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 49, 1))
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 51, 55))
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
-}
-function privateFunctionWithPrivateParmeterTypes(param = exporter.createExportedWidget1()) {
->privateFunctionWithPrivateParmeterTypes : Symbol(privateFunctionWithPrivateParmeterTypes, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 52, 1))
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 53, 49))
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
-}
-export function publicFunctionWithPrivateParmeterTypes1(param = exporter.createExportedWidget3()) { // Error
->publicFunctionWithPrivateParmeterTypes1 : Symbol(publicFunctionWithPrivateParmeterTypes1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 54, 1))
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 55, 56))
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
-}
-function privateFunctionWithPrivateParmeterTypes1(param = exporter.createExportedWidget3()) {
->privateFunctionWithPrivateParmeterTypes1 : Symbol(privateFunctionWithPrivateParmeterTypes1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 56, 1))
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 57, 50))
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
-}
-
-
-export class publicClassWithPrivateModuleParameterTypes {
->publicClassWithPrivateModuleParameterTypes : Symbol(publicClassWithPrivateModuleParameterTypes, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 58, 1))
-
-    static myPublicStaticMethod(param= exporter.createExportedWidget2()) { // Error
->myPublicStaticMethod : Symbol(publicClassWithPrivateModuleParameterTypes.myPublicStaticMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 61, 57))
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 62, 32))
->exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
-    }
-    myPublicMethod(param= exporter.createExportedWidget2()) { // Error
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 63, 5))
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 64, 19))
->exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
-    }
-    constructor(param= exporter.createExportedWidget2(), private param1= exporter.createExportedWidget2(), public param2= exporter.createExportedWidget2()) { // Error
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 66, 16))
->exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
->param1 : Symbol(param1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 66, 56))
->exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
->param2 : Symbol(param2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 66, 106))
->exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
-    }
-}
-export class publicClassWithPrivateModuleParameterTypes2 {
->publicClassWithPrivateModuleParameterTypes2 : Symbol(publicClassWithPrivateModuleParameterTypes2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 68, 1))
-
-    static myPublicStaticMethod(param= exporter.createExportedWidget4()) { // Error
->myPublicStaticMethod : Symbol(publicClassWithPrivateModuleParameterTypes2.myPublicStaticMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 69, 58))
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 70, 32))
->exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
-    }
-    myPublicMethod(param= exporter.createExportedWidget4()) { // Error
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 71, 5))
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 72, 19))
->exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
-    }
-    constructor(param= exporter.createExportedWidget4(), private param1= exporter.createExportedWidget4(), public param2= exporter.createExportedWidget4()) { // Error
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 74, 16))
->exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
->param1 : Symbol(param1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 74, 56))
->exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
->param2 : Symbol(param2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 74, 106))
->exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
-    }
-}
-export function publicFunctionWithPrivateModuleParameterTypes(param= exporter.createExportedWidget2()) { // Error
->publicFunctionWithPrivateModuleParameterTypes : Symbol(publicFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 76, 1))
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 77, 62))
->exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
-}
-export function publicFunctionWithPrivateModuleParameterTypes1(param= exporter.createExportedWidget4()) { // Error
->publicFunctionWithPrivateModuleParameterTypes1 : Symbol(publicFunctionWithPrivateModuleParameterTypes1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 78, 1))
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 79, 63))
->exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
-}
-
-
-class privateClassWithPrivateModuleParameterTypes {
->privateClassWithPrivateModuleParameterTypes : Symbol(privateClassWithPrivateModuleParameterTypes, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 80, 1))
-
-    static myPublicStaticMethod(param= exporter.createExportedWidget2()) {
->myPublicStaticMethod : Symbol(privateClassWithPrivateModuleParameterTypes.myPublicStaticMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 83, 51))
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 84, 32))
->exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
-    }
-    myPublicMethod(param= exporter.createExportedWidget2()) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 85, 5))
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 86, 19))
->exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
-    }
-    constructor(param= exporter.createExportedWidget2(), private param1= exporter.createExportedWidget2(), public param2= exporter.createExportedWidget2()) {
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 88, 16))
->exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
->param1 : Symbol(param1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 88, 56))
->exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
->param2 : Symbol(param2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 88, 106))
->exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
-    }
-}
-class privateClassWithPrivateModuleParameterTypes1 {
->privateClassWithPrivateModuleParameterTypes1 : Symbol(privateClassWithPrivateModuleParameterTypes1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 90, 1))
-
-    static myPublicStaticMethod(param= exporter.createExportedWidget4()) {
->myPublicStaticMethod : Symbol(privateClassWithPrivateModuleParameterTypes1.myPublicStaticMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 91, 52))
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 92, 32))
->exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
-    }
-    myPublicMethod(param= exporter.createExportedWidget4()) {
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 93, 5))
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 94, 19))
->exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
-    }
-    constructor(param= exporter.createExportedWidget4(), private param1= exporter.createExportedWidget4(), public param2= exporter.createExportedWidget4()) {
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 96, 16))
->exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
->param1 : Symbol(param1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 96, 56))
->exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
->param2 : Symbol(param2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 96, 106))
->exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
-    }
-}
-function privateFunctionWithPrivateModuleParameterTypes(param= exporter.createExportedWidget2()) {
->privateFunctionWithPrivateModuleParameterTypes : Symbol(privateFunctionWithPrivateModuleParameterTypes, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 98, 1))
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 99, 56))
->exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
-}
-function privateFunctionWithPrivateModuleParameterTypes1(param= exporter.createExportedWidget4()) {
->privateFunctionWithPrivateModuleParameterTypes1 : Symbol(privateFunctionWithPrivateModuleParameterTypes1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 100, 1))
->param : Symbol(param, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 101, 57))
->exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionCannotNameParameterTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
-}
-=== tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts ===
-
-
-declare module "GlobalWidgets" {
-    export class Widget3 {
->Widget3 : Symbol(Widget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts, 2, 32))
-
-        name: string;
->name : Symbol(name, Decl(privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts, 3, 26))
-    }
-    export function createWidget3(): Widget3;
->createWidget3 : Symbol(createWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts, 5, 5))
->Widget3 : Symbol(Widget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts, 2, 32))
-
-    export module SpecializedGlobalWidget {
->SpecializedGlobalWidget : Symbol(SpecializedGlobalWidget, Decl(privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts, 6, 45))
-
-        export class Widget4 {
->Widget4 : Symbol(Widget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts, 8, 43))
-
-            name: string;
->name : Symbol(name, Decl(privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts, 9, 30))
-        }
-        function createWidget4(): Widget4;
->createWidget4 : Symbol(createWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts, 11, 9))
->Widget4 : Symbol(Widget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts, 8, 43))
-    }
-}
-
-=== tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_Widgets.ts ===
-export class Widget1 {
->Widget1 : Symbol(Widget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_Widgets.ts, 0, 0))
-
-    name = 'one';
->name : Symbol(name, Decl(privacyFunctionCannotNameParameterTypeDeclFile_Widgets.ts, 0, 22))
-}
-export function createWidget1() {
->createWidget1 : Symbol(createWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_Widgets.ts, 2, 1))
-
-    return new Widget1();
->Widget1 : Symbol(Widget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_Widgets.ts, 0, 0))
-}
-
-export module SpecializedWidget {
->SpecializedWidget : Symbol(SpecializedWidget, Decl(privacyFunctionCannotNameParameterTypeDeclFile_Widgets.ts, 5, 1))
-
-    export class Widget2 {
->Widget2 : Symbol(Widget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_Widgets.ts, 7, 33))
-
-        name = 'one';
->name : Symbol(name, Decl(privacyFunctionCannotNameParameterTypeDeclFile_Widgets.ts, 8, 26))
-    }
-    export function createWidget2() {
->createWidget2 : Symbol(createWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_Widgets.ts, 10, 5))
-
-        return new Widget2();
->Widget2 : Symbol(Widget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_Widgets.ts, 7, 33))
-    }
-}
-
-=== tests/cases/compiler/privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts ===
-///<reference path='privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts'/>
-import Widgets = require("privacyFunctionCannotNameParameterTypeDeclFile_Widgets");
->Widgets : Symbol(Widgets, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 0, 0))
-
-import Widgets1 = require("GlobalWidgets");
->Widgets1 : Symbol(Widgets1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 1, 83))
-
-export function createExportedWidget1() {
->createExportedWidget1 : Symbol(createExportedWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 2, 43))
-
-    return Widgets.createWidget1();
->Widgets.createWidget1 : Symbol(Widgets.createWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_Widgets.ts, 2, 1))
->Widgets : Symbol(Widgets, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 0, 0))
->createWidget1 : Symbol(Widgets.createWidget1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_Widgets.ts, 2, 1))
-}
-export function createExportedWidget2() {
->createExportedWidget2 : Symbol(createExportedWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 5, 1))
-
-    return Widgets.SpecializedWidget.createWidget2();
->Widgets.SpecializedWidget.createWidget2 : Symbol(Widgets.SpecializedWidget.createWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_Widgets.ts, 10, 5))
->Widgets.SpecializedWidget : Symbol(Widgets.SpecializedWidget, Decl(privacyFunctionCannotNameParameterTypeDeclFile_Widgets.ts, 5, 1))
->Widgets : Symbol(Widgets, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 0, 0))
->SpecializedWidget : Symbol(Widgets.SpecializedWidget, Decl(privacyFunctionCannotNameParameterTypeDeclFile_Widgets.ts, 5, 1))
->createWidget2 : Symbol(Widgets.SpecializedWidget.createWidget2, Decl(privacyFunctionCannotNameParameterTypeDeclFile_Widgets.ts, 10, 5))
-}
-export function createExportedWidget3() {
->createExportedWidget3 : Symbol(createExportedWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 8, 1))
-
-    return Widgets1.createWidget3();
->Widgets1.createWidget3 : Symbol(Widgets1.createWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts, 5, 5))
->Widgets1 : Symbol(Widgets1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 1, 83))
->createWidget3 : Symbol(Widgets1.createWidget3, Decl(privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts, 5, 5))
-}
-export function createExportedWidget4() {
->createExportedWidget4 : Symbol(createExportedWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 11, 1))
-
-    return Widgets1.SpecializedGlobalWidget.createWidget4();
->Widgets1.SpecializedGlobalWidget.createWidget4 : Symbol(Widgets1.SpecializedGlobalWidget.createWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts, 11, 9))
->Widgets1.SpecializedGlobalWidget : Symbol(Widgets1.SpecializedGlobalWidget, Decl(privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts, 6, 45))
->Widgets1 : Symbol(Widgets1, Decl(privacyFunctionCannotNameParameterTypeDeclFile_exporter.ts, 1, 83))
->SpecializedGlobalWidget : Symbol(Widgets1.SpecializedGlobalWidget, Decl(privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts, 6, 45))
->createWidget4 : Symbol(Widgets1.SpecializedGlobalWidget.createWidget4, Decl(privacyFunctionCannotNameParameterTypeDeclFile_GlobalWidgets.ts, 11, 9))
-}
-
diff --git a/tests/baselines/reference/privacyFunctionCannotNameReturnTypeDeclFile.errors.txt b/tests/baselines/reference/privacyFunctionCannotNameReturnTypeDeclFile.errors.txt
index 4be9aec9abee2..32892208b379e 100644
--- a/tests/baselines/reference/privacyFunctionCannotNameReturnTypeDeclFile.errors.txt
+++ b/tests/baselines/reference/privacyFunctionCannotNameReturnTypeDeclFile.errors.txt
@@ -1,15 +1,15 @@
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(3,12): error TS4050: Return type of public static method from exported class has or is using name 'Widget1' from external module "tests/cases/compiler/privacyFunctionReturnTypeDeclFile_Widgets" but cannot be named.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(9,5): error TS4053: Return type of public method from exported class has or is using name 'Widget1' from external module "tests/cases/compiler/privacyFunctionReturnTypeDeclFile_Widgets" but cannot be named.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(15,12): error TS4050: Return type of public static method from exported class has or is using name 'Widget3' from external module "GlobalWidgets" but cannot be named.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(21,5): error TS4053: Return type of public method from exported class has or is using name 'Widget3' from external module "GlobalWidgets" but cannot be named.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(56,17): error TS4058: Return type of exported function has or is using name 'Widget1' from external module "tests/cases/compiler/privacyFunctionReturnTypeDeclFile_Widgets" but cannot be named.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(62,17): error TS4058: Return type of exported function has or is using name 'Widget3' from external module "GlobalWidgets" but cannot be named.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(70,12): error TS4050: Return type of public static method from exported class has or is using name 'SpecializedWidget.Widget2' from external module "tests/cases/compiler/privacyFunctionReturnTypeDeclFile_Widgets" but cannot be named.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(73,5): error TS4053: Return type of public method from exported class has or is using name 'SpecializedWidget.Widget2' from external module "tests/cases/compiler/privacyFunctionReturnTypeDeclFile_Widgets" but cannot be named.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(76,12): error TS4050: Return type of public static method from exported class has or is using name 'SpecializedGlobalWidget.Widget4' from external module "GlobalWidgets" but cannot be named.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(79,5): error TS4053: Return type of public method from exported class has or is using name 'SpecializedGlobalWidget.Widget4' from external module "GlobalWidgets" but cannot be named.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(83,17): error TS4058: Return type of exported function has or is using name 'SpecializedWidget.Widget2' from external module "tests/cases/compiler/privacyFunctionReturnTypeDeclFile_Widgets" but cannot be named.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(86,17): error TS4058: Return type of exported function has or is using name 'SpecializedGlobalWidget.Widget4' from external module "GlobalWidgets" but cannot be named.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(3,12): error TS4039: Name of inferred return type of method 'myPublicStaticMethod' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(9,5): error TS4039: Name of inferred return type of method 'myPublicMethod' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(15,12): error TS4039: Name of inferred return type of method 'myPublicStaticMethod1' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(21,5): error TS4039: Name of inferred return type of method 'myPublicMethod1' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(56,17): error TS4061: Name of inferred return type of function 'publicFunctionWithPrivateParmeterTypes' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(62,17): error TS4061: Name of inferred return type of function 'publicFunctionWithPrivateParmeterTypes1' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(70,12): error TS4039: Name of inferred return type of method 'myPublicStaticMethod' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(73,5): error TS4039: Name of inferred return type of method 'myPublicMethod' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(76,12): error TS4039: Name of inferred return type of method 'myPublicStaticMethod1' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(79,5): error TS4039: Name of inferred return type of method 'myPublicMethod1' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(83,17): error TS4061: Name of inferred return type of function 'publicFunctionWithPrivateModuleReturnTypes' could not be written. Consider adding an explicit type annotation.
+tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(86,17): error TS4061: Name of inferred return type of function 'publicFunctionWithPrivateModuleReturnTypes1' could not be written. Consider adding an explicit type annotation.
 
 
 ==== tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts (12 errors) ====
@@ -17,7 +17,7 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(86,17): error
     export class publicClassWithWithPrivateParmeterTypes {
         static myPublicStaticMethod() { // Error
                ~~~~~~~~~~~~~~~~~~~~
-!!! error TS4050: Return type of public static method from exported class has or is using name 'Widget1' from external module "tests/cases/compiler/privacyFunctionReturnTypeDeclFile_Widgets" but cannot be named.
+!!! error TS4039: Name of inferred return type of method 'myPublicStaticMethod' could not be written. Consider adding an explicit type annotation.
             return exporter.createExportedWidget1();
         }
         private static myPrivateStaticMethod() {
@@ -25,7 +25,7 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(86,17): error
         }
         myPublicMethod() { // Error
         ~~~~~~~~~~~~~~
-!!! error TS4053: Return type of public method from exported class has or is using name 'Widget1' from external module "tests/cases/compiler/privacyFunctionReturnTypeDeclFile_Widgets" but cannot be named.
+!!! error TS4039: Name of inferred return type of method 'myPublicMethod' could not be written. Consider adding an explicit type annotation.
             return exporter.createExportedWidget1();;
         }
         private myPrivateMethod() {
@@ -33,7 +33,7 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(86,17): error
         }
         static myPublicStaticMethod1() { // Error
                ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4050: Return type of public static method from exported class has or is using name 'Widget3' from external module "GlobalWidgets" but cannot be named.
+!!! error TS4039: Name of inferred return type of method 'myPublicStaticMethod1' could not be written. Consider adding an explicit type annotation.
             return exporter.createExportedWidget3();
         }
         private static myPrivateStaticMethod1() {
@@ -41,7 +41,7 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(86,17): error
         }
         myPublicMethod1() { // Error
         ~~~~~~~~~~~~~~~
-!!! error TS4053: Return type of public method from exported class has or is using name 'Widget3' from external module "GlobalWidgets" but cannot be named.
+!!! error TS4039: Name of inferred return type of method 'myPublicMethod1' could not be written. Consider adding an explicit type annotation.
             return exporter.createExportedWidget3();;
         }
         private myPrivateMethod1() {
@@ -78,7 +78,7 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(86,17): error
     
     export function publicFunctionWithPrivateParmeterTypes() { // Error
                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4058: Return type of exported function has or is using name 'Widget1' from external module "tests/cases/compiler/privacyFunctionReturnTypeDeclFile_Widgets" but cannot be named.
+!!! error TS4061: Name of inferred return type of function 'publicFunctionWithPrivateParmeterTypes' could not be written. Consider adding an explicit type annotation.
         return exporter.createExportedWidget1();
     }
     function privateFunctionWithPrivateParmeterTypes()   {
@@ -86,7 +86,7 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(86,17): error
     }
     export function publicFunctionWithPrivateParmeterTypes1() { // Error
                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4058: Return type of exported function has or is using name 'Widget3' from external module "GlobalWidgets" but cannot be named.
+!!! error TS4061: Name of inferred return type of function 'publicFunctionWithPrivateParmeterTypes1' could not be written. Consider adding an explicit type annotation.
         return exporter.createExportedWidget3();
     }
     function privateFunctionWithPrivateParmeterTypes1() {
@@ -96,33 +96,33 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(86,17): error
     export class publicClassWithPrivateModuleReturnTypes {
         static myPublicStaticMethod() { // Error
                ~~~~~~~~~~~~~~~~~~~~
-!!! error TS4050: Return type of public static method from exported class has or is using name 'SpecializedWidget.Widget2' from external module "tests/cases/compiler/privacyFunctionReturnTypeDeclFile_Widgets" but cannot be named.
+!!! error TS4039: Name of inferred return type of method 'myPublicStaticMethod' could not be written. Consider adding an explicit type annotation.
             return exporter.createExportedWidget2();
         }
         myPublicMethod() { // Error
         ~~~~~~~~~~~~~~
-!!! error TS4053: Return type of public method from exported class has or is using name 'SpecializedWidget.Widget2' from external module "tests/cases/compiler/privacyFunctionReturnTypeDeclFile_Widgets" but cannot be named.
+!!! error TS4039: Name of inferred return type of method 'myPublicMethod' could not be written. Consider adding an explicit type annotation.
             return exporter.createExportedWidget2();
         }
         static myPublicStaticMethod1() { // Error
                ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4050: Return type of public static method from exported class has or is using name 'SpecializedGlobalWidget.Widget4' from external module "GlobalWidgets" but cannot be named.
+!!! error TS4039: Name of inferred return type of method 'myPublicStaticMethod1' could not be written. Consider adding an explicit type annotation.
             return exporter.createExportedWidget4();
         }
         myPublicMethod1() { // Error
         ~~~~~~~~~~~~~~~
-!!! error TS4053: Return type of public method from exported class has or is using name 'SpecializedGlobalWidget.Widget4' from external module "GlobalWidgets" but cannot be named.
+!!! error TS4039: Name of inferred return type of method 'myPublicMethod1' could not be written. Consider adding an explicit type annotation.
             return exporter.createExportedWidget4();
         }
     }
     export function publicFunctionWithPrivateModuleReturnTypes() { // Error
                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4058: Return type of exported function has or is using name 'SpecializedWidget.Widget2' from external module "tests/cases/compiler/privacyFunctionReturnTypeDeclFile_Widgets" but cannot be named.
+!!! error TS4061: Name of inferred return type of function 'publicFunctionWithPrivateModuleReturnTypes' could not be written. Consider adding an explicit type annotation.
         return exporter.createExportedWidget2();
     }
     export function publicFunctionWithPrivateModuleReturnTypes1() { // Error
                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4058: Return type of exported function has or is using name 'SpecializedGlobalWidget.Widget4' from external module "GlobalWidgets" but cannot be named.
+!!! error TS4061: Name of inferred return type of function 'publicFunctionWithPrivateModuleReturnTypes1' could not be written. Consider adding an explicit type annotation.
         return exporter.createExportedWidget4();
     }
     
diff --git a/tests/baselines/reference/privacyFunctionCannotNameReturnTypeDeclFile.symbols b/tests/baselines/reference/privacyFunctionCannotNameReturnTypeDeclFile.symbols
deleted file mode 100644
index 11bacd1923f10..0000000000000
--- a/tests/baselines/reference/privacyFunctionCannotNameReturnTypeDeclFile.symbols
+++ /dev/null
@@ -1,386 +0,0 @@
-=== tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts ===
-import exporter = require("privacyFunctionReturnTypeDeclFile_exporter");
->exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
-
-export class publicClassWithWithPrivateParmeterTypes {
->publicClassWithWithPrivateParmeterTypes : Symbol(publicClassWithWithPrivateParmeterTypes, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 72))
-
-    static myPublicStaticMethod() { // Error
->myPublicStaticMethod : Symbol(publicClassWithWithPrivateParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 1, 54))
-
-        return exporter.createExportedWidget1();
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
-    }
-    private static myPrivateStaticMethod() {
->myPrivateStaticMethod : Symbol(publicClassWithWithPrivateParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 4, 5))
-
-        return exporter.createExportedWidget1();;
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
-    }
-    myPublicMethod() { // Error
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 7, 5))
-
-        return exporter.createExportedWidget1();;
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
-    }
-    private myPrivateMethod() {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 10, 5))
-
-        return exporter.createExportedWidget1();;
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
-    }
-    static myPublicStaticMethod1() { // Error
->myPublicStaticMethod1 : Symbol(publicClassWithWithPrivateParmeterTypes.myPublicStaticMethod1, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 13, 5))
-
-        return exporter.createExportedWidget3();
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
-    }
-    private static myPrivateStaticMethod1() {
->myPrivateStaticMethod1 : Symbol(publicClassWithWithPrivateParmeterTypes.myPrivateStaticMethod1, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 16, 5))
-
-        return exporter.createExportedWidget3();;
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
-    }
-    myPublicMethod1() { // Error
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 19, 5))
-
-        return exporter.createExportedWidget3();;
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
-    }
-    private myPrivateMethod1() {
->myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 22, 5))
-
-        return exporter.createExportedWidget3();;
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
-    }
-}
-
-class privateClassWithWithPrivateParmeterTypes {
->privateClassWithWithPrivateParmeterTypes : Symbol(privateClassWithWithPrivateParmeterTypes, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 26, 1))
-
-    static myPublicStaticMethod() { 
->myPublicStaticMethod : Symbol(privateClassWithWithPrivateParmeterTypes.myPublicStaticMethod, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 28, 48))
-
-        return exporter.createExportedWidget1();
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
-    }
-    private static myPrivateStaticMethod() {
->myPrivateStaticMethod : Symbol(privateClassWithWithPrivateParmeterTypes.myPrivateStaticMethod, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 31, 5))
-
-        return exporter.createExportedWidget1();;
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
-    }
-    myPublicMethod() { 
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 34, 5))
-
-        return exporter.createExportedWidget1();;
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
-    }
-    private myPrivateMethod() {
->myPrivateMethod : Symbol(myPrivateMethod, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 37, 5))
-
-        return exporter.createExportedWidget1();;
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
-    }
-    static myPublicStaticMethod1() { 
->myPublicStaticMethod1 : Symbol(privateClassWithWithPrivateParmeterTypes.myPublicStaticMethod1, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 40, 5))
-
-        return exporter.createExportedWidget3();
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
-    }
-    private static myPrivateStaticMethod1() {
->myPrivateStaticMethod1 : Symbol(privateClassWithWithPrivateParmeterTypes.myPrivateStaticMethod1, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 43, 5))
-
-        return exporter.createExportedWidget3();;
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
-    }
-    myPublicMethod1() { 
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 46, 5))
-
-        return exporter.createExportedWidget3();;
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
-    }
-    private myPrivateMethod1() {
->myPrivateMethod1 : Symbol(myPrivateMethod1, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 49, 5))
-
-        return exporter.createExportedWidget3();;
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
-    }
-}
-
-export function publicFunctionWithPrivateParmeterTypes() { // Error
->publicFunctionWithPrivateParmeterTypes : Symbol(publicFunctionWithPrivateParmeterTypes, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 53, 1))
-
-    return exporter.createExportedWidget1();
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
-}
-function privateFunctionWithPrivateParmeterTypes()   {
->privateFunctionWithPrivateParmeterTypes : Symbol(privateFunctionWithPrivateParmeterTypes, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 57, 1))
-
-    return exporter.createExportedWidget1();
->exporter.createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
->exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget1 : Symbol(exporter.createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
-}
-export function publicFunctionWithPrivateParmeterTypes1() { // Error
->publicFunctionWithPrivateParmeterTypes1 : Symbol(publicFunctionWithPrivateParmeterTypes1, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 60, 1))
-
-    return exporter.createExportedWidget3();
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
-}
-function privateFunctionWithPrivateParmeterTypes1() {
->privateFunctionWithPrivateParmeterTypes1 : Symbol(privateFunctionWithPrivateParmeterTypes1, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 63, 1))
-
-    return exporter.createExportedWidget3();
->exporter.createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget3 : Symbol(exporter.createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
-}
-
-export class publicClassWithPrivateModuleReturnTypes {
->publicClassWithPrivateModuleReturnTypes : Symbol(publicClassWithPrivateModuleReturnTypes, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 66, 1))
-
-    static myPublicStaticMethod() { // Error
->myPublicStaticMethod : Symbol(publicClassWithPrivateModuleReturnTypes.myPublicStaticMethod, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 68, 54))
-
-        return exporter.createExportedWidget2();
->exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 5, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 5, 1))
-    }
-    myPublicMethod() { // Error
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 71, 5))
-
-        return exporter.createExportedWidget2();
->exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 5, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 5, 1))
-    }
-    static myPublicStaticMethod1() { // Error
->myPublicStaticMethod1 : Symbol(publicClassWithPrivateModuleReturnTypes.myPublicStaticMethod1, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 74, 5))
-
-        return exporter.createExportedWidget4();
->exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 11, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 11, 1))
-    }
-    myPublicMethod1() { // Error
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 77, 5))
-
-        return exporter.createExportedWidget4();
->exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 11, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 11, 1))
-    }
-}
-export function publicFunctionWithPrivateModuleReturnTypes() { // Error
->publicFunctionWithPrivateModuleReturnTypes : Symbol(publicFunctionWithPrivateModuleReturnTypes, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 81, 1))
-
-    return exporter.createExportedWidget2();
->exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 5, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 5, 1))
-}
-export function publicFunctionWithPrivateModuleReturnTypes1() { // Error
->publicFunctionWithPrivateModuleReturnTypes1 : Symbol(publicFunctionWithPrivateModuleReturnTypes1, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 84, 1))
-
-    return exporter.createExportedWidget4();
->exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 11, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 11, 1))
-}
-
-class privateClassWithPrivateModuleReturnTypes {
->privateClassWithPrivateModuleReturnTypes : Symbol(privateClassWithPrivateModuleReturnTypes, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 87, 1))
-
-    static myPublicStaticMethod() { 
->myPublicStaticMethod : Symbol(privateClassWithPrivateModuleReturnTypes.myPublicStaticMethod, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 89, 48))
-
-        return exporter.createExportedWidget2();
->exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 5, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 5, 1))
-    }
-    myPublicMethod() { 
->myPublicMethod : Symbol(myPublicMethod, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 92, 5))
-
-        return exporter.createExportedWidget2();
->exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 5, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 5, 1))
-    }
-    static myPublicStaticMethod1() { // Error
->myPublicStaticMethod1 : Symbol(privateClassWithPrivateModuleReturnTypes.myPublicStaticMethod1, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 95, 5))
-
-        return exporter.createExportedWidget4();
->exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 11, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 11, 1))
-    }
-    myPublicMethod1() { // Error
->myPublicMethod1 : Symbol(myPublicMethod1, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 98, 5))
-
-        return exporter.createExportedWidget4();
->exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 11, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 11, 1))
-    }
-}
-function privateFunctionWithPrivateModuleReturnTypes() { 
->privateFunctionWithPrivateModuleReturnTypes : Symbol(privateFunctionWithPrivateModuleReturnTypes, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 102, 1))
-
-    return exporter.createExportedWidget2();
->exporter.createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 5, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget2 : Symbol(exporter.createExportedWidget2, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 5, 1))
-}
-function privateFunctionWithPrivateModuleReturnTypes1() {
->privateFunctionWithPrivateModuleReturnTypes1 : Symbol(privateFunctionWithPrivateModuleReturnTypes1, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 105, 1))
-
-    return exporter.createExportedWidget4();
->exporter.createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 11, 1))
->exporter : Symbol(exporter, Decl(privacyFunctionReturnTypeDeclFile_consumer.ts, 0, 0))
->createExportedWidget4 : Symbol(exporter.createExportedWidget4, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 11, 1))
-}
-
-=== tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts ===
-
-
-declare module "GlobalWidgets" {
-    export class Widget3 {
->Widget3 : Symbol(Widget3, Decl(privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts, 2, 32))
-
-        name: string;
->name : Symbol(name, Decl(privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts, 3, 26))
-    }
-    export function createWidget3(): Widget3;
->createWidget3 : Symbol(createWidget3, Decl(privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts, 5, 5))
->Widget3 : Symbol(Widget3, Decl(privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts, 2, 32))
-
-    export module SpecializedGlobalWidget {
->SpecializedGlobalWidget : Symbol(SpecializedGlobalWidget, Decl(privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts, 6, 45))
-
-        export class Widget4 {
->Widget4 : Symbol(Widget4, Decl(privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts, 8, 43))
-
-            name: string;
->name : Symbol(name, Decl(privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts, 9, 30))
-        }
-        function createWidget4(): Widget4;
->createWidget4 : Symbol(createWidget4, Decl(privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts, 11, 9))
->Widget4 : Symbol(Widget4, Decl(privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts, 8, 43))
-    }
-}
-
-=== tests/cases/compiler/privacyFunctionReturnTypeDeclFile_Widgets.ts ===
-export class Widget1 {
->Widget1 : Symbol(Widget1, Decl(privacyFunctionReturnTypeDeclFile_Widgets.ts, 0, 0))
-
-    name = 'one';
->name : Symbol(name, Decl(privacyFunctionReturnTypeDeclFile_Widgets.ts, 0, 22))
-}
-export function createWidget1() {
->createWidget1 : Symbol(createWidget1, Decl(privacyFunctionReturnTypeDeclFile_Widgets.ts, 2, 1))
-
-    return new Widget1();
->Widget1 : Symbol(Widget1, Decl(privacyFunctionReturnTypeDeclFile_Widgets.ts, 0, 0))
-}
-
-export module SpecializedWidget {
->SpecializedWidget : Symbol(SpecializedWidget, Decl(privacyFunctionReturnTypeDeclFile_Widgets.ts, 5, 1))
-
-    export class Widget2 {
->Widget2 : Symbol(Widget2, Decl(privacyFunctionReturnTypeDeclFile_Widgets.ts, 7, 33))
-
-        name = 'one';
->name : Symbol(name, Decl(privacyFunctionReturnTypeDeclFile_Widgets.ts, 8, 26))
-    }
-    export function createWidget2() {
->createWidget2 : Symbol(createWidget2, Decl(privacyFunctionReturnTypeDeclFile_Widgets.ts, 10, 5))
-
-        return new Widget2();
->Widget2 : Symbol(Widget2, Decl(privacyFunctionReturnTypeDeclFile_Widgets.ts, 7, 33))
-    }
-}
-
-=== tests/cases/compiler/privacyFunctionReturnTypeDeclFile_exporter.ts ===
-///<reference path='privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts'/>
-import Widgets = require("privacyFunctionReturnTypeDeclFile_Widgets");
->Widgets : Symbol(Widgets, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 0, 0))
-
-import Widgets1 = require("GlobalWidgets");
->Widgets1 : Symbol(Widgets1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 1, 70))
-
-export function createExportedWidget1() {
->createExportedWidget1 : Symbol(createExportedWidget1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 2, 43))
-
-    return Widgets.createWidget1();
->Widgets.createWidget1 : Symbol(Widgets.createWidget1, Decl(privacyFunctionReturnTypeDeclFile_Widgets.ts, 2, 1))
->Widgets : Symbol(Widgets, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 0, 0))
->createWidget1 : Symbol(Widgets.createWidget1, Decl(privacyFunctionReturnTypeDeclFile_Widgets.ts, 2, 1))
-}
-export function createExportedWidget2() {
->createExportedWidget2 : Symbol(createExportedWidget2, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 5, 1))
-
-    return Widgets.SpecializedWidget.createWidget2();
->Widgets.SpecializedWidget.createWidget2 : Symbol(Widgets.SpecializedWidget.createWidget2, Decl(privacyFunctionReturnTypeDeclFile_Widgets.ts, 10, 5))
->Widgets.SpecializedWidget : Symbol(Widgets.SpecializedWidget, Decl(privacyFunctionReturnTypeDeclFile_Widgets.ts, 5, 1))
->Widgets : Symbol(Widgets, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 0, 0))
->SpecializedWidget : Symbol(Widgets.SpecializedWidget, Decl(privacyFunctionReturnTypeDeclFile_Widgets.ts, 5, 1))
->createWidget2 : Symbol(Widgets.SpecializedWidget.createWidget2, Decl(privacyFunctionReturnTypeDeclFile_Widgets.ts, 10, 5))
-}
-export function createExportedWidget3() {
->createExportedWidget3 : Symbol(createExportedWidget3, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 8, 1))
-
-    return Widgets1.createWidget3();
->Widgets1.createWidget3 : Symbol(Widgets1.createWidget3, Decl(privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts, 5, 5))
->Widgets1 : Symbol(Widgets1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 1, 70))
->createWidget3 : Symbol(Widgets1.createWidget3, Decl(privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts, 5, 5))
-}
-export function createExportedWidget4() {
->createExportedWidget4 : Symbol(createExportedWidget4, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 11, 1))
-
-    return Widgets1.SpecializedGlobalWidget.createWidget4();
->Widgets1.SpecializedGlobalWidget.createWidget4 : Symbol(Widgets1.SpecializedGlobalWidget.createWidget4, Decl(privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts, 11, 9))
->Widgets1.SpecializedGlobalWidget : Symbol(Widgets1.SpecializedGlobalWidget, Decl(privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts, 6, 45))
->Widgets1 : Symbol(Widgets1, Decl(privacyFunctionReturnTypeDeclFile_exporter.ts, 1, 70))
->SpecializedGlobalWidget : Symbol(Widgets1.SpecializedGlobalWidget, Decl(privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts, 6, 45))
->createWidget4 : Symbol(Widgets1.SpecializedGlobalWidget.createWidget4, Decl(privacyFunctionReturnTypeDeclFile_GlobalWidgets.ts, 11, 9))
-}
-
diff --git a/tests/baselines/reference/privacyFunctionParameterDeclFile.errors.txt b/tests/baselines/reference/privacyFunctionParameterDeclFile.errors.txt
index 56312953a5763..7b0b165c79938 100644
--- a/tests/baselines/reference/privacyFunctionParameterDeclFile.errors.txt
+++ b/tests/baselines/reference/privacyFunctionParameterDeclFile.errors.txt
@@ -1,105 +1,105 @@
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(39,25): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(39,25): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(40,21): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(41,29): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(63,48): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(67,35): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(71,32): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(71,62): error TS4028: Type of parameter 'param1' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(71,91): error TS4028: Type of parameter 'param2' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(114,71): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(123,86): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(129,25): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(130,21): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(131,29): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(134,48): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(136,35): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(138,32): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(138,75): error TS4028: Type of parameter 'param1' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(138,117): error TS4028: Type of parameter 'param2' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(141,78): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(143,93): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(164,21): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(165,17): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(166,25): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(188,44): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(192,31): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(196,28): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(196,58): error TS4028: Type of parameter 'param1' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(196,87): error TS4028: Type of parameter 'param2' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(239,67): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(248,82): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(254,21): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(255,17): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(256,25): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(259,44): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(261,31): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(263,28): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(263,71): error TS4028: Type of parameter 'param1' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(263,113): error TS4028: Type of parameter 'param2' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(266,74): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(268,89): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(9,17): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(10,13): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(11,21): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(33,40): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(37,27): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(41,24): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(41,54): error TS4028: Type of parameter 'param1' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(41,83): error TS4028: Type of parameter 'param2' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(84,63): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(93,78): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(99,17): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(100,13): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(101,21): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(104,40): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(106,27): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(108,24): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(108,67): error TS4028: Type of parameter 'param1' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(108,109): error TS4028: Type of parameter 'param2' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(111,70): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(113,85): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(141,21): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(142,17): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(143,25): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(165,44): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(169,31): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(173,28): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(173,58): error TS4028: Type of parameter 'param1' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(173,87): error TS4028: Type of parameter 'param2' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(216,67): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(225,82): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(231,21): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(232,17): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(233,25): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(236,44): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(238,31): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(240,28): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(240,71): error TS4028: Type of parameter 'param1' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(240,113): error TS4028: Type of parameter 'param2' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(243,74): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(245,89): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(274,21): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(274,21): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(275,17): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(276,25): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(298,44): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(302,31): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(306,28): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(306,58): error TS4028: Type of parameter 'param1' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(306,87): error TS4028: Type of parameter 'param2' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(349,67): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(358,82): error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(364,21): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(365,17): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(366,25): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(369,44): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(371,31): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(373,28): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(373,71): error TS4028: Type of parameter 'param1' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(373,113): error TS4028: Type of parameter 'param2' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(376,74): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89): error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(39,25): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(39,25): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(40,21): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(41,29): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(63,48): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(67,35): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(71,32): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(71,62): error TS4030: Type of parameter 'param1' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(71,91): error TS4030: Type of parameter 'param2' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(114,71): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(123,86): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(129,25): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(130,21): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(131,29): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(134,48): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(136,35): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(138,32): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(138,75): error TS4030: Type of parameter 'param1' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(138,117): error TS4030: Type of parameter 'param2' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(141,78): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(143,93): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(164,21): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(165,17): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(166,25): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(188,44): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(192,31): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(196,28): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(196,58): error TS4030: Type of parameter 'param1' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(196,87): error TS4030: Type of parameter 'param2' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(239,67): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(248,82): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(254,21): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(255,17): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(256,25): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(259,44): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(261,31): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(263,28): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(263,71): error TS4030: Type of parameter 'param1' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(263,113): error TS4030: Type of parameter 'param2' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(266,74): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(268,89): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(9,17): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(10,13): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(11,21): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(33,40): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(37,27): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(41,24): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(41,54): error TS4030: Type of parameter 'param1' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(41,83): error TS4030: Type of parameter 'param2' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(84,63): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(93,78): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(99,17): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(100,13): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(101,21): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(104,40): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(106,27): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(108,24): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(108,67): error TS4030: Type of parameter 'param1' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(108,109): error TS4030: Type of parameter 'param2' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(111,70): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(113,85): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(141,21): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(142,17): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(143,25): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(165,44): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(169,31): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(173,28): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(173,58): error TS4030: Type of parameter 'param1' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(173,87): error TS4030: Type of parameter 'param2' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(216,67): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(225,82): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(231,21): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(232,17): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(233,25): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(236,44): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(238,31): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(240,28): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(240,71): error TS4030: Type of parameter 'param1' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(240,113): error TS4030: Type of parameter 'param2' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(243,74): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(245,89): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(274,21): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(274,21): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(275,17): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(276,25): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(298,44): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(302,31): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(306,28): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(306,58): error TS4030: Type of parameter 'param1' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(306,87): error TS4030: Type of parameter 'param2' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(349,67): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(358,82): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(364,21): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(365,17): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(366,25): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(369,44): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(371,31): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(373,28): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(373,71): error TS4030: Type of parameter 'param1' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(373,113): error TS4030: Type of parameter 'param2' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(376,74): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
+tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
 
 
 ==== tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts (61 errors) ====
@@ -113,13 +113,13 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89):
     export interface publicInterfaceWithPrivateParmeterTypes {
         new (param: privateClass): publicClass; // Error
                     ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
         (param: privateClass): publicClass; // Error
                 ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
         myMethod(param: privateClass): void; // Error
                         ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
     }
     
     export interface publicInterfaceWithPublicParmeterTypes {
@@ -143,23 +143,23 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89):
     export class publicClassWithWithPrivateParmeterTypes {
         static myPublicStaticMethod(param: privateClass) { // Error
                                            ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
         }
         private static myPrivateStaticMethod(param: privateClass) {
         }
         myPublicMethod(param: privateClass) { // Error
                               ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
         }
         private myPrivateMethod(param: privateClass) {
         }
         constructor(param: privateClass, private param1: privateClass, public param2: privateClass) { // Error
                            ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
                                                          ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param1' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param1' references inaccessible name 'privateClass'.
                                                                                       ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param2' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param2' references inaccessible name 'privateClass'.
         }
     }
     
@@ -204,7 +204,7 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89):
     
     export function publicFunctionWithPrivateParmeterTypes(param: privateClass) { // Error
                                                                   ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
     }
     export function publicFunctionWithPublicParmeterTypes(param: publicClass) {
     }
@@ -215,7 +215,7 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89):
     
     export declare function publicAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void; // Error
                                                                                  ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
     export declare function publicAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
     declare function privateAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void;
     declare function privateAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
@@ -223,39 +223,39 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89):
     export interface publicInterfaceWithPrivateModuleParameterTypes {
         new (param: privateModule.publicClass): publicClass; // Error
                     ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
         (param: privateModule.publicClass): publicClass; // Error
                 ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
         myMethod(param: privateModule.publicClass): void; // Error
                         ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
     }
     export class publicClassWithPrivateModuleParameterTypes {
         static myPublicStaticMethod(param: privateModule.publicClass) { // Error
                                            ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
         }
         myPublicMethod(param: privateModule.publicClass) { // Error
                               ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
         }
         constructor(param: privateModule.publicClass, private param1: privateModule.publicClass, public param2: privateModule.publicClass) { // Error
                            ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
                                                                       ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param1' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param1' references inaccessible name 'privateModule'.
                                                                                                                 ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param2' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param2' references inaccessible name 'privateModule'.
         }
     }
     export function publicFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass) { // Error
                                                                          ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
     }
     export declare function publicAmbientFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass): void; // Error
                                                                                         ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
     
     interface privateInterfaceWithPrivateModuleParameterTypes {
         new (param: privateModule.publicClass): publicClass;
@@ -285,13 +285,13 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89):
         export interface publicInterfaceWithPrivateParmeterTypes {
             new (param: privateClass): publicClass; // Error
                         ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
             (param: privateClass): publicClass; // Error
                     ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
             myMethod(param: privateClass): void; // Error
                             ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
         }
     
         export interface publicInterfaceWithPublicParmeterTypes {
@@ -315,23 +315,23 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89):
         export class publicClassWithWithPrivateParmeterTypes {
             static myPublicStaticMethod(param: privateClass) { // Error
                                                ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
             }
             private static myPrivateStaticMethod(param: privateClass) {
             }
             myPublicMethod(param: privateClass) { // Error
                                   ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
             }
             private myPrivateMethod(param: privateClass) {
             }
             constructor(param: privateClass, private param1: privateClass, public param2: privateClass) { // Error
                                ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
                                                              ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param1' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param1' references inaccessible name 'privateClass'.
                                                                                           ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param2' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param2' references inaccessible name 'privateClass'.
             }
         }
     
@@ -376,7 +376,7 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89):
     
         export function publicFunctionWithPrivateParmeterTypes(param: privateClass) { // Error
                                                                       ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
         }
         export function publicFunctionWithPublicParmeterTypes(param: publicClass) {
         }
@@ -387,7 +387,7 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89):
     
         export declare function publicAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void; // Error
                                                                                      ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
         export declare function publicAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
         declare function privateAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void;
         declare function privateAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
@@ -395,39 +395,39 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89):
         export interface publicInterfaceWithPrivateModuleParameterTypes {
             new (param: privateModule.publicClass): publicClass; // Error
                         ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
             (param: privateModule.publicClass): publicClass; // Error
                     ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
             myMethod(param: privateModule.publicClass): void; // Error
                             ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
         }
         export class publicClassWithPrivateModuleParameterTypes {
             static myPublicStaticMethod(param: privateModule.publicClass) { // Error
                                                ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
             }
             myPublicMethod(param: privateModule.publicClass) { // Error
                                   ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
             }
             constructor(param: privateModule.publicClass, private param1: privateModule.publicClass, public param2: privateModule.publicClass) { // Error
                                ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
                                                                           ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param1' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param1' references inaccessible name 'privateModule'.
                                                                                                                     ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param2' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param2' references inaccessible name 'privateModule'.
             }
         }
         export function publicFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass) { // Error
                                                                              ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
         }
         export declare function publicAmbientFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass): void; // Error
                                                                                             ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
     
         interface privateInterfaceWithPrivateModuleParameterTypes {
             new (param: privateModule.publicClass): publicClass;
@@ -458,15 +458,15 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89):
         export interface publicInterfaceWithPrivateParmeterTypes {
             new (param: privateClass): publicClass;
                         ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
                         ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
             (param: privateClass): publicClass;
                     ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
             myMethod(param: privateClass): void;
                             ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
         }
     
         export interface publicInterfaceWithPublicParmeterTypes {
@@ -490,23 +490,23 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89):
         export class publicClassWithWithPrivateParmeterTypes {
             static myPublicStaticMethod(param: privateClass) {
                                                ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
             }
             private static myPrivateStaticMethod(param: privateClass) {
             }
             myPublicMethod(param: privateClass) {
                                   ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
             }
             private myPrivateMethod(param: privateClass) {
             }
             constructor(param: privateClass, private param1: privateClass, public param2: privateClass) {
                                ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
                                                              ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param1' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param1' references inaccessible name 'privateClass'.
                                                                                           ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param2' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param2' references inaccessible name 'privateClass'.
             }
         }
     
@@ -551,7 +551,7 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89):
     
         export function publicFunctionWithPrivateParmeterTypes(param: privateClass) {
                                                                       ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
         }
         export function publicFunctionWithPublicParmeterTypes(param: publicClass) {
         }
@@ -562,7 +562,7 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89):
     
         export declare function publicAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void;
                                                                                      ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
         export declare function publicAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
         declare function privateAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void;
         declare function privateAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
@@ -570,39 +570,39 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89):
         export interface publicInterfaceWithPrivateModuleParameterTypes {
             new (param: privateModule.publicClass): publicClass;
                         ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
             (param: privateModule.publicClass): publicClass;
                     ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
             myMethod(param: privateModule.publicClass): void;
                             ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
         }
         export class publicClassWithPrivateModuleParameterTypes {
             static myPublicStaticMethod(param: privateModule.publicClass) {
                                                ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
             }
             myPublicMethod(param: privateModule.publicClass) {
                                   ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
             }
             constructor(param: privateModule.publicClass, private param1: privateModule.publicClass, public param2: privateModule.publicClass) {
                                ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
                                                                           ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param1' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param1' references inaccessible name 'privateModule'.
                                                                                                                     ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param2' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param2' references inaccessible name 'privateModule'.
             }
         }
         export function publicFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass) {
                                                                              ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
         }
         export declare function publicAmbientFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass): void;
                                                                                             ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
     
         interface privateInterfaceWithPrivateModuleParameterTypes {
             new (param: privateModule.publicClass): publicClass;
@@ -663,15 +663,15 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89):
             export interface publicInterfaceWithPrivateParmeterTypes {
                 new (param: privateClass): publicClass;
                             ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
                             ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
                 (param: privateClass): publicClass;
                         ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
                 myMethod(param: privateClass): void;
                                 ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
             }
     
             export interface publicInterfaceWithPublicParmeterTypes {
@@ -695,23 +695,23 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89):
             export class publicClassWithWithPrivateParmeterTypes {
                 static myPublicStaticMethod(param: privateClass) {
                                                    ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
                 }
                 private static myPrivateStaticMethod(param: privateClass) {
                 }
                 myPublicMethod(param: privateClass) {
                                       ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
                 }
                 private myPrivateMethod(param: privateClass) {
                 }
                 constructor(param: privateClass, private param1: privateClass, public param2: privateClass) {
                                    ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
                                                                  ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param1' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param1' references inaccessible name 'privateClass'.
                                                                                               ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param2' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param2' references inaccessible name 'privateClass'.
                 }
             }
     
@@ -756,7 +756,7 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89):
     
             export function publicFunctionWithPrivateParmeterTypes(param: privateClass) {
                                                                           ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
             }
             export function publicFunctionWithPublicParmeterTypes(param: publicClass) {
             }
@@ -767,7 +767,7 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89):
     
             export declare function publicAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void;
                                                                                          ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
             export declare function publicAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
             declare function privateAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void;
             declare function privateAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
@@ -775,39 +775,39 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89):
             export interface publicInterfaceWithPrivateModuleParameterTypes {
                 new (param: privateModule.publicClass): publicClass;
                             ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
                 (param: privateModule.publicClass): publicClass;
                         ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
                 myMethod(param: privateModule.publicClass): void;
                                 ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
             }
             export class publicClassWithPrivateModuleParameterTypes {
                 static myPublicStaticMethod(param: privateModule.publicClass) {
                                                    ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
                 }
                 myPublicMethod(param: privateModule.publicClass) {
                                       ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
                 }
                 constructor(param: privateModule.publicClass, private param1: privateModule.publicClass, public param2: privateModule.publicClass) {
                                    ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
                                                                               ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param1' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param1' references inaccessible name 'privateModule'.
                                                                                                                         ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param2' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param2' references inaccessible name 'privateModule'.
                 }
             }
             export function publicFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass) {
                                                                                  ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
             }
             export declare function publicAmbientFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass): void;
                                                                                                 ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
     
             interface privateInterfaceWithPrivateModuleParameterTypes {
                 new (param: privateModule.publicClass): publicClass;
@@ -830,13 +830,13 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89):
         export interface publicInterfaceWithPrivateParmeterTypes {
             new (param: privateClass): publicClass; // Error
                         ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
             (param: privateClass): publicClass; // Error
                     ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
             myMethod(param: privateClass): void; // Error
                             ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
         }
     
         export interface publicInterfaceWithPublicParmeterTypes {
@@ -860,23 +860,23 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89):
         export class publicClassWithWithPrivateParmeterTypes {
             static myPublicStaticMethod(param: privateClass) { // Error
                                                ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
             }
             private static myPrivateStaticMethod(param: privateClass) {
             }
             myPublicMethod(param: privateClass) { // Error
                                   ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
             }
             private myPrivateMethod(param: privateClass) {
             }
             constructor(param: privateClass, private param1: privateClass, public param2: privateClass) { // Error
                                ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
                                                              ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param1' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param1' references inaccessible name 'privateClass'.
                                                                                           ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param2' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param2' references inaccessible name 'privateClass'.
             }
         }
     
@@ -921,7 +921,7 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89):
     
         export function publicFunctionWithPrivateParmeterTypes(param: privateClass) { // Error
                                                                       ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
         }
         export function publicFunctionWithPublicParmeterTypes(param: publicClass) {
         }
@@ -932,7 +932,7 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89):
     
         export declare function publicAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void; // Error
                                                                                      ~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateClass'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
         export declare function publicAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
         declare function privateAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void;
         declare function privateAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
@@ -940,39 +940,39 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89):
         export interface publicInterfaceWithPrivateModuleParameterTypes {
             new (param: privateModule.publicClass): publicClass; // Error
                         ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
             (param: privateModule.publicClass): publicClass; // Error
                     ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
             myMethod(param: privateModule.publicClass): void; // Error
                             ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
         }
         export class publicClassWithPrivateModuleParameterTypes {
             static myPublicStaticMethod(param: privateModule.publicClass) { // Error
                                                ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
             }
             myPublicMethod(param: privateModule.publicClass) { // Error
                                   ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
             }
             constructor(param: privateModule.publicClass, private param1: privateModule.publicClass, public param2: privateModule.publicClass) { // Error
                                ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
                                                                           ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param1' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param1' references inaccessible name 'privateModule'.
                                                                                                                     ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param2' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param2' references inaccessible name 'privateModule'.
             }
         }
         export function publicFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass) { // Error
                                                                              ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
         }
         export declare function publicAmbientFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass): void; // Error
                                                                                             ~~~~~~~~~~~~~
-!!! error TS4028: Type of parameter 'param' references inaccessible name 'privateModule'.
+!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
     
         interface privateInterfaceWithPrivateModuleParameterTypes {
             new (param: privateModule.publicClass): publicClass;
diff --git a/tests/baselines/reference/symbolDeclarationEmit12.errors.txt b/tests/baselines/reference/symbolDeclarationEmit12.errors.txt
index d7f739dc905ea..09df161f12e65 100644
--- a/tests/baselines/reference/symbolDeclarationEmit12.errors.txt
+++ b/tests/baselines/reference/symbolDeclarationEmit12.errors.txt
@@ -1,10 +1,10 @@
 tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts(4,28): error TS4028: Type of property '[Symbol.iterator]' references inaccessible name 'I'.
 tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts(5,9): error TS2300: Duplicate identifier '[Symbol.toPrimitive]'.
-tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts(5,33): error TS4028: Type of parameter 'x' references inaccessible name 'I'.
+tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts(5,33): error TS4030: Type of parameter 'x' references inaccessible name 'I'.
 tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts(6,40): error TS4038: Return type of method '[Symbol.isConcatSpreadable]' references inaccessible name 'I'.
 tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts(9,13): error TS2300: Duplicate identifier '[Symbol.toPrimitive]'.
 tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts(10,13): error TS2300: Duplicate identifier '[Symbol.toPrimitive]'.
-tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts(10,37): error TS4028: Type of parameter 'x' references inaccessible name 'I'.
+tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts(10,37): error TS4030: Type of parameter 'x' references inaccessible name 'I'.
 
 
 ==== tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts (7 errors) ====
@@ -18,7 +18,7 @@ tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts(10,37): error TS4
             ~~~~~~~~~~~~~~~~~~~~
 !!! error TS2300: Duplicate identifier '[Symbol.toPrimitive]'.
                                     ~
-!!! error TS4028: Type of parameter 'x' references inaccessible name 'I'.
+!!! error TS4030: Type of parameter 'x' references inaccessible name 'I'.
             [Symbol.isConcatSpreadable](): I {
                                            ~
 !!! error TS4038: Return type of method '[Symbol.isConcatSpreadable]' references inaccessible name 'I'.
@@ -31,6 +31,6 @@ tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts(10,37): error TS4
                 ~~~~~~~~~~~~~~~~~~~~
 !!! error TS2300: Duplicate identifier '[Symbol.toPrimitive]'.
                                         ~
-!!! error TS4028: Type of parameter 'x' references inaccessible name 'I'.
+!!! error TS4030: Type of parameter 'x' references inaccessible name 'I'.
         }
     }
\ No newline at end of file
diff --git a/tests/cases/compiler/privacyCannotNameAccessorDeclFile2.ts b/tests/cases/compiler/privacyCannotNameAccessorDeclFile2.ts
new file mode 100644
index 0000000000000..0cf65b7d4c7e5
--- /dev/null
+++ b/tests/cases/compiler/privacyCannotNameAccessorDeclFile2.ts
@@ -0,0 +1,24 @@
+// @target: ES5
+// @declaration: true
+
+namespace M {
+    export interface I { }
+}
+
+namespace N {
+    export function getI(): M.I {
+        return undefined
+    }
+}
+
+namespace O {
+    // shadow M with a local namespace declaration
+    export namespace M {
+        export var x = 0;
+    }
+
+    // Error, return type cannot be named
+    export function getIlocally() {
+        return N.getI();
+    }
+}

From 57aae4031c3855e1b1c72de5294cdf4e7122419c Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Thu, 16 Jul 2015 11:10:32 -0700
Subject: [PATCH 40/57] accept baselines

---
 .../reference/tsxAttributeResolution9.symbols | 47 ------------------
 .../reference/tsxAttributeResolution9.types   | 49 -------------------
 2 files changed, 96 deletions(-)
 delete mode 100644 tests/baselines/reference/tsxAttributeResolution9.symbols
 delete mode 100644 tests/baselines/reference/tsxAttributeResolution9.types

diff --git a/tests/baselines/reference/tsxAttributeResolution9.symbols b/tests/baselines/reference/tsxAttributeResolution9.symbols
deleted file mode 100644
index 081482d5d47a4..0000000000000
--- a/tests/baselines/reference/tsxAttributeResolution9.symbols
+++ /dev/null
@@ -1,47 +0,0 @@
-=== tests/cases/conformance/jsx/react.d.ts ===
-
-declare module JSX {
->JSX : Symbol(JSX, Decl(react.d.ts, 0, 0))
-
-	interface Element { }
->Element : Symbol(Element, Decl(react.d.ts, 1, 20))
-
-	interface IntrinsicElements {
->IntrinsicElements : Symbol(IntrinsicElements, Decl(react.d.ts, 2, 22))
-	}
-	interface ElementAttributesProperty {
->ElementAttributesProperty : Symbol(ElementAttributesProperty, Decl(react.d.ts, 4, 2))
-
-		props;
->props : Symbol(props, Decl(react.d.ts, 5, 38))
-	}
-}
-
-interface Props {  
->Props : Symbol(Props, Decl(react.d.ts, 8, 1))
-
-  foo: string;
->foo : Symbol(foo, Decl(react.d.ts, 10, 17))
-}
-
-=== tests/cases/conformance/jsx/file.tsx ===
-export class MyComponent {  
->MyComponent : Symbol(MyComponent, Decl(file.tsx, 0, 0))
-
-  render() {
->render : Symbol(render, Decl(file.tsx, 0, 26))
-  }
-
-  props: { foo: string; }
->props : Symbol(props, Decl(file.tsx, 2, 3))
->foo : Symbol(foo, Decl(file.tsx, 4, 10))
-}
-
-<MyComponent foo="bar" />; // ok  
->MyComponent : Symbol(MyComponent, Decl(file.tsx, 0, 0))
->foo : Symbol(unknown)
-
-<MyComponent foo={0} />; // should be an error
->MyComponent : Symbol(MyComponent, Decl(file.tsx, 0, 0))
->foo : Symbol(unknown)
-
diff --git a/tests/baselines/reference/tsxAttributeResolution9.types b/tests/baselines/reference/tsxAttributeResolution9.types
deleted file mode 100644
index 1b2c6d423896a..0000000000000
--- a/tests/baselines/reference/tsxAttributeResolution9.types
+++ /dev/null
@@ -1,49 +0,0 @@
-=== tests/cases/conformance/jsx/react.d.ts ===
-
-declare module JSX {
->JSX : any
-
-	interface Element { }
->Element : Element
-
-	interface IntrinsicElements {
->IntrinsicElements : IntrinsicElements
-	}
-	interface ElementAttributesProperty {
->ElementAttributesProperty : ElementAttributesProperty
-
-		props;
->props : any
-	}
-}
-
-interface Props {  
->Props : Props
-
-  foo: string;
->foo : string
-}
-
-=== tests/cases/conformance/jsx/file.tsx ===
-export class MyComponent {  
->MyComponent : MyComponent
-
-  render() {
->render : () => void
-  }
-
-  props: { foo: string; }
->props : { foo: string; }
->foo : string
-}
-
-<MyComponent foo="bar" />; // ok  
-><MyComponent foo="bar" /> : JSX.Element
->MyComponent : typeof MyComponent
->foo : any
-
-<MyComponent foo={0} />; // should be an error
-><MyComponent foo={0} /> : JSX.Element
->MyComponent : typeof MyComponent
->foo : any
-

From b44fba35fc16450ed8233ffc7d76005c1a06c104 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Thu, 16 Jul 2015 11:10:46 -0700
Subject: [PATCH 41/57] remove unused code from checker

---
 src/compiler/checker.ts | 340 +---------------------------------------
 src/compiler/types.ts   |  33 ----
 2 files changed, 1 insertion(+), 372 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index b168161f4d959..b7a87325152c2 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -635,19 +635,6 @@ namespace ts {
             return false;
         }
 
-        function getAnyImportSyntax(node: Node): AnyImportSyntax {
-            if (isAliasSymbolDeclaration(node)) {
-                if (node.kind === SyntaxKind.ImportEqualsDeclaration) {
-                    return <ImportEqualsDeclaration>node;
-                }
-
-                while (node && node.kind !== SyntaxKind.ImportDeclaration) {
-                    node = node.parent;
-                }
-                return <ImportDeclaration>node;
-            }
-        }
-
         function getDeclarationOfAliasSymbol(symbol: Symbol): Declaration {
             return forEach(symbol.declarations, d => isAliasSymbolDeclaration(d) ? d : undefined);
         }
@@ -1296,145 +1283,12 @@ namespace ts {
             return qualify;
         }
 
-        function isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessiblityResult {
-            if (symbol && enclosingDeclaration && !(symbol.flags & SymbolFlags.TypeParameter)) {
-                let initialSymbol = symbol;
-                let meaningToLook = meaning;
-                while (symbol) {
-                    // Symbol is accessible if it by itself is accessible
-                    let accessibleSymbolChain = getAccessibleSymbolChain(symbol, enclosingDeclaration, meaningToLook, /*useOnlyExternalAliasing*/ false);
-                    if (accessibleSymbolChain) {
-                        let hasAccessibleDeclarations = hasVisibleDeclarations(accessibleSymbolChain[0]);
-                        if (!hasAccessibleDeclarations) {
-                            return <SymbolAccessiblityResult>{
-                                accessibility: SymbolAccessibility.NotAccessible,
-                                errorSymbolName: symbolToString(initialSymbol, enclosingDeclaration, meaning),
-                                errorModuleName: symbol !== initialSymbol ? symbolToString(symbol, enclosingDeclaration, SymbolFlags.Namespace) : undefined,
-                            };
-                        }
-                        return hasAccessibleDeclarations;
-                    }
-
-                    // If we haven't got the accessible symbol, it doesn't mean the symbol is actually inaccessible.
-                    // It could be a qualified symbol and hence verify the path
-                    // e.g.:
-                    // module m {
-                    //     export class c {
-                    //     }
-                    // }
-                    // let x: typeof m.c
-                    // In the above example when we start with checking if typeof m.c symbol is accessible,
-                    // we are going to see if c can be accessed in scope directly.
-                    // But it can't, hence the accessible is going to be undefined, but that doesn't mean m.c is inaccessible
-                    // It is accessible if the parent m is accessible because then m.c can be accessed through qualification
-                    meaningToLook = getQualifiedLeftMeaning(meaning);
-                    symbol = getParentOfSymbol(symbol);
-                }
-
-                // This could be a symbol that is not exported in the external module
-                // or it could be a symbol from different external module that is not aliased and hence cannot be named
-                let symbolExternalModule = forEach(initialSymbol.declarations, getExternalModuleContainer);
-                if (symbolExternalModule) {
-                    let enclosingExternalModule = getExternalModuleContainer(enclosingDeclaration);
-                    if (symbolExternalModule !== enclosingExternalModule) {
-                        // name from different external module that is not visible
-                        return {
-                            accessibility: SymbolAccessibility.CannotBeNamed,
-                            errorSymbolName: symbolToString(initialSymbol, enclosingDeclaration, meaning),
-                            errorModuleName: symbolToString(symbolExternalModule)
-                        };
-                    }
-                }
-
-                // Just a local name that is not accessible
-                return {
-                    accessibility: SymbolAccessibility.NotAccessible,
-                    errorSymbolName: symbolToString(initialSymbol, enclosingDeclaration, meaning),
-                };
-            }
-
-            return { accessibility: SymbolAccessibility.Accessible };
-
-            function getExternalModuleContainer(declaration: Node) {
-                for (; declaration; declaration = declaration.parent) {
-                    if (hasExternalModuleSymbol(declaration)) {
-                        return getSymbolOfNode(declaration);
-                    }
-                }
-            }
-        }
-
         function hasExternalModuleSymbol(declaration: Node) {
             return (declaration.kind === SyntaxKind.ModuleDeclaration && (<ModuleDeclaration>declaration).name.kind === SyntaxKind.StringLiteral) ||
                 (declaration.kind === SyntaxKind.SourceFile && isExternalModule(<SourceFile>declaration));
         }
 
-        function hasVisibleDeclarations(symbol: Symbol): SymbolVisibilityResult {
-            let aliasesToMakeVisible: AnyImportSyntax[];
-            if (forEach(symbol.declarations, declaration => !getIsDeclarationVisible(declaration))) {
-                return undefined;
-            }
-            return { accessibility: SymbolAccessibility.Accessible, aliasesToMakeVisible };
-
-            function getIsDeclarationVisible(declaration: Declaration) {
-                if (!isDeclarationVisible(declaration)) {
-                    // Mark the unexported alias as visible if its parent is visible
-                    // because these kind of aliases can be used to name types in declaration file
-
-                    let anyImportSyntax = getAnyImportSyntax(declaration);
-                    if (anyImportSyntax &&
-                        !(anyImportSyntax.flags & NodeFlags.Export) && // import clause without export
-                        isDeclarationVisible(<Declaration>anyImportSyntax.parent)) {
-                        getNodeLinks(declaration).isVisible = true;
-                        if (aliasesToMakeVisible) {
-                            if (!contains(aliasesToMakeVisible, anyImportSyntax)) {
-                                aliasesToMakeVisible.push(anyImportSyntax);
-                            }
-                        }
-                        else {
-                            aliasesToMakeVisible = [anyImportSyntax];
-                        }
-                        return true;
-                    }
-
-                    // Declaration is not visible
-                    return false;
-                }
-
-                return true;
-            }
-        }
-
-        function isEntityNameVisible(entityName: EntityName | Expression, enclosingDeclaration: Node): SymbolVisibilityResult {
-            // get symbol of the first identifier of the entityName
-            let meaning: SymbolFlags;
-            if (entityName.parent.kind === SyntaxKind.TypeQuery) {
-                // Typeof value
-                meaning = SymbolFlags.Value | SymbolFlags.ExportValue;
-            }
-            else if (entityName.kind === SyntaxKind.QualifiedName || entityName.kind === SyntaxKind.PropertyAccessExpression ||
-                entityName.parent.kind === SyntaxKind.ImportEqualsDeclaration) {
-                // Left identifier from type reference or TypeAlias
-                // Entity name of the import declaration
-                meaning = SymbolFlags.Namespace;
-            }
-            else {
-                // Type Reference or TypeAlias entity = Identifier
-                meaning = SymbolFlags.Type;
-            }
-
-            let firstIdentifier = getFirstIdentifier(entityName);
-            let symbol = resolveName(enclosingDeclaration, (<Identifier>firstIdentifier).text, meaning, /*nodeNotFoundErrorMessage*/ undefined, /*nameArg*/ undefined);
-
-            // Verify if the symbol is accessible
-            return (symbol && hasVisibleDeclarations(symbol)) || <SymbolVisibilityResult>{
-                accessibility: SymbolAccessibility.NotAccessible,
-                errorSymbolName: getTextOfNode(firstIdentifier),
-                errorNode: firstIdentifier
-            };
-        }
-
-        function writeKeyword(writer: SymbolWriter, kind: SyntaxKind) {
+       function writeKeyword(writer: SymbolWriter, kind: SyntaxKind) {
             writer.writeKeyword(tokenToString(kind));
         }
 
@@ -2028,188 +1882,6 @@ namespace ts {
             });
         }
 
-        function isDeclarationVisible(node: Declaration): boolean {
-            function getContainingExternalModule(node: Node) {
-                for (; node; node = node.parent) {
-                    if (node.kind === SyntaxKind.ModuleDeclaration) {
-                        if ((<ModuleDeclaration>node).name.kind === SyntaxKind.StringLiteral) {
-                            return node;
-                        }
-                    }
-                    else if (node.kind === SyntaxKind.SourceFile) {
-                        return isExternalModule(<SourceFile>node) ? node : undefined;
-                    }
-                }
-                Debug.fail("getContainingModule cant reach here");
-            }
-
-            function isUsedInExportAssignment(node: Node) {
-                // Get source File and see if it is external module and has export assigned symbol
-                let externalModule = getContainingExternalModule(node);
-                let exportAssignmentSymbol: Symbol;
-                let resolvedExportSymbol: Symbol;
-                if (externalModule) {
-                    // This is export assigned symbol node
-                    let externalModuleSymbol = getSymbolOfNode(externalModule);
-                    exportAssignmentSymbol = getExportAssignmentSymbol(externalModuleSymbol);
-                    let symbolOfNode = getSymbolOfNode(node);
-                    if (isSymbolUsedInExportAssignment(symbolOfNode)) {
-                        return true;
-                    }
-
-                    // if symbolOfNode is alias declaration, resolve the symbol declaration and check
-                    if (symbolOfNode.flags & SymbolFlags.Alias) {
-                        return isSymbolUsedInExportAssignment(resolveAlias(symbolOfNode));
-                    }
-                }
-
-                // Check if the symbol is used in export assignment
-                function isSymbolUsedInExportAssignment(symbol: Symbol) {
-                    if (exportAssignmentSymbol === symbol) {
-                        return true;
-                    }
-
-                    if (exportAssignmentSymbol && !!(exportAssignmentSymbol.flags & SymbolFlags.Alias)) {
-                        // if export assigned symbol is alias declaration, resolve the alias
-                        resolvedExportSymbol = resolvedExportSymbol || resolveAlias(exportAssignmentSymbol);
-                        if (resolvedExportSymbol === symbol) {
-                            return true;
-                        }
-
-                        // Container of resolvedExportSymbol is visible
-                        return forEach(resolvedExportSymbol.declarations, (current: Node) => {
-                            while (current) {
-                                if (current === node) {
-                                    return true;
-                                }
-                                current = current.parent;
-                            }
-                        });
-                    }
-                }
-            }
-
-            function determineIfDeclarationIsVisible() {
-                switch (node.kind) {
-                    case SyntaxKind.BindingElement:
-                        return isDeclarationVisible(<Declaration>node.parent.parent);
-                    case SyntaxKind.VariableDeclaration:
-                        if (isBindingPattern(node.name) &&
-                            !(<BindingPattern>node.name).elements.length) {
-                            // If the binding pattern is empty, this variable declaration is not visible
-                            return false;
-                        }
-                    // Otherwise fall through
-                    case SyntaxKind.ModuleDeclaration:
-                    case SyntaxKind.ClassDeclaration:
-                    case SyntaxKind.InterfaceDeclaration:
-                    case SyntaxKind.TypeAliasDeclaration:
-                    case SyntaxKind.FunctionDeclaration:
-                    case SyntaxKind.EnumDeclaration:
-                    case SyntaxKind.ImportEqualsDeclaration:
-                        let parent = getDeclarationContainer(node);
-                        // If the node is not exported or it is not ambient module element (except import declaration)
-                        if (!(getCombinedNodeFlags(node) & NodeFlags.Export) &&
-                            !(node.kind !== SyntaxKind.ImportEqualsDeclaration && parent.kind !== SyntaxKind.SourceFile && isInAmbientContext(parent))) {
-                            return isGlobalSourceFile(parent);
-                        }
-                        // Exported members/ambient module elements (exception import declaration) are visible if parent is visible
-                        return isDeclarationVisible(<Declaration>parent);
-
-                    case SyntaxKind.PropertyDeclaration:
-                    case SyntaxKind.PropertySignature:
-                    case SyntaxKind.GetAccessor:
-                    case SyntaxKind.SetAccessor:
-                    case SyntaxKind.MethodDeclaration:
-                    case SyntaxKind.MethodSignature:
-                        if (node.flags & (NodeFlags.Private | NodeFlags.Protected)) {
-                            // Private/protected properties/methods are not visible
-                            return false;
-                        }
-                    // Public properties/methods are visible if its parents are visible, so let it fall into next case statement
-
-                    case SyntaxKind.Constructor:
-                    case SyntaxKind.ConstructSignature:
-                    case SyntaxKind.CallSignature:
-                    case SyntaxKind.IndexSignature:
-                    case SyntaxKind.Parameter:
-                    case SyntaxKind.ModuleBlock:
-                    case SyntaxKind.FunctionType:
-                    case SyntaxKind.ConstructorType:
-                    case SyntaxKind.TypeLiteral:
-                    case SyntaxKind.TypeReference:
-                    case SyntaxKind.ArrayType:
-                    case SyntaxKind.TupleType:
-                    case SyntaxKind.UnionType:
-                    case SyntaxKind.IntersectionType:
-                    case SyntaxKind.ParenthesizedType:
-                        return isDeclarationVisible(<Declaration>node.parent);
-
-                    // Default binding, import specifier and namespace import is visible
-                    // only on demand so by default it is not visible
-                    case SyntaxKind.ImportClause:
-                    case SyntaxKind.NamespaceImport:
-                    case SyntaxKind.ImportSpecifier:
-                        return false;
-
-                    // Type parameters are always visible
-                    case SyntaxKind.TypeParameter:
-                    // Source file is always visible
-                    case SyntaxKind.SourceFile:
-                        return true;
-
-                    // Export assignements do not create name bindings outside the module
-                    case SyntaxKind.ExportAssignment:
-                        return false;
-
-                    default:
-                        Debug.fail("isDeclarationVisible unknown: SyntaxKind: " + node.kind);
-                }
-            }
-
-            if (node) {
-                let links = getNodeLinks(node);
-                if (links.isVisible === undefined) {
-                    links.isVisible = !!determineIfDeclarationIsVisible();
-                }
-                return links.isVisible;
-            }
-        }
-
-        function collectLinkedAliases(node: Identifier): Node[] {
-            let exportSymbol: Symbol;
-            if (node.parent && node.parent.kind === SyntaxKind.ExportAssignment) {
-                exportSymbol = resolveName(node.parent, node.text, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace, Diagnostics.Cannot_find_name_0, node);
-            }
-            else if (node.parent.kind === SyntaxKind.ExportSpecifier) {
-                exportSymbol = getTargetOfExportSpecifier(<ExportSpecifier>node.parent);
-            }
-            let result: Node[] = [];
-            if (exportSymbol) {
-                buildVisibleNodeList(exportSymbol.declarations);
-            }
-            return result;
-
-            function buildVisibleNodeList(declarations: Declaration[]) {
-                forEach(declarations, declaration => {
-                    getNodeLinks(declaration).isVisible = true;
-                    let resultNode = getAnyImportSyntax(declaration) || declaration;
-                    if (!contains(result, resultNode)) {
-                        result.push(resultNode);
-                    }
-
-                    if (isInternalModuleImportEqualsDeclaration(declaration)) {
-                        // Add the referenced top container visible
-                        let internalModuleReference = <Identifier | QualifiedName>(<ImportEqualsDeclaration>declaration).moduleReference;
-                        let firstIdentifier = getFirstIdentifier(internalModuleReference);
-                        let importSymbol = resolveName(declaration, firstIdentifier.text, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace,
-                            Diagnostics.Cannot_find_name_0, firstIdentifier);
-                        buildVisibleNodeList(importSymbol.declarations);
-                    }
-                });
-            }
-        }
-
         // Push an entry on the type resolution stack. If an entry with the given target is not already on the stack,
         // a new entry with that target and an associated result value of true is pushed on the stack, and the value
         // true is returned. Otherwise, a circularity has occurred and the result values of the existing entry and
@@ -14187,27 +13859,17 @@ namespace ts {
                 isReferencedAliasDeclaration,
                 getNodeCheckFlags,
                 isTopLevelValueImportEqualsWithEntityName,
-                isDeclarationVisible,
                 isImplementationOfOverload,
                 writeTypeOfDeclaration,
                 writeReturnTypeOfSignatureDeclaration,
                 writeTypeOfExpression,
                 writeBaseConstructorTypeOfClass,
-                isSymbolAccessible,
-                isEntityNameVisible,
                 getConstantValue,
-                collectLinkedAliases,
                 getBlockScopedVariableId,
                 getReferencedValueDeclaration,
                 getTypeReferenceSerializationKind,
-                resolveName,
                 getSymbolAtLocation,
-                resolveAlias,
                 getLocalTargetOfAliasDeclaration,
-                getTypeOfSymbol,
-                getReturnTypeOfSignature,
-                getSignatureFromDeclaration,
-                getSignaturesOfType,
             };
         }
 
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 5c45d6d4fb9d6..002f192bd9dc7 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -1501,35 +1501,12 @@ namespace ts {
         UseOnlyExternalAliasing = 0x00000002,
     }
 
-    /* @internal */
-    export const enum SymbolAccessibility {
-        Accessible,
-        NotAccessible,
-        CannotBeNamed
-    }
-
     export interface TypePredicate {
         parameterName: string;
         parameterIndex: number;
         type: Type;
     }
 
-    /* @internal */
-    export type AnyImportSyntax = ImportDeclaration | ImportEqualsDeclaration;
-
-    /* @internal */
-    export interface SymbolVisibilityResult {
-        accessibility: SymbolAccessibility;
-        aliasesToMakeVisible?: AnyImportSyntax[]; // aliases that need to have this symbol visible
-        errorSymbolName?: string; // Optional symbol name that results in error
-        errorNode?: Node; // optional node that results in error
-    }
-
-    /* @internal */
-    export interface SymbolAccessiblityResult extends SymbolVisibilityResult {
-        errorModuleName?: string; // If the symbol is not visible from module, module's name
-    }
-    
     /** Indicates how to serialize the name for a TypeReferenceNode when emitting decorator 
       * metadata */
     /* @internal */
@@ -1562,28 +1539,18 @@ namespace ts {
         isReferencedAliasDeclaration(node: Node, checkChildren?: boolean): boolean;
         isTopLevelValueImportEqualsWithEntityName(node: ImportEqualsDeclaration): boolean;
         getNodeCheckFlags(node: Node): NodeCheckFlags;
-        isDeclarationVisible(node: Declaration): boolean;
-        collectLinkedAliases(node: Identifier): Node[];
         isImplementationOfOverload(node: FunctionLikeDeclaration): boolean;
         writeTypeOfDeclaration(declaration: AccessorDeclaration | VariableLikeDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
         writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
         writeTypeOfExpression(expr: Expression, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
         writeBaseConstructorTypeOfClass(expr: ClassLikeDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
-        isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessiblityResult;
-        isEntityNameVisible(entityName: EntityName | Expression, enclosingDeclaration: Node): SymbolVisibilityResult;
         // Returns the constant value this property access resolves to, or 'undefined' for a non-constant
         getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number;
         getBlockScopedVariableId(node: Identifier): number;
         getReferencedValueDeclaration(reference: Identifier): Declaration;
         getTypeReferenceSerializationKind(node: TypeReferenceNode): TypeReferenceSerializationKind;
-        resolveName(location: Node, name: string, meaning: SymbolFlags, nameNotFoundMessage: DiagnosticMessage, nameArg: string | Identifier): Symbol;
         getSymbolAtLocation(node: Node): Symbol;
-        resolveAlias(symbol: Symbol): Symbol;
         getLocalTargetOfAliasDeclaration(node: Declaration): Symbol;
-        getTypeOfSymbol(symbol: Symbol): Type;
-        getReturnTypeOfSignature(signature: Signature): Type;
-        getSignatureFromDeclaration(declaration: SignatureDeclaration): Signature;
-        getSignaturesOfType(type: Type, kind: SignatureKind): Signature[];
     }
 
     export const enum SymbolFlags {

From 1bf2d0abf7d4a3453983f5e9d5c6e0b388f5fb5d Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Thu, 16 Jul 2015 12:17:41 -0700
Subject: [PATCH 42/57] Make trackSymbol optional and use an empty writer in
 visitNode

---
 src/compiler/checker.ts            |   6 +-
 src/compiler/declarationEmitter.ts | 226 +++++++++++++++--------------
 src/compiler/types.ts              |   4 +-
 src/compiler/utilities.ts          |   2 -
 src/services/utilities.ts          |   2 -
 5 files changed, 124 insertions(+), 116 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index b7a87325152c2..a46b5de1d96dc 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -1372,8 +1372,8 @@ namespace ts {
             function appendSymbolNameOnly(symbol: Symbol, writer: SymbolWriter, isTypeSymbol: boolean): void {
                 writer.writeSymbol(getNameOfSymbol(symbol), symbol);
 
-                if (isTypeSymbol) {
-                    writer.trackSymbol(symbol);
+                if (isTypeSymbol && writer.trackTypeSymbol) {
+                    writer.trackTypeSymbol(symbol);
                 }
             }
 
@@ -1422,7 +1422,7 @@ namespace ts {
                         }
                         else {
 
-                            if (!parentSymbol) {
+                            if (!parentSymbol && writer.trackInaccesibleSymbol) {
                                 writer.trackInaccesibleSymbol(symbol);
                             }
 
diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index ebd68b789c6fa..07a28f5966bbd 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -27,6 +27,8 @@ namespace ts {
         return diagnostics;
     }
 
+    const emptyHandler = () => { };
+
     function emitDeclarations(host: EmitHost, resolver: EmitResolver, diagnostics: Diagnostic[], jsFilePath: string, root?: SourceFile): DeclarationEmit {
         let newLine = host.getNewLine();
         let compilerOptions = host.getCompilerOptions();
@@ -127,8 +129,6 @@ namespace ts {
 
         function createNewTextWriterWithSymbolWriter(): EmitTextWriterWithSymbolWriter {
             let writer = <EmitTextWriterWithSymbolWriter>createTextWriter(newLine);
-            writer.trackSymbol = trackSymbol;
-            writer.trackInaccesibleSymbol = trackInaccesibleSymbol;
             writer.writeKeyword = writer.write;
             writer.writeOperator = writer.write;
             writer.writePunctuation = writer.write;
@@ -148,17 +148,22 @@ namespace ts {
             decreaseIndent = newWriter.decreaseIndent;
         }
 
-        var currentErrorNode: Node;
-        function trackSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags) {
-            if (currentErrorNode) {
-                collectDeclarations(symbol, currentErrorNode);
-            }
-        }
-
-        function trackInaccesibleSymbol(symbol: Symbol): void {
-            if (currentErrorNode) {
-                reportUnamedDeclarationMessage(currentErrorNode);
-            }
+        function createVoidSymbolWriter(trackTypeSymbol: (s: Symbol) => void, trackInaccesibleSymbol: (s: Symbol) => void): SymbolWriter {
+            return {
+                writeLine: emptyHandler,
+                writeKeyword: emptyHandler,
+                writeOperator: emptyHandler,
+                writePunctuation: emptyHandler,
+                writeSpace: emptyHandler,
+                writeStringLiteral: emptyHandler,
+                writeParameter: emptyHandler,
+                writeSymbol: emptyHandler,
+                decreaseIndent: emptyHandler,
+                increaseIndent: emptyHandler,
+                clear: emptyHandler,
+                trackTypeSymbol,
+                trackInaccesibleSymbol
+            };
         }
 
         function emitTypeOfDeclaration(declaration: AccessorDeclaration | VariableLikeDeclaration, type: TypeNode) {
@@ -466,16 +471,16 @@ namespace ts {
             }
 
             if (node.importClause.namedBindings) {
-              if (node.importClause.namedBindings.kind === SyntaxKind.NamespaceImport &&
-                indexOf(children, node.importClause.namedBindings) >= 0) {
-                write("* as ");
-                writeTextOfNode(currentSourceFile, (<NamespaceImport>node.importClause.namedBindings).name);
-              }
-              else if (children.length) {
-                write("{ ");
-                emitCommaList(children, emitImportOrExportSpecifier);
-                write(" }");
-              }
+                if (node.importClause.namedBindings.kind === SyntaxKind.NamespaceImport &&
+                    indexOf(children, node.importClause.namedBindings) >= 0) {
+                    write("* as ");
+                    writeTextOfNode(currentSourceFile, (<NamespaceImport>node.importClause.namedBindings).name);
+                }
+                else if (children.length) {
+                    write("{ ");
+                    emitCommaList(children, emitImportOrExportSpecifier);
+                    write(" }");
+                }
             }
 
             write(" from ");
@@ -758,7 +763,7 @@ namespace ts {
             }
         }
 
-        function hasChildDeclaration(node: VariableStatement): boolean{
+        function hasChildDeclaration(node: VariableStatement): boolean {
             return forEach(<VariableDeclaration[]>getNodeLinks(node).visibleChildren, child => {
                 if (isBindingPattern(child.name)) {
                     return forEach((<BindingPattern>child.name).elements, e => {
@@ -1069,70 +1074,87 @@ namespace ts {
             referencePathsOutput += "/// <reference path=\"" + declFileName + "\" />" + newLine;
         }
 
+        function collectReferencedDeclarations(node: Node): void {
+            let currentErrorNode: Node;
+            let typeWriter = createVoidSymbolWriter(trackTypeSymbol, trackInaccesibleSymbol);
 
-        function visitNode(node: Node): void {
-            if (!node) return;
+            return visitNode(node);
 
-            switch (node.kind) {
-                case SyntaxKind.ExportDeclaration:
-                    return visitExportDeclaration(<ExportDeclaration>node);
-                case SyntaxKind.ImportEqualsDeclaration:
-                    return visitImportEqualsDeclaration(<ImportEqualsDeclaration>node);
-                case SyntaxKind.ExportAssignment:
-                    return visitExportAssignment(<ExportAssignment>node);
-                case SyntaxKind.ImportDeclaration:
-                case SyntaxKind.ImportClause:
-                    // Nothing to visit, import declarations are only pulled in if referenced
-                    return;
+            function trackTypeSymbol(symbol: Symbol) {
+                if (currentErrorNode) {
+                    collectDeclarations(symbol, currentErrorNode);
+                }
+            }
 
-                case SyntaxKind.InterfaceDeclaration:
-                case SyntaxKind.ClassDeclaration:
-                    return visitNodes((<InterfaceDeclaration|ClassDeclaration>node).typeParameters) ||
-                        forEach((<InterfaceDeclaration|ClassDeclaration>node).heritageClauses, visitHeritageClause);
+            function trackInaccesibleSymbol(symbol: Symbol): void {
+                if (currentErrorNode) {
+                    reportUnamedDeclarationMessage(currentErrorNode);
+                }
+            }
 
-                case SyntaxKind.ModuleDeclaration:
-                case SyntaxKind.EnumDeclaration:
-                case SyntaxKind.EnumMember:
-                    // Nothing to visit here
-                    return;
+            function visitNode(node: Node): void {
+                if (!node) return;
 
-                case SyntaxKind.TypeAliasDeclaration:
-                    return visitNodes((<TypeAliasDeclaration>node).typeParameters) ||
-                        visitNode((<TypeAliasDeclaration>node).type);
+                switch (node.kind) {
+                    case SyntaxKind.ExportDeclaration:
+                        return visitExportDeclaration(<ExportDeclaration>node);
+                    case SyntaxKind.ImportEqualsDeclaration:
+                        return visitImportEqualsDeclaration(<ImportEqualsDeclaration>node);
+                    case SyntaxKind.ExportAssignment:
+                        return visitExportAssignment(<ExportAssignment>node);
+                    case SyntaxKind.ImportDeclaration:
+                    case SyntaxKind.ImportClause:
+                        // Nothing to visit, import declarations are only pulled in if referenced
+                        return;
 
-                case SyntaxKind.TypeParameter:
-                    return visitNode((<TypeParameterDeclaration>node).constraint);
+                    case SyntaxKind.InterfaceDeclaration:
+                    case SyntaxKind.ClassDeclaration:
+                        return visitNodes((<InterfaceDeclaration|ClassDeclaration>node).typeParameters) ||
+                            forEach((<InterfaceDeclaration|ClassDeclaration>node).heritageClauses, visitHeritageClause);
 
-                case SyntaxKind.FunctionDeclaration:
-                case SyntaxKind.Constructor:
-                case SyntaxKind.MethodDeclaration:
-                case SyntaxKind.MethodSignature:
-                case SyntaxKind.ConstructSignature:
-                case SyntaxKind.CallSignature:
-                case SyntaxKind.IndexSignature:
-                case SyntaxKind.FunctionType:
-                case SyntaxKind.ConstructorType:
-                    return visitSignatureDeclaration(<FunctionLikeDeclaration>node);
+                    case SyntaxKind.ModuleDeclaration:
+                    case SyntaxKind.EnumDeclaration:
+                    case SyntaxKind.EnumMember:
+                        // Nothing to visit here
+                        return;
 
-                case SyntaxKind.GetAccessor:
-                case SyntaxKind.SetAccessor:
-                    return visitAccessorDeclaration(<AccessorDeclaration>node);
+                    case SyntaxKind.TypeAliasDeclaration:
+                        return visitNodes((<TypeAliasDeclaration>node).typeParameters) ||
+                            visitNode((<TypeAliasDeclaration>node).type);
 
-                case SyntaxKind.Parameter:
-                case SyntaxKind.VariableDeclaration:
-                case SyntaxKind.PropertyDeclaration:
-                case SyntaxKind.PropertySignature:
-                case SyntaxKind.BindingElement:
-                    return visitPropertyDeclaration(<PropertyDeclaration>node);
+                    case SyntaxKind.TypeParameter:
+                        return visitNode((<TypeParameterDeclaration>node).constraint);
 
-                case SyntaxKind.Identifier:
-                    return visitTypeName(<Identifier>node);
+                    case SyntaxKind.FunctionDeclaration:
+                    case SyntaxKind.Constructor:
+                    case SyntaxKind.MethodDeclaration:
+                    case SyntaxKind.MethodSignature:
+                    case SyntaxKind.ConstructSignature:
+                    case SyntaxKind.CallSignature:
+                    case SyntaxKind.IndexSignature:
+                    case SyntaxKind.FunctionType:
+                    case SyntaxKind.ConstructorType:
+                        return visitSignatureDeclaration(<FunctionLikeDeclaration>node);
 
-                default:
-                    return forEachChild(node, visitNode);
-            }
+                    case SyntaxKind.GetAccessor:
+                    case SyntaxKind.SetAccessor:
+                        return visitAccessorDeclaration(<AccessorDeclaration>node);
+
+                    case SyntaxKind.Parameter:
+                    case SyntaxKind.VariableDeclaration:
+                    case SyntaxKind.PropertyDeclaration:
+                    case SyntaxKind.PropertySignature:
+                    case SyntaxKind.BindingElement:
+                        return visitPropertyDeclaration(<PropertyDeclaration>node);
+
+                    case SyntaxKind.Identifier:
+                        return visitTypeName(<Identifier>node);
+
+                    default:
+                        return forEachChild(node, visitNode);
+                }
 
-            return;
+            }
 
             function visitExportDeclaration(node: ExportDeclaration): void {
                 if (!node.moduleSpecifier) {
@@ -1151,12 +1173,10 @@ namespace ts {
                     collectAliasDeclaration(node, node.expression);
                 }
                 else if (!node.isExportEquals) { 
-                    // TODO: handel expressions
-                    // TODO: Cache the result
-                    let writer = createNewTextWriterWithSymbolWriter();
+                    // handel expressions
                     let previousErrorNode = currentErrorNode;
                     currentErrorNode = node.expression;
-                    resolver.writeTypeOfExpression(node.expression, getEnclosingDeclaration(node), TypeFormatFlags.UseTypeOfFunction, writer);
+                    resolver.writeTypeOfExpression(node.expression, getEnclosingDeclaration(node), TypeFormatFlags.UseTypeOfFunction, typeWriter);
                     currentErrorNode = previousErrorNode;
                 }
             }
@@ -1173,12 +1193,10 @@ namespace ts {
                     visitNode(node.type);
                 }
                 else if (node.kind !== SyntaxKind.Constructor) {
-                    // TODO: handel infered type
-                    // TODO: Cache the result
-                    let writer = createNewTextWriterWithSymbolWriter();
+                    // handel infered type
                     let previousErrorNode = currentErrorNode;
                     currentErrorNode = node.name || node;
-                    resolver.writeReturnTypeOfSignatureDeclaration(node, getEnclosingDeclaration(node), TypeFormatFlags.UseTypeOfFunction, writer);
+                    resolver.writeReturnTypeOfSignatureDeclaration(node, getEnclosingDeclaration(node), TypeFormatFlags.UseTypeOfFunction, typeWriter);
                     currentErrorNode = previousErrorNode;
                 }
             }
@@ -1196,12 +1214,10 @@ namespace ts {
                         visitNode(type);
                     }
                     else {
-                        // TODO: handel infered type
-                        // TODO: Cache the result
-                        let writer = createNewTextWriterWithSymbolWriter();
+                        // handel infered type
                         let previousErrorNode = currentErrorNode;
                         currentErrorNode = accessors.getAccessor ? accessors.getAccessor.name : node.name;
-                        resolver.writeTypeOfDeclaration(node, getEnclosingDeclaration(node), TypeFormatFlags.UseTypeOfFunction, writer);
+                        resolver.writeTypeOfDeclaration(node, getEnclosingDeclaration(node), TypeFormatFlags.UseTypeOfFunction, typeWriter);
                         currentErrorNode = previousErrorNode;
                     }
                 }
@@ -1224,12 +1240,10 @@ namespace ts {
                     visitNode(node.type);
                 }
                 else {
-                    // TODO: handel infered type
-                    // TODO: Cache the result
-                    let writer = createNewTextWriterWithSymbolWriter();
+                    // handel infered type
                     let previousErrorNode = currentErrorNode;
                     currentErrorNode = node.name;
-                    resolver.writeTypeOfDeclaration(node, getEnclosingDeclaration(node), TypeFormatFlags.UseTypeOfFunction, writer);
+                    resolver.writeTypeOfDeclaration(node, getEnclosingDeclaration(node), TypeFormatFlags.UseTypeOfFunction, typeWriter);
                     currentErrorNode = previousErrorNode;
                 }
             }
@@ -1239,11 +1253,9 @@ namespace ts {
                 if (node.token === SyntaxKind.ExtendsKeyword &&
                     firstEntry && !isSupportedExpressionWithTypeArguments(firstEntry)) {
                     // An expression in an extends clause
-                    // TODO: Cache the result
-                    let writer = createNewTextWriterWithSymbolWriter();
                     let previousErrorNode = currentErrorNode;
                     currentErrorNode = firstEntry;
-                    resolver.writeBaseConstructorTypeOfClass((<ClassLikeDeclaration>node.parent), getEnclosingDeclaration(node), TypeFormatFlags.UseTypeOfFunction, writer);
+                    resolver.writeBaseConstructorTypeOfClass((<ClassLikeDeclaration>node.parent), getEnclosingDeclaration(node), TypeFormatFlags.UseTypeOfFunction, typeWriter);
                     currentErrorNode = previousErrorNode;
                 }
                 else {
@@ -1268,12 +1280,16 @@ namespace ts {
             function visitNodes(nodes: NodeArray<any>): void {
                 forEach(nodes, visitNode);
             }
-        }
 
-        function collectAliasDeclaration(node: ImportOrExportSpecifier|ImportEqualsDeclaration|ExportAssignment, errorNode: Node) {
-            let target = resolver.getLocalTargetOfAliasDeclaration(node);
-            if (target) {
-                collectDeclarations(target, errorNode);
+            function collectAliasDeclaration(node: ImportOrExportSpecifier|ImportEqualsDeclaration|ExportAssignment, errorNode: Node) {
+                let target = resolver.getLocalTargetOfAliasDeclaration(node);
+                if (target) {
+                    collectDeclarations(target, errorNode);
+                }
+            }
+
+            function collectDeclarations(symbol: Symbol, errorNode: Node): void {
+                forEach(symbol.declarations, d => collectDeclaration(d, errorNode));
             }
         }
 
@@ -1339,7 +1355,7 @@ namespace ts {
                 case SyntaxKind.ClassDeclaration:
                     forEach((<InterfaceDeclaration|EnumDeclaration|ClassDeclaration>node).members, action);
                     break;
-                case SyntaxKind.VariableStatement: 
+                case SyntaxKind.VariableStatement:
                     forEach((<VariableStatement>node).declarationList.declarations, action);
                     break;
                 case SyntaxKind.ModuleDeclaration:
@@ -1371,10 +1387,6 @@ namespace ts {
             return undefined;
         }
 
-        function collectDeclarations(symbol: Symbol, errorNode: Node): void {
-            forEach(symbol.declarations, d => collectDeclaration(d, errorNode));
-        }
-
         function hasExportDeclatations(node: Node): boolean {
             let links = getNodeLinks(node);
             if (typeof links.hasExportDeclarations === "undefined") {
@@ -1399,7 +1411,7 @@ namespace ts {
          * they have an export modifier or not.
          *
          */
-        function canWriteDeclaration(node: Node): boolean{
+        function canWriteDeclaration(node: Node): boolean {
             if (node.kind === SyntaxKind.VariableDeclaration || node.kind === SyntaxKind.BindingElement) {
                 node = node.parent.parent;
             }
@@ -1598,7 +1610,7 @@ namespace ts {
                 links.collected = true;
 
                 // Collect any dependencies
-                visitNode(node);
+                collectReferencedDeclarations(node);
 
                 // Collect children as well
                 switch (node.kind) {
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 002f192bd9dc7..da7c45b7da3e3 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -1470,8 +1470,8 @@ namespace ts {
         // Called when the symbol writer encounters a symbol to write.  Currently only used by the
         // declaration emitter to help determine if it should patch up the final declaration file
         // with import statements it previously saw (but chose not to emit).
-        trackSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): void;
-        trackInaccesibleSymbol(symbol: Symbol): void;
+        trackTypeSymbol?(symbol: Symbol): void;
+        trackInaccesibleSymbol?(symbol: Symbol): void;
     }
 
     export const enum TypeFormatFlags {
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index 1d8555b34bb3d..5e67a6546540c 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -64,8 +64,6 @@ namespace ts {
                 increaseIndent: () => { },
                 decreaseIndent: () => { },
                 clear: () => str = "",
-                trackSymbol: () => { },
-                trackInaccesibleSymbol: () => { }
             };
         }
 
diff --git a/src/services/utilities.ts b/src/services/utilities.ts
index c3e55b2bff63b..7cc38fbdb6049 100644
--- a/src/services/utilities.ts
+++ b/src/services/utilities.ts
@@ -528,8 +528,6 @@ namespace ts {
             increaseIndent: () => { indent++; },
             decreaseIndent: () => { indent--; },
             clear: resetWriter,
-            trackSymbol: () => { },
-            trackInaccesibleSymbol: () => { }
         };
 
         function writeIndent() {

From 0758e1552d692b76001d9aab412a343ebc22d861 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Thu, 16 Jul 2015 12:48:44 -0700
Subject: [PATCH 43/57] Remove unused interfaces, and simplify the writer logic

---
 src/compiler/declarationEmitter.ts | 65 ++++++++++--------------------
 src/compiler/program.ts            |  4 +-
 2 files changed, 23 insertions(+), 46 deletions(-)

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index 07a28f5966bbd..fa552bb845de4 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -2,22 +2,17 @@
 
 /* @internal */
 namespace ts {
-    interface ModuleElementDeclarationEmitInfo {
-        node: Node;
-        outputPos: number;
-        indent: number;
-        asynchronousOutput?: string; // If the output for alias was written asynchronously, the corresponding output
-        subModuleElementDeclarationEmitInfo?: ModuleElementDeclarationEmitInfo[];
-        isVisible?: boolean;
-    }
-
     interface DeclarationEmit {
-        reportedDeclarationError: boolean;
-        synchronousDeclarationOutput: string;
+        hasDeclarationDiagnostics: boolean;
+        output: string;
         referencePathsOutput: string;
     }
 
-    interface EmitTextWriterWithSymbolWriter extends EmitTextWriter, SymbolWriter {
+    interface NodeLinks {
+        visibleChildren?: Node[];
+        visited?: boolean;
+        collected?: boolean;
+        hasExportDeclarations?: boolean;
     }
 
     export function getDeclarationDiagnostics(host: EmitHost, resolver: EmitResolver, targetSourceFile: SourceFile): Diagnostic[] {
@@ -33,31 +28,22 @@ namespace ts {
         let newLine = host.getNewLine();
         let compilerOptions = host.getCompilerOptions();
 
-        let write: (s: string) => void;
-        let writeLine: () => void;
-        let increaseIndent: () => void;
-        let decreaseIndent: () => void;
-        let writeTextOfNode: (sourceFile: SourceFile, node: Node) => void;
-
         let writer = createNewTextWriterWithSymbolWriter();
-        setWriter(writer);
+        let write = writer.write;
+        let writeTextOfNode = writer.writeTextOfNode;
+        let writeLine = writer.writeLine;
+        let increaseIndent = writer.increaseIndent;
+        let decreaseIndent = writer.decreaseIndent;
 
         let enclosingDeclaration: Node;
         let currentSourceFile: SourceFile;
-        let reportedDeclarationError = false;
+        let hasDeclarationDiagnostics = false;
 
         // Contains the reference paths that needs to go in the declaration file.
         // Collecting this separately because reference paths need to be first thing in the declaration file
         // and we could be collecting these paths from multiple files into single one with --out option
         let referencePathsOutput = "";
 
-        interface NodeLinks {
-            visibleChildren?: Node[];
-            visited?: boolean;
-            collected?: boolean;
-            hasExportDeclarations?: boolean;
-        }
-
         let nodeLinks: NodeLinks[] = [];
         function getNodeLinks(node: Node): NodeLinks {
             let nodeId = getNodeId(node);
@@ -112,8 +98,8 @@ namespace ts {
         }
 
         return {
-            reportedDeclarationError,
-            synchronousDeclarationOutput: writer.getText(),
+            hasDeclarationDiagnostics,
+            output: writer.getText(),
             referencePathsOutput,
         };
 
@@ -127,8 +113,8 @@ namespace ts {
             return forEach(getLeadingCommentRanges(currentSourceFile.text, node.pos), hasInternalAnnotation)
         }
 
-        function createNewTextWriterWithSymbolWriter(): EmitTextWriterWithSymbolWriter {
-            let writer = <EmitTextWriterWithSymbolWriter>createTextWriter(newLine);
+        function createNewTextWriterWithSymbolWriter(): EmitTextWriter & SymbolWriter {
+            let writer = <EmitTextWriter & SymbolWriter>createTextWriter(newLine);
             writer.writeKeyword = writer.write;
             writer.writeOperator = writer.write;
             writer.writePunctuation = writer.write;
@@ -139,15 +125,6 @@ namespace ts {
             return writer;
         }
 
-        function setWriter(newWriter: EmitTextWriterWithSymbolWriter) {
-            writer = newWriter;
-            write = newWriter.write;
-            writeTextOfNode = newWriter.writeTextOfNode;
-            writeLine = newWriter.writeLine;
-            increaseIndent = newWriter.increaseIndent;
-            decreaseIndent = newWriter.decreaseIndent;
-        }
-
         function createVoidSymbolWriter(trackTypeSymbol: (s: Symbol) => void, trackInaccesibleSymbol: (s: Symbol) => void): SymbolWriter {
             return {
                 writeLine: emptyHandler,
@@ -1451,7 +1428,7 @@ namespace ts {
         function reportDeclarationAccessiblityMessage(referencedDeclaration: Declaration, errorNode: Node): void {
             Debug.assert(referencedDeclaration.name && referencedDeclaration.name.kind === SyntaxKind.Identifier);
 
-            reportedDeclarationError = true;
+            hasDeclarationDiagnostics = true;
 
             let referencedDeclarationName = (<Identifier>referencedDeclaration.name).text;
             let container = errorNode;
@@ -1545,7 +1522,7 @@ namespace ts {
         }
 
         function reportUnamedDeclarationMessage(errorNode: Node): void {
-            reportedDeclarationError = true;
+            hasDeclarationDiagnostics = true;
             let container = errorNode;
 
             while (container) {
@@ -1691,9 +1668,9 @@ namespace ts {
         let emitDeclarationResult = emitDeclarations(host, resolver, diagnostics, jsFilePath, sourceFile);
         // TODO(shkamat): Should we not write any declaration file if any of them can produce error,
         // or should we just not write this file like we are doing now
-        if (!emitDeclarationResult.reportedDeclarationError) {
+        if (!emitDeclarationResult.hasDeclarationDiagnostics) {
             let declarationOutput = emitDeclarationResult.referencePathsOutput
-                + emitDeclarationResult.synchronousDeclarationOutput;
+                + emitDeclarationResult.output;
             writeFile(host, diagnostics, removeFileExtension(jsFilePath) + ".d.ts", declarationOutput, host.getCompilerOptions().emitBOM);
         }
     }
diff --git a/src/compiler/program.ts b/src/compiler/program.ts
index 5ce4846b43b33..ca12f6de03def 100644
--- a/src/compiler/program.ts
+++ b/src/compiler/program.ts
@@ -341,7 +341,7 @@ namespace ts {
             });
         }
 
-        function getDeclarationDiagnosticsForFile(sourceFile: SourceFile, cancellationToken: CancellationToken): Diagnostic[] {
+        function getDeclarationDiagnosticsForFile(sourceFile: SourceFile, cancellationToken: CancellationToken): Diagnostic[] {
             return runWithCancellationToken(() => {
                 if (!isDeclarationFile(sourceFile)) {
                     let resolver = getDiagnosticsProducingTypeChecker().getEmitResolver(sourceFile, cancellationToken);
@@ -350,7 +350,7 @@ namespace ts {
                     return ts.getDeclarationDiagnostics(getEmitHost(writeFile), resolver, sourceFile);
                 }
             });
-        }
+        }
 
         function getOptionsDiagnostics(): Diagnostic[] {
             let allDiagnostics: Diagnostic[] = [];

From 4b2aa4730749f6f6c833e4060acc738e654dd4f0 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Thu, 16 Jul 2015 13:47:50 -0700
Subject: [PATCH 44/57] Reorganize how triple slash references are being
 emitted

---
 src/compiler/declarationEmitter.ts | 147 ++++++++++++++++-------------
 1 file changed, 82 insertions(+), 65 deletions(-)

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index fa552bb845de4..045d9ea510cb8 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -39,59 +39,23 @@ namespace ts {
         let currentSourceFile: SourceFile;
         let hasDeclarationDiagnostics = false;
 
-        // Contains the reference paths that needs to go in the declaration file.
-        // Collecting this separately because reference paths need to be first thing in the declaration file
-        // and we could be collecting these paths from multiple files into single one with --out option
-        let referencePathsOutput = "";
-
         let nodeLinks: NodeLinks[] = [];
         function getNodeLinks(node: Node): NodeLinks {
             let nodeId = getNodeId(node);
             return nodeLinks[nodeId] || (nodeLinks[nodeId] = {});
         }
 
+        // Emit any triple-slash references
+        emitTripleSlashReferences(root);
+
         if (root) {
             // Emitting just a single file, so emit references in this file only
-            if (!compilerOptions.noResolve) {
-                let addedGlobalFileReference = false;
-                forEach(root.referencedFiles, fileReference => {
-                    let referencedFile = tryResolveScriptReference(host, root, fileReference);
-
-                    // All the references that are not going to be part of same file
-                    if (referencedFile && ((referencedFile.flags & NodeFlags.DeclarationFile) || // This is a declare file reference
-                        shouldEmitToOwnFile(referencedFile, compilerOptions) || // This is referenced file is emitting its own js file
-                        !addedGlobalFileReference)) { // Or the global out file corresponding to this reference was not added
-
-                        emitReferencePath(referencedFile);
-                        if (!isExternalModuleOrDeclarationFile(referencedFile)) {
-                            addedGlobalFileReference = true;
-                        }
-                    }
-                });
-            }
-
             emitSourceFile(root);
         }
         else {
             // Emit references corresponding to this file
-            let emittedReferencedFiles: SourceFile[] = [];
             forEach(host.getSourceFiles(), sourceFile => {
                 if (!isExternalModuleOrDeclarationFile(sourceFile)) {
-                    // Check what references need to be added
-                    if (!compilerOptions.noResolve) {
-                        forEach(sourceFile.referencedFiles, fileReference => {
-                            let referencedFile = tryResolveScriptReference(host, sourceFile, fileReference);
-
-                            // If the reference file is a declaration file or an external module, emit that reference
-                            if (referencedFile && (isExternalModuleOrDeclarationFile(referencedFile) &&
-                                !contains(emittedReferencedFiles, referencedFile))) { // If the file reference was not already emitted
-
-                                emitReferencePath(referencedFile);
-                                emittedReferencedFiles.push(referencedFile);
-                            }
-                        });
-                    }
-
                     emitSourceFile(sourceFile);
                 }
             });
@@ -100,9 +64,82 @@ namespace ts {
         return {
             hasDeclarationDiagnostics,
             output: writer.getText(),
-            referencePathsOutput,
+            referencePathsOutput : "",
         };
 
+        function emitTripleSlashReferences(root: SourceFile) {
+            if (compilerOptions.noResolve) {
+                // Nothing to do
+                return;
+            }
+
+            let emittedReferencedFiles: SourceFile[] = [];
+            let addedGlobalFileReference = false;
+
+            if (root) {
+                // Emitting just a single file, so emit references in this file only
+                emitTripleSlashReferncesInFile(root);
+            }
+            else {
+                // Emit references corresponding to this file
+                forEach(host.getSourceFiles(), sourceFile => {
+                    if (!isExternalModuleOrDeclarationFile(sourceFile)) {
+                        emitTripleSlashReferncesInFile(sourceFile);
+                    }
+                });
+            }
+
+            return;
+
+            function emitTripleSlashReferncesInFile(sourceFile: SourceFile): void {
+                forEach(sourceFile.referencedFiles, fileReference => {
+                    let referencedFile = tryResolveScriptReference(host, sourceFile, fileReference);
+
+                    // Could not find the file, or has been already emitted
+                    if (!referencedFile || contains(emittedReferencedFiles, referencedFile)) {
+                        return false;
+                    }
+
+                    let shouldEmitRefrence: boolean
+                    
+                    if (isDeclarationFile(referencedFile) || shouldEmitToOwnFile(referencedFile, compilerOptions)) {
+                        // If the reference file is a declaration file or an external module,
+                        // we know there is going to be a .d.ts file matching it. Emit that reference
+                        shouldEmitRefrence = true;
+                    }
+                    else if (compilerOptions.out && !addedGlobalFileReference && isExternalModule(sourceFile)) {
+                        // This is a reference to a file in the global island, since out is on, all files
+                        // in the global island will be merged into one. so keep only one of these references
+                        addedGlobalFileReference = true;
+                        shouldEmitRefrence = true;
+                    }
+
+                    if (shouldEmitRefrence) {
+                        emitReferencePath(referencedFile);
+                        emittedReferencedFiles.push(referencedFile);
+                    }
+                });
+            }
+
+            function emitReferencePath(referencedFile: SourceFile) {
+                let declFileName = referencedFile.flags & NodeFlags.DeclarationFile
+                    ? referencedFile.fileName // Declaration file, use declaration file name
+                    : shouldEmitToOwnFile(referencedFile, compilerOptions)
+                        ? getOwnEmitOutputFilePath(referencedFile, host, ".d.ts") // Own output file so get the .d.ts file
+                        : removeFileExtension(compilerOptions.out) + ".d.ts"; // Global out file
+
+                declFileName = getRelativePathToDirectoryOrUrl(
+                    getDirectoryPath(normalizeSlashes(jsFilePath)),
+                    declFileName,
+                    host.getCurrentDirectory(),
+                    host.getCanonicalFileName,
+                    /*isAbsolutePathAnUrl*/ false);
+
+                write(`/// <reference path="${ declFileName }" />`);
+                writeLine();
+            }
+        }
+
         function hasInternalAnnotation(range: CommentRange) {
             let text = currentSourceFile.text;
             let comment = text.substring(range.pos, range.end);
@@ -326,13 +363,7 @@ namespace ts {
                 write("}");
             }
         }
-
-        function emitSourceFile(node: SourceFile) {
-            currentSourceFile = node;
-            enclosingDeclaration = node;
-            emitSourceFileDeclarations(node);
-        }
-
+        
         // Return a temp variable name to be used in `export default` statements.
         // The temp name will be of the form _default_counter.
         // Note that export default is only allowed at most once in a module, so we
@@ -1034,23 +1065,6 @@ namespace ts {
             }
         }
 
-        function emitReferencePath(referencedFile: SourceFile) {
-            let declFileName = referencedFile.flags & NodeFlags.DeclarationFile
-                ? referencedFile.fileName // Declaration file, use declaration file name
-                : shouldEmitToOwnFile(referencedFile, compilerOptions)
-                    ? getOwnEmitOutputFilePath(referencedFile, host, ".d.ts") // Own output file so get the .d.ts file
-                    : removeFileExtension(compilerOptions.out) + ".d.ts"; // Global out file
-
-            declFileName = getRelativePathToDirectoryOrUrl(
-                getDirectoryPath(normalizeSlashes(jsFilePath)),
-                declFileName,
-                host.getCurrentDirectory(),
-                host.getCanonicalFileName,
-            /*isAbsolutePathAnUrl*/ false);
-
-            referencePathsOutput += "/// <reference path=\"" + declFileName + "\" />" + newLine;
-        }
-
         function collectReferencedDeclarations(node: Node): void {
             let currentErrorNode: Node;
             let typeWriter = createVoidSymbolWriter(trackTypeSymbol, trackInaccesibleSymbol);
@@ -1654,7 +1668,10 @@ namespace ts {
             forEach(sortDeclarations(getNodeLinks(node).visibleChildren), emitNode);
         }
 
-        function emitSourceFileDeclarations(sourceFile: SourceFile): void {
+        function emitSourceFile(sourceFile: SourceFile): void {
+            currentSourceFile = sourceFile;
+            enclosingDeclaration = sourceFile;
+
             // Collect all visible declarations
             collectTopLevelChildDeclarations(sourceFile);
 

From 0f58d94a86f57731b86b531b9d6f8d44c631b6c4 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Thu, 16 Jul 2015 17:21:46 -0700
Subject: [PATCH 45/57] remove unsused variable

---
 src/compiler/declarationEmitter.ts | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index 045d9ea510cb8..708417af9ceb2 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -5,7 +5,6 @@ namespace ts {
     interface DeclarationEmit {
         hasDeclarationDiagnostics: boolean;
         output: string;
-        referencePathsOutput: string;
     }
 
     interface NodeLinks {
@@ -64,7 +63,6 @@ namespace ts {
         return {
             hasDeclarationDiagnostics,
             output: writer.getText(),
-            referencePathsOutput : "",
         };
 
         function emitTripleSlashReferences(root: SourceFile) {
@@ -1686,9 +1684,7 @@ namespace ts {
         // TODO(shkamat): Should we not write any declaration file if any of them can produce error,
         // or should we just not write this file like we are doing now
         if (!emitDeclarationResult.hasDeclarationDiagnostics) {
-            let declarationOutput = emitDeclarationResult.referencePathsOutput
-                + emitDeclarationResult.output;
-            writeFile(host, diagnostics, removeFileExtension(jsFilePath) + ".d.ts", declarationOutput, host.getCompilerOptions().emitBOM);
+            writeFile(host, diagnostics, removeFileExtension(jsFilePath) + ".d.ts", emitDeclarationResult.output, host.getCompilerOptions().emitBOM);
         }
     }
 }
\ No newline at end of file

From ca07040df2d452a135f78b32f29506b9f21e4dbd Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Mon, 20 Jul 2015 14:29:16 -0700
Subject: [PATCH 46/57] Consolidate emit logic in one place, and split the
 process into two phases preporcess and write

---
 src/compiler/core.ts                          |   2 +-
 src/compiler/declarationEmitter.ts            | 252 +++++++++++-------
 src/compiler/emitter.ts                       |  15 +-
 src/compiler/utilities.ts                     |   9 +
 .../amd/declarationsCascadingImports.json     |   2 +-
 .../node/declarationsCascadingImports.json    |   2 +-
 .../amd/declarationsGlobalImport.json         |   2 +-
 .../node/declarationsGlobalImport.json        |   2 +-
 .../amd/declarationsImportedInPrivate.json    |   2 +-
 .../node/declarationsImportedInPrivate.json   |   2 +-
 .../declarationsImportedUseInFunction.json    |   2 +-
 .../declarationsImportedUseInFunction.json    |   2 +-
 .../amd/declarationsMultipleTimesImport.json  |   2 +-
 .../node/declarationsMultipleTimesImport.json |   2 +-
 ...clarationsMultipleTimesMultipleImport.json |   4 +-
 ...clarationsMultipleTimesMultipleImport.json |   4 +-
 .../amd/declarationsSimpleImport.json         |   2 +-
 .../node/declarationsSimpleImport.json        |   2 +-
 ...ootAbsolutePathMixedSubfolderNoOutdir.json |   4 +-
 ...ootAbsolutePathMixedSubfolderNoOutdir.json |   4 +-
 ...hMixedSubfolderSpecifyOutputDirectory.json |   4 +-
 ...hMixedSubfolderSpecifyOutputDirectory.json |   4 +-
 ...tePathMixedSubfolderSpecifyOutputFile.json |   2 +-
 ...tePathMixedSubfolderSpecifyOutputFile.json |   2 +-
 ...erSpecifyOutputFileAndOutputDirectory.json |   2 +-
 ...erSpecifyOutputFileAndOutputDirectory.json |   2 +-
 ...AbsolutePathModuleMultifolderNoOutdir.json |   4 +-
 ...AbsolutePathModuleMultifolderNoOutdir.json |   4 +-
 ...duleMultifolderSpecifyOutputDirectory.json |   4 +-
 ...duleMultifolderSpecifyOutputDirectory.json |   4 +-
 ...athModuleMultifolderSpecifyOutputFile.json |   6 +-
 ...athModuleMultifolderSpecifyOutputFile.json |   6 +-
 ...pRootAbsolutePathModuleSimpleNoOutdir.json |   2 +-
 ...pRootAbsolutePathModuleSimpleNoOutdir.json |   2 +-
 ...athModuleSimpleSpecifyOutputDirectory.json |   2 +-
 ...athModuleSimpleSpecifyOutputDirectory.json |   2 +-
 ...lutePathModuleSimpleSpecifyOutputFile.json |   4 +-
 ...lutePathModuleSimpleSpecifyOutputFile.json |   4 +-
 ...otAbsolutePathModuleSubfolderNoOutdir.json |   2 +-
 ...otAbsolutePathModuleSubfolderNoOutdir.json |   2 +-
 ...ModuleSubfolderSpecifyOutputDirectory.json |   2 +-
 ...ModuleSubfolderSpecifyOutputDirectory.json |   2 +-
 ...ePathModuleSubfolderSpecifyOutputFile.json |   4 +-
 ...ePathModuleSubfolderSpecifyOutputFile.json |   4 +-
 ...apRootAbsolutePathMultifolderNoOutdir.json |   4 +-
 ...apRootAbsolutePathMultifolderNoOutdir.json |   4 +-
 ...PathMultifolderSpecifyOutputDirectory.json |   4 +-
 ...PathMultifolderSpecifyOutputDirectory.json |   4 +-
 .../mapRootAbsolutePathSimpleNoOutdir.json    |   2 +-
 .../mapRootAbsolutePathSimpleNoOutdir.json    |   2 +-
 ...olutePathSimpleSpecifyOutputDirectory.json |   2 +-
 ...olutePathSimpleSpecifyOutputDirectory.json |   2 +-
 .../mapRootAbsolutePathSubfolderNoOutdir.json |   2 +-
 .../mapRootAbsolutePathSubfolderNoOutdir.json |   2 +-
 ...tePathSubfolderSpecifyOutputDirectory.json |   2 +-
 ...tePathSubfolderSpecifyOutputDirectory.json |   2 +-
 ...ootRelativePathMixedSubfolderNoOutdir.json |   4 +-
 ...ootRelativePathMixedSubfolderNoOutdir.json |   4 +-
 ...hMixedSubfolderSpecifyOutputDirectory.json |   4 +-
 ...hMixedSubfolderSpecifyOutputDirectory.json |   4 +-
 ...vePathMixedSubfolderSpecifyOutputFile.json |   2 +-
 ...vePathMixedSubfolderSpecifyOutputFile.json |   2 +-
 ...erSpecifyOutputFileAndOutputDirectory.json |   2 +-
 ...erSpecifyOutputFileAndOutputDirectory.json |   2 +-
 ...RelativePathModuleMultifolderNoOutdir.json |   4 +-
 ...RelativePathModuleMultifolderNoOutdir.json |   4 +-
 ...duleMultifolderSpecifyOutputDirectory.json |   4 +-
 ...duleMultifolderSpecifyOutputDirectory.json |   4 +-
 ...athModuleMultifolderSpecifyOutputFile.json |   6 +-
 ...athModuleMultifolderSpecifyOutputFile.json |   6 +-
 ...pRootRelativePathModuleSimpleNoOutdir.json |   2 +-
 ...pRootRelativePathModuleSimpleNoOutdir.json |   2 +-
 ...athModuleSimpleSpecifyOutputDirectory.json |   2 +-
 ...athModuleSimpleSpecifyOutputDirectory.json |   2 +-
 ...tivePathModuleSimpleSpecifyOutputFile.json |   4 +-
 ...tivePathModuleSimpleSpecifyOutputFile.json |   4 +-
 ...otRelativePathModuleSubfolderNoOutdir.json |   2 +-
 ...otRelativePathModuleSubfolderNoOutdir.json |   2 +-
 ...ModuleSubfolderSpecifyOutputDirectory.json |   2 +-
 ...ModuleSubfolderSpecifyOutputDirectory.json |   2 +-
 ...ePathModuleSubfolderSpecifyOutputFile.json |   4 +-
 ...ePathModuleSubfolderSpecifyOutputFile.json |   4 +-
 ...apRootRelativePathMultifolderNoOutdir.json |   4 +-
 ...apRootRelativePathMultifolderNoOutdir.json |   4 +-
 ...PathMultifolderSpecifyOutputDirectory.json |   4 +-
 ...PathMultifolderSpecifyOutputDirectory.json |   4 +-
 .../mapRootRelativePathSimpleNoOutdir.json    |   2 +-
 .../mapRootRelativePathSimpleNoOutdir.json    |   2 +-
 ...ativePathSimpleSpecifyOutputDirectory.json |   2 +-
 ...ativePathSimpleSpecifyOutputDirectory.json |   2 +-
 .../mapRootRelativePathSubfolderNoOutdir.json |   2 +-
 .../mapRootRelativePathSubfolderNoOutdir.json |   2 +-
 ...vePathSubfolderSpecifyOutputDirectory.json |   2 +-
 ...vePathSubfolderSpecifyOutputDirectory.json |   2 +-
 .../amd/maprootUrlMixedSubfolderNoOutdir.json |   4 +-
 .../maprootUrlMixedSubfolderNoOutdir.json     |   4 +-
 ...lMixedSubfolderSpecifyOutputDirectory.json |   4 +-
 ...lMixedSubfolderSpecifyOutputDirectory.json |   4 +-
 ...ootUrlMixedSubfolderSpecifyOutputFile.json |   2 +-
 ...ootUrlMixedSubfolderSpecifyOutputFile.json |   2 +-
 ...erSpecifyOutputFileAndOutputDirectory.json |   2 +-
 ...erSpecifyOutputFileAndOutputDirectory.json |   2 +-
 .../maprootUrlModuleMultifolderNoOutdir.json  |   4 +-
 .../maprootUrlModuleMultifolderNoOutdir.json  |   4 +-
 ...duleMultifolderSpecifyOutputDirectory.json |   4 +-
 ...duleMultifolderSpecifyOutputDirectory.json |   4 +-
 ...UrlModuleMultifolderSpecifyOutputFile.json |   6 +-
 ...UrlModuleMultifolderSpecifyOutputFile.json |   6 +-
 .../amd/maprootUrlModuleSimpleNoOutdir.json   |   2 +-
 .../node/maprootUrlModuleSimpleNoOutdir.json  |   2 +-
 ...UrlModuleSimpleSpecifyOutputDirectory.json |   2 +-
 ...UrlModuleSimpleSpecifyOutputDirectory.json |   2 +-
 ...prootUrlModuleSimpleSpecifyOutputFile.json |   4 +-
 ...prootUrlModuleSimpleSpecifyOutputFile.json |   4 +-
 .../maprootUrlModuleSubfolderNoOutdir.json    |   2 +-
 .../maprootUrlModuleSubfolderNoOutdir.json    |   2 +-
 ...ModuleSubfolderSpecifyOutputDirectory.json |   2 +-
 ...ModuleSubfolderSpecifyOutputDirectory.json |   2 +-
 ...otUrlModuleSubfolderSpecifyOutputFile.json |   4 +-
 ...otUrlModuleSubfolderSpecifyOutputFile.json |   4 +-
 .../amd/maprootUrlMultifolderNoOutdir.json    |   4 +-
 .../node/maprootUrlMultifolderNoOutdir.json   |   4 +-
 ...tUrlMultifolderSpecifyOutputDirectory.json |   4 +-
 ...tUrlMultifolderSpecifyOutputDirectory.json |   4 +-
 .../amd/maprootUrlSimpleNoOutdir.json         |   2 +-
 .../node/maprootUrlSimpleNoOutdir.json        |   2 +-
 ...aprootUrlSimpleSpecifyOutputDirectory.json |   2 +-
 ...aprootUrlSimpleSpecifyOutputDirectory.json |   2 +-
 .../amd/maprootUrlSubfolderNoOutdir.json      |   2 +-
 .../node/maprootUrlSubfolderNoOutdir.json     |   2 +-
 ...ootUrlSubfolderSpecifyOutputDirectory.json |   2 +-
 ...ootUrlSubfolderSpecifyOutputDirectory.json |   2 +-
 ...rlsourcerootUrlMixedSubfolderNoOutdir.json |   4 +-
 ...rlsourcerootUrlMixedSubfolderNoOutdir.json |   4 +-
 ...lMixedSubfolderSpecifyOutputDirectory.json |   4 +-
 ...lMixedSubfolderSpecifyOutputDirectory.json |   4 +-
 ...ootUrlMixedSubfolderSpecifyOutputFile.json |   2 +-
 ...ootUrlMixedSubfolderSpecifyOutputFile.json |   2 +-
 ...erSpecifyOutputFileAndOutputDirectory.json |   2 +-
 ...erSpecifyOutputFileAndOutputDirectory.json |   2 +-
 ...ourcerootUrlModuleMultifolderNoOutdir.json |   4 +-
 ...ourcerootUrlModuleMultifolderNoOutdir.json |   4 +-
 ...duleMultifolderSpecifyOutputDirectory.json |   4 +-
 ...duleMultifolderSpecifyOutputDirectory.json |   4 +-
 ...UrlModuleMultifolderSpecifyOutputFile.json |   6 +-
 ...UrlModuleMultifolderSpecifyOutputFile.json |   6 +-
 ...tUrlsourcerootUrlModuleSimpleNoOutdir.json |   2 +-
 ...tUrlsourcerootUrlModuleSimpleNoOutdir.json |   2 +-
 ...UrlModuleSimpleSpecifyOutputDirectory.json |   2 +-
 ...UrlModuleSimpleSpecifyOutputDirectory.json |   2 +-
 ...erootUrlModuleSimpleSpecifyOutputFile.json |   4 +-
 ...erootUrlModuleSimpleSpecifyOutputFile.json |   4 +-
 ...lsourcerootUrlModuleSubfolderNoOutdir.json |   2 +-
 ...lsourcerootUrlModuleSubfolderNoOutdir.json |   2 +-
 ...ModuleSubfolderSpecifyOutputDirectory.json |   2 +-
 ...ModuleSubfolderSpecifyOutputDirectory.json |   2 +-
 ...otUrlModuleSubfolderSpecifyOutputFile.json |   4 +-
 ...otUrlModuleSubfolderSpecifyOutputFile.json |   4 +-
 ...otUrlsourcerootUrlMultifolderNoOutdir.json |   4 +-
 ...otUrlsourcerootUrlMultifolderNoOutdir.json |   4 +-
 ...tUrlMultifolderSpecifyOutputDirectory.json |   4 +-
 ...tUrlMultifolderSpecifyOutputDirectory.json |   4 +-
 ...maprootUrlsourcerootUrlSimpleNoOutdir.json |   2 +-
 ...maprootUrlsourcerootUrlSimpleNoOutdir.json |   2 +-
 ...cerootUrlSimpleSpecifyOutputDirectory.json |   2 +-
 ...cerootUrlSimpleSpecifyOutputDirectory.json |   2 +-
 ...rootUrlsourcerootUrlSubfolderNoOutdir.json |   2 +-
 ...rootUrlsourcerootUrlSubfolderNoOutdir.json |   2 +-
 ...ootUrlSubfolderSpecifyOutputDirectory.json |   2 +-
 ...ootUrlSubfolderSpecifyOutputDirectory.json |   2 +-
 .../amd/outMixedSubfolderNoOutdir.json        |   4 +-
 .../node/outMixedSubfolderNoOutdir.json       |   4 +-
 ...tMixedSubfolderSpecifyOutputDirectory.json |   4 +-
 ...tMixedSubfolderSpecifyOutputDirectory.json |   4 +-
 .../outMixedSubfolderSpecifyOutputFile.json   |   2 +-
 .../outMixedSubfolderSpecifyOutputFile.json   |   2 +-
 ...erSpecifyOutputFileAndOutputDirectory.json |   2 +-
 ...erSpecifyOutputFileAndOutputDirectory.json |   2 +-
 .../amd/outModuleMultifolderNoOutdir.json     |   4 +-
 .../node/outModuleMultifolderNoOutdir.json    |   4 +-
 ...duleMultifolderSpecifyOutputDirectory.json |   4 +-
 ...duleMultifolderSpecifyOutputDirectory.json |   4 +-
 ...outModuleMultifolderSpecifyOutputFile.json |   6 +-
 ...outModuleMultifolderSpecifyOutputFile.json |   6 +-
 .../amd/outModuleSimpleNoOutdir.json          |   2 +-
 .../node/outModuleSimpleNoOutdir.json         |   2 +-
 ...outModuleSimpleSpecifyOutputDirectory.json |   2 +-
 ...outModuleSimpleSpecifyOutputDirectory.json |   2 +-
 .../amd/outModuleSimpleSpecifyOutputFile.json |   4 +-
 .../outModuleSimpleSpecifyOutputFile.json     |   4 +-
 .../amd/outModuleSubfolderNoOutdir.json       |   2 +-
 .../node/outModuleSubfolderNoOutdir.json      |   2 +-
 ...ModuleSubfolderSpecifyOutputDirectory.json |   2 +-
 ...ModuleSubfolderSpecifyOutputDirectory.json |   2 +-
 .../outModuleSubfolderSpecifyOutputFile.json  |   4 +-
 .../outModuleSubfolderSpecifyOutputFile.json  |   4 +-
 .../amd/outMultifolderNoOutdir.json           |   4 +-
 .../node/outMultifolderNoOutdir.json          |   4 +-
 .../outMultifolderSpecifyOutputDirectory.json |   4 +-
 .../outMultifolderSpecifyOutputDirectory.json |   4 +-
 .../amd/outSimpleNoOutdir.json                |   2 +-
 .../node/outSimpleNoOutdir.json               |   2 +-
 .../amd/outSimpleSpecifyOutputDirectory.json  |   2 +-
 .../node/outSimpleSpecifyOutputDirectory.json |   2 +-
 .../amd/outSubfolderNoOutdir.json             |   2 +-
 .../node/outSubfolderNoOutdir.json            |   2 +-
 .../outSubfolderSpecifyOutputDirectory.json   |   2 +-
 .../outSubfolderSpecifyOutputDirectory.json   |   2 +-
 .../amd/quotesInFileAndDirectoryNames.json    |   2 +-
 .../node/quotesInFileAndDirectoryNames.json   |   2 +-
 .../amd/referenceResolutionRelativePaths.json |   2 +-
 .../referenceResolutionRelativePaths.json     |   2 +-
 ...olutionRelativePathsFromRootDirectory.json |   2 +-
 ...olutionRelativePathsFromRootDirectory.json |   2 +-
 ...renceResolutionRelativePathsNoResolve.json |   2 +-
 ...renceResolutionRelativePathsNoResolve.json |   2 +-
 ...nRelativePathsRelativeToRootDirectory.json |   2 +-
 ...nRelativePathsRelativeToRootDirectory.json |   2 +-
 .../rootDirectory/amd/rootDirectory.json      |   2 +-
 .../rootDirectory/node/rootDirectory.json     |   2 +-
 .../amd/rootDirectoryErrors.json              |   2 +-
 .../node/rootDirectoryErrors.json             |   2 +-
 ...ootAbsolutePathMixedSubfolderNoOutdir.json |   4 +-
 ...ootAbsolutePathMixedSubfolderNoOutdir.json |   4 +-
 ...hMixedSubfolderSpecifyOutputDirectory.json |   4 +-
 ...hMixedSubfolderSpecifyOutputDirectory.json |   4 +-
 ...tePathMixedSubfolderSpecifyOutputFile.json |   2 +-
 ...tePathMixedSubfolderSpecifyOutputFile.json |   2 +-
 ...erSpecifyOutputFileAndOutputDirectory.json |   2 +-
 ...erSpecifyOutputFileAndOutputDirectory.json |   2 +-
 ...AbsolutePathModuleMultifolderNoOutdir.json |   4 +-
 ...AbsolutePathModuleMultifolderNoOutdir.json |   4 +-
 ...duleMultifolderSpecifyOutputDirectory.json |   4 +-
 ...duleMultifolderSpecifyOutputDirectory.json |   4 +-
 ...athModuleMultifolderSpecifyOutputFile.json |   6 +-
 ...athModuleMultifolderSpecifyOutputFile.json |   6 +-
 ...eRootAbsolutePathModuleSimpleNoOutdir.json |   2 +-
 ...eRootAbsolutePathModuleSimpleNoOutdir.json |   2 +-
 ...athModuleSimpleSpecifyOutputDirectory.json |   2 +-
 ...athModuleSimpleSpecifyOutputDirectory.json |   2 +-
 ...lutePathModuleSimpleSpecifyOutputFile.json |   4 +-
 ...lutePathModuleSimpleSpecifyOutputFile.json |   4 +-
 ...otAbsolutePathModuleSubfolderNoOutdir.json |   2 +-
 ...otAbsolutePathModuleSubfolderNoOutdir.json |   2 +-
 ...ModuleSubfolderSpecifyOutputDirectory.json |   2 +-
 ...ModuleSubfolderSpecifyOutputDirectory.json |   2 +-
 ...ePathModuleSubfolderSpecifyOutputFile.json |   4 +-
 ...ePathModuleSubfolderSpecifyOutputFile.json |   4 +-
 ...ceRootAbsolutePathMultifolderNoOutdir.json |   4 +-
 ...ceRootAbsolutePathMultifolderNoOutdir.json |   4 +-
 ...PathMultifolderSpecifyOutputDirectory.json |   4 +-
 ...PathMultifolderSpecifyOutputDirectory.json |   4 +-
 .../sourceRootAbsolutePathSimpleNoOutdir.json |   2 +-
 .../sourceRootAbsolutePathSimpleNoOutdir.json |   2 +-
 ...olutePathSimpleSpecifyOutputDirectory.json |   2 +-
 ...olutePathSimpleSpecifyOutputDirectory.json |   2 +-
 ...urceRootAbsolutePathSubfolderNoOutdir.json |   2 +-
 ...urceRootAbsolutePathSubfolderNoOutdir.json |   2 +-
 ...tePathSubfolderSpecifyOutputDirectory.json |   2 +-
 ...tePathSubfolderSpecifyOutputDirectory.json |   2 +-
 ...ootRelativePathMixedSubfolderNoOutdir.json |   4 +-
 ...ootRelativePathMixedSubfolderNoOutdir.json |   4 +-
 ...hMixedSubfolderSpecifyOutputDirectory.json |   4 +-
 ...hMixedSubfolderSpecifyOutputDirectory.json |   4 +-
 ...vePathMixedSubfolderSpecifyOutputFile.json |   2 +-
 ...vePathMixedSubfolderSpecifyOutputFile.json |   2 +-
 ...erSpecifyOutputFileAndOutputDirectory.json |   2 +-
 ...erSpecifyOutputFileAndOutputDirectory.json |   2 +-
 ...RelativePathModuleMultifolderNoOutdir.json |   4 +-
 ...RelativePathModuleMultifolderNoOutdir.json |   4 +-
 ...duleMultifolderSpecifyOutputDirectory.json |   4 +-
 ...duleMultifolderSpecifyOutputDirectory.json |   4 +-
 ...athModuleMultifolderSpecifyOutputFile.json |   6 +-
 ...athModuleMultifolderSpecifyOutputFile.json |   6 +-
 ...eRootRelativePathModuleSimpleNoOutdir.json |   2 +-
 ...eRootRelativePathModuleSimpleNoOutdir.json |   2 +-
 ...athModuleSimpleSpecifyOutputDirectory.json |   2 +-
 ...athModuleSimpleSpecifyOutputDirectory.json |   2 +-
 ...tivePathModuleSimpleSpecifyOutputFile.json |   4 +-
 ...tivePathModuleSimpleSpecifyOutputFile.json |   4 +-
 ...otRelativePathModuleSubfolderNoOutdir.json |   2 +-
 ...otRelativePathModuleSubfolderNoOutdir.json |   2 +-
 ...ModuleSubfolderSpecifyOutputDirectory.json |   2 +-
 ...ModuleSubfolderSpecifyOutputDirectory.json |   2 +-
 ...ePathModuleSubfolderSpecifyOutputFile.json |   4 +-
 ...ePathModuleSubfolderSpecifyOutputFile.json |   4 +-
 ...ceRootRelativePathMultifolderNoOutdir.json |   4 +-
 ...ceRootRelativePathMultifolderNoOutdir.json |   4 +-
 ...PathMultifolderSpecifyOutputDirectory.json |   4 +-
 ...PathMultifolderSpecifyOutputDirectory.json |   4 +-
 .../sourceRootRelativePathSimpleNoOutdir.json |   2 +-
 .../sourceRootRelativePathSimpleNoOutdir.json |   2 +-
 ...ativePathSimpleSpecifyOutputDirectory.json |   2 +-
 ...ativePathSimpleSpecifyOutputDirectory.json |   2 +-
 ...urceRootRelativePathSubfolderNoOutdir.json |   2 +-
 ...urceRootRelativePathSubfolderNoOutdir.json |   2 +-
 ...vePathSubfolderSpecifyOutputDirectory.json |   2 +-
 ...vePathSubfolderSpecifyOutputDirectory.json |   2 +-
 .../amd/sourcemapMixedSubfolderNoOutdir.json  |   4 +-
 .../node/sourcemapMixedSubfolderNoOutdir.json |   4 +-
 ...pMixedSubfolderSpecifyOutputDirectory.json |   4 +-
 ...pMixedSubfolderSpecifyOutputDirectory.json |   4 +-
 ...rcemapMixedSubfolderSpecifyOutputFile.json |   2 +-
 ...rcemapMixedSubfolderSpecifyOutputFile.json |   2 +-
 ...erSpecifyOutputFileAndOutputDirectory.json |   2 +-
 ...erSpecifyOutputFileAndOutputDirectory.json |   2 +-
 .../sourcemapModuleMultifolderNoOutdir.json   |   4 +-
 .../sourcemapModuleMultifolderNoOutdir.json   |   4 +-
 ...duleMultifolderSpecifyOutputDirectory.json |   4 +-
 ...duleMultifolderSpecifyOutputDirectory.json |   4 +-
 ...mapModuleMultifolderSpecifyOutputFile.json |   6 +-
 ...mapModuleMultifolderSpecifyOutputFile.json |   6 +-
 .../amd/sourcemapModuleSimpleNoOutdir.json    |   2 +-
 .../node/sourcemapModuleSimpleNoOutdir.json   |   2 +-
 ...mapModuleSimpleSpecifyOutputDirectory.json |   2 +-
 ...mapModuleSimpleSpecifyOutputDirectory.json |   2 +-
 ...ourcemapModuleSimpleSpecifyOutputFile.json |   4 +-
 ...ourcemapModuleSimpleSpecifyOutputFile.json |   4 +-
 .../amd/sourcemapModuleSubfolderNoOutdir.json |   2 +-
 .../sourcemapModuleSubfolderNoOutdir.json     |   2 +-
 ...ModuleSubfolderSpecifyOutputDirectory.json |   2 +-
 ...ModuleSubfolderSpecifyOutputDirectory.json |   2 +-
 ...cemapModuleSubfolderSpecifyOutputFile.json |   4 +-
 ...cemapModuleSubfolderSpecifyOutputFile.json |   4 +-
 .../amd/sourcemapMultifolderNoOutdir.json     |   4 +-
 .../node/sourcemapMultifolderNoOutdir.json    |   4 +-
 ...emapMultifolderSpecifyOutputDirectory.json |   4 +-
 ...emapMultifolderSpecifyOutputDirectory.json |   4 +-
 .../amd/sourcemapSimpleNoOutdir.json          |   2 +-
 .../node/sourcemapSimpleNoOutdir.json         |   2 +-
 ...sourcemapSimpleSpecifyOutputDirectory.json |   2 +-
 ...sourcemapSimpleSpecifyOutputDirectory.json |   2 +-
 .../amd/sourcemapSubfolderNoOutdir.json       |   2 +-
 .../node/sourcemapSubfolderNoOutdir.json      |   2 +-
 ...rcemapSubfolderSpecifyOutputDirectory.json |   2 +-
 ...rcemapSubfolderSpecifyOutputDirectory.json |   2 +-
 .../sourcerootUrlMixedSubfolderNoOutdir.json  |   4 +-
 .../sourcerootUrlMixedSubfolderNoOutdir.json  |   4 +-
 ...lMixedSubfolderSpecifyOutputDirectory.json |   4 +-
 ...lMixedSubfolderSpecifyOutputDirectory.json |   4 +-
 ...ootUrlMixedSubfolderSpecifyOutputFile.json |   2 +-
 ...ootUrlMixedSubfolderSpecifyOutputFile.json |   2 +-
 ...erSpecifyOutputFileAndOutputDirectory.json |   2 +-
 ...erSpecifyOutputFileAndOutputDirectory.json |   2 +-
 ...ourcerootUrlModuleMultifolderNoOutdir.json |   4 +-
 ...ourcerootUrlModuleMultifolderNoOutdir.json |   4 +-
 ...duleMultifolderSpecifyOutputDirectory.json |   4 +-
 ...duleMultifolderSpecifyOutputDirectory.json |   4 +-
 ...UrlModuleMultifolderSpecifyOutputFile.json |   6 +-
 ...UrlModuleMultifolderSpecifyOutputFile.json |   6 +-
 .../sourcerootUrlModuleSimpleNoOutdir.json    |   2 +-
 .../sourcerootUrlModuleSimpleNoOutdir.json    |   2 +-
 ...UrlModuleSimpleSpecifyOutputDirectory.json |   2 +-
 ...UrlModuleSimpleSpecifyOutputDirectory.json |   2 +-
 ...erootUrlModuleSimpleSpecifyOutputFile.json |   4 +-
 ...erootUrlModuleSimpleSpecifyOutputFile.json |   4 +-
 .../sourcerootUrlModuleSubfolderNoOutdir.json |   2 +-
 .../sourcerootUrlModuleSubfolderNoOutdir.json |   2 +-
 ...ModuleSubfolderSpecifyOutputDirectory.json |   2 +-
 ...ModuleSubfolderSpecifyOutputDirectory.json |   2 +-
 ...otUrlModuleSubfolderSpecifyOutputFile.json |   4 +-
 ...otUrlModuleSubfolderSpecifyOutputFile.json |   4 +-
 .../amd/sourcerootUrlMultifolderNoOutdir.json |   4 +-
 .../sourcerootUrlMultifolderNoOutdir.json     |   4 +-
 ...tUrlMultifolderSpecifyOutputDirectory.json |   4 +-
 ...tUrlMultifolderSpecifyOutputDirectory.json |   4 +-
 .../amd/sourcerootUrlSimpleNoOutdir.json      |   2 +-
 .../node/sourcerootUrlSimpleNoOutdir.json     |   2 +-
 ...cerootUrlSimpleSpecifyOutputDirectory.json |   2 +-
 ...cerootUrlSimpleSpecifyOutputDirectory.json |   2 +-
 .../amd/sourcerootUrlSubfolderNoOutdir.json   |   2 +-
 .../node/sourcerootUrlSubfolderNoOutdir.json  |   2 +-
 ...ootUrlSubfolderSpecifyOutputDirectory.json |   2 +-
 ...ootUrlSubfolderSpecifyOutputDirectory.json |   2 +-
 374 files changed, 718 insertions(+), 664 deletions(-)

diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index ec171d4aee298..3cd7c17e622e2 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -805,4 +805,4 @@ namespace ts {
             Debug.assert(false, message);
         }
     }
-}
+}
diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index 708417af9ceb2..5b38da85fe1be 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -2,11 +2,6 @@
 
 /* @internal */
 namespace ts {
-    interface DeclarationEmit {
-        hasDeclarationDiagnostics: boolean;
-        output: string;
-    }
-
     interface NodeLinks {
         visibleChildren?: Node[];
         visited?: boolean;
@@ -14,19 +9,24 @@ namespace ts {
         hasExportDeclarations?: boolean;
     }
 
-    export function getDeclarationDiagnostics(host: EmitHost, resolver: EmitResolver, targetSourceFile: SourceFile): Diagnostic[] {
-        let diagnostics: Diagnostic[] = [];
-        let jsFilePath = getOwnEmitOutputFilePath(targetSourceFile, host, ".js");
-        emitDeclarations(host, resolver, diagnostics, jsFilePath, targetSourceFile);
-        return diagnostics;
+    interface PreprocessResults {
+        sourceFiles: SourceFile[];
+        nodeLinks: NodeLinks[];
+        resolver: EmitResolver;
     }
 
     const emptyHandler = () => { };
 
-    function emitDeclarations(host: EmitHost, resolver: EmitResolver, diagnostics: Diagnostic[], jsFilePath: string, root?: SourceFile): DeclarationEmit {
+    function writeDeclarations(outputFileName: string, preprocessResults: PreprocessResults,  host: EmitHost, diagnostics: Diagnostic[]): void {
         let newLine = host.getNewLine();
         let compilerOptions = host.getCompilerOptions();
+        let enclosingDeclaration: Node;
+        let currentSourceFile: SourceFile;
 
+        let resolver = preprocessResults.resolver;
+        let nodeLinks = preprocessResults.nodeLinks;
+
+        // setup the writer
         let writer = createNewTextWriterWithSymbolWriter();
         let write = writer.write;
         let writeTextOfNode = writer.writeTextOfNode;
@@ -34,38 +34,25 @@ namespace ts {
         let increaseIndent = writer.increaseIndent;
         let decreaseIndent = writer.decreaseIndent;
 
-        let enclosingDeclaration: Node;
-        let currentSourceFile: SourceFile;
-        let hasDeclarationDiagnostics = false;
+        // Emit any triple-slash references
+        emitTripleSlashReferences(preprocessResults.sourceFiles);
 
-        let nodeLinks: NodeLinks[] = [];
-        function getNodeLinks(node: Node): NodeLinks {
-            let nodeId = getNodeId(node);
-            return nodeLinks[nodeId] || (nodeLinks[nodeId] = {});
+        for (let sourceFile of preprocessResults.sourceFiles) {
+            // emit the declarations from this file
+            emitSourceFile(sourceFile);
         }
 
-        // Emit any triple-slash references
-        emitTripleSlashReferences(root);
+        // write the output to disk
+        writeFile(host, diagnostics, outputFileName, writer.getText(), compilerOptions.emitBOM);
 
-        if (root) {
-            // Emitting just a single file, so emit references in this file only
-            emitSourceFile(root);
-        }
-        else {
-            // Emit references corresponding to this file
-            forEach(host.getSourceFiles(), sourceFile => {
-                if (!isExternalModuleOrDeclarationFile(sourceFile)) {
-                    emitSourceFile(sourceFile);
-                }
-            });
-        }
+        return;
 
-        return {
-            hasDeclarationDiagnostics,
-            output: writer.getText(),
-        };
+        function getNodeLinks(node: Node): NodeLinks {
+            let nodeId = getNodeId(node);
+            return nodeLinks[nodeId] || (nodeLinks[nodeId] = {});
+        }
 
-        function emitTripleSlashReferences(root: SourceFile) {
+        function emitTripleSlashReferences(sourceFiles: SourceFile[]) {
             if (compilerOptions.noResolve) {
                 // Nothing to do
                 return;
@@ -74,17 +61,9 @@ namespace ts {
             let emittedReferencedFiles: SourceFile[] = [];
             let addedGlobalFileReference = false;
 
-            if (root) {
-                // Emitting just a single file, so emit references in this file only
-                emitTripleSlashReferncesInFile(root);
-            }
-            else {
-                // Emit references corresponding to this file
-                forEach(host.getSourceFiles(), sourceFile => {
-                    if (!isExternalModuleOrDeclarationFile(sourceFile)) {
-                        emitTripleSlashReferncesInFile(sourceFile);
-                    }
-                });
+            // Emit references corresponding to this file
+            for (let sourceFile of sourceFiles) {
+                emitTripleSlashReferncesInFile(sourceFile);
             }
 
             return;
@@ -99,7 +78,7 @@ namespace ts {
                     }
 
                     let shouldEmitRefrence: boolean
-                    
+
                     if (isDeclarationFile(referencedFile) || shouldEmitToOwnFile(referencedFile, compilerOptions)) {
                         // If the reference file is a declaration file or an external module,
                         // we know there is going to be a .d.ts file matching it. Emit that reference
@@ -127,7 +106,7 @@ namespace ts {
                         : removeFileExtension(compilerOptions.out) + ".d.ts"; // Global out file
 
                 declFileName = getRelativePathToDirectoryOrUrl(
-                    getDirectoryPath(normalizeSlashes(jsFilePath)),
+                    getDirectoryPath(normalizeSlashes(outputFileName)),
                     declFileName,
                     host.getCurrentDirectory(),
                     host.getCanonicalFileName,
@@ -160,24 +139,6 @@ namespace ts {
             return writer;
         }
 
-        function createVoidSymbolWriter(trackTypeSymbol: (s: Symbol) => void, trackInaccesibleSymbol: (s: Symbol) => void): SymbolWriter {
-            return {
-                writeLine: emptyHandler,
-                writeKeyword: emptyHandler,
-                writeOperator: emptyHandler,
-                writePunctuation: emptyHandler,
-                writeSpace: emptyHandler,
-                writeStringLiteral: emptyHandler,
-                writeParameter: emptyHandler,
-                writeSymbol: emptyHandler,
-                decreaseIndent: emptyHandler,
-                increaseIndent: emptyHandler,
-                clear: emptyHandler,
-                trackTypeSymbol,
-                trackInaccesibleSymbol
-            };
-        }
-
         function emitTypeOfDeclaration(declaration: AccessorDeclaration | VariableLikeDeclaration, type: TypeNode) {
             write(": ");
             if (type) {
@@ -800,15 +761,6 @@ namespace ts {
             }
         }
 
-        function getTypeAnnotationFromAccessor(getAccessor: AccessorDeclaration, setAccessor: AccessorDeclaration): TypeNode {
-            if (getAccessor && getAccessor.type) {
-                return getAccessor.type // Getter - return type
-            }
-            if (setAccessor && setAccessor.parameters.length > 0) {
-                return setAccessor.parameters[0].type;
-            }
-        }
-
         function emitAccessorDeclaration(node: AccessorDeclaration) {
             if (hasDynamicName(node)) {
                 return;
@@ -1063,6 +1015,56 @@ namespace ts {
             }
         }
 
+        function writeChildDeclarations(node: Node): void {
+            forEach(sortDeclarations(getNodeLinks(node).visibleChildren), emitNode);
+        }
+
+        function emitSourceFile(sourceFile: SourceFile): void {
+            currentSourceFile = sourceFile;
+            enclosingDeclaration = sourceFile;
+
+            // write the declarations
+            writeChildDeclarations(sourceFile);
+        }
+
+        function compareDeclarations(d1: Node, d2: Node): Comparison {
+            return compareValues(d1.pos, d2.pos) || Comparison.EqualTo;
+        }
+
+        function sortDeclarations(nodes: Node[]): Node[] {
+            return nodes && nodes.sort(compareDeclarations);
+        }
+    }
+
+    function preprocessDeclarations(sourceFiles: SourceFile[], resolver: EmitResolver, diagnostics: Diagnostic[], compilerOptions: CompilerOptions): PreprocessResults {
+        let currentSourceFile: SourceFile;
+        let nodeLinks: NodeLinks[] = [];
+
+        for (let sourceFile of sourceFiles) {
+            preprocessSourceFile(sourceFile);
+        }
+
+        return {
+            sourceFiles,
+            nodeLinks,
+            resolver
+        };
+
+        function getNodeLinks(node: Node): NodeLinks {
+            let nodeId = getNodeId(node);
+            return nodeLinks[nodeId] || (nodeLinks[nodeId] = {});
+        }
+
+        function hasInternalAnnotation(range: CommentRange) {
+            let text = currentSourceFile.text;
+            let comment = text.substring(range.pos, range.end);
+            return comment.indexOf("@internal") >= 0;
+        }
+
+        function isInternal(node: Node) {
+            return forEach(getLeadingCommentRanges(currentSourceFile.text, node.pos), hasInternalAnnotation)
+        }
+
         function collectReferencedDeclarations(node: Node): void {
             let currentErrorNode: Node;
             let typeWriter = createVoidSymbolWriter(trackTypeSymbol, trackInaccesibleSymbol);
@@ -1081,6 +1083,24 @@ namespace ts {
                 }
             }
 
+            function createVoidSymbolWriter(trackTypeSymbol: (s: Symbol) => void, trackInaccesibleSymbol: (s: Symbol) => void): SymbolWriter {
+                return {
+                    writeLine: emptyHandler,
+                    writeKeyword: emptyHandler,
+                    writeOperator: emptyHandler,
+                    writePunctuation: emptyHandler,
+                    writeSpace: emptyHandler,
+                    writeStringLiteral: emptyHandler,
+                    writeParameter: emptyHandler,
+                    writeSymbol: emptyHandler,
+                    decreaseIndent: emptyHandler,
+                    increaseIndent: emptyHandler,
+                    clear: emptyHandler,
+                    trackTypeSymbol,
+                    trackInaccesibleSymbol
+                };
+            }
+
             function visitNode(node: Node): void {
                 if (!node) return;
 
@@ -1440,8 +1460,6 @@ namespace ts {
         function reportDeclarationAccessiblityMessage(referencedDeclaration: Declaration, errorNode: Node): void {
             Debug.assert(referencedDeclaration.name && referencedDeclaration.name.kind === SyntaxKind.Identifier);
 
-            hasDeclarationDiagnostics = true;
-
             let referencedDeclarationName = (<Identifier>referencedDeclaration.name).text;
             let container = errorNode;
 
@@ -1534,7 +1552,6 @@ namespace ts {
         }
 
         function reportUnamedDeclarationMessage(errorNode: Node): void {
-            hasDeclarationDiagnostics = true;
             let container = errorNode;
 
             while (container) {
@@ -1654,37 +1671,68 @@ namespace ts {
             links.visibleChildren.push(child);
         }
 
-        function compareDeclarations(d1: Node, d2: Node): Comparison {
-            return compareValues(d1.pos, d2.pos) || Comparison.EqualTo;
-        }
+        function preprocessSourceFile(sourceFile: SourceFile): void {
+            currentSourceFile = sourceFile;
 
-        function sortDeclarations(nodes: Node[]): Node[] {
-            return nodes && nodes.sort(compareDeclarations);
+            // Collect all visible declarations
+            collectTopLevelChildDeclarations(sourceFile);
         }
+    }
 
-        function writeChildDeclarations(node: Node): void {
-            forEach(sortDeclarations(getNodeLinks(node).visibleChildren), emitNode);
+    function forEachExpectedOutputFile(host: EmitHost, targetSourceFile: SourceFile, action: (name: string, sources: SourceFile[]) => void) {
+        let compilerOptions = host.getCompilerOptions();
+        if (targetSourceFile) {
+            // If we have a targetSourceFile (e.g calling emitter from language service to getEmitOutput)
+            // only emit the outputs of this file
+            if (shouldEmitToOwnFile(targetSourceFile, compilerOptions)) {
+                let outputFilePath = getOwnEmitOutputFilePath(targetSourceFile, host, ".d.ts");
+                action(outputFilePath, [targetSourceFile]);
+                return;
+            }
+            // Fall through to the --out case, i.e. shouldEmitToOwnFile()=== false
+        }
+        else {
+            // No targetSourceFile, we need to emit all files
+            for (let sourceFile of host.getSourceFiles()) {
+                if (shouldEmitToOwnFile(sourceFile, compilerOptions)) {
+                    let outputFilePath = getOwnEmitOutputFilePath(sourceFile, host, ".d.ts");
+                    action(outputFilePath, [sourceFile]);
+                }
+            }
         }
 
-        function emitSourceFile(sourceFile: SourceFile): void {
-            currentSourceFile = sourceFile;
-            enclosingDeclaration = sourceFile;
-
-            // Collect all visible declarations
-            collectTopLevelChildDeclarations(sourceFile);
+        if (compilerOptions.out) {
+            // Emit any files that did not have their own output file
+            // all these files will emit to a single output file specified by compiler options.out
+            let outputFilePath = removeFileExtension(compilerOptions.out) + ".d.ts"
+            let sourceFiles = filter(host.getSourceFiles(), sourceFile => !isExternalModuleOrDeclarationFile(sourceFile));
+            action(outputFilePath, sourceFiles);;
+        }
+    }
 
-            // write the declarations
-            writeChildDeclarations(sourceFile);
+    export function getDeclarationDiagnostics(host: EmitHost, resolver: EmitResolver, targetSourceFile: SourceFile): Diagnostic[] {
+        let diagnostics: Diagnostic[] = [];
+        forEachExpectedOutputFile(host, targetSourceFile, (outputFileName, sourceFiles) => {
+            preprocessDeclarations(sourceFiles, resolver, diagnostics, host.getCompilerOptions());
+        });
+        
+        if (targetSourceFile) {
+            return filter(diagnostics, d => d.file === targetSourceFile);
+        }
+        else {
+            return diagnostics;
         }
     }
 
     /* @internal */
-    export function writeDeclarationFile(jsFilePath: string, sourceFile: SourceFile, host: EmitHost, resolver: EmitResolver, diagnostics: Diagnostic[]) {
-        let emitDeclarationResult = emitDeclarations(host, resolver, diagnostics, jsFilePath, sourceFile);
-        // TODO(shkamat): Should we not write any declaration file if any of them can produce error,
-        // or should we just not write this file like we are doing now
-        if (!emitDeclarationResult.hasDeclarationDiagnostics) {
-            writeFile(host, diagnostics, removeFileExtension(jsFilePath) + ".d.ts", emitDeclarationResult.output, host.getCompilerOptions().emitBOM);
-        }
+    export function emitDeclarations(host: EmitHost, resolver: EmitResolver, targetSourceFile: SourceFile, diagnostics: Diagnostic[]): void {
+        forEachExpectedOutputFile(host, targetSourceFile, (outputFileName, sourceFiles) => {
+            let fileDiagnostics: Diagnostic[] = [];
+            let preprocessResult = preprocessDeclarations(sourceFiles, resolver, fileDiagnostics, host.getCompilerOptions());
+            if (fileDiagnostics.length === 0) {
+                writeDeclarations(outputFileName, preprocessResult, host, fileDiagnostics);
+            }
+            diagnostics.push.apply(diagnostics, fileDiagnostics);
+        });
     }
 }
\ No newline at end of file
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index fd0d4ad796e5d..712ceb54a2209 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -93,6 +93,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
         }
 
+        // Emit declarations
+        if (compilerOptions.declaration) {
+            emitDeclarations(host, resolver, targetSourceFile, diagnostics);
+        }
+
         // Sort and make the unique list of diagnostics
         diagnostics = sortAndDeduplicateDiagnostics(diagnostics);
 
@@ -122,7 +127,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             return true;
         }
 
-        function emitJavaScript(jsFilePath: string, root?: SourceFile) {
+        function emitFile(jsFilePath: string, root?: SourceFile) {
             let writer = createTextWriter(newLine);
             let write = writer.write;
             let writeTextOfNode = writer.writeTextOfNode;
@@ -6901,13 +6906,5 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 }
             }
         }
-
-        function emitFile(jsFilePath: string, sourceFile?: SourceFile) {
-            emitJavaScript(jsFilePath, sourceFile);
-
-            if (compilerOptions.declaration) {
-                writeDeclarationFile(jsFilePath, sourceFile, host, resolver, diagnostics);
-            }
-        }
     }
 }
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index 5e67a6546540c..17287df8132b9 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -2315,4 +2315,13 @@ namespace ts {
             }
         }
     }
+
+    export function getTypeAnnotationFromAccessor(getAccessor: AccessorDeclaration, setAccessor: AccessorDeclaration): TypeNode {
+        if (getAccessor && getAccessor.type) {
+            return getAccessor.type // Getter - return type
+        }
+        if (setAccessor && setAccessor.parameters.length > 0) {
+            return setAccessor.parameters[0].type;
+        }
+    }
 }
diff --git a/tests/baselines/reference/project/declarationsCascadingImports/amd/declarationsCascadingImports.json b/tests/baselines/reference/project/declarationsCascadingImports/amd/declarationsCascadingImports.json
index 12c70b9ee2c74..a7985c5b24953 100644
--- a/tests/baselines/reference/project/declarationsCascadingImports/amd/declarationsCascadingImports.json
+++ b/tests/baselines/reference/project/declarationsCascadingImports/amd/declarationsCascadingImports.json
@@ -13,8 +13,8 @@
     ],
     "emittedFiles": [
         "m4.js",
-        "m4.d.ts",
         "useModule.js",
+        "m4.d.ts",
         "useModule.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/declarationsCascadingImports/node/declarationsCascadingImports.json b/tests/baselines/reference/project/declarationsCascadingImports/node/declarationsCascadingImports.json
index 12c70b9ee2c74..a7985c5b24953 100644
--- a/tests/baselines/reference/project/declarationsCascadingImports/node/declarationsCascadingImports.json
+++ b/tests/baselines/reference/project/declarationsCascadingImports/node/declarationsCascadingImports.json
@@ -13,8 +13,8 @@
     ],
     "emittedFiles": [
         "m4.js",
-        "m4.d.ts",
         "useModule.js",
+        "m4.d.ts",
         "useModule.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/declarationsGlobalImport/amd/declarationsGlobalImport.json b/tests/baselines/reference/project/declarationsGlobalImport/amd/declarationsGlobalImport.json
index 78bf819430eb3..5e8317a90ffbe 100644
--- a/tests/baselines/reference/project/declarationsGlobalImport/amd/declarationsGlobalImport.json
+++ b/tests/baselines/reference/project/declarationsGlobalImport/amd/declarationsGlobalImport.json
@@ -13,8 +13,8 @@
     ],
     "emittedFiles": [
         "glo_m4.js",
-        "glo_m4.d.ts",
         "useModule.js",
+        "glo_m4.d.ts",
         "useModule.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/declarationsGlobalImport/node/declarationsGlobalImport.json b/tests/baselines/reference/project/declarationsGlobalImport/node/declarationsGlobalImport.json
index 78bf819430eb3..5e8317a90ffbe 100644
--- a/tests/baselines/reference/project/declarationsGlobalImport/node/declarationsGlobalImport.json
+++ b/tests/baselines/reference/project/declarationsGlobalImport/node/declarationsGlobalImport.json
@@ -13,8 +13,8 @@
     ],
     "emittedFiles": [
         "glo_m4.js",
-        "glo_m4.d.ts",
         "useModule.js",
+        "glo_m4.d.ts",
         "useModule.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/declarationsImportedInPrivate/amd/declarationsImportedInPrivate.json b/tests/baselines/reference/project/declarationsImportedInPrivate/amd/declarationsImportedInPrivate.json
index c6e51b9fc3b51..7a93ab4321f30 100644
--- a/tests/baselines/reference/project/declarationsImportedInPrivate/amd/declarationsImportedInPrivate.json
+++ b/tests/baselines/reference/project/declarationsImportedInPrivate/amd/declarationsImportedInPrivate.json
@@ -13,8 +13,8 @@
     ],
     "emittedFiles": [
         "private_m4.js",
-        "private_m4.d.ts",
         "useModule.js",
+        "private_m4.d.ts",
         "useModule.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/declarationsImportedInPrivate/node/declarationsImportedInPrivate.json b/tests/baselines/reference/project/declarationsImportedInPrivate/node/declarationsImportedInPrivate.json
index c6e51b9fc3b51..7a93ab4321f30 100644
--- a/tests/baselines/reference/project/declarationsImportedInPrivate/node/declarationsImportedInPrivate.json
+++ b/tests/baselines/reference/project/declarationsImportedInPrivate/node/declarationsImportedInPrivate.json
@@ -13,8 +13,8 @@
     ],
     "emittedFiles": [
         "private_m4.js",
-        "private_m4.d.ts",
         "useModule.js",
+        "private_m4.d.ts",
         "useModule.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/declarationsImportedUseInFunction/amd/declarationsImportedUseInFunction.json b/tests/baselines/reference/project/declarationsImportedUseInFunction/amd/declarationsImportedUseInFunction.json
index 71dc130b83d19..3a9829372169b 100644
--- a/tests/baselines/reference/project/declarationsImportedUseInFunction/amd/declarationsImportedUseInFunction.json
+++ b/tests/baselines/reference/project/declarationsImportedUseInFunction/amd/declarationsImportedUseInFunction.json
@@ -13,8 +13,8 @@
     ],
     "emittedFiles": [
         "fncOnly_m4.js",
-        "fncOnly_m4.d.ts",
         "useModule.js",
+        "fncOnly_m4.d.ts",
         "useModule.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/declarationsImportedUseInFunction/node/declarationsImportedUseInFunction.json b/tests/baselines/reference/project/declarationsImportedUseInFunction/node/declarationsImportedUseInFunction.json
index 71dc130b83d19..3a9829372169b 100644
--- a/tests/baselines/reference/project/declarationsImportedUseInFunction/node/declarationsImportedUseInFunction.json
+++ b/tests/baselines/reference/project/declarationsImportedUseInFunction/node/declarationsImportedUseInFunction.json
@@ -13,8 +13,8 @@
     ],
     "emittedFiles": [
         "fncOnly_m4.js",
-        "fncOnly_m4.d.ts",
         "useModule.js",
+        "fncOnly_m4.d.ts",
         "useModule.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/declarationsMultipleTimesImport/amd/declarationsMultipleTimesImport.json b/tests/baselines/reference/project/declarationsMultipleTimesImport/amd/declarationsMultipleTimesImport.json
index 5f5cd70b619fe..0a03d90f3a7f3 100644
--- a/tests/baselines/reference/project/declarationsMultipleTimesImport/amd/declarationsMultipleTimesImport.json
+++ b/tests/baselines/reference/project/declarationsMultipleTimesImport/amd/declarationsMultipleTimesImport.json
@@ -13,8 +13,8 @@
     ],
     "emittedFiles": [
         "m4.js",
-        "m4.d.ts",
         "useModule.js",
+        "m4.d.ts",
         "useModule.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/declarationsMultipleTimesImport/node/declarationsMultipleTimesImport.json b/tests/baselines/reference/project/declarationsMultipleTimesImport/node/declarationsMultipleTimesImport.json
index 5f5cd70b619fe..0a03d90f3a7f3 100644
--- a/tests/baselines/reference/project/declarationsMultipleTimesImport/node/declarationsMultipleTimesImport.json
+++ b/tests/baselines/reference/project/declarationsMultipleTimesImport/node/declarationsMultipleTimesImport.json
@@ -13,8 +13,8 @@
     ],
     "emittedFiles": [
         "m4.js",
-        "m4.d.ts",
         "useModule.js",
+        "m4.d.ts",
         "useModule.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/declarationsMultipleTimesMultipleImport/amd/declarationsMultipleTimesMultipleImport.json b/tests/baselines/reference/project/declarationsMultipleTimesMultipleImport/amd/declarationsMultipleTimesMultipleImport.json
index c5f28aeb3c4f6..31cb74c66eedf 100644
--- a/tests/baselines/reference/project/declarationsMultipleTimesMultipleImport/amd/declarationsMultipleTimesMultipleImport.json
+++ b/tests/baselines/reference/project/declarationsMultipleTimesMultipleImport/amd/declarationsMultipleTimesMultipleImport.json
@@ -14,10 +14,10 @@
     ],
     "emittedFiles": [
         "m4.js",
-        "m4.d.ts",
         "m5.js",
-        "m5.d.ts",
         "useModule.js",
+        "m4.d.ts",
+        "m5.d.ts",
         "useModule.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/declarationsMultipleTimesMultipleImport/node/declarationsMultipleTimesMultipleImport.json b/tests/baselines/reference/project/declarationsMultipleTimesMultipleImport/node/declarationsMultipleTimesMultipleImport.json
index c5f28aeb3c4f6..31cb74c66eedf 100644
--- a/tests/baselines/reference/project/declarationsMultipleTimesMultipleImport/node/declarationsMultipleTimesMultipleImport.json
+++ b/tests/baselines/reference/project/declarationsMultipleTimesMultipleImport/node/declarationsMultipleTimesMultipleImport.json
@@ -14,10 +14,10 @@
     ],
     "emittedFiles": [
         "m4.js",
-        "m4.d.ts",
         "m5.js",
-        "m5.d.ts",
         "useModule.js",
+        "m4.d.ts",
+        "m5.d.ts",
         "useModule.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/declarationsSimpleImport/amd/declarationsSimpleImport.json b/tests/baselines/reference/project/declarationsSimpleImport/amd/declarationsSimpleImport.json
index 41a5dcb845bca..a5aedb2dfbc60 100644
--- a/tests/baselines/reference/project/declarationsSimpleImport/amd/declarationsSimpleImport.json
+++ b/tests/baselines/reference/project/declarationsSimpleImport/amd/declarationsSimpleImport.json
@@ -13,8 +13,8 @@
     ],
     "emittedFiles": [
         "m4.js",
-        "m4.d.ts",
         "useModule.js",
+        "m4.d.ts",
         "useModule.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/declarationsSimpleImport/node/declarationsSimpleImport.json b/tests/baselines/reference/project/declarationsSimpleImport/node/declarationsSimpleImport.json
index 41a5dcb845bca..a5aedb2dfbc60 100644
--- a/tests/baselines/reference/project/declarationsSimpleImport/node/declarationsSimpleImport.json
+++ b/tests/baselines/reference/project/declarationsSimpleImport/node/declarationsSimpleImport.json
@@ -13,8 +13,8 @@
     ],
     "emittedFiles": [
         "m4.js",
-        "m4.d.ts",
         "useModule.js",
+        "m4.d.ts",
         "useModule.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathMixedSubfolderNoOutdir/amd/mapRootAbsolutePathMixedSubfolderNoOutdir.json b/tests/baselines/reference/project/mapRootAbsolutePathMixedSubfolderNoOutdir/amd/mapRootAbsolutePathMixedSubfolderNoOutdir.json
index fa9e0b566a937..287190af76ff9 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathMixedSubfolderNoOutdir/amd/mapRootAbsolutePathMixedSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathMixedSubfolderNoOutdir/amd/mapRootAbsolutePathMixedSubfolderNoOutdir.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "ref/m2.js.map",
         "ref/m2.js",
-        "ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathMixedSubfolderNoOutdir/node/mapRootAbsolutePathMixedSubfolderNoOutdir.json b/tests/baselines/reference/project/mapRootAbsolutePathMixedSubfolderNoOutdir/node/mapRootAbsolutePathMixedSubfolderNoOutdir.json
index fa9e0b566a937..287190af76ff9 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathMixedSubfolderNoOutdir/node/mapRootAbsolutePathMixedSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathMixedSubfolderNoOutdir/node/mapRootAbsolutePathMixedSubfolderNoOutdir.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "ref/m2.js.map",
         "ref/m2.js",
-        "ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathMixedSubfolderSpecifyOutputDirectory/amd/mapRootAbsolutePathMixedSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/mapRootAbsolutePathMixedSubfolderSpecifyOutputDirectory/amd/mapRootAbsolutePathMixedSubfolderSpecifyOutputDirectory.json
index ebaec46d1e3e9..f1487f4e090e0 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathMixedSubfolderSpecifyOutputDirectory/amd/mapRootAbsolutePathMixedSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathMixedSubfolderSpecifyOutputDirectory/amd/mapRootAbsolutePathMixedSubfolderSpecifyOutputDirectory.json
@@ -19,12 +19,12 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/ref/m2.js.map",
         "outdir/simple/ref/m2.js",
-        "outdir/simple/ref/m2.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
+        "outdir/simple/ref/m2.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathMixedSubfolderSpecifyOutputDirectory/node/mapRootAbsolutePathMixedSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/mapRootAbsolutePathMixedSubfolderSpecifyOutputDirectory/node/mapRootAbsolutePathMixedSubfolderSpecifyOutputDirectory.json
index ebaec46d1e3e9..f1487f4e090e0 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathMixedSubfolderSpecifyOutputDirectory/node/mapRootAbsolutePathMixedSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathMixedSubfolderSpecifyOutputDirectory/node/mapRootAbsolutePathMixedSubfolderSpecifyOutputDirectory.json
@@ -19,12 +19,12 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/ref/m2.js.map",
         "outdir/simple/ref/m2.js",
-        "outdir/simple/ref/m2.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
+        "outdir/simple/ref/m2.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathMixedSubfolderSpecifyOutputFile/amd/mapRootAbsolutePathMixedSubfolderSpecifyOutputFile.json b/tests/baselines/reference/project/mapRootAbsolutePathMixedSubfolderSpecifyOutputFile/amd/mapRootAbsolutePathMixedSubfolderSpecifyOutputFile.json
index ee020b0ff8054..b0a62a683b6c7 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathMixedSubfolderSpecifyOutputFile/amd/mapRootAbsolutePathMixedSubfolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathMixedSubfolderSpecifyOutputFile/amd/mapRootAbsolutePathMixedSubfolderSpecifyOutputFile.json
@@ -19,9 +19,9 @@
     "emittedFiles": [
         "ref/m2.js.map",
         "ref/m2.js",
-        "ref/m2.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m2.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathMixedSubfolderSpecifyOutputFile/node/mapRootAbsolutePathMixedSubfolderSpecifyOutputFile.json b/tests/baselines/reference/project/mapRootAbsolutePathMixedSubfolderSpecifyOutputFile/node/mapRootAbsolutePathMixedSubfolderSpecifyOutputFile.json
index ee020b0ff8054..b0a62a683b6c7 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathMixedSubfolderSpecifyOutputFile/node/mapRootAbsolutePathMixedSubfolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathMixedSubfolderSpecifyOutputFile/node/mapRootAbsolutePathMixedSubfolderSpecifyOutputFile.json
@@ -19,9 +19,9 @@
     "emittedFiles": [
         "ref/m2.js.map",
         "ref/m2.js",
-        "ref/m2.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m2.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathMixedSubfolderSpecifyOutputFileAndOutputDirectory/amd/mapRootAbsolutePathMixedSubfolderSpecifyOutputFileAndOutputDirectory.json b/tests/baselines/reference/project/mapRootAbsolutePathMixedSubfolderSpecifyOutputFileAndOutputDirectory/amd/mapRootAbsolutePathMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
index ed7bcd289e722..fca812016902f 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathMixedSubfolderSpecifyOutputFileAndOutputDirectory/amd/mapRootAbsolutePathMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathMixedSubfolderSpecifyOutputFileAndOutputDirectory/amd/mapRootAbsolutePathMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
@@ -20,9 +20,9 @@
     "emittedFiles": [
         "outdir/outAndOutDirFolder/ref/m2.js.map",
         "outdir/outAndOutDirFolder/ref/m2.js",
-        "outdir/outAndOutDirFolder/ref/m2.d.ts",
         "bin/outAndOutDirFile.js.map",
         "bin/outAndOutDirFile.js",
+        "outdir/outAndOutDirFolder/ref/m2.d.ts",
         "bin/outAndOutDirFile.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathMixedSubfolderSpecifyOutputFileAndOutputDirectory/node/mapRootAbsolutePathMixedSubfolderSpecifyOutputFileAndOutputDirectory.json b/tests/baselines/reference/project/mapRootAbsolutePathMixedSubfolderSpecifyOutputFileAndOutputDirectory/node/mapRootAbsolutePathMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
index ed7bcd289e722..fca812016902f 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathMixedSubfolderSpecifyOutputFileAndOutputDirectory/node/mapRootAbsolutePathMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathMixedSubfolderSpecifyOutputFileAndOutputDirectory/node/mapRootAbsolutePathMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
@@ -20,9 +20,9 @@
     "emittedFiles": [
         "outdir/outAndOutDirFolder/ref/m2.js.map",
         "outdir/outAndOutDirFolder/ref/m2.js",
-        "outdir/outAndOutDirFolder/ref/m2.d.ts",
         "bin/outAndOutDirFile.js.map",
         "bin/outAndOutDirFile.js",
+        "outdir/outAndOutDirFolder/ref/m2.d.ts",
         "bin/outAndOutDirFile.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderNoOutdir/amd/mapRootAbsolutePathModuleMultifolderNoOutdir.json b/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderNoOutdir/amd/mapRootAbsolutePathModuleMultifolderNoOutdir.json
index 8f512dcc98c55..52e56e8c428b8 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderNoOutdir/amd/mapRootAbsolutePathModuleMultifolderNoOutdir.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderNoOutdir/amd/mapRootAbsolutePathModuleMultifolderNoOutdir.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_module_multifolder_ref/m2.js.map",
         "../outputdir_module_multifolder_ref/m2.js",
-        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderNoOutdir/node/mapRootAbsolutePathModuleMultifolderNoOutdir.json b/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderNoOutdir/node/mapRootAbsolutePathModuleMultifolderNoOutdir.json
index 8f512dcc98c55..52e56e8c428b8 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderNoOutdir/node/mapRootAbsolutePathModuleMultifolderNoOutdir.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderNoOutdir/node/mapRootAbsolutePathModuleMultifolderNoOutdir.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_module_multifolder_ref/m2.js.map",
         "../outputdir_module_multifolder_ref/m2.js",
-        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputDirectory/amd/mapRootAbsolutePathModuleMultifolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputDirectory/amd/mapRootAbsolutePathModuleMultifolderSpecifyOutputDirectory.json
index 4f65daf7560a9..56f4bc3a45965 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputDirectory/amd/mapRootAbsolutePathModuleMultifolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputDirectory/amd/mapRootAbsolutePathModuleMultifolderSpecifyOutputDirectory.json
@@ -19,12 +19,12 @@
     "emittedFiles": [
         "outdir/simple/outputdir_module_multifolder/ref/m1.js.map",
         "outdir/simple/outputdir_module_multifolder/ref/m1.js",
-        "outdir/simple/outputdir_module_multifolder/ref/m1.d.ts",
         "outdir/simple/outputdir_module_multifolder_ref/m2.js.map",
         "outdir/simple/outputdir_module_multifolder_ref/m2.js",
-        "outdir/simple/outputdir_module_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_module_multifolder/test.js.map",
         "outdir/simple/outputdir_module_multifolder/test.js",
+        "outdir/simple/outputdir_module_multifolder/ref/m1.d.ts",
+        "outdir/simple/outputdir_module_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_module_multifolder/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputDirectory/node/mapRootAbsolutePathModuleMultifolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputDirectory/node/mapRootAbsolutePathModuleMultifolderSpecifyOutputDirectory.json
index 4f65daf7560a9..56f4bc3a45965 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputDirectory/node/mapRootAbsolutePathModuleMultifolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputDirectory/node/mapRootAbsolutePathModuleMultifolderSpecifyOutputDirectory.json
@@ -19,12 +19,12 @@
     "emittedFiles": [
         "outdir/simple/outputdir_module_multifolder/ref/m1.js.map",
         "outdir/simple/outputdir_module_multifolder/ref/m1.js",
-        "outdir/simple/outputdir_module_multifolder/ref/m1.d.ts",
         "outdir/simple/outputdir_module_multifolder_ref/m2.js.map",
         "outdir/simple/outputdir_module_multifolder_ref/m2.js",
-        "outdir/simple/outputdir_module_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_module_multifolder/test.js.map",
         "outdir/simple/outputdir_module_multifolder/test.js",
+        "outdir/simple/outputdir_module_multifolder/ref/m1.d.ts",
+        "outdir/simple/outputdir_module_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_module_multifolder/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile.json b/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile.json
index 6432d5ae91e75..9fd644b9b24b9 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile.json
@@ -19,15 +19,15 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_module_multifolder_ref/m2.js.map",
         "../outputdir_module_multifolder_ref/m2.js",
-        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m1.d.ts",
+        "../outputdir_module_multifolder_ref/m2.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/node/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile.json b/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/node/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile.json
index 6432d5ae91e75..9fd644b9b24b9 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/node/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/node/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile.json
@@ -19,15 +19,15 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_module_multifolder_ref/m2.js.map",
         "../outputdir_module_multifolder_ref/m2.js",
-        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m1.d.ts",
+        "../outputdir_module_multifolder_ref/m2.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathModuleSimpleNoOutdir/amd/mapRootAbsolutePathModuleSimpleNoOutdir.json b/tests/baselines/reference/project/mapRootAbsolutePathModuleSimpleNoOutdir/amd/mapRootAbsolutePathModuleSimpleNoOutdir.json
index 31a0fb89c5026..be3f5dbe8d7c1 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathModuleSimpleNoOutdir/amd/mapRootAbsolutePathModuleSimpleNoOutdir.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathModuleSimpleNoOutdir/amd/mapRootAbsolutePathModuleSimpleNoOutdir.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
+        "m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathModuleSimpleNoOutdir/node/mapRootAbsolutePathModuleSimpleNoOutdir.json b/tests/baselines/reference/project/mapRootAbsolutePathModuleSimpleNoOutdir/node/mapRootAbsolutePathModuleSimpleNoOutdir.json
index 31a0fb89c5026..be3f5dbe8d7c1 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathModuleSimpleNoOutdir/node/mapRootAbsolutePathModuleSimpleNoOutdir.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathModuleSimpleNoOutdir/node/mapRootAbsolutePathModuleSimpleNoOutdir.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
+        "m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathModuleSimpleSpecifyOutputDirectory/amd/mapRootAbsolutePathModuleSimpleSpecifyOutputDirectory.json b/tests/baselines/reference/project/mapRootAbsolutePathModuleSimpleSpecifyOutputDirectory/amd/mapRootAbsolutePathModuleSimpleSpecifyOutputDirectory.json
index 355458526bc92..3f7396e180581 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathModuleSimpleSpecifyOutputDirectory/amd/mapRootAbsolutePathModuleSimpleSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathModuleSimpleSpecifyOutputDirectory/amd/mapRootAbsolutePathModuleSimpleSpecifyOutputDirectory.json
@@ -18,9 +18,9 @@
     "emittedFiles": [
         "outdir/simple/m1.js.map",
         "outdir/simple/m1.js",
-        "outdir/simple/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathModuleSimpleSpecifyOutputDirectory/node/mapRootAbsolutePathModuleSimpleSpecifyOutputDirectory.json b/tests/baselines/reference/project/mapRootAbsolutePathModuleSimpleSpecifyOutputDirectory/node/mapRootAbsolutePathModuleSimpleSpecifyOutputDirectory.json
index 355458526bc92..3f7396e180581 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathModuleSimpleSpecifyOutputDirectory/node/mapRootAbsolutePathModuleSimpleSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathModuleSimpleSpecifyOutputDirectory/node/mapRootAbsolutePathModuleSimpleSpecifyOutputDirectory.json
@@ -18,9 +18,9 @@
     "emittedFiles": [
         "outdir/simple/m1.js.map",
         "outdir/simple/m1.js",
-        "outdir/simple/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathModuleSimpleSpecifyOutputFile/amd/mapRootAbsolutePathModuleSimpleSpecifyOutputFile.json b/tests/baselines/reference/project/mapRootAbsolutePathModuleSimpleSpecifyOutputFile/amd/mapRootAbsolutePathModuleSimpleSpecifyOutputFile.json
index f703a63b71fba..96725033d93e4 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathModuleSimpleSpecifyOutputFile/amd/mapRootAbsolutePathModuleSimpleSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathModuleSimpleSpecifyOutputFile/amd/mapRootAbsolutePathModuleSimpleSpecifyOutputFile.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "m1.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathModuleSimpleSpecifyOutputFile/node/mapRootAbsolutePathModuleSimpleSpecifyOutputFile.json b/tests/baselines/reference/project/mapRootAbsolutePathModuleSimpleSpecifyOutputFile/node/mapRootAbsolutePathModuleSimpleSpecifyOutputFile.json
index f703a63b71fba..96725033d93e4 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathModuleSimpleSpecifyOutputFile/node/mapRootAbsolutePathModuleSimpleSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathModuleSimpleSpecifyOutputFile/node/mapRootAbsolutePathModuleSimpleSpecifyOutputFile.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "m1.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathModuleSubfolderNoOutdir/amd/mapRootAbsolutePathModuleSubfolderNoOutdir.json b/tests/baselines/reference/project/mapRootAbsolutePathModuleSubfolderNoOutdir/amd/mapRootAbsolutePathModuleSubfolderNoOutdir.json
index a6bc71dd664d0..c7b6732d83833 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathModuleSubfolderNoOutdir/amd/mapRootAbsolutePathModuleSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathModuleSubfolderNoOutdir/amd/mapRootAbsolutePathModuleSubfolderNoOutdir.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathModuleSubfolderNoOutdir/node/mapRootAbsolutePathModuleSubfolderNoOutdir.json b/tests/baselines/reference/project/mapRootAbsolutePathModuleSubfolderNoOutdir/node/mapRootAbsolutePathModuleSubfolderNoOutdir.json
index a6bc71dd664d0..c7b6732d83833 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathModuleSubfolderNoOutdir/node/mapRootAbsolutePathModuleSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathModuleSubfolderNoOutdir/node/mapRootAbsolutePathModuleSubfolderNoOutdir.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathModuleSubfolderSpecifyOutputDirectory/amd/mapRootAbsolutePathModuleSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/mapRootAbsolutePathModuleSubfolderSpecifyOutputDirectory/amd/mapRootAbsolutePathModuleSubfolderSpecifyOutputDirectory.json
index e873c8fc472e5..3655926e50b3f 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathModuleSubfolderSpecifyOutputDirectory/amd/mapRootAbsolutePathModuleSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathModuleSubfolderSpecifyOutputDirectory/amd/mapRootAbsolutePathModuleSubfolderSpecifyOutputDirectory.json
@@ -18,9 +18,9 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathModuleSubfolderSpecifyOutputDirectory/node/mapRootAbsolutePathModuleSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/mapRootAbsolutePathModuleSubfolderSpecifyOutputDirectory/node/mapRootAbsolutePathModuleSubfolderSpecifyOutputDirectory.json
index e873c8fc472e5..3655926e50b3f 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathModuleSubfolderSpecifyOutputDirectory/node/mapRootAbsolutePathModuleSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathModuleSubfolderSpecifyOutputDirectory/node/mapRootAbsolutePathModuleSubfolderSpecifyOutputDirectory.json
@@ -18,9 +18,9 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathModuleSubfolderSpecifyOutputFile/amd/mapRootAbsolutePathModuleSubfolderSpecifyOutputFile.json b/tests/baselines/reference/project/mapRootAbsolutePathModuleSubfolderSpecifyOutputFile/amd/mapRootAbsolutePathModuleSubfolderSpecifyOutputFile.json
index d8f4cc74008a0..34682148522eb 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathModuleSubfolderSpecifyOutputFile/amd/mapRootAbsolutePathModuleSubfolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathModuleSubfolderSpecifyOutputFile/amd/mapRootAbsolutePathModuleSubfolderSpecifyOutputFile.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m1.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathModuleSubfolderSpecifyOutputFile/node/mapRootAbsolutePathModuleSubfolderSpecifyOutputFile.json b/tests/baselines/reference/project/mapRootAbsolutePathModuleSubfolderSpecifyOutputFile/node/mapRootAbsolutePathModuleSubfolderSpecifyOutputFile.json
index d8f4cc74008a0..34682148522eb 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathModuleSubfolderSpecifyOutputFile/node/mapRootAbsolutePathModuleSubfolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathModuleSubfolderSpecifyOutputFile/node/mapRootAbsolutePathModuleSubfolderSpecifyOutputFile.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m1.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathMultifolderNoOutdir/amd/mapRootAbsolutePathMultifolderNoOutdir.json b/tests/baselines/reference/project/mapRootAbsolutePathMultifolderNoOutdir/amd/mapRootAbsolutePathMultifolderNoOutdir.json
index 49018ee59734b..1c22575071cc6 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathMultifolderNoOutdir/amd/mapRootAbsolutePathMultifolderNoOutdir.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathMultifolderNoOutdir/amd/mapRootAbsolutePathMultifolderNoOutdir.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_multifolder_ref/m2.js.map",
         "../outputdir_multifolder_ref/m2.js",
-        "../outputdir_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "../outputdir_multifolder_ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathMultifolderNoOutdir/node/mapRootAbsolutePathMultifolderNoOutdir.json b/tests/baselines/reference/project/mapRootAbsolutePathMultifolderNoOutdir/node/mapRootAbsolutePathMultifolderNoOutdir.json
index 49018ee59734b..1c22575071cc6 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathMultifolderNoOutdir/node/mapRootAbsolutePathMultifolderNoOutdir.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathMultifolderNoOutdir/node/mapRootAbsolutePathMultifolderNoOutdir.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_multifolder_ref/m2.js.map",
         "../outputdir_multifolder_ref/m2.js",
-        "../outputdir_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "../outputdir_multifolder_ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathMultifolderSpecifyOutputDirectory/amd/mapRootAbsolutePathMultifolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/mapRootAbsolutePathMultifolderSpecifyOutputDirectory/amd/mapRootAbsolutePathMultifolderSpecifyOutputDirectory.json
index 097c9bbf2097c..6fb90b9f9296d 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathMultifolderSpecifyOutputDirectory/amd/mapRootAbsolutePathMultifolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathMultifolderSpecifyOutputDirectory/amd/mapRootAbsolutePathMultifolderSpecifyOutputDirectory.json
@@ -19,12 +19,12 @@
     "emittedFiles": [
         "outdir/simple/outputdir_multifolder/ref/m1.js.map",
         "outdir/simple/outputdir_multifolder/ref/m1.js",
-        "outdir/simple/outputdir_multifolder/ref/m1.d.ts",
         "outdir/simple/outputdir_multifolder_ref/m2.js.map",
         "outdir/simple/outputdir_multifolder_ref/m2.js",
-        "outdir/simple/outputdir_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_multifolder/test.js.map",
         "outdir/simple/outputdir_multifolder/test.js",
+        "outdir/simple/outputdir_multifolder/ref/m1.d.ts",
+        "outdir/simple/outputdir_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_multifolder/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathMultifolderSpecifyOutputDirectory/node/mapRootAbsolutePathMultifolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/mapRootAbsolutePathMultifolderSpecifyOutputDirectory/node/mapRootAbsolutePathMultifolderSpecifyOutputDirectory.json
index 097c9bbf2097c..6fb90b9f9296d 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathMultifolderSpecifyOutputDirectory/node/mapRootAbsolutePathMultifolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathMultifolderSpecifyOutputDirectory/node/mapRootAbsolutePathMultifolderSpecifyOutputDirectory.json
@@ -19,12 +19,12 @@
     "emittedFiles": [
         "outdir/simple/outputdir_multifolder/ref/m1.js.map",
         "outdir/simple/outputdir_multifolder/ref/m1.js",
-        "outdir/simple/outputdir_multifolder/ref/m1.d.ts",
         "outdir/simple/outputdir_multifolder_ref/m2.js.map",
         "outdir/simple/outputdir_multifolder_ref/m2.js",
-        "outdir/simple/outputdir_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_multifolder/test.js.map",
         "outdir/simple/outputdir_multifolder/test.js",
+        "outdir/simple/outputdir_multifolder/ref/m1.d.ts",
+        "outdir/simple/outputdir_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_multifolder/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathSimpleNoOutdir/amd/mapRootAbsolutePathSimpleNoOutdir.json b/tests/baselines/reference/project/mapRootAbsolutePathSimpleNoOutdir/amd/mapRootAbsolutePathSimpleNoOutdir.json
index d5914d929503b..9f72eef5ff4d5 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathSimpleNoOutdir/amd/mapRootAbsolutePathSimpleNoOutdir.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathSimpleNoOutdir/amd/mapRootAbsolutePathSimpleNoOutdir.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
+        "m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathSimpleNoOutdir/node/mapRootAbsolutePathSimpleNoOutdir.json b/tests/baselines/reference/project/mapRootAbsolutePathSimpleNoOutdir/node/mapRootAbsolutePathSimpleNoOutdir.json
index d5914d929503b..9f72eef5ff4d5 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathSimpleNoOutdir/node/mapRootAbsolutePathSimpleNoOutdir.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathSimpleNoOutdir/node/mapRootAbsolutePathSimpleNoOutdir.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
+        "m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathSimpleSpecifyOutputDirectory/amd/mapRootAbsolutePathSimpleSpecifyOutputDirectory.json b/tests/baselines/reference/project/mapRootAbsolutePathSimpleSpecifyOutputDirectory/amd/mapRootAbsolutePathSimpleSpecifyOutputDirectory.json
index 2c5e1dae38a29..e961add7da7b7 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathSimpleSpecifyOutputDirectory/amd/mapRootAbsolutePathSimpleSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathSimpleSpecifyOutputDirectory/amd/mapRootAbsolutePathSimpleSpecifyOutputDirectory.json
@@ -18,9 +18,9 @@
     "emittedFiles": [
         "outdir/simple/m1.js.map",
         "outdir/simple/m1.js",
-        "outdir/simple/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathSimpleSpecifyOutputDirectory/node/mapRootAbsolutePathSimpleSpecifyOutputDirectory.json b/tests/baselines/reference/project/mapRootAbsolutePathSimpleSpecifyOutputDirectory/node/mapRootAbsolutePathSimpleSpecifyOutputDirectory.json
index 2c5e1dae38a29..e961add7da7b7 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathSimpleSpecifyOutputDirectory/node/mapRootAbsolutePathSimpleSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathSimpleSpecifyOutputDirectory/node/mapRootAbsolutePathSimpleSpecifyOutputDirectory.json
@@ -18,9 +18,9 @@
     "emittedFiles": [
         "outdir/simple/m1.js.map",
         "outdir/simple/m1.js",
-        "outdir/simple/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathSubfolderNoOutdir/amd/mapRootAbsolutePathSubfolderNoOutdir.json b/tests/baselines/reference/project/mapRootAbsolutePathSubfolderNoOutdir/amd/mapRootAbsolutePathSubfolderNoOutdir.json
index 1b09decc58d02..6236d59130c6c 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathSubfolderNoOutdir/amd/mapRootAbsolutePathSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathSubfolderNoOutdir/amd/mapRootAbsolutePathSubfolderNoOutdir.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathSubfolderNoOutdir/node/mapRootAbsolutePathSubfolderNoOutdir.json b/tests/baselines/reference/project/mapRootAbsolutePathSubfolderNoOutdir/node/mapRootAbsolutePathSubfolderNoOutdir.json
index 1b09decc58d02..6236d59130c6c 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathSubfolderNoOutdir/node/mapRootAbsolutePathSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathSubfolderNoOutdir/node/mapRootAbsolutePathSubfolderNoOutdir.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathSubfolderSpecifyOutputDirectory/amd/mapRootAbsolutePathSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/mapRootAbsolutePathSubfolderSpecifyOutputDirectory/amd/mapRootAbsolutePathSubfolderSpecifyOutputDirectory.json
index a02eb484aa248..a13b299509303 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathSubfolderSpecifyOutputDirectory/amd/mapRootAbsolutePathSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathSubfolderSpecifyOutputDirectory/amd/mapRootAbsolutePathSubfolderSpecifyOutputDirectory.json
@@ -18,9 +18,9 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootAbsolutePathSubfolderSpecifyOutputDirectory/node/mapRootAbsolutePathSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/mapRootAbsolutePathSubfolderSpecifyOutputDirectory/node/mapRootAbsolutePathSubfolderSpecifyOutputDirectory.json
index a02eb484aa248..a13b299509303 100644
--- a/tests/baselines/reference/project/mapRootAbsolutePathSubfolderSpecifyOutputDirectory/node/mapRootAbsolutePathSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/mapRootAbsolutePathSubfolderSpecifyOutputDirectory/node/mapRootAbsolutePathSubfolderSpecifyOutputDirectory.json
@@ -18,9 +18,9 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathMixedSubfolderNoOutdir/amd/mapRootRelativePathMixedSubfolderNoOutdir.json b/tests/baselines/reference/project/mapRootRelativePathMixedSubfolderNoOutdir/amd/mapRootRelativePathMixedSubfolderNoOutdir.json
index 5352fd8a988f2..c46a4d9d7e6f7 100644
--- a/tests/baselines/reference/project/mapRootRelativePathMixedSubfolderNoOutdir/amd/mapRootRelativePathMixedSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/mapRootRelativePathMixedSubfolderNoOutdir/amd/mapRootRelativePathMixedSubfolderNoOutdir.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "ref/m2.js.map",
         "ref/m2.js",
-        "ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathMixedSubfolderNoOutdir/node/mapRootRelativePathMixedSubfolderNoOutdir.json b/tests/baselines/reference/project/mapRootRelativePathMixedSubfolderNoOutdir/node/mapRootRelativePathMixedSubfolderNoOutdir.json
index 5352fd8a988f2..c46a4d9d7e6f7 100644
--- a/tests/baselines/reference/project/mapRootRelativePathMixedSubfolderNoOutdir/node/mapRootRelativePathMixedSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/mapRootRelativePathMixedSubfolderNoOutdir/node/mapRootRelativePathMixedSubfolderNoOutdir.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "ref/m2.js.map",
         "ref/m2.js",
-        "ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathMixedSubfolderSpecifyOutputDirectory/amd/mapRootRelativePathMixedSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/mapRootRelativePathMixedSubfolderSpecifyOutputDirectory/amd/mapRootRelativePathMixedSubfolderSpecifyOutputDirectory.json
index 0a0d68e300a05..c915bd08081b7 100644
--- a/tests/baselines/reference/project/mapRootRelativePathMixedSubfolderSpecifyOutputDirectory/amd/mapRootRelativePathMixedSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/mapRootRelativePathMixedSubfolderSpecifyOutputDirectory/amd/mapRootRelativePathMixedSubfolderSpecifyOutputDirectory.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/ref/m2.js.map",
         "outdir/simple/ref/m2.js",
-        "outdir/simple/ref/m2.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
+        "outdir/simple/ref/m2.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathMixedSubfolderSpecifyOutputDirectory/node/mapRootRelativePathMixedSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/mapRootRelativePathMixedSubfolderSpecifyOutputDirectory/node/mapRootRelativePathMixedSubfolderSpecifyOutputDirectory.json
index 0a0d68e300a05..c915bd08081b7 100644
--- a/tests/baselines/reference/project/mapRootRelativePathMixedSubfolderSpecifyOutputDirectory/node/mapRootRelativePathMixedSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/mapRootRelativePathMixedSubfolderSpecifyOutputDirectory/node/mapRootRelativePathMixedSubfolderSpecifyOutputDirectory.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/ref/m2.js.map",
         "outdir/simple/ref/m2.js",
-        "outdir/simple/ref/m2.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
+        "outdir/simple/ref/m2.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathMixedSubfolderSpecifyOutputFile/amd/mapRootRelativePathMixedSubfolderSpecifyOutputFile.json b/tests/baselines/reference/project/mapRootRelativePathMixedSubfolderSpecifyOutputFile/amd/mapRootRelativePathMixedSubfolderSpecifyOutputFile.json
index 8e87f61b8df1b..d8f1ebca2062a 100644
--- a/tests/baselines/reference/project/mapRootRelativePathMixedSubfolderSpecifyOutputFile/amd/mapRootRelativePathMixedSubfolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/mapRootRelativePathMixedSubfolderSpecifyOutputFile/amd/mapRootRelativePathMixedSubfolderSpecifyOutputFile.json
@@ -18,9 +18,9 @@
     "emittedFiles": [
         "ref/m2.js.map",
         "ref/m2.js",
-        "ref/m2.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m2.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathMixedSubfolderSpecifyOutputFile/node/mapRootRelativePathMixedSubfolderSpecifyOutputFile.json b/tests/baselines/reference/project/mapRootRelativePathMixedSubfolderSpecifyOutputFile/node/mapRootRelativePathMixedSubfolderSpecifyOutputFile.json
index 8e87f61b8df1b..d8f1ebca2062a 100644
--- a/tests/baselines/reference/project/mapRootRelativePathMixedSubfolderSpecifyOutputFile/node/mapRootRelativePathMixedSubfolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/mapRootRelativePathMixedSubfolderSpecifyOutputFile/node/mapRootRelativePathMixedSubfolderSpecifyOutputFile.json
@@ -18,9 +18,9 @@
     "emittedFiles": [
         "ref/m2.js.map",
         "ref/m2.js",
-        "ref/m2.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m2.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathMixedSubfolderSpecifyOutputFileAndOutputDirectory/amd/mapRootRelativePathMixedSubfolderSpecifyOutputFileAndOutputDirectory.json b/tests/baselines/reference/project/mapRootRelativePathMixedSubfolderSpecifyOutputFileAndOutputDirectory/amd/mapRootRelativePathMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
index 4ed441e255240..35ae232af110f 100644
--- a/tests/baselines/reference/project/mapRootRelativePathMixedSubfolderSpecifyOutputFileAndOutputDirectory/amd/mapRootRelativePathMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
+++ b/tests/baselines/reference/project/mapRootRelativePathMixedSubfolderSpecifyOutputFileAndOutputDirectory/amd/mapRootRelativePathMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
@@ -19,9 +19,9 @@
     "emittedFiles": [
         "outdir/outAndOutDirFolder/ref/m2.js.map",
         "outdir/outAndOutDirFolder/ref/m2.js",
-        "outdir/outAndOutDirFolder/ref/m2.d.ts",
         "bin/outAndOutDirFile.js.map",
         "bin/outAndOutDirFile.js",
+        "outdir/outAndOutDirFolder/ref/m2.d.ts",
         "bin/outAndOutDirFile.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathMixedSubfolderSpecifyOutputFileAndOutputDirectory/node/mapRootRelativePathMixedSubfolderSpecifyOutputFileAndOutputDirectory.json b/tests/baselines/reference/project/mapRootRelativePathMixedSubfolderSpecifyOutputFileAndOutputDirectory/node/mapRootRelativePathMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
index 4ed441e255240..35ae232af110f 100644
--- a/tests/baselines/reference/project/mapRootRelativePathMixedSubfolderSpecifyOutputFileAndOutputDirectory/node/mapRootRelativePathMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
+++ b/tests/baselines/reference/project/mapRootRelativePathMixedSubfolderSpecifyOutputFileAndOutputDirectory/node/mapRootRelativePathMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
@@ -19,9 +19,9 @@
     "emittedFiles": [
         "outdir/outAndOutDirFolder/ref/m2.js.map",
         "outdir/outAndOutDirFolder/ref/m2.js",
-        "outdir/outAndOutDirFolder/ref/m2.d.ts",
         "bin/outAndOutDirFile.js.map",
         "bin/outAndOutDirFile.js",
+        "outdir/outAndOutDirFolder/ref/m2.d.ts",
         "bin/outAndOutDirFile.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderNoOutdir/amd/mapRootRelativePathModuleMultifolderNoOutdir.json b/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderNoOutdir/amd/mapRootRelativePathModuleMultifolderNoOutdir.json
index 8ec143b2dce59..2c404cc0b3a57 100644
--- a/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderNoOutdir/amd/mapRootRelativePathModuleMultifolderNoOutdir.json
+++ b/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderNoOutdir/amd/mapRootRelativePathModuleMultifolderNoOutdir.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_module_multifolder_ref/m2.js.map",
         "../outputdir_module_multifolder_ref/m2.js",
-        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderNoOutdir/node/mapRootRelativePathModuleMultifolderNoOutdir.json b/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderNoOutdir/node/mapRootRelativePathModuleMultifolderNoOutdir.json
index 8ec143b2dce59..2c404cc0b3a57 100644
--- a/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderNoOutdir/node/mapRootRelativePathModuleMultifolderNoOutdir.json
+++ b/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderNoOutdir/node/mapRootRelativePathModuleMultifolderNoOutdir.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_module_multifolder_ref/m2.js.map",
         "../outputdir_module_multifolder_ref/m2.js",
-        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputDirectory/amd/mapRootRelativePathModuleMultifolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputDirectory/amd/mapRootRelativePathModuleMultifolderSpecifyOutputDirectory.json
index 96777b6f502f6..a11b414f131c2 100644
--- a/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputDirectory/amd/mapRootRelativePathModuleMultifolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputDirectory/amd/mapRootRelativePathModuleMultifolderSpecifyOutputDirectory.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "outdir/simple/outputdir_module_multifolder/ref/m1.js.map",
         "outdir/simple/outputdir_module_multifolder/ref/m1.js",
-        "outdir/simple/outputdir_module_multifolder/ref/m1.d.ts",
         "outdir/simple/outputdir_module_multifolder_ref/m2.js.map",
         "outdir/simple/outputdir_module_multifolder_ref/m2.js",
-        "outdir/simple/outputdir_module_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_module_multifolder/test.js.map",
         "outdir/simple/outputdir_module_multifolder/test.js",
+        "outdir/simple/outputdir_module_multifolder/ref/m1.d.ts",
+        "outdir/simple/outputdir_module_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_module_multifolder/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputDirectory/node/mapRootRelativePathModuleMultifolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputDirectory/node/mapRootRelativePathModuleMultifolderSpecifyOutputDirectory.json
index 96777b6f502f6..a11b414f131c2 100644
--- a/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputDirectory/node/mapRootRelativePathModuleMultifolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputDirectory/node/mapRootRelativePathModuleMultifolderSpecifyOutputDirectory.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "outdir/simple/outputdir_module_multifolder/ref/m1.js.map",
         "outdir/simple/outputdir_module_multifolder/ref/m1.js",
-        "outdir/simple/outputdir_module_multifolder/ref/m1.d.ts",
         "outdir/simple/outputdir_module_multifolder_ref/m2.js.map",
         "outdir/simple/outputdir_module_multifolder_ref/m2.js",
-        "outdir/simple/outputdir_module_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_module_multifolder/test.js.map",
         "outdir/simple/outputdir_module_multifolder/test.js",
+        "outdir/simple/outputdir_module_multifolder/ref/m1.d.ts",
+        "outdir/simple/outputdir_module_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_module_multifolder/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/amd/mapRootRelativePathModuleMultifolderSpecifyOutputFile.json b/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/amd/mapRootRelativePathModuleMultifolderSpecifyOutputFile.json
index f3c86f22eb74d..2df5007b7bc58 100644
--- a/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/amd/mapRootRelativePathModuleMultifolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/amd/mapRootRelativePathModuleMultifolderSpecifyOutputFile.json
@@ -18,15 +18,15 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_module_multifolder_ref/m2.js.map",
         "../outputdir_module_multifolder_ref/m2.js",
-        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m1.d.ts",
+        "../outputdir_module_multifolder_ref/m2.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/node/mapRootRelativePathModuleMultifolderSpecifyOutputFile.json b/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/node/mapRootRelativePathModuleMultifolderSpecifyOutputFile.json
index f3c86f22eb74d..2df5007b7bc58 100644
--- a/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/node/mapRootRelativePathModuleMultifolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/node/mapRootRelativePathModuleMultifolderSpecifyOutputFile.json
@@ -18,15 +18,15 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_module_multifolder_ref/m2.js.map",
         "../outputdir_module_multifolder_ref/m2.js",
-        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m1.d.ts",
+        "../outputdir_module_multifolder_ref/m2.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathModuleSimpleNoOutdir/amd/mapRootRelativePathModuleSimpleNoOutdir.json b/tests/baselines/reference/project/mapRootRelativePathModuleSimpleNoOutdir/amd/mapRootRelativePathModuleSimpleNoOutdir.json
index a4e8c09b004df..8edab343aee8d 100644
--- a/tests/baselines/reference/project/mapRootRelativePathModuleSimpleNoOutdir/amd/mapRootRelativePathModuleSimpleNoOutdir.json
+++ b/tests/baselines/reference/project/mapRootRelativePathModuleSimpleNoOutdir/amd/mapRootRelativePathModuleSimpleNoOutdir.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
+        "m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathModuleSimpleNoOutdir/node/mapRootRelativePathModuleSimpleNoOutdir.json b/tests/baselines/reference/project/mapRootRelativePathModuleSimpleNoOutdir/node/mapRootRelativePathModuleSimpleNoOutdir.json
index a4e8c09b004df..8edab343aee8d 100644
--- a/tests/baselines/reference/project/mapRootRelativePathModuleSimpleNoOutdir/node/mapRootRelativePathModuleSimpleNoOutdir.json
+++ b/tests/baselines/reference/project/mapRootRelativePathModuleSimpleNoOutdir/node/mapRootRelativePathModuleSimpleNoOutdir.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
+        "m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathModuleSimpleSpecifyOutputDirectory/amd/mapRootRelativePathModuleSimpleSpecifyOutputDirectory.json b/tests/baselines/reference/project/mapRootRelativePathModuleSimpleSpecifyOutputDirectory/amd/mapRootRelativePathModuleSimpleSpecifyOutputDirectory.json
index f4a8884b58eea..075e031bb4e78 100644
--- a/tests/baselines/reference/project/mapRootRelativePathModuleSimpleSpecifyOutputDirectory/amd/mapRootRelativePathModuleSimpleSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/mapRootRelativePathModuleSimpleSpecifyOutputDirectory/amd/mapRootRelativePathModuleSimpleSpecifyOutputDirectory.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "outdir/simple/m1.js.map",
         "outdir/simple/m1.js",
-        "outdir/simple/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathModuleSimpleSpecifyOutputDirectory/node/mapRootRelativePathModuleSimpleSpecifyOutputDirectory.json b/tests/baselines/reference/project/mapRootRelativePathModuleSimpleSpecifyOutputDirectory/node/mapRootRelativePathModuleSimpleSpecifyOutputDirectory.json
index f4a8884b58eea..075e031bb4e78 100644
--- a/tests/baselines/reference/project/mapRootRelativePathModuleSimpleSpecifyOutputDirectory/node/mapRootRelativePathModuleSimpleSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/mapRootRelativePathModuleSimpleSpecifyOutputDirectory/node/mapRootRelativePathModuleSimpleSpecifyOutputDirectory.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "outdir/simple/m1.js.map",
         "outdir/simple/m1.js",
-        "outdir/simple/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathModuleSimpleSpecifyOutputFile/amd/mapRootRelativePathModuleSimpleSpecifyOutputFile.json b/tests/baselines/reference/project/mapRootRelativePathModuleSimpleSpecifyOutputFile/amd/mapRootRelativePathModuleSimpleSpecifyOutputFile.json
index fe0b8045a5c17..ba07cb6a8bfb4 100644
--- a/tests/baselines/reference/project/mapRootRelativePathModuleSimpleSpecifyOutputFile/amd/mapRootRelativePathModuleSimpleSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/mapRootRelativePathModuleSimpleSpecifyOutputFile/amd/mapRootRelativePathModuleSimpleSpecifyOutputFile.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "m1.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathModuleSimpleSpecifyOutputFile/node/mapRootRelativePathModuleSimpleSpecifyOutputFile.json b/tests/baselines/reference/project/mapRootRelativePathModuleSimpleSpecifyOutputFile/node/mapRootRelativePathModuleSimpleSpecifyOutputFile.json
index fe0b8045a5c17..ba07cb6a8bfb4 100644
--- a/tests/baselines/reference/project/mapRootRelativePathModuleSimpleSpecifyOutputFile/node/mapRootRelativePathModuleSimpleSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/mapRootRelativePathModuleSimpleSpecifyOutputFile/node/mapRootRelativePathModuleSimpleSpecifyOutputFile.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "m1.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathModuleSubfolderNoOutdir/amd/mapRootRelativePathModuleSubfolderNoOutdir.json b/tests/baselines/reference/project/mapRootRelativePathModuleSubfolderNoOutdir/amd/mapRootRelativePathModuleSubfolderNoOutdir.json
index a2779060068a2..fb31913e6b108 100644
--- a/tests/baselines/reference/project/mapRootRelativePathModuleSubfolderNoOutdir/amd/mapRootRelativePathModuleSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/mapRootRelativePathModuleSubfolderNoOutdir/amd/mapRootRelativePathModuleSubfolderNoOutdir.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathModuleSubfolderNoOutdir/node/mapRootRelativePathModuleSubfolderNoOutdir.json b/tests/baselines/reference/project/mapRootRelativePathModuleSubfolderNoOutdir/node/mapRootRelativePathModuleSubfolderNoOutdir.json
index a2779060068a2..fb31913e6b108 100644
--- a/tests/baselines/reference/project/mapRootRelativePathModuleSubfolderNoOutdir/node/mapRootRelativePathModuleSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/mapRootRelativePathModuleSubfolderNoOutdir/node/mapRootRelativePathModuleSubfolderNoOutdir.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathModuleSubfolderSpecifyOutputDirectory/amd/mapRootRelativePathModuleSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/mapRootRelativePathModuleSubfolderSpecifyOutputDirectory/amd/mapRootRelativePathModuleSubfolderSpecifyOutputDirectory.json
index 120bb5afbb6ea..a28ffcfea2006 100644
--- a/tests/baselines/reference/project/mapRootRelativePathModuleSubfolderSpecifyOutputDirectory/amd/mapRootRelativePathModuleSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/mapRootRelativePathModuleSubfolderSpecifyOutputDirectory/amd/mapRootRelativePathModuleSubfolderSpecifyOutputDirectory.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathModuleSubfolderSpecifyOutputDirectory/node/mapRootRelativePathModuleSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/mapRootRelativePathModuleSubfolderSpecifyOutputDirectory/node/mapRootRelativePathModuleSubfolderSpecifyOutputDirectory.json
index 120bb5afbb6ea..a28ffcfea2006 100644
--- a/tests/baselines/reference/project/mapRootRelativePathModuleSubfolderSpecifyOutputDirectory/node/mapRootRelativePathModuleSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/mapRootRelativePathModuleSubfolderSpecifyOutputDirectory/node/mapRootRelativePathModuleSubfolderSpecifyOutputDirectory.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathModuleSubfolderSpecifyOutputFile/amd/mapRootRelativePathModuleSubfolderSpecifyOutputFile.json b/tests/baselines/reference/project/mapRootRelativePathModuleSubfolderSpecifyOutputFile/amd/mapRootRelativePathModuleSubfolderSpecifyOutputFile.json
index a87c7d36d8ede..afac8a4f153b6 100644
--- a/tests/baselines/reference/project/mapRootRelativePathModuleSubfolderSpecifyOutputFile/amd/mapRootRelativePathModuleSubfolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/mapRootRelativePathModuleSubfolderSpecifyOutputFile/amd/mapRootRelativePathModuleSubfolderSpecifyOutputFile.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m1.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathModuleSubfolderSpecifyOutputFile/node/mapRootRelativePathModuleSubfolderSpecifyOutputFile.json b/tests/baselines/reference/project/mapRootRelativePathModuleSubfolderSpecifyOutputFile/node/mapRootRelativePathModuleSubfolderSpecifyOutputFile.json
index a87c7d36d8ede..afac8a4f153b6 100644
--- a/tests/baselines/reference/project/mapRootRelativePathModuleSubfolderSpecifyOutputFile/node/mapRootRelativePathModuleSubfolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/mapRootRelativePathModuleSubfolderSpecifyOutputFile/node/mapRootRelativePathModuleSubfolderSpecifyOutputFile.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m1.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathMultifolderNoOutdir/amd/mapRootRelativePathMultifolderNoOutdir.json b/tests/baselines/reference/project/mapRootRelativePathMultifolderNoOutdir/amd/mapRootRelativePathMultifolderNoOutdir.json
index 718cfdabf0f08..29c1ef818399f 100644
--- a/tests/baselines/reference/project/mapRootRelativePathMultifolderNoOutdir/amd/mapRootRelativePathMultifolderNoOutdir.json
+++ b/tests/baselines/reference/project/mapRootRelativePathMultifolderNoOutdir/amd/mapRootRelativePathMultifolderNoOutdir.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_multifolder_ref/m2.js.map",
         "../outputdir_multifolder_ref/m2.js",
-        "../outputdir_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "../outputdir_multifolder_ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathMultifolderNoOutdir/node/mapRootRelativePathMultifolderNoOutdir.json b/tests/baselines/reference/project/mapRootRelativePathMultifolderNoOutdir/node/mapRootRelativePathMultifolderNoOutdir.json
index 718cfdabf0f08..29c1ef818399f 100644
--- a/tests/baselines/reference/project/mapRootRelativePathMultifolderNoOutdir/node/mapRootRelativePathMultifolderNoOutdir.json
+++ b/tests/baselines/reference/project/mapRootRelativePathMultifolderNoOutdir/node/mapRootRelativePathMultifolderNoOutdir.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_multifolder_ref/m2.js.map",
         "../outputdir_multifolder_ref/m2.js",
-        "../outputdir_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "../outputdir_multifolder_ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathMultifolderSpecifyOutputDirectory/amd/mapRootRelativePathMultifolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/mapRootRelativePathMultifolderSpecifyOutputDirectory/amd/mapRootRelativePathMultifolderSpecifyOutputDirectory.json
index f51e53f02f6e7..b64fe05673d43 100644
--- a/tests/baselines/reference/project/mapRootRelativePathMultifolderSpecifyOutputDirectory/amd/mapRootRelativePathMultifolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/mapRootRelativePathMultifolderSpecifyOutputDirectory/amd/mapRootRelativePathMultifolderSpecifyOutputDirectory.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "outdir/simple/outputdir_multifolder/ref/m1.js.map",
         "outdir/simple/outputdir_multifolder/ref/m1.js",
-        "outdir/simple/outputdir_multifolder/ref/m1.d.ts",
         "outdir/simple/outputdir_multifolder_ref/m2.js.map",
         "outdir/simple/outputdir_multifolder_ref/m2.js",
-        "outdir/simple/outputdir_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_multifolder/test.js.map",
         "outdir/simple/outputdir_multifolder/test.js",
+        "outdir/simple/outputdir_multifolder/ref/m1.d.ts",
+        "outdir/simple/outputdir_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_multifolder/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathMultifolderSpecifyOutputDirectory/node/mapRootRelativePathMultifolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/mapRootRelativePathMultifolderSpecifyOutputDirectory/node/mapRootRelativePathMultifolderSpecifyOutputDirectory.json
index f51e53f02f6e7..b64fe05673d43 100644
--- a/tests/baselines/reference/project/mapRootRelativePathMultifolderSpecifyOutputDirectory/node/mapRootRelativePathMultifolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/mapRootRelativePathMultifolderSpecifyOutputDirectory/node/mapRootRelativePathMultifolderSpecifyOutputDirectory.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "outdir/simple/outputdir_multifolder/ref/m1.js.map",
         "outdir/simple/outputdir_multifolder/ref/m1.js",
-        "outdir/simple/outputdir_multifolder/ref/m1.d.ts",
         "outdir/simple/outputdir_multifolder_ref/m2.js.map",
         "outdir/simple/outputdir_multifolder_ref/m2.js",
-        "outdir/simple/outputdir_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_multifolder/test.js.map",
         "outdir/simple/outputdir_multifolder/test.js",
+        "outdir/simple/outputdir_multifolder/ref/m1.d.ts",
+        "outdir/simple/outputdir_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_multifolder/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathSimpleNoOutdir/amd/mapRootRelativePathSimpleNoOutdir.json b/tests/baselines/reference/project/mapRootRelativePathSimpleNoOutdir/amd/mapRootRelativePathSimpleNoOutdir.json
index d4d500a397e17..a8174fcfa644b 100644
--- a/tests/baselines/reference/project/mapRootRelativePathSimpleNoOutdir/amd/mapRootRelativePathSimpleNoOutdir.json
+++ b/tests/baselines/reference/project/mapRootRelativePathSimpleNoOutdir/amd/mapRootRelativePathSimpleNoOutdir.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
+        "m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathSimpleNoOutdir/node/mapRootRelativePathSimpleNoOutdir.json b/tests/baselines/reference/project/mapRootRelativePathSimpleNoOutdir/node/mapRootRelativePathSimpleNoOutdir.json
index d4d500a397e17..a8174fcfa644b 100644
--- a/tests/baselines/reference/project/mapRootRelativePathSimpleNoOutdir/node/mapRootRelativePathSimpleNoOutdir.json
+++ b/tests/baselines/reference/project/mapRootRelativePathSimpleNoOutdir/node/mapRootRelativePathSimpleNoOutdir.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
+        "m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathSimpleSpecifyOutputDirectory/amd/mapRootRelativePathSimpleSpecifyOutputDirectory.json b/tests/baselines/reference/project/mapRootRelativePathSimpleSpecifyOutputDirectory/amd/mapRootRelativePathSimpleSpecifyOutputDirectory.json
index 12801537d2bdf..c97cd8feb865a 100644
--- a/tests/baselines/reference/project/mapRootRelativePathSimpleSpecifyOutputDirectory/amd/mapRootRelativePathSimpleSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/mapRootRelativePathSimpleSpecifyOutputDirectory/amd/mapRootRelativePathSimpleSpecifyOutputDirectory.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "outdir/simple/m1.js.map",
         "outdir/simple/m1.js",
-        "outdir/simple/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathSimpleSpecifyOutputDirectory/node/mapRootRelativePathSimpleSpecifyOutputDirectory.json b/tests/baselines/reference/project/mapRootRelativePathSimpleSpecifyOutputDirectory/node/mapRootRelativePathSimpleSpecifyOutputDirectory.json
index 12801537d2bdf..c97cd8feb865a 100644
--- a/tests/baselines/reference/project/mapRootRelativePathSimpleSpecifyOutputDirectory/node/mapRootRelativePathSimpleSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/mapRootRelativePathSimpleSpecifyOutputDirectory/node/mapRootRelativePathSimpleSpecifyOutputDirectory.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "outdir/simple/m1.js.map",
         "outdir/simple/m1.js",
-        "outdir/simple/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathSubfolderNoOutdir/amd/mapRootRelativePathSubfolderNoOutdir.json b/tests/baselines/reference/project/mapRootRelativePathSubfolderNoOutdir/amd/mapRootRelativePathSubfolderNoOutdir.json
index b5b1dfba62eea..f801748956f46 100644
--- a/tests/baselines/reference/project/mapRootRelativePathSubfolderNoOutdir/amd/mapRootRelativePathSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/mapRootRelativePathSubfolderNoOutdir/amd/mapRootRelativePathSubfolderNoOutdir.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathSubfolderNoOutdir/node/mapRootRelativePathSubfolderNoOutdir.json b/tests/baselines/reference/project/mapRootRelativePathSubfolderNoOutdir/node/mapRootRelativePathSubfolderNoOutdir.json
index b5b1dfba62eea..f801748956f46 100644
--- a/tests/baselines/reference/project/mapRootRelativePathSubfolderNoOutdir/node/mapRootRelativePathSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/mapRootRelativePathSubfolderNoOutdir/node/mapRootRelativePathSubfolderNoOutdir.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathSubfolderSpecifyOutputDirectory/amd/mapRootRelativePathSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/mapRootRelativePathSubfolderSpecifyOutputDirectory/amd/mapRootRelativePathSubfolderSpecifyOutputDirectory.json
index a06e2f34d5ac5..721bb91e48505 100644
--- a/tests/baselines/reference/project/mapRootRelativePathSubfolderSpecifyOutputDirectory/amd/mapRootRelativePathSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/mapRootRelativePathSubfolderSpecifyOutputDirectory/amd/mapRootRelativePathSubfolderSpecifyOutputDirectory.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/mapRootRelativePathSubfolderSpecifyOutputDirectory/node/mapRootRelativePathSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/mapRootRelativePathSubfolderSpecifyOutputDirectory/node/mapRootRelativePathSubfolderSpecifyOutputDirectory.json
index a06e2f34d5ac5..721bb91e48505 100644
--- a/tests/baselines/reference/project/mapRootRelativePathSubfolderSpecifyOutputDirectory/node/mapRootRelativePathSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/mapRootRelativePathSubfolderSpecifyOutputDirectory/node/mapRootRelativePathSubfolderSpecifyOutputDirectory.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlMixedSubfolderNoOutdir/amd/maprootUrlMixedSubfolderNoOutdir.json b/tests/baselines/reference/project/maprootUrlMixedSubfolderNoOutdir/amd/maprootUrlMixedSubfolderNoOutdir.json
index c661284121066..bb402d3387bf2 100644
--- a/tests/baselines/reference/project/maprootUrlMixedSubfolderNoOutdir/amd/maprootUrlMixedSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/maprootUrlMixedSubfolderNoOutdir/amd/maprootUrlMixedSubfolderNoOutdir.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "ref/m2.js.map",
         "ref/m2.js",
-        "ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlMixedSubfolderNoOutdir/node/maprootUrlMixedSubfolderNoOutdir.json b/tests/baselines/reference/project/maprootUrlMixedSubfolderNoOutdir/node/maprootUrlMixedSubfolderNoOutdir.json
index c661284121066..bb402d3387bf2 100644
--- a/tests/baselines/reference/project/maprootUrlMixedSubfolderNoOutdir/node/maprootUrlMixedSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/maprootUrlMixedSubfolderNoOutdir/node/maprootUrlMixedSubfolderNoOutdir.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "ref/m2.js.map",
         "ref/m2.js",
-        "ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlMixedSubfolderSpecifyOutputDirectory/amd/maprootUrlMixedSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/maprootUrlMixedSubfolderSpecifyOutputDirectory/amd/maprootUrlMixedSubfolderSpecifyOutputDirectory.json
index b225c4e408f6b..33beca3b068ca 100644
--- a/tests/baselines/reference/project/maprootUrlMixedSubfolderSpecifyOutputDirectory/amd/maprootUrlMixedSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/maprootUrlMixedSubfolderSpecifyOutputDirectory/amd/maprootUrlMixedSubfolderSpecifyOutputDirectory.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/ref/m2.js.map",
         "outdir/simple/ref/m2.js",
-        "outdir/simple/ref/m2.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
+        "outdir/simple/ref/m2.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlMixedSubfolderSpecifyOutputDirectory/node/maprootUrlMixedSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/maprootUrlMixedSubfolderSpecifyOutputDirectory/node/maprootUrlMixedSubfolderSpecifyOutputDirectory.json
index b225c4e408f6b..33beca3b068ca 100644
--- a/tests/baselines/reference/project/maprootUrlMixedSubfolderSpecifyOutputDirectory/node/maprootUrlMixedSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/maprootUrlMixedSubfolderSpecifyOutputDirectory/node/maprootUrlMixedSubfolderSpecifyOutputDirectory.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/ref/m2.js.map",
         "outdir/simple/ref/m2.js",
-        "outdir/simple/ref/m2.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
+        "outdir/simple/ref/m2.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlMixedSubfolderSpecifyOutputFile/amd/maprootUrlMixedSubfolderSpecifyOutputFile.json b/tests/baselines/reference/project/maprootUrlMixedSubfolderSpecifyOutputFile/amd/maprootUrlMixedSubfolderSpecifyOutputFile.json
index f987aa49ffeb3..12c5add488f99 100644
--- a/tests/baselines/reference/project/maprootUrlMixedSubfolderSpecifyOutputFile/amd/maprootUrlMixedSubfolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/maprootUrlMixedSubfolderSpecifyOutputFile/amd/maprootUrlMixedSubfolderSpecifyOutputFile.json
@@ -18,9 +18,9 @@
     "emittedFiles": [
         "ref/m2.js.map",
         "ref/m2.js",
-        "ref/m2.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m2.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlMixedSubfolderSpecifyOutputFile/node/maprootUrlMixedSubfolderSpecifyOutputFile.json b/tests/baselines/reference/project/maprootUrlMixedSubfolderSpecifyOutputFile/node/maprootUrlMixedSubfolderSpecifyOutputFile.json
index f987aa49ffeb3..12c5add488f99 100644
--- a/tests/baselines/reference/project/maprootUrlMixedSubfolderSpecifyOutputFile/node/maprootUrlMixedSubfolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/maprootUrlMixedSubfolderSpecifyOutputFile/node/maprootUrlMixedSubfolderSpecifyOutputFile.json
@@ -18,9 +18,9 @@
     "emittedFiles": [
         "ref/m2.js.map",
         "ref/m2.js",
-        "ref/m2.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m2.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory/amd/maprootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory.json b/tests/baselines/reference/project/maprootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory/amd/maprootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
index 2bb23cdc61028..e8e5ba0856b2c 100644
--- a/tests/baselines/reference/project/maprootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory/amd/maprootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
+++ b/tests/baselines/reference/project/maprootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory/amd/maprootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
@@ -19,9 +19,9 @@
     "emittedFiles": [
         "outdir/outAndOutDirFolder/ref/m2.js.map",
         "outdir/outAndOutDirFolder/ref/m2.js",
-        "outdir/outAndOutDirFolder/ref/m2.d.ts",
         "bin/outAndOutDirFile.js.map",
         "bin/outAndOutDirFile.js",
+        "outdir/outAndOutDirFolder/ref/m2.d.ts",
         "bin/outAndOutDirFile.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory/node/maprootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory.json b/tests/baselines/reference/project/maprootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory/node/maprootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
index 2bb23cdc61028..e8e5ba0856b2c 100644
--- a/tests/baselines/reference/project/maprootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory/node/maprootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
+++ b/tests/baselines/reference/project/maprootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory/node/maprootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
@@ -19,9 +19,9 @@
     "emittedFiles": [
         "outdir/outAndOutDirFolder/ref/m2.js.map",
         "outdir/outAndOutDirFolder/ref/m2.js",
-        "outdir/outAndOutDirFolder/ref/m2.d.ts",
         "bin/outAndOutDirFile.js.map",
         "bin/outAndOutDirFile.js",
+        "outdir/outAndOutDirFolder/ref/m2.d.ts",
         "bin/outAndOutDirFile.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlModuleMultifolderNoOutdir/amd/maprootUrlModuleMultifolderNoOutdir.json b/tests/baselines/reference/project/maprootUrlModuleMultifolderNoOutdir/amd/maprootUrlModuleMultifolderNoOutdir.json
index 6ecdc26ccd446..088f87dd02e5d 100644
--- a/tests/baselines/reference/project/maprootUrlModuleMultifolderNoOutdir/amd/maprootUrlModuleMultifolderNoOutdir.json
+++ b/tests/baselines/reference/project/maprootUrlModuleMultifolderNoOutdir/amd/maprootUrlModuleMultifolderNoOutdir.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_module_multifolder_ref/m2.js.map",
         "../outputdir_module_multifolder_ref/m2.js",
-        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlModuleMultifolderNoOutdir/node/maprootUrlModuleMultifolderNoOutdir.json b/tests/baselines/reference/project/maprootUrlModuleMultifolderNoOutdir/node/maprootUrlModuleMultifolderNoOutdir.json
index 6ecdc26ccd446..088f87dd02e5d 100644
--- a/tests/baselines/reference/project/maprootUrlModuleMultifolderNoOutdir/node/maprootUrlModuleMultifolderNoOutdir.json
+++ b/tests/baselines/reference/project/maprootUrlModuleMultifolderNoOutdir/node/maprootUrlModuleMultifolderNoOutdir.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_module_multifolder_ref/m2.js.map",
         "../outputdir_module_multifolder_ref/m2.js",
-        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputDirectory/amd/maprootUrlModuleMultifolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputDirectory/amd/maprootUrlModuleMultifolderSpecifyOutputDirectory.json
index 9884550745c4b..50a663abdd75d 100644
--- a/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputDirectory/amd/maprootUrlModuleMultifolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputDirectory/amd/maprootUrlModuleMultifolderSpecifyOutputDirectory.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "outdir/simple/outputdir_module_multifolder/ref/m1.js.map",
         "outdir/simple/outputdir_module_multifolder/ref/m1.js",
-        "outdir/simple/outputdir_module_multifolder/ref/m1.d.ts",
         "outdir/simple/outputdir_module_multifolder_ref/m2.js.map",
         "outdir/simple/outputdir_module_multifolder_ref/m2.js",
-        "outdir/simple/outputdir_module_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_module_multifolder/test.js.map",
         "outdir/simple/outputdir_module_multifolder/test.js",
+        "outdir/simple/outputdir_module_multifolder/ref/m1.d.ts",
+        "outdir/simple/outputdir_module_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_module_multifolder/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputDirectory/node/maprootUrlModuleMultifolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputDirectory/node/maprootUrlModuleMultifolderSpecifyOutputDirectory.json
index 9884550745c4b..50a663abdd75d 100644
--- a/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputDirectory/node/maprootUrlModuleMultifolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputDirectory/node/maprootUrlModuleMultifolderSpecifyOutputDirectory.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "outdir/simple/outputdir_module_multifolder/ref/m1.js.map",
         "outdir/simple/outputdir_module_multifolder/ref/m1.js",
-        "outdir/simple/outputdir_module_multifolder/ref/m1.d.ts",
         "outdir/simple/outputdir_module_multifolder_ref/m2.js.map",
         "outdir/simple/outputdir_module_multifolder_ref/m2.js",
-        "outdir/simple/outputdir_module_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_module_multifolder/test.js.map",
         "outdir/simple/outputdir_module_multifolder/test.js",
+        "outdir/simple/outputdir_module_multifolder/ref/m1.d.ts",
+        "outdir/simple/outputdir_module_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_module_multifolder/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/amd/maprootUrlModuleMultifolderSpecifyOutputFile.json b/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/amd/maprootUrlModuleMultifolderSpecifyOutputFile.json
index e061982b32fc3..fbf02ee21f1c1 100644
--- a/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/amd/maprootUrlModuleMultifolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/amd/maprootUrlModuleMultifolderSpecifyOutputFile.json
@@ -18,15 +18,15 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_module_multifolder_ref/m2.js.map",
         "../outputdir_module_multifolder_ref/m2.js",
-        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m1.d.ts",
+        "../outputdir_module_multifolder_ref/m2.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/node/maprootUrlModuleMultifolderSpecifyOutputFile.json b/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/node/maprootUrlModuleMultifolderSpecifyOutputFile.json
index e061982b32fc3..fbf02ee21f1c1 100644
--- a/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/node/maprootUrlModuleMultifolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/maprootUrlModuleMultifolderSpecifyOutputFile/node/maprootUrlModuleMultifolderSpecifyOutputFile.json
@@ -18,15 +18,15 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_module_multifolder_ref/m2.js.map",
         "../outputdir_module_multifolder_ref/m2.js",
-        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m1.d.ts",
+        "../outputdir_module_multifolder_ref/m2.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlModuleSimpleNoOutdir/amd/maprootUrlModuleSimpleNoOutdir.json b/tests/baselines/reference/project/maprootUrlModuleSimpleNoOutdir/amd/maprootUrlModuleSimpleNoOutdir.json
index f9f02dcf7894e..46e2831bd729a 100644
--- a/tests/baselines/reference/project/maprootUrlModuleSimpleNoOutdir/amd/maprootUrlModuleSimpleNoOutdir.json
+++ b/tests/baselines/reference/project/maprootUrlModuleSimpleNoOutdir/amd/maprootUrlModuleSimpleNoOutdir.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
+        "m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlModuleSimpleNoOutdir/node/maprootUrlModuleSimpleNoOutdir.json b/tests/baselines/reference/project/maprootUrlModuleSimpleNoOutdir/node/maprootUrlModuleSimpleNoOutdir.json
index f9f02dcf7894e..46e2831bd729a 100644
--- a/tests/baselines/reference/project/maprootUrlModuleSimpleNoOutdir/node/maprootUrlModuleSimpleNoOutdir.json
+++ b/tests/baselines/reference/project/maprootUrlModuleSimpleNoOutdir/node/maprootUrlModuleSimpleNoOutdir.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
+        "m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlModuleSimpleSpecifyOutputDirectory/amd/maprootUrlModuleSimpleSpecifyOutputDirectory.json b/tests/baselines/reference/project/maprootUrlModuleSimpleSpecifyOutputDirectory/amd/maprootUrlModuleSimpleSpecifyOutputDirectory.json
index db2995acf6956..e642fe7291330 100644
--- a/tests/baselines/reference/project/maprootUrlModuleSimpleSpecifyOutputDirectory/amd/maprootUrlModuleSimpleSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/maprootUrlModuleSimpleSpecifyOutputDirectory/amd/maprootUrlModuleSimpleSpecifyOutputDirectory.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "outdir/simple/m1.js.map",
         "outdir/simple/m1.js",
-        "outdir/simple/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlModuleSimpleSpecifyOutputDirectory/node/maprootUrlModuleSimpleSpecifyOutputDirectory.json b/tests/baselines/reference/project/maprootUrlModuleSimpleSpecifyOutputDirectory/node/maprootUrlModuleSimpleSpecifyOutputDirectory.json
index db2995acf6956..e642fe7291330 100644
--- a/tests/baselines/reference/project/maprootUrlModuleSimpleSpecifyOutputDirectory/node/maprootUrlModuleSimpleSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/maprootUrlModuleSimpleSpecifyOutputDirectory/node/maprootUrlModuleSimpleSpecifyOutputDirectory.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "outdir/simple/m1.js.map",
         "outdir/simple/m1.js",
-        "outdir/simple/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlModuleSimpleSpecifyOutputFile/amd/maprootUrlModuleSimpleSpecifyOutputFile.json b/tests/baselines/reference/project/maprootUrlModuleSimpleSpecifyOutputFile/amd/maprootUrlModuleSimpleSpecifyOutputFile.json
index e636ce61f7e6e..483d579fa5d87 100644
--- a/tests/baselines/reference/project/maprootUrlModuleSimpleSpecifyOutputFile/amd/maprootUrlModuleSimpleSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/maprootUrlModuleSimpleSpecifyOutputFile/amd/maprootUrlModuleSimpleSpecifyOutputFile.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "m1.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlModuleSimpleSpecifyOutputFile/node/maprootUrlModuleSimpleSpecifyOutputFile.json b/tests/baselines/reference/project/maprootUrlModuleSimpleSpecifyOutputFile/node/maprootUrlModuleSimpleSpecifyOutputFile.json
index e636ce61f7e6e..483d579fa5d87 100644
--- a/tests/baselines/reference/project/maprootUrlModuleSimpleSpecifyOutputFile/node/maprootUrlModuleSimpleSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/maprootUrlModuleSimpleSpecifyOutputFile/node/maprootUrlModuleSimpleSpecifyOutputFile.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "m1.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlModuleSubfolderNoOutdir/amd/maprootUrlModuleSubfolderNoOutdir.json b/tests/baselines/reference/project/maprootUrlModuleSubfolderNoOutdir/amd/maprootUrlModuleSubfolderNoOutdir.json
index 2c7699ff0faed..9b3be09b60f96 100644
--- a/tests/baselines/reference/project/maprootUrlModuleSubfolderNoOutdir/amd/maprootUrlModuleSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/maprootUrlModuleSubfolderNoOutdir/amd/maprootUrlModuleSubfolderNoOutdir.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlModuleSubfolderNoOutdir/node/maprootUrlModuleSubfolderNoOutdir.json b/tests/baselines/reference/project/maprootUrlModuleSubfolderNoOutdir/node/maprootUrlModuleSubfolderNoOutdir.json
index 2c7699ff0faed..9b3be09b60f96 100644
--- a/tests/baselines/reference/project/maprootUrlModuleSubfolderNoOutdir/node/maprootUrlModuleSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/maprootUrlModuleSubfolderNoOutdir/node/maprootUrlModuleSubfolderNoOutdir.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlModuleSubfolderSpecifyOutputDirectory/amd/maprootUrlModuleSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/maprootUrlModuleSubfolderSpecifyOutputDirectory/amd/maprootUrlModuleSubfolderSpecifyOutputDirectory.json
index a61a50a760d15..9b8a2e6cdd64e 100644
--- a/tests/baselines/reference/project/maprootUrlModuleSubfolderSpecifyOutputDirectory/amd/maprootUrlModuleSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/maprootUrlModuleSubfolderSpecifyOutputDirectory/amd/maprootUrlModuleSubfolderSpecifyOutputDirectory.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlModuleSubfolderSpecifyOutputDirectory/node/maprootUrlModuleSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/maprootUrlModuleSubfolderSpecifyOutputDirectory/node/maprootUrlModuleSubfolderSpecifyOutputDirectory.json
index a61a50a760d15..9b8a2e6cdd64e 100644
--- a/tests/baselines/reference/project/maprootUrlModuleSubfolderSpecifyOutputDirectory/node/maprootUrlModuleSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/maprootUrlModuleSubfolderSpecifyOutputDirectory/node/maprootUrlModuleSubfolderSpecifyOutputDirectory.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlModuleSubfolderSpecifyOutputFile/amd/maprootUrlModuleSubfolderSpecifyOutputFile.json b/tests/baselines/reference/project/maprootUrlModuleSubfolderSpecifyOutputFile/amd/maprootUrlModuleSubfolderSpecifyOutputFile.json
index 05da8c15292e1..5632ef23ce611 100644
--- a/tests/baselines/reference/project/maprootUrlModuleSubfolderSpecifyOutputFile/amd/maprootUrlModuleSubfolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/maprootUrlModuleSubfolderSpecifyOutputFile/amd/maprootUrlModuleSubfolderSpecifyOutputFile.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m1.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlModuleSubfolderSpecifyOutputFile/node/maprootUrlModuleSubfolderSpecifyOutputFile.json b/tests/baselines/reference/project/maprootUrlModuleSubfolderSpecifyOutputFile/node/maprootUrlModuleSubfolderSpecifyOutputFile.json
index 05da8c15292e1..5632ef23ce611 100644
--- a/tests/baselines/reference/project/maprootUrlModuleSubfolderSpecifyOutputFile/node/maprootUrlModuleSubfolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/maprootUrlModuleSubfolderSpecifyOutputFile/node/maprootUrlModuleSubfolderSpecifyOutputFile.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m1.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlMultifolderNoOutdir/amd/maprootUrlMultifolderNoOutdir.json b/tests/baselines/reference/project/maprootUrlMultifolderNoOutdir/amd/maprootUrlMultifolderNoOutdir.json
index 5ea7aa806651d..b8e04aea77a15 100644
--- a/tests/baselines/reference/project/maprootUrlMultifolderNoOutdir/amd/maprootUrlMultifolderNoOutdir.json
+++ b/tests/baselines/reference/project/maprootUrlMultifolderNoOutdir/amd/maprootUrlMultifolderNoOutdir.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_multifolder_ref/m2.js.map",
         "../outputdir_multifolder_ref/m2.js",
-        "../outputdir_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "../outputdir_multifolder_ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlMultifolderNoOutdir/node/maprootUrlMultifolderNoOutdir.json b/tests/baselines/reference/project/maprootUrlMultifolderNoOutdir/node/maprootUrlMultifolderNoOutdir.json
index 5ea7aa806651d..b8e04aea77a15 100644
--- a/tests/baselines/reference/project/maprootUrlMultifolderNoOutdir/node/maprootUrlMultifolderNoOutdir.json
+++ b/tests/baselines/reference/project/maprootUrlMultifolderNoOutdir/node/maprootUrlMultifolderNoOutdir.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_multifolder_ref/m2.js.map",
         "../outputdir_multifolder_ref/m2.js",
-        "../outputdir_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "../outputdir_multifolder_ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlMultifolderSpecifyOutputDirectory/amd/maprootUrlMultifolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/maprootUrlMultifolderSpecifyOutputDirectory/amd/maprootUrlMultifolderSpecifyOutputDirectory.json
index 0d16b53af662f..a4df3caacc4cc 100644
--- a/tests/baselines/reference/project/maprootUrlMultifolderSpecifyOutputDirectory/amd/maprootUrlMultifolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/maprootUrlMultifolderSpecifyOutputDirectory/amd/maprootUrlMultifolderSpecifyOutputDirectory.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "outdir/simple/outputdir_multifolder/ref/m1.js.map",
         "outdir/simple/outputdir_multifolder/ref/m1.js",
-        "outdir/simple/outputdir_multifolder/ref/m1.d.ts",
         "outdir/simple/outputdir_multifolder_ref/m2.js.map",
         "outdir/simple/outputdir_multifolder_ref/m2.js",
-        "outdir/simple/outputdir_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_multifolder/test.js.map",
         "outdir/simple/outputdir_multifolder/test.js",
+        "outdir/simple/outputdir_multifolder/ref/m1.d.ts",
+        "outdir/simple/outputdir_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_multifolder/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlMultifolderSpecifyOutputDirectory/node/maprootUrlMultifolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/maprootUrlMultifolderSpecifyOutputDirectory/node/maprootUrlMultifolderSpecifyOutputDirectory.json
index 0d16b53af662f..a4df3caacc4cc 100644
--- a/tests/baselines/reference/project/maprootUrlMultifolderSpecifyOutputDirectory/node/maprootUrlMultifolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/maprootUrlMultifolderSpecifyOutputDirectory/node/maprootUrlMultifolderSpecifyOutputDirectory.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "outdir/simple/outputdir_multifolder/ref/m1.js.map",
         "outdir/simple/outputdir_multifolder/ref/m1.js",
-        "outdir/simple/outputdir_multifolder/ref/m1.d.ts",
         "outdir/simple/outputdir_multifolder_ref/m2.js.map",
         "outdir/simple/outputdir_multifolder_ref/m2.js",
-        "outdir/simple/outputdir_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_multifolder/test.js.map",
         "outdir/simple/outputdir_multifolder/test.js",
+        "outdir/simple/outputdir_multifolder/ref/m1.d.ts",
+        "outdir/simple/outputdir_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_multifolder/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlSimpleNoOutdir/amd/maprootUrlSimpleNoOutdir.json b/tests/baselines/reference/project/maprootUrlSimpleNoOutdir/amd/maprootUrlSimpleNoOutdir.json
index 6f141f8151104..06b15f003da4c 100644
--- a/tests/baselines/reference/project/maprootUrlSimpleNoOutdir/amd/maprootUrlSimpleNoOutdir.json
+++ b/tests/baselines/reference/project/maprootUrlSimpleNoOutdir/amd/maprootUrlSimpleNoOutdir.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
+        "m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlSimpleNoOutdir/node/maprootUrlSimpleNoOutdir.json b/tests/baselines/reference/project/maprootUrlSimpleNoOutdir/node/maprootUrlSimpleNoOutdir.json
index 6f141f8151104..06b15f003da4c 100644
--- a/tests/baselines/reference/project/maprootUrlSimpleNoOutdir/node/maprootUrlSimpleNoOutdir.json
+++ b/tests/baselines/reference/project/maprootUrlSimpleNoOutdir/node/maprootUrlSimpleNoOutdir.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
+        "m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlSimpleSpecifyOutputDirectory/amd/maprootUrlSimpleSpecifyOutputDirectory.json b/tests/baselines/reference/project/maprootUrlSimpleSpecifyOutputDirectory/amd/maprootUrlSimpleSpecifyOutputDirectory.json
index 1f73a2a33d6cc..812734f7a8d9e 100644
--- a/tests/baselines/reference/project/maprootUrlSimpleSpecifyOutputDirectory/amd/maprootUrlSimpleSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/maprootUrlSimpleSpecifyOutputDirectory/amd/maprootUrlSimpleSpecifyOutputDirectory.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "outdir/simple/m1.js.map",
         "outdir/simple/m1.js",
-        "outdir/simple/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlSimpleSpecifyOutputDirectory/node/maprootUrlSimpleSpecifyOutputDirectory.json b/tests/baselines/reference/project/maprootUrlSimpleSpecifyOutputDirectory/node/maprootUrlSimpleSpecifyOutputDirectory.json
index 1f73a2a33d6cc..812734f7a8d9e 100644
--- a/tests/baselines/reference/project/maprootUrlSimpleSpecifyOutputDirectory/node/maprootUrlSimpleSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/maprootUrlSimpleSpecifyOutputDirectory/node/maprootUrlSimpleSpecifyOutputDirectory.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "outdir/simple/m1.js.map",
         "outdir/simple/m1.js",
-        "outdir/simple/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlSubfolderNoOutdir/amd/maprootUrlSubfolderNoOutdir.json b/tests/baselines/reference/project/maprootUrlSubfolderNoOutdir/amd/maprootUrlSubfolderNoOutdir.json
index edd08fbfe107f..881d3fadbe847 100644
--- a/tests/baselines/reference/project/maprootUrlSubfolderNoOutdir/amd/maprootUrlSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/maprootUrlSubfolderNoOutdir/amd/maprootUrlSubfolderNoOutdir.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlSubfolderNoOutdir/node/maprootUrlSubfolderNoOutdir.json b/tests/baselines/reference/project/maprootUrlSubfolderNoOutdir/node/maprootUrlSubfolderNoOutdir.json
index edd08fbfe107f..881d3fadbe847 100644
--- a/tests/baselines/reference/project/maprootUrlSubfolderNoOutdir/node/maprootUrlSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/maprootUrlSubfolderNoOutdir/node/maprootUrlSubfolderNoOutdir.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlSubfolderSpecifyOutputDirectory/amd/maprootUrlSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/maprootUrlSubfolderSpecifyOutputDirectory/amd/maprootUrlSubfolderSpecifyOutputDirectory.json
index 0b2ea47302960..dd185336880c6 100644
--- a/tests/baselines/reference/project/maprootUrlSubfolderSpecifyOutputDirectory/amd/maprootUrlSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/maprootUrlSubfolderSpecifyOutputDirectory/amd/maprootUrlSubfolderSpecifyOutputDirectory.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlSubfolderSpecifyOutputDirectory/node/maprootUrlSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/maprootUrlSubfolderSpecifyOutputDirectory/node/maprootUrlSubfolderSpecifyOutputDirectory.json
index 0b2ea47302960..dd185336880c6 100644
--- a/tests/baselines/reference/project/maprootUrlSubfolderSpecifyOutputDirectory/node/maprootUrlSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/maprootUrlSubfolderSpecifyOutputDirectory/node/maprootUrlSubfolderSpecifyOutputDirectory.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlMixedSubfolderNoOutdir/amd/maprootUrlsourcerootUrlMixedSubfolderNoOutdir.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlMixedSubfolderNoOutdir/amd/maprootUrlsourcerootUrlMixedSubfolderNoOutdir.json
index 2f2a4280abf1c..51f78361c1fca 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlMixedSubfolderNoOutdir/amd/maprootUrlsourcerootUrlMixedSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlMixedSubfolderNoOutdir/amd/maprootUrlsourcerootUrlMixedSubfolderNoOutdir.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "ref/m2.js.map",
         "ref/m2.js",
-        "ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlMixedSubfolderNoOutdir/node/maprootUrlsourcerootUrlMixedSubfolderNoOutdir.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlMixedSubfolderNoOutdir/node/maprootUrlsourcerootUrlMixedSubfolderNoOutdir.json
index 2f2a4280abf1c..51f78361c1fca 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlMixedSubfolderNoOutdir/node/maprootUrlsourcerootUrlMixedSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlMixedSubfolderNoOutdir/node/maprootUrlsourcerootUrlMixedSubfolderNoOutdir.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "ref/m2.js.map",
         "ref/m2.js",
-        "ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputDirectory/amd/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputDirectory/amd/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputDirectory.json
index 006720b1cc3d5..f01a83c4f1948 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputDirectory/amd/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputDirectory/amd/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputDirectory.json
@@ -19,12 +19,12 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/ref/m2.js.map",
         "outdir/simple/ref/m2.js",
-        "outdir/simple/ref/m2.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
+        "outdir/simple/ref/m2.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputDirectory/node/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputDirectory/node/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputDirectory.json
index 006720b1cc3d5..f01a83c4f1948 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputDirectory/node/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputDirectory/node/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputDirectory.json
@@ -19,12 +19,12 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/ref/m2.js.map",
         "outdir/simple/ref/m2.js",
-        "outdir/simple/ref/m2.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
+        "outdir/simple/ref/m2.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputFile/amd/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputFile.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputFile/amd/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputFile.json
index c36f3ade5e08b..86008e58bbc47 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputFile/amd/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputFile/amd/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputFile.json
@@ -19,9 +19,9 @@
     "emittedFiles": [
         "ref/m2.js.map",
         "ref/m2.js",
-        "ref/m2.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m2.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputFile/node/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputFile.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputFile/node/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputFile.json
index c36f3ade5e08b..86008e58bbc47 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputFile/node/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputFile/node/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputFile.json
@@ -19,9 +19,9 @@
     "emittedFiles": [
         "ref/m2.js.map",
         "ref/m2.js",
-        "ref/m2.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m2.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory/amd/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory/amd/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
index 4741b9cf9e18d..22ef38fb6aa97 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory/amd/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory/amd/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
@@ -20,9 +20,9 @@
     "emittedFiles": [
         "outdir/outAndOutDirFolder/ref/m2.js.map",
         "outdir/outAndOutDirFolder/ref/m2.js",
-        "outdir/outAndOutDirFolder/ref/m2.d.ts",
         "bin/outAndOutDirFile.js.map",
         "bin/outAndOutDirFile.js",
+        "outdir/outAndOutDirFolder/ref/m2.d.ts",
         "bin/outAndOutDirFile.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory/node/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory/node/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
index 4741b9cf9e18d..22ef38fb6aa97 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory/node/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory/node/maprootUrlsourcerootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
@@ -20,9 +20,9 @@
     "emittedFiles": [
         "outdir/outAndOutDirFolder/ref/m2.js.map",
         "outdir/outAndOutDirFolder/ref/m2.js",
-        "outdir/outAndOutDirFolder/ref/m2.d.ts",
         "bin/outAndOutDirFile.js.map",
         "bin/outAndOutDirFile.js",
+        "outdir/outAndOutDirFolder/ref/m2.d.ts",
         "bin/outAndOutDirFile.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderNoOutdir/amd/maprootUrlsourcerootUrlModuleMultifolderNoOutdir.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderNoOutdir/amd/maprootUrlsourcerootUrlModuleMultifolderNoOutdir.json
index ec6313ac50c0c..526eb1522a593 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderNoOutdir/amd/maprootUrlsourcerootUrlModuleMultifolderNoOutdir.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderNoOutdir/amd/maprootUrlsourcerootUrlModuleMultifolderNoOutdir.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_module_multifolder_ref/m2.js.map",
         "../outputdir_module_multifolder_ref/m2.js",
-        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderNoOutdir/node/maprootUrlsourcerootUrlModuleMultifolderNoOutdir.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderNoOutdir/node/maprootUrlsourcerootUrlModuleMultifolderNoOutdir.json
index ec6313ac50c0c..526eb1522a593 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderNoOutdir/node/maprootUrlsourcerootUrlModuleMultifolderNoOutdir.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderNoOutdir/node/maprootUrlsourcerootUrlModuleMultifolderNoOutdir.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_module_multifolder_ref/m2.js.map",
         "../outputdir_module_multifolder_ref/m2.js",
-        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputDirectory/amd/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputDirectory/amd/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputDirectory.json
index 9a0d0258ca4bd..e73e9f2346f31 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputDirectory/amd/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputDirectory/amd/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputDirectory.json
@@ -19,12 +19,12 @@
     "emittedFiles": [
         "outdir/simple/outputdir_module_multifolder/ref/m1.js.map",
         "outdir/simple/outputdir_module_multifolder/ref/m1.js",
-        "outdir/simple/outputdir_module_multifolder/ref/m1.d.ts",
         "outdir/simple/outputdir_module_multifolder_ref/m2.js.map",
         "outdir/simple/outputdir_module_multifolder_ref/m2.js",
-        "outdir/simple/outputdir_module_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_module_multifolder/test.js.map",
         "outdir/simple/outputdir_module_multifolder/test.js",
+        "outdir/simple/outputdir_module_multifolder/ref/m1.d.ts",
+        "outdir/simple/outputdir_module_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_module_multifolder/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputDirectory/node/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputDirectory/node/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputDirectory.json
index 9a0d0258ca4bd..e73e9f2346f31 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputDirectory/node/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputDirectory/node/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputDirectory.json
@@ -19,12 +19,12 @@
     "emittedFiles": [
         "outdir/simple/outputdir_module_multifolder/ref/m1.js.map",
         "outdir/simple/outputdir_module_multifolder/ref/m1.js",
-        "outdir/simple/outputdir_module_multifolder/ref/m1.d.ts",
         "outdir/simple/outputdir_module_multifolder_ref/m2.js.map",
         "outdir/simple/outputdir_module_multifolder_ref/m2.js",
-        "outdir/simple/outputdir_module_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_module_multifolder/test.js.map",
         "outdir/simple/outputdir_module_multifolder/test.js",
+        "outdir/simple/outputdir_module_multifolder/ref/m1.d.ts",
+        "outdir/simple/outputdir_module_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_module_multifolder/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/amd/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/amd/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile.json
index 3ecf4bc4cc448..e8376879922ef 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/amd/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/amd/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile.json
@@ -19,15 +19,15 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_module_multifolder_ref/m2.js.map",
         "../outputdir_module_multifolder_ref/m2.js",
-        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m1.d.ts",
+        "../outputdir_module_multifolder_ref/m2.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/node/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/node/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile.json
index 3ecf4bc4cc448..e8376879922ef 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/node/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/node/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile.json
@@ -19,15 +19,15 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_module_multifolder_ref/m2.js.map",
         "../outputdir_module_multifolder_ref/m2.js",
-        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m1.d.ts",
+        "../outputdir_module_multifolder_ref/m2.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSimpleNoOutdir/amd/maprootUrlsourcerootUrlModuleSimpleNoOutdir.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSimpleNoOutdir/amd/maprootUrlsourcerootUrlModuleSimpleNoOutdir.json
index d901eb0a79073..6fe2de6eca6d2 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSimpleNoOutdir/amd/maprootUrlsourcerootUrlModuleSimpleNoOutdir.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSimpleNoOutdir/amd/maprootUrlsourcerootUrlModuleSimpleNoOutdir.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
+        "m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSimpleNoOutdir/node/maprootUrlsourcerootUrlModuleSimpleNoOutdir.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSimpleNoOutdir/node/maprootUrlsourcerootUrlModuleSimpleNoOutdir.json
index d901eb0a79073..6fe2de6eca6d2 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSimpleNoOutdir/node/maprootUrlsourcerootUrlModuleSimpleNoOutdir.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSimpleNoOutdir/node/maprootUrlsourcerootUrlModuleSimpleNoOutdir.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
+        "m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSimpleSpecifyOutputDirectory/amd/maprootUrlsourcerootUrlModuleSimpleSpecifyOutputDirectory.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSimpleSpecifyOutputDirectory/amd/maprootUrlsourcerootUrlModuleSimpleSpecifyOutputDirectory.json
index 278bc2c86e5de..72ad20902b450 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSimpleSpecifyOutputDirectory/amd/maprootUrlsourcerootUrlModuleSimpleSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSimpleSpecifyOutputDirectory/amd/maprootUrlsourcerootUrlModuleSimpleSpecifyOutputDirectory.json
@@ -18,9 +18,9 @@
     "emittedFiles": [
         "outdir/simple/m1.js.map",
         "outdir/simple/m1.js",
-        "outdir/simple/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSimpleSpecifyOutputDirectory/node/maprootUrlsourcerootUrlModuleSimpleSpecifyOutputDirectory.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSimpleSpecifyOutputDirectory/node/maprootUrlsourcerootUrlModuleSimpleSpecifyOutputDirectory.json
index 278bc2c86e5de..72ad20902b450 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSimpleSpecifyOutputDirectory/node/maprootUrlsourcerootUrlModuleSimpleSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSimpleSpecifyOutputDirectory/node/maprootUrlsourcerootUrlModuleSimpleSpecifyOutputDirectory.json
@@ -18,9 +18,9 @@
     "emittedFiles": [
         "outdir/simple/m1.js.map",
         "outdir/simple/m1.js",
-        "outdir/simple/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSimpleSpecifyOutputFile/amd/maprootUrlsourcerootUrlModuleSimpleSpecifyOutputFile.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSimpleSpecifyOutputFile/amd/maprootUrlsourcerootUrlModuleSimpleSpecifyOutputFile.json
index 2cfc9aebda200..1798c2bf9ca1f 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSimpleSpecifyOutputFile/amd/maprootUrlsourcerootUrlModuleSimpleSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSimpleSpecifyOutputFile/amd/maprootUrlsourcerootUrlModuleSimpleSpecifyOutputFile.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "m1.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSimpleSpecifyOutputFile/node/maprootUrlsourcerootUrlModuleSimpleSpecifyOutputFile.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSimpleSpecifyOutputFile/node/maprootUrlsourcerootUrlModuleSimpleSpecifyOutputFile.json
index 2cfc9aebda200..1798c2bf9ca1f 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSimpleSpecifyOutputFile/node/maprootUrlsourcerootUrlModuleSimpleSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSimpleSpecifyOutputFile/node/maprootUrlsourcerootUrlModuleSimpleSpecifyOutputFile.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "m1.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSubfolderNoOutdir/amd/maprootUrlsourcerootUrlModuleSubfolderNoOutdir.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSubfolderNoOutdir/amd/maprootUrlsourcerootUrlModuleSubfolderNoOutdir.json
index fc4e8b7c9db59..51348c58a5211 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSubfolderNoOutdir/amd/maprootUrlsourcerootUrlModuleSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSubfolderNoOutdir/amd/maprootUrlsourcerootUrlModuleSubfolderNoOutdir.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSubfolderNoOutdir/node/maprootUrlsourcerootUrlModuleSubfolderNoOutdir.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSubfolderNoOutdir/node/maprootUrlsourcerootUrlModuleSubfolderNoOutdir.json
index fc4e8b7c9db59..51348c58a5211 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSubfolderNoOutdir/node/maprootUrlsourcerootUrlModuleSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSubfolderNoOutdir/node/maprootUrlsourcerootUrlModuleSubfolderNoOutdir.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSubfolderSpecifyOutputDirectory/amd/maprootUrlsourcerootUrlModuleSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSubfolderSpecifyOutputDirectory/amd/maprootUrlsourcerootUrlModuleSubfolderSpecifyOutputDirectory.json
index a20ecf2d6c97d..6e1f5e245efd0 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSubfolderSpecifyOutputDirectory/amd/maprootUrlsourcerootUrlModuleSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSubfolderSpecifyOutputDirectory/amd/maprootUrlsourcerootUrlModuleSubfolderSpecifyOutputDirectory.json
@@ -18,9 +18,9 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSubfolderSpecifyOutputDirectory/node/maprootUrlsourcerootUrlModuleSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSubfolderSpecifyOutputDirectory/node/maprootUrlsourcerootUrlModuleSubfolderSpecifyOutputDirectory.json
index a20ecf2d6c97d..6e1f5e245efd0 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSubfolderSpecifyOutputDirectory/node/maprootUrlsourcerootUrlModuleSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSubfolderSpecifyOutputDirectory/node/maprootUrlsourcerootUrlModuleSubfolderSpecifyOutputDirectory.json
@@ -18,9 +18,9 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSubfolderSpecifyOutputFile/amd/maprootUrlsourcerootUrlModuleSubfolderSpecifyOutputFile.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSubfolderSpecifyOutputFile/amd/maprootUrlsourcerootUrlModuleSubfolderSpecifyOutputFile.json
index cfa0ec5cb81b5..bdeb01b773dce 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSubfolderSpecifyOutputFile/amd/maprootUrlsourcerootUrlModuleSubfolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSubfolderSpecifyOutputFile/amd/maprootUrlsourcerootUrlModuleSubfolderSpecifyOutputFile.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m1.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSubfolderSpecifyOutputFile/node/maprootUrlsourcerootUrlModuleSubfolderSpecifyOutputFile.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSubfolderSpecifyOutputFile/node/maprootUrlsourcerootUrlModuleSubfolderSpecifyOutputFile.json
index cfa0ec5cb81b5..bdeb01b773dce 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSubfolderSpecifyOutputFile/node/maprootUrlsourcerootUrlModuleSubfolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSubfolderSpecifyOutputFile/node/maprootUrlsourcerootUrlModuleSubfolderSpecifyOutputFile.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m1.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlMultifolderNoOutdir/amd/maprootUrlsourcerootUrlMultifolderNoOutdir.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlMultifolderNoOutdir/amd/maprootUrlsourcerootUrlMultifolderNoOutdir.json
index ddfa8259401e4..2b823979409de 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlMultifolderNoOutdir/amd/maprootUrlsourcerootUrlMultifolderNoOutdir.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlMultifolderNoOutdir/amd/maprootUrlsourcerootUrlMultifolderNoOutdir.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_multifolder_ref/m2.js.map",
         "../outputdir_multifolder_ref/m2.js",
-        "../outputdir_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "../outputdir_multifolder_ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlMultifolderNoOutdir/node/maprootUrlsourcerootUrlMultifolderNoOutdir.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlMultifolderNoOutdir/node/maprootUrlsourcerootUrlMultifolderNoOutdir.json
index ddfa8259401e4..2b823979409de 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlMultifolderNoOutdir/node/maprootUrlsourcerootUrlMultifolderNoOutdir.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlMultifolderNoOutdir/node/maprootUrlsourcerootUrlMultifolderNoOutdir.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_multifolder_ref/m2.js.map",
         "../outputdir_multifolder_ref/m2.js",
-        "../outputdir_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "../outputdir_multifolder_ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlMultifolderSpecifyOutputDirectory/amd/maprootUrlsourcerootUrlMultifolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlMultifolderSpecifyOutputDirectory/amd/maprootUrlsourcerootUrlMultifolderSpecifyOutputDirectory.json
index 6e6c3e73c0390..818dd58a0f905 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlMultifolderSpecifyOutputDirectory/amd/maprootUrlsourcerootUrlMultifolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlMultifolderSpecifyOutputDirectory/amd/maprootUrlsourcerootUrlMultifolderSpecifyOutputDirectory.json
@@ -19,12 +19,12 @@
     "emittedFiles": [
         "outdir/simple/outputdir_multifolder/ref/m1.js.map",
         "outdir/simple/outputdir_multifolder/ref/m1.js",
-        "outdir/simple/outputdir_multifolder/ref/m1.d.ts",
         "outdir/simple/outputdir_multifolder_ref/m2.js.map",
         "outdir/simple/outputdir_multifolder_ref/m2.js",
-        "outdir/simple/outputdir_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_multifolder/test.js.map",
         "outdir/simple/outputdir_multifolder/test.js",
+        "outdir/simple/outputdir_multifolder/ref/m1.d.ts",
+        "outdir/simple/outputdir_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_multifolder/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlMultifolderSpecifyOutputDirectory/node/maprootUrlsourcerootUrlMultifolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlMultifolderSpecifyOutputDirectory/node/maprootUrlsourcerootUrlMultifolderSpecifyOutputDirectory.json
index 6e6c3e73c0390..818dd58a0f905 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlMultifolderSpecifyOutputDirectory/node/maprootUrlsourcerootUrlMultifolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlMultifolderSpecifyOutputDirectory/node/maprootUrlsourcerootUrlMultifolderSpecifyOutputDirectory.json
@@ -19,12 +19,12 @@
     "emittedFiles": [
         "outdir/simple/outputdir_multifolder/ref/m1.js.map",
         "outdir/simple/outputdir_multifolder/ref/m1.js",
-        "outdir/simple/outputdir_multifolder/ref/m1.d.ts",
         "outdir/simple/outputdir_multifolder_ref/m2.js.map",
         "outdir/simple/outputdir_multifolder_ref/m2.js",
-        "outdir/simple/outputdir_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_multifolder/test.js.map",
         "outdir/simple/outputdir_multifolder/test.js",
+        "outdir/simple/outputdir_multifolder/ref/m1.d.ts",
+        "outdir/simple/outputdir_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_multifolder/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlSimpleNoOutdir/amd/maprootUrlsourcerootUrlSimpleNoOutdir.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlSimpleNoOutdir/amd/maprootUrlsourcerootUrlSimpleNoOutdir.json
index c85db0226a2c0..5d6ff3c6d2b9f 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlSimpleNoOutdir/amd/maprootUrlsourcerootUrlSimpleNoOutdir.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlSimpleNoOutdir/amd/maprootUrlsourcerootUrlSimpleNoOutdir.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
+        "m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlSimpleNoOutdir/node/maprootUrlsourcerootUrlSimpleNoOutdir.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlSimpleNoOutdir/node/maprootUrlsourcerootUrlSimpleNoOutdir.json
index c85db0226a2c0..5d6ff3c6d2b9f 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlSimpleNoOutdir/node/maprootUrlsourcerootUrlSimpleNoOutdir.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlSimpleNoOutdir/node/maprootUrlsourcerootUrlSimpleNoOutdir.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
+        "m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlSimpleSpecifyOutputDirectory/amd/maprootUrlsourcerootUrlSimpleSpecifyOutputDirectory.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlSimpleSpecifyOutputDirectory/amd/maprootUrlsourcerootUrlSimpleSpecifyOutputDirectory.json
index ceda4546fcebf..bfcb7c031160b 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlSimpleSpecifyOutputDirectory/amd/maprootUrlsourcerootUrlSimpleSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlSimpleSpecifyOutputDirectory/amd/maprootUrlsourcerootUrlSimpleSpecifyOutputDirectory.json
@@ -18,9 +18,9 @@
     "emittedFiles": [
         "outdir/simple/m1.js.map",
         "outdir/simple/m1.js",
-        "outdir/simple/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlSimpleSpecifyOutputDirectory/node/maprootUrlsourcerootUrlSimpleSpecifyOutputDirectory.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlSimpleSpecifyOutputDirectory/node/maprootUrlsourcerootUrlSimpleSpecifyOutputDirectory.json
index ceda4546fcebf..bfcb7c031160b 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlSimpleSpecifyOutputDirectory/node/maprootUrlsourcerootUrlSimpleSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlSimpleSpecifyOutputDirectory/node/maprootUrlsourcerootUrlSimpleSpecifyOutputDirectory.json
@@ -18,9 +18,9 @@
     "emittedFiles": [
         "outdir/simple/m1.js.map",
         "outdir/simple/m1.js",
-        "outdir/simple/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlSubfolderNoOutdir/amd/maprootUrlsourcerootUrlSubfolderNoOutdir.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlSubfolderNoOutdir/amd/maprootUrlsourcerootUrlSubfolderNoOutdir.json
index 5f6d0ccd74b8d..0faeae128357c 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlSubfolderNoOutdir/amd/maprootUrlsourcerootUrlSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlSubfolderNoOutdir/amd/maprootUrlsourcerootUrlSubfolderNoOutdir.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlSubfolderNoOutdir/node/maprootUrlsourcerootUrlSubfolderNoOutdir.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlSubfolderNoOutdir/node/maprootUrlsourcerootUrlSubfolderNoOutdir.json
index 5f6d0ccd74b8d..0faeae128357c 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlSubfolderNoOutdir/node/maprootUrlsourcerootUrlSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlSubfolderNoOutdir/node/maprootUrlsourcerootUrlSubfolderNoOutdir.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlSubfolderSpecifyOutputDirectory/amd/maprootUrlsourcerootUrlSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlSubfolderSpecifyOutputDirectory/amd/maprootUrlsourcerootUrlSubfolderSpecifyOutputDirectory.json
index 9dca1ba6d4b78..4aacef680f6a2 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlSubfolderSpecifyOutputDirectory/amd/maprootUrlsourcerootUrlSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlSubfolderSpecifyOutputDirectory/amd/maprootUrlsourcerootUrlSubfolderSpecifyOutputDirectory.json
@@ -18,9 +18,9 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/maprootUrlsourcerootUrlSubfolderSpecifyOutputDirectory/node/maprootUrlsourcerootUrlSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/maprootUrlsourcerootUrlSubfolderSpecifyOutputDirectory/node/maprootUrlsourcerootUrlSubfolderSpecifyOutputDirectory.json
index 9dca1ba6d4b78..4aacef680f6a2 100644
--- a/tests/baselines/reference/project/maprootUrlsourcerootUrlSubfolderSpecifyOutputDirectory/node/maprootUrlsourcerootUrlSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/maprootUrlsourcerootUrlSubfolderSpecifyOutputDirectory/node/maprootUrlsourcerootUrlSubfolderSpecifyOutputDirectory.json
@@ -18,9 +18,9 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outMixedSubfolderNoOutdir/amd/outMixedSubfolderNoOutdir.json b/tests/baselines/reference/project/outMixedSubfolderNoOutdir/amd/outMixedSubfolderNoOutdir.json
index 82eaf9fdb388e..f3f6c757f1880 100644
--- a/tests/baselines/reference/project/outMixedSubfolderNoOutdir/amd/outMixedSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/outMixedSubfolderNoOutdir/amd/outMixedSubfolderNoOutdir.json
@@ -14,10 +14,10 @@
     ],
     "emittedFiles": [
         "ref/m1.js",
-        "ref/m1.d.ts",
         "ref/m2.js",
-        "ref/m2.d.ts",
         "test.js",
+        "ref/m1.d.ts",
+        "ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outMixedSubfolderNoOutdir/node/outMixedSubfolderNoOutdir.json b/tests/baselines/reference/project/outMixedSubfolderNoOutdir/node/outMixedSubfolderNoOutdir.json
index 82eaf9fdb388e..f3f6c757f1880 100644
--- a/tests/baselines/reference/project/outMixedSubfolderNoOutdir/node/outMixedSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/outMixedSubfolderNoOutdir/node/outMixedSubfolderNoOutdir.json
@@ -14,10 +14,10 @@
     ],
     "emittedFiles": [
         "ref/m1.js",
-        "ref/m1.d.ts",
         "ref/m2.js",
-        "ref/m2.d.ts",
         "test.js",
+        "ref/m1.d.ts",
+        "ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outMixedSubfolderSpecifyOutputDirectory/amd/outMixedSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/outMixedSubfolderSpecifyOutputDirectory/amd/outMixedSubfolderSpecifyOutputDirectory.json
index 9fc077c55cae6..b6e1b91e9644f 100644
--- a/tests/baselines/reference/project/outMixedSubfolderSpecifyOutputDirectory/amd/outMixedSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/outMixedSubfolderSpecifyOutputDirectory/amd/outMixedSubfolderSpecifyOutputDirectory.json
@@ -15,10 +15,10 @@
     ],
     "emittedFiles": [
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/ref/m2.js",
-        "outdir/simple/ref/m2.d.ts",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
+        "outdir/simple/ref/m2.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outMixedSubfolderSpecifyOutputDirectory/node/outMixedSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/outMixedSubfolderSpecifyOutputDirectory/node/outMixedSubfolderSpecifyOutputDirectory.json
index 9fc077c55cae6..b6e1b91e9644f 100644
--- a/tests/baselines/reference/project/outMixedSubfolderSpecifyOutputDirectory/node/outMixedSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/outMixedSubfolderSpecifyOutputDirectory/node/outMixedSubfolderSpecifyOutputDirectory.json
@@ -15,10 +15,10 @@
     ],
     "emittedFiles": [
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/ref/m2.js",
-        "outdir/simple/ref/m2.d.ts",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
+        "outdir/simple/ref/m2.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outMixedSubfolderSpecifyOutputFile/amd/outMixedSubfolderSpecifyOutputFile.json b/tests/baselines/reference/project/outMixedSubfolderSpecifyOutputFile/amd/outMixedSubfolderSpecifyOutputFile.json
index 975fcf59ca98c..b3ec5815c21bf 100644
--- a/tests/baselines/reference/project/outMixedSubfolderSpecifyOutputFile/amd/outMixedSubfolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/outMixedSubfolderSpecifyOutputFile/amd/outMixedSubfolderSpecifyOutputFile.json
@@ -15,8 +15,8 @@
     ],
     "emittedFiles": [
         "ref/m2.js",
-        "ref/m2.d.ts",
         "bin/test.js",
+        "ref/m2.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outMixedSubfolderSpecifyOutputFile/node/outMixedSubfolderSpecifyOutputFile.json b/tests/baselines/reference/project/outMixedSubfolderSpecifyOutputFile/node/outMixedSubfolderSpecifyOutputFile.json
index 975fcf59ca98c..b3ec5815c21bf 100644
--- a/tests/baselines/reference/project/outMixedSubfolderSpecifyOutputFile/node/outMixedSubfolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/outMixedSubfolderSpecifyOutputFile/node/outMixedSubfolderSpecifyOutputFile.json
@@ -15,8 +15,8 @@
     ],
     "emittedFiles": [
         "ref/m2.js",
-        "ref/m2.d.ts",
         "bin/test.js",
+        "ref/m2.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outMixedSubfolderSpecifyOutputFileAndOutputDirectory/amd/outMixedSubfolderSpecifyOutputFileAndOutputDirectory.json b/tests/baselines/reference/project/outMixedSubfolderSpecifyOutputFileAndOutputDirectory/amd/outMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
index 2b0a20e739a44..70537fa2772c0 100644
--- a/tests/baselines/reference/project/outMixedSubfolderSpecifyOutputFileAndOutputDirectory/amd/outMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
+++ b/tests/baselines/reference/project/outMixedSubfolderSpecifyOutputFileAndOutputDirectory/amd/outMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
@@ -16,8 +16,8 @@
     ],
     "emittedFiles": [
         "outdir/outAndOutDirFolder/ref/m2.js",
-        "outdir/outAndOutDirFolder/ref/m2.d.ts",
         "bin/outAndOutDirFile.js",
+        "outdir/outAndOutDirFolder/ref/m2.d.ts",
         "bin/outAndOutDirFile.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outMixedSubfolderSpecifyOutputFileAndOutputDirectory/node/outMixedSubfolderSpecifyOutputFileAndOutputDirectory.json b/tests/baselines/reference/project/outMixedSubfolderSpecifyOutputFileAndOutputDirectory/node/outMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
index 2b0a20e739a44..70537fa2772c0 100644
--- a/tests/baselines/reference/project/outMixedSubfolderSpecifyOutputFileAndOutputDirectory/node/outMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
+++ b/tests/baselines/reference/project/outMixedSubfolderSpecifyOutputFileAndOutputDirectory/node/outMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
@@ -16,8 +16,8 @@
     ],
     "emittedFiles": [
         "outdir/outAndOutDirFolder/ref/m2.js",
-        "outdir/outAndOutDirFolder/ref/m2.d.ts",
         "bin/outAndOutDirFile.js",
+        "outdir/outAndOutDirFolder/ref/m2.d.ts",
         "bin/outAndOutDirFile.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outModuleMultifolderNoOutdir/amd/outModuleMultifolderNoOutdir.json b/tests/baselines/reference/project/outModuleMultifolderNoOutdir/amd/outModuleMultifolderNoOutdir.json
index 2cbfa1a6c6e3d..3602302b46dbd 100644
--- a/tests/baselines/reference/project/outModuleMultifolderNoOutdir/amd/outModuleMultifolderNoOutdir.json
+++ b/tests/baselines/reference/project/outModuleMultifolderNoOutdir/amd/outModuleMultifolderNoOutdir.json
@@ -14,10 +14,10 @@
     ],
     "emittedFiles": [
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_module_multifolder_ref/m2.js",
-        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.js",
+        "ref/m1.d.ts",
+        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outModuleMultifolderNoOutdir/node/outModuleMultifolderNoOutdir.json b/tests/baselines/reference/project/outModuleMultifolderNoOutdir/node/outModuleMultifolderNoOutdir.json
index 2cbfa1a6c6e3d..3602302b46dbd 100644
--- a/tests/baselines/reference/project/outModuleMultifolderNoOutdir/node/outModuleMultifolderNoOutdir.json
+++ b/tests/baselines/reference/project/outModuleMultifolderNoOutdir/node/outModuleMultifolderNoOutdir.json
@@ -14,10 +14,10 @@
     ],
     "emittedFiles": [
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_module_multifolder_ref/m2.js",
-        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.js",
+        "ref/m1.d.ts",
+        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputDirectory/amd/outModuleMultifolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputDirectory/amd/outModuleMultifolderSpecifyOutputDirectory.json
index a65215b0814da..f4f639eced427 100644
--- a/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputDirectory/amd/outModuleMultifolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputDirectory/amd/outModuleMultifolderSpecifyOutputDirectory.json
@@ -15,10 +15,10 @@
     ],
     "emittedFiles": [
         "outdir/simple/outputdir_module_multifolder/ref/m1.js",
-        "outdir/simple/outputdir_module_multifolder/ref/m1.d.ts",
         "outdir/simple/outputdir_module_multifolder_ref/m2.js",
-        "outdir/simple/outputdir_module_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_module_multifolder/test.js",
+        "outdir/simple/outputdir_module_multifolder/ref/m1.d.ts",
+        "outdir/simple/outputdir_module_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_module_multifolder/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputDirectory/node/outModuleMultifolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputDirectory/node/outModuleMultifolderSpecifyOutputDirectory.json
index a65215b0814da..f4f639eced427 100644
--- a/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputDirectory/node/outModuleMultifolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputDirectory/node/outModuleMultifolderSpecifyOutputDirectory.json
@@ -15,10 +15,10 @@
     ],
     "emittedFiles": [
         "outdir/simple/outputdir_module_multifolder/ref/m1.js",
-        "outdir/simple/outputdir_module_multifolder/ref/m1.d.ts",
         "outdir/simple/outputdir_module_multifolder_ref/m2.js",
-        "outdir/simple/outputdir_module_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_module_multifolder/test.js",
+        "outdir/simple/outputdir_module_multifolder/ref/m1.d.ts",
+        "outdir/simple/outputdir_module_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_module_multifolder/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/amd/outModuleMultifolderSpecifyOutputFile.json b/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/amd/outModuleMultifolderSpecifyOutputFile.json
index 66eced5cc015e..bff5ed155e950 100644
--- a/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/amd/outModuleMultifolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/amd/outModuleMultifolderSpecifyOutputFile.json
@@ -15,12 +15,12 @@
     ],
     "emittedFiles": [
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_module_multifolder_ref/m2.js",
-        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.js",
-        "test.d.ts",
         "bin/test.js",
+        "ref/m1.d.ts",
+        "../outputdir_module_multifolder_ref/m2.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/node/outModuleMultifolderSpecifyOutputFile.json b/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/node/outModuleMultifolderSpecifyOutputFile.json
index 66eced5cc015e..bff5ed155e950 100644
--- a/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/node/outModuleMultifolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/node/outModuleMultifolderSpecifyOutputFile.json
@@ -15,12 +15,12 @@
     ],
     "emittedFiles": [
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_module_multifolder_ref/m2.js",
-        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.js",
-        "test.d.ts",
         "bin/test.js",
+        "ref/m1.d.ts",
+        "../outputdir_module_multifolder_ref/m2.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outModuleSimpleNoOutdir/amd/outModuleSimpleNoOutdir.json b/tests/baselines/reference/project/outModuleSimpleNoOutdir/amd/outModuleSimpleNoOutdir.json
index 01945c9b97019..b5944fd4a6ebd 100644
--- a/tests/baselines/reference/project/outModuleSimpleNoOutdir/amd/outModuleSimpleNoOutdir.json
+++ b/tests/baselines/reference/project/outModuleSimpleNoOutdir/amd/outModuleSimpleNoOutdir.json
@@ -13,8 +13,8 @@
     ],
     "emittedFiles": [
         "m1.js",
-        "m1.d.ts",
         "test.js",
+        "m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outModuleSimpleNoOutdir/node/outModuleSimpleNoOutdir.json b/tests/baselines/reference/project/outModuleSimpleNoOutdir/node/outModuleSimpleNoOutdir.json
index 01945c9b97019..b5944fd4a6ebd 100644
--- a/tests/baselines/reference/project/outModuleSimpleNoOutdir/node/outModuleSimpleNoOutdir.json
+++ b/tests/baselines/reference/project/outModuleSimpleNoOutdir/node/outModuleSimpleNoOutdir.json
@@ -13,8 +13,8 @@
     ],
     "emittedFiles": [
         "m1.js",
-        "m1.d.ts",
         "test.js",
+        "m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outModuleSimpleSpecifyOutputDirectory/amd/outModuleSimpleSpecifyOutputDirectory.json b/tests/baselines/reference/project/outModuleSimpleSpecifyOutputDirectory/amd/outModuleSimpleSpecifyOutputDirectory.json
index d285d2f095232..217a6dcecbbee 100644
--- a/tests/baselines/reference/project/outModuleSimpleSpecifyOutputDirectory/amd/outModuleSimpleSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/outModuleSimpleSpecifyOutputDirectory/amd/outModuleSimpleSpecifyOutputDirectory.json
@@ -14,8 +14,8 @@
     ],
     "emittedFiles": [
         "outdir/simple/m1.js",
-        "outdir/simple/m1.d.ts",
         "outdir/simple/test.js",
+        "outdir/simple/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outModuleSimpleSpecifyOutputDirectory/node/outModuleSimpleSpecifyOutputDirectory.json b/tests/baselines/reference/project/outModuleSimpleSpecifyOutputDirectory/node/outModuleSimpleSpecifyOutputDirectory.json
index d285d2f095232..217a6dcecbbee 100644
--- a/tests/baselines/reference/project/outModuleSimpleSpecifyOutputDirectory/node/outModuleSimpleSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/outModuleSimpleSpecifyOutputDirectory/node/outModuleSimpleSpecifyOutputDirectory.json
@@ -14,8 +14,8 @@
     ],
     "emittedFiles": [
         "outdir/simple/m1.js",
-        "outdir/simple/m1.d.ts",
         "outdir/simple/test.js",
+        "outdir/simple/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outModuleSimpleSpecifyOutputFile/amd/outModuleSimpleSpecifyOutputFile.json b/tests/baselines/reference/project/outModuleSimpleSpecifyOutputFile/amd/outModuleSimpleSpecifyOutputFile.json
index 166aaa982e7ea..81d463240c6ec 100644
--- a/tests/baselines/reference/project/outModuleSimpleSpecifyOutputFile/amd/outModuleSimpleSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/outModuleSimpleSpecifyOutputFile/amd/outModuleSimpleSpecifyOutputFile.json
@@ -14,10 +14,10 @@
     ],
     "emittedFiles": [
         "m1.js",
-        "m1.d.ts",
         "test.js",
-        "test.d.ts",
         "bin/test.js",
+        "m1.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outModuleSimpleSpecifyOutputFile/node/outModuleSimpleSpecifyOutputFile.json b/tests/baselines/reference/project/outModuleSimpleSpecifyOutputFile/node/outModuleSimpleSpecifyOutputFile.json
index 166aaa982e7ea..81d463240c6ec 100644
--- a/tests/baselines/reference/project/outModuleSimpleSpecifyOutputFile/node/outModuleSimpleSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/outModuleSimpleSpecifyOutputFile/node/outModuleSimpleSpecifyOutputFile.json
@@ -14,10 +14,10 @@
     ],
     "emittedFiles": [
         "m1.js",
-        "m1.d.ts",
         "test.js",
-        "test.d.ts",
         "bin/test.js",
+        "m1.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outModuleSubfolderNoOutdir/amd/outModuleSubfolderNoOutdir.json b/tests/baselines/reference/project/outModuleSubfolderNoOutdir/amd/outModuleSubfolderNoOutdir.json
index af995f809655e..b945df8f1c044 100644
--- a/tests/baselines/reference/project/outModuleSubfolderNoOutdir/amd/outModuleSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/outModuleSubfolderNoOutdir/amd/outModuleSubfolderNoOutdir.json
@@ -13,8 +13,8 @@
     ],
     "emittedFiles": [
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js",
+        "ref/m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outModuleSubfolderNoOutdir/node/outModuleSubfolderNoOutdir.json b/tests/baselines/reference/project/outModuleSubfolderNoOutdir/node/outModuleSubfolderNoOutdir.json
index af995f809655e..b945df8f1c044 100644
--- a/tests/baselines/reference/project/outModuleSubfolderNoOutdir/node/outModuleSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/outModuleSubfolderNoOutdir/node/outModuleSubfolderNoOutdir.json
@@ -13,8 +13,8 @@
     ],
     "emittedFiles": [
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js",
+        "ref/m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outModuleSubfolderSpecifyOutputDirectory/amd/outModuleSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/outModuleSubfolderSpecifyOutputDirectory/amd/outModuleSubfolderSpecifyOutputDirectory.json
index 2688aeab19328..b4c5749b45146 100644
--- a/tests/baselines/reference/project/outModuleSubfolderSpecifyOutputDirectory/amd/outModuleSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/outModuleSubfolderSpecifyOutputDirectory/amd/outModuleSubfolderSpecifyOutputDirectory.json
@@ -14,8 +14,8 @@
     ],
     "emittedFiles": [
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outModuleSubfolderSpecifyOutputDirectory/node/outModuleSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/outModuleSubfolderSpecifyOutputDirectory/node/outModuleSubfolderSpecifyOutputDirectory.json
index 2688aeab19328..b4c5749b45146 100644
--- a/tests/baselines/reference/project/outModuleSubfolderSpecifyOutputDirectory/node/outModuleSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/outModuleSubfolderSpecifyOutputDirectory/node/outModuleSubfolderSpecifyOutputDirectory.json
@@ -14,8 +14,8 @@
     ],
     "emittedFiles": [
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outModuleSubfolderSpecifyOutputFile/amd/outModuleSubfolderSpecifyOutputFile.json b/tests/baselines/reference/project/outModuleSubfolderSpecifyOutputFile/amd/outModuleSubfolderSpecifyOutputFile.json
index f11b95edde911..3b134636144cf 100644
--- a/tests/baselines/reference/project/outModuleSubfolderSpecifyOutputFile/amd/outModuleSubfolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/outModuleSubfolderSpecifyOutputFile/amd/outModuleSubfolderSpecifyOutputFile.json
@@ -14,10 +14,10 @@
     ],
     "emittedFiles": [
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js",
-        "test.d.ts",
         "bin/test.js",
+        "ref/m1.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outModuleSubfolderSpecifyOutputFile/node/outModuleSubfolderSpecifyOutputFile.json b/tests/baselines/reference/project/outModuleSubfolderSpecifyOutputFile/node/outModuleSubfolderSpecifyOutputFile.json
index f11b95edde911..3b134636144cf 100644
--- a/tests/baselines/reference/project/outModuleSubfolderSpecifyOutputFile/node/outModuleSubfolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/outModuleSubfolderSpecifyOutputFile/node/outModuleSubfolderSpecifyOutputFile.json
@@ -14,10 +14,10 @@
     ],
     "emittedFiles": [
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js",
-        "test.d.ts",
         "bin/test.js",
+        "ref/m1.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outMultifolderNoOutdir/amd/outMultifolderNoOutdir.json b/tests/baselines/reference/project/outMultifolderNoOutdir/amd/outMultifolderNoOutdir.json
index 2b3760733c72c..27ef307f803c6 100644
--- a/tests/baselines/reference/project/outMultifolderNoOutdir/amd/outMultifolderNoOutdir.json
+++ b/tests/baselines/reference/project/outMultifolderNoOutdir/amd/outMultifolderNoOutdir.json
@@ -14,10 +14,10 @@
     ],
     "emittedFiles": [
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_multifolder_ref/m2.js",
-        "../outputdir_multifolder_ref/m2.d.ts",
         "test.js",
+        "ref/m1.d.ts",
+        "../outputdir_multifolder_ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outMultifolderNoOutdir/node/outMultifolderNoOutdir.json b/tests/baselines/reference/project/outMultifolderNoOutdir/node/outMultifolderNoOutdir.json
index 2b3760733c72c..27ef307f803c6 100644
--- a/tests/baselines/reference/project/outMultifolderNoOutdir/node/outMultifolderNoOutdir.json
+++ b/tests/baselines/reference/project/outMultifolderNoOutdir/node/outMultifolderNoOutdir.json
@@ -14,10 +14,10 @@
     ],
     "emittedFiles": [
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_multifolder_ref/m2.js",
-        "../outputdir_multifolder_ref/m2.d.ts",
         "test.js",
+        "ref/m1.d.ts",
+        "../outputdir_multifolder_ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outMultifolderSpecifyOutputDirectory/amd/outMultifolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/outMultifolderSpecifyOutputDirectory/amd/outMultifolderSpecifyOutputDirectory.json
index 9e77628b36862..dc1c436ce8fa4 100644
--- a/tests/baselines/reference/project/outMultifolderSpecifyOutputDirectory/amd/outMultifolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/outMultifolderSpecifyOutputDirectory/amd/outMultifolderSpecifyOutputDirectory.json
@@ -15,10 +15,10 @@
     ],
     "emittedFiles": [
         "outdir/simple/outputdir_multifolder/ref/m1.js",
-        "outdir/simple/outputdir_multifolder/ref/m1.d.ts",
         "outdir/simple/outputdir_multifolder_ref/m2.js",
-        "outdir/simple/outputdir_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_multifolder/test.js",
+        "outdir/simple/outputdir_multifolder/ref/m1.d.ts",
+        "outdir/simple/outputdir_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_multifolder/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outMultifolderSpecifyOutputDirectory/node/outMultifolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/outMultifolderSpecifyOutputDirectory/node/outMultifolderSpecifyOutputDirectory.json
index 9e77628b36862..dc1c436ce8fa4 100644
--- a/tests/baselines/reference/project/outMultifolderSpecifyOutputDirectory/node/outMultifolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/outMultifolderSpecifyOutputDirectory/node/outMultifolderSpecifyOutputDirectory.json
@@ -15,10 +15,10 @@
     ],
     "emittedFiles": [
         "outdir/simple/outputdir_multifolder/ref/m1.js",
-        "outdir/simple/outputdir_multifolder/ref/m1.d.ts",
         "outdir/simple/outputdir_multifolder_ref/m2.js",
-        "outdir/simple/outputdir_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_multifolder/test.js",
+        "outdir/simple/outputdir_multifolder/ref/m1.d.ts",
+        "outdir/simple/outputdir_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_multifolder/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outSimpleNoOutdir/amd/outSimpleNoOutdir.json b/tests/baselines/reference/project/outSimpleNoOutdir/amd/outSimpleNoOutdir.json
index 0e35df542d2d9..be508edd6b649 100644
--- a/tests/baselines/reference/project/outSimpleNoOutdir/amd/outSimpleNoOutdir.json
+++ b/tests/baselines/reference/project/outSimpleNoOutdir/amd/outSimpleNoOutdir.json
@@ -13,8 +13,8 @@
     ],
     "emittedFiles": [
         "m1.js",
-        "m1.d.ts",
         "test.js",
+        "m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outSimpleNoOutdir/node/outSimpleNoOutdir.json b/tests/baselines/reference/project/outSimpleNoOutdir/node/outSimpleNoOutdir.json
index 0e35df542d2d9..be508edd6b649 100644
--- a/tests/baselines/reference/project/outSimpleNoOutdir/node/outSimpleNoOutdir.json
+++ b/tests/baselines/reference/project/outSimpleNoOutdir/node/outSimpleNoOutdir.json
@@ -13,8 +13,8 @@
     ],
     "emittedFiles": [
         "m1.js",
-        "m1.d.ts",
         "test.js",
+        "m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outSimpleSpecifyOutputDirectory/amd/outSimpleSpecifyOutputDirectory.json b/tests/baselines/reference/project/outSimpleSpecifyOutputDirectory/amd/outSimpleSpecifyOutputDirectory.json
index 26795d9489e8c..7ca4b7cf001b0 100644
--- a/tests/baselines/reference/project/outSimpleSpecifyOutputDirectory/amd/outSimpleSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/outSimpleSpecifyOutputDirectory/amd/outSimpleSpecifyOutputDirectory.json
@@ -14,8 +14,8 @@
     ],
     "emittedFiles": [
         "outdir/simple/m1.js",
-        "outdir/simple/m1.d.ts",
         "outdir/simple/test.js",
+        "outdir/simple/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outSimpleSpecifyOutputDirectory/node/outSimpleSpecifyOutputDirectory.json b/tests/baselines/reference/project/outSimpleSpecifyOutputDirectory/node/outSimpleSpecifyOutputDirectory.json
index 26795d9489e8c..7ca4b7cf001b0 100644
--- a/tests/baselines/reference/project/outSimpleSpecifyOutputDirectory/node/outSimpleSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/outSimpleSpecifyOutputDirectory/node/outSimpleSpecifyOutputDirectory.json
@@ -14,8 +14,8 @@
     ],
     "emittedFiles": [
         "outdir/simple/m1.js",
-        "outdir/simple/m1.d.ts",
         "outdir/simple/test.js",
+        "outdir/simple/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outSubfolderNoOutdir/amd/outSubfolderNoOutdir.json b/tests/baselines/reference/project/outSubfolderNoOutdir/amd/outSubfolderNoOutdir.json
index 33dae01c2e5a7..fd415cba71367 100644
--- a/tests/baselines/reference/project/outSubfolderNoOutdir/amd/outSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/outSubfolderNoOutdir/amd/outSubfolderNoOutdir.json
@@ -13,8 +13,8 @@
     ],
     "emittedFiles": [
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js",
+        "ref/m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outSubfolderNoOutdir/node/outSubfolderNoOutdir.json b/tests/baselines/reference/project/outSubfolderNoOutdir/node/outSubfolderNoOutdir.json
index 33dae01c2e5a7..fd415cba71367 100644
--- a/tests/baselines/reference/project/outSubfolderNoOutdir/node/outSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/outSubfolderNoOutdir/node/outSubfolderNoOutdir.json
@@ -13,8 +13,8 @@
     ],
     "emittedFiles": [
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js",
+        "ref/m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outSubfolderSpecifyOutputDirectory/amd/outSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/outSubfolderSpecifyOutputDirectory/amd/outSubfolderSpecifyOutputDirectory.json
index f1deedfb0e599..00d46369aeef5 100644
--- a/tests/baselines/reference/project/outSubfolderSpecifyOutputDirectory/amd/outSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/outSubfolderSpecifyOutputDirectory/amd/outSubfolderSpecifyOutputDirectory.json
@@ -14,8 +14,8 @@
     ],
     "emittedFiles": [
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/outSubfolderSpecifyOutputDirectory/node/outSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/outSubfolderSpecifyOutputDirectory/node/outSubfolderSpecifyOutputDirectory.json
index f1deedfb0e599..00d46369aeef5 100644
--- a/tests/baselines/reference/project/outSubfolderSpecifyOutputDirectory/node/outSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/outSubfolderSpecifyOutputDirectory/node/outSubfolderSpecifyOutputDirectory.json
@@ -14,8 +14,8 @@
     ],
     "emittedFiles": [
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/quotesInFileAndDirectoryNames/amd/quotesInFileAndDirectoryNames.json b/tests/baselines/reference/project/quotesInFileAndDirectoryNames/amd/quotesInFileAndDirectoryNames.json
index b18b813804da1..3f3bfc9994525 100644
--- a/tests/baselines/reference/project/quotesInFileAndDirectoryNames/amd/quotesInFileAndDirectoryNames.json
+++ b/tests/baselines/reference/project/quotesInFileAndDirectoryNames/amd/quotesInFileAndDirectoryNames.json
@@ -13,8 +13,8 @@
     ],
     "emittedFiles": [
         "li'b/class'A.js",
-        "li'b/class'A.d.ts",
         "m'ain.js",
+        "li'b/class'A.d.ts",
         "m'ain.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/quotesInFileAndDirectoryNames/node/quotesInFileAndDirectoryNames.json b/tests/baselines/reference/project/quotesInFileAndDirectoryNames/node/quotesInFileAndDirectoryNames.json
index b18b813804da1..3f3bfc9994525 100644
--- a/tests/baselines/reference/project/quotesInFileAndDirectoryNames/node/quotesInFileAndDirectoryNames.json
+++ b/tests/baselines/reference/project/quotesInFileAndDirectoryNames/node/quotesInFileAndDirectoryNames.json
@@ -13,8 +13,8 @@
     ],
     "emittedFiles": [
         "li'b/class'A.js",
-        "li'b/class'A.d.ts",
         "m'ain.js",
+        "li'b/class'A.d.ts",
         "m'ain.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/referenceResolutionRelativePaths/amd/referenceResolutionRelativePaths.json b/tests/baselines/reference/project/referenceResolutionRelativePaths/amd/referenceResolutionRelativePaths.json
index fe07bb38b9207..fde5d653c9c55 100644
--- a/tests/baselines/reference/project/referenceResolutionRelativePaths/amd/referenceResolutionRelativePaths.json
+++ b/tests/baselines/reference/project/referenceResolutionRelativePaths/amd/referenceResolutionRelativePaths.json
@@ -13,8 +13,8 @@
     ],
     "emittedFiles": [
         "../../../bar/bar.js",
-        "../../../bar/bar.d.ts",
         "foo.js",
+        "../../../bar/bar.d.ts",
         "foo.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/referenceResolutionRelativePaths/node/referenceResolutionRelativePaths.json b/tests/baselines/reference/project/referenceResolutionRelativePaths/node/referenceResolutionRelativePaths.json
index fe07bb38b9207..fde5d653c9c55 100644
--- a/tests/baselines/reference/project/referenceResolutionRelativePaths/node/referenceResolutionRelativePaths.json
+++ b/tests/baselines/reference/project/referenceResolutionRelativePaths/node/referenceResolutionRelativePaths.json
@@ -13,8 +13,8 @@
     ],
     "emittedFiles": [
         "../../../bar/bar.js",
-        "../../../bar/bar.d.ts",
         "foo.js",
+        "../../../bar/bar.d.ts",
         "foo.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/referenceResolutionRelativePathsFromRootDirectory/amd/referenceResolutionRelativePathsFromRootDirectory.json b/tests/baselines/reference/project/referenceResolutionRelativePathsFromRootDirectory/amd/referenceResolutionRelativePathsFromRootDirectory.json
index b24993bcf8fef..2eec71e9b250f 100644
--- a/tests/baselines/reference/project/referenceResolutionRelativePathsFromRootDirectory/amd/referenceResolutionRelativePathsFromRootDirectory.json
+++ b/tests/baselines/reference/project/referenceResolutionRelativePathsFromRootDirectory/amd/referenceResolutionRelativePathsFromRootDirectory.json
@@ -13,8 +13,8 @@
     ],
     "emittedFiles": [
         "bar/bar.js",
-        "bar/bar.d.ts",
         "src/ts/foo/foo.js",
+        "bar/bar.d.ts",
         "src/ts/foo/foo.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/referenceResolutionRelativePathsFromRootDirectory/node/referenceResolutionRelativePathsFromRootDirectory.json b/tests/baselines/reference/project/referenceResolutionRelativePathsFromRootDirectory/node/referenceResolutionRelativePathsFromRootDirectory.json
index b24993bcf8fef..2eec71e9b250f 100644
--- a/tests/baselines/reference/project/referenceResolutionRelativePathsFromRootDirectory/node/referenceResolutionRelativePathsFromRootDirectory.json
+++ b/tests/baselines/reference/project/referenceResolutionRelativePathsFromRootDirectory/node/referenceResolutionRelativePathsFromRootDirectory.json
@@ -13,8 +13,8 @@
     ],
     "emittedFiles": [
         "bar/bar.js",
-        "bar/bar.d.ts",
         "src/ts/foo/foo.js",
+        "bar/bar.d.ts",
         "src/ts/foo/foo.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/referenceResolutionRelativePathsNoResolve/amd/referenceResolutionRelativePathsNoResolve.json b/tests/baselines/reference/project/referenceResolutionRelativePathsNoResolve/amd/referenceResolutionRelativePathsNoResolve.json
index 16831b328e9c7..2bbae48c4c6e1 100644
--- a/tests/baselines/reference/project/referenceResolutionRelativePathsNoResolve/amd/referenceResolutionRelativePathsNoResolve.json
+++ b/tests/baselines/reference/project/referenceResolutionRelativePathsNoResolve/amd/referenceResolutionRelativePathsNoResolve.json
@@ -14,8 +14,8 @@
     ],
     "emittedFiles": [
         "foo.js",
-        "foo.d.ts",
         "../../../bar/bar.js",
+        "foo.d.ts",
         "../../../bar/bar.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/referenceResolutionRelativePathsNoResolve/node/referenceResolutionRelativePathsNoResolve.json b/tests/baselines/reference/project/referenceResolutionRelativePathsNoResolve/node/referenceResolutionRelativePathsNoResolve.json
index 16831b328e9c7..2bbae48c4c6e1 100644
--- a/tests/baselines/reference/project/referenceResolutionRelativePathsNoResolve/node/referenceResolutionRelativePathsNoResolve.json
+++ b/tests/baselines/reference/project/referenceResolutionRelativePathsNoResolve/node/referenceResolutionRelativePathsNoResolve.json
@@ -14,8 +14,8 @@
     ],
     "emittedFiles": [
         "foo.js",
-        "foo.d.ts",
         "../../../bar/bar.js",
+        "foo.d.ts",
         "../../../bar/bar.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/referenceResolutionRelativePathsRelativeToRootDirectory/amd/referenceResolutionRelativePathsRelativeToRootDirectory.json b/tests/baselines/reference/project/referenceResolutionRelativePathsRelativeToRootDirectory/amd/referenceResolutionRelativePathsRelativeToRootDirectory.json
index 79b73ec775b4b..c729c60f4f895 100644
--- a/tests/baselines/reference/project/referenceResolutionRelativePathsRelativeToRootDirectory/amd/referenceResolutionRelativePathsRelativeToRootDirectory.json
+++ b/tests/baselines/reference/project/referenceResolutionRelativePathsRelativeToRootDirectory/amd/referenceResolutionRelativePathsRelativeToRootDirectory.json
@@ -13,8 +13,8 @@
     ],
     "emittedFiles": [
         "../../../bar/bar.js",
-        "../../../bar/bar.d.ts",
         "../../../src/ts/foo/foo.js",
+        "../../../bar/bar.d.ts",
         "../../../src/ts/foo/foo.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/referenceResolutionRelativePathsRelativeToRootDirectory/node/referenceResolutionRelativePathsRelativeToRootDirectory.json b/tests/baselines/reference/project/referenceResolutionRelativePathsRelativeToRootDirectory/node/referenceResolutionRelativePathsRelativeToRootDirectory.json
index 79b73ec775b4b..c729c60f4f895 100644
--- a/tests/baselines/reference/project/referenceResolutionRelativePathsRelativeToRootDirectory/node/referenceResolutionRelativePathsRelativeToRootDirectory.json
+++ b/tests/baselines/reference/project/referenceResolutionRelativePathsRelativeToRootDirectory/node/referenceResolutionRelativePathsRelativeToRootDirectory.json
@@ -13,8 +13,8 @@
     ],
     "emittedFiles": [
         "../../../bar/bar.js",
-        "../../../bar/bar.d.ts",
         "../../../src/ts/foo/foo.js",
+        "../../../bar/bar.d.ts",
         "../../../src/ts/foo/foo.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/rootDirectory/amd/rootDirectory.json b/tests/baselines/reference/project/rootDirectory/amd/rootDirectory.json
index 2ec18b3ac5acf..bed4f12f6563f 100644
--- a/tests/baselines/reference/project/rootDirectory/amd/rootDirectory.json
+++ b/tests/baselines/reference/project/rootDirectory/amd/rootDirectory.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "outdir/simple/FolderB/FolderC/fileC.js.map",
         "outdir/simple/FolderB/FolderC/fileC.js",
-        "outdir/simple/FolderB/FolderC/fileC.d.ts",
         "outdir/simple/FolderB/fileB.js.map",
         "outdir/simple/FolderB/fileB.js",
+        "outdir/simple/FolderB/FolderC/fileC.d.ts",
         "outdir/simple/FolderB/fileB.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/rootDirectory/node/rootDirectory.json b/tests/baselines/reference/project/rootDirectory/node/rootDirectory.json
index 2ec18b3ac5acf..bed4f12f6563f 100644
--- a/tests/baselines/reference/project/rootDirectory/node/rootDirectory.json
+++ b/tests/baselines/reference/project/rootDirectory/node/rootDirectory.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "outdir/simple/FolderB/FolderC/fileC.js.map",
         "outdir/simple/FolderB/FolderC/fileC.js",
-        "outdir/simple/FolderB/FolderC/fileC.d.ts",
         "outdir/simple/FolderB/fileB.js.map",
         "outdir/simple/FolderB/fileB.js",
+        "outdir/simple/FolderB/FolderC/fileC.d.ts",
         "outdir/simple/FolderB/fileB.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/rootDirectoryErrors/amd/rootDirectoryErrors.json b/tests/baselines/reference/project/rootDirectoryErrors/amd/rootDirectoryErrors.json
index fdde42592ca8d..05cb062cfe200 100644
--- a/tests/baselines/reference/project/rootDirectoryErrors/amd/rootDirectoryErrors.json
+++ b/tests/baselines/reference/project/rootDirectoryErrors/amd/rootDirectoryErrors.json
@@ -15,8 +15,8 @@
     ],
     "emittedFiles": [
         "outdir/simple/FolderC/fileC.js",
-        "outdir/simple/FolderC/fileC.d.ts",
         "outdir/simple/fileB.js",
+        "outdir/simple/FolderC/fileC.d.ts",
         "outdir/simple/fileB.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/rootDirectoryErrors/node/rootDirectoryErrors.json b/tests/baselines/reference/project/rootDirectoryErrors/node/rootDirectoryErrors.json
index fdde42592ca8d..05cb062cfe200 100644
--- a/tests/baselines/reference/project/rootDirectoryErrors/node/rootDirectoryErrors.json
+++ b/tests/baselines/reference/project/rootDirectoryErrors/node/rootDirectoryErrors.json
@@ -15,8 +15,8 @@
     ],
     "emittedFiles": [
         "outdir/simple/FolderC/fileC.js",
-        "outdir/simple/FolderC/fileC.d.ts",
         "outdir/simple/fileB.js",
+        "outdir/simple/FolderC/fileC.d.ts",
         "outdir/simple/fileB.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathMixedSubfolderNoOutdir/amd/sourceRootAbsolutePathMixedSubfolderNoOutdir.json b/tests/baselines/reference/project/sourceRootAbsolutePathMixedSubfolderNoOutdir/amd/sourceRootAbsolutePathMixedSubfolderNoOutdir.json
index 43059eaa5c6bc..cc78623ebc487 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathMixedSubfolderNoOutdir/amd/sourceRootAbsolutePathMixedSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathMixedSubfolderNoOutdir/amd/sourceRootAbsolutePathMixedSubfolderNoOutdir.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "ref/m2.js.map",
         "ref/m2.js",
-        "ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathMixedSubfolderNoOutdir/node/sourceRootAbsolutePathMixedSubfolderNoOutdir.json b/tests/baselines/reference/project/sourceRootAbsolutePathMixedSubfolderNoOutdir/node/sourceRootAbsolutePathMixedSubfolderNoOutdir.json
index 43059eaa5c6bc..cc78623ebc487 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathMixedSubfolderNoOutdir/node/sourceRootAbsolutePathMixedSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathMixedSubfolderNoOutdir/node/sourceRootAbsolutePathMixedSubfolderNoOutdir.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "ref/m2.js.map",
         "ref/m2.js",
-        "ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathMixedSubfolderSpecifyOutputDirectory/amd/sourceRootAbsolutePathMixedSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourceRootAbsolutePathMixedSubfolderSpecifyOutputDirectory/amd/sourceRootAbsolutePathMixedSubfolderSpecifyOutputDirectory.json
index 6d9cf2998a884..af083b57920ec 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathMixedSubfolderSpecifyOutputDirectory/amd/sourceRootAbsolutePathMixedSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathMixedSubfolderSpecifyOutputDirectory/amd/sourceRootAbsolutePathMixedSubfolderSpecifyOutputDirectory.json
@@ -19,12 +19,12 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/ref/m2.js.map",
         "outdir/simple/ref/m2.js",
-        "outdir/simple/ref/m2.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
+        "outdir/simple/ref/m2.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathMixedSubfolderSpecifyOutputDirectory/node/sourceRootAbsolutePathMixedSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourceRootAbsolutePathMixedSubfolderSpecifyOutputDirectory/node/sourceRootAbsolutePathMixedSubfolderSpecifyOutputDirectory.json
index 6d9cf2998a884..af083b57920ec 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathMixedSubfolderSpecifyOutputDirectory/node/sourceRootAbsolutePathMixedSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathMixedSubfolderSpecifyOutputDirectory/node/sourceRootAbsolutePathMixedSubfolderSpecifyOutputDirectory.json
@@ -19,12 +19,12 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/ref/m2.js.map",
         "outdir/simple/ref/m2.js",
-        "outdir/simple/ref/m2.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
+        "outdir/simple/ref/m2.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathMixedSubfolderSpecifyOutputFile/amd/sourceRootAbsolutePathMixedSubfolderSpecifyOutputFile.json b/tests/baselines/reference/project/sourceRootAbsolutePathMixedSubfolderSpecifyOutputFile/amd/sourceRootAbsolutePathMixedSubfolderSpecifyOutputFile.json
index 09c6092f16447..85b5f7af64411 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathMixedSubfolderSpecifyOutputFile/amd/sourceRootAbsolutePathMixedSubfolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathMixedSubfolderSpecifyOutputFile/amd/sourceRootAbsolutePathMixedSubfolderSpecifyOutputFile.json
@@ -19,9 +19,9 @@
     "emittedFiles": [
         "ref/m2.js.map",
         "ref/m2.js",
-        "ref/m2.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m2.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathMixedSubfolderSpecifyOutputFile/node/sourceRootAbsolutePathMixedSubfolderSpecifyOutputFile.json b/tests/baselines/reference/project/sourceRootAbsolutePathMixedSubfolderSpecifyOutputFile/node/sourceRootAbsolutePathMixedSubfolderSpecifyOutputFile.json
index 09c6092f16447..85b5f7af64411 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathMixedSubfolderSpecifyOutputFile/node/sourceRootAbsolutePathMixedSubfolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathMixedSubfolderSpecifyOutputFile/node/sourceRootAbsolutePathMixedSubfolderSpecifyOutputFile.json
@@ -19,9 +19,9 @@
     "emittedFiles": [
         "ref/m2.js.map",
         "ref/m2.js",
-        "ref/m2.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m2.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathMixedSubfolderSpecifyOutputFileAndOutputDirectory/amd/sourceRootAbsolutePathMixedSubfolderSpecifyOutputFileAndOutputDirectory.json b/tests/baselines/reference/project/sourceRootAbsolutePathMixedSubfolderSpecifyOutputFileAndOutputDirectory/amd/sourceRootAbsolutePathMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
index 6fb17fa06b80c..3594db2685f10 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathMixedSubfolderSpecifyOutputFileAndOutputDirectory/amd/sourceRootAbsolutePathMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathMixedSubfolderSpecifyOutputFileAndOutputDirectory/amd/sourceRootAbsolutePathMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
@@ -20,9 +20,9 @@
     "emittedFiles": [
         "outdir/outAndOutDirFolder/ref/m2.js.map",
         "outdir/outAndOutDirFolder/ref/m2.js",
-        "outdir/outAndOutDirFolder/ref/m2.d.ts",
         "bin/outAndOutDirFile.js.map",
         "bin/outAndOutDirFile.js",
+        "outdir/outAndOutDirFolder/ref/m2.d.ts",
         "bin/outAndOutDirFile.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathMixedSubfolderSpecifyOutputFileAndOutputDirectory/node/sourceRootAbsolutePathMixedSubfolderSpecifyOutputFileAndOutputDirectory.json b/tests/baselines/reference/project/sourceRootAbsolutePathMixedSubfolderSpecifyOutputFileAndOutputDirectory/node/sourceRootAbsolutePathMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
index 6fb17fa06b80c..3594db2685f10 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathMixedSubfolderSpecifyOutputFileAndOutputDirectory/node/sourceRootAbsolutePathMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathMixedSubfolderSpecifyOutputFileAndOutputDirectory/node/sourceRootAbsolutePathMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
@@ -20,9 +20,9 @@
     "emittedFiles": [
         "outdir/outAndOutDirFolder/ref/m2.js.map",
         "outdir/outAndOutDirFolder/ref/m2.js",
-        "outdir/outAndOutDirFolder/ref/m2.d.ts",
         "bin/outAndOutDirFile.js.map",
         "bin/outAndOutDirFile.js",
+        "outdir/outAndOutDirFolder/ref/m2.d.ts",
         "bin/outAndOutDirFile.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderNoOutdir/amd/sourceRootAbsolutePathModuleMultifolderNoOutdir.json b/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderNoOutdir/amd/sourceRootAbsolutePathModuleMultifolderNoOutdir.json
index 9e98d46666fa0..7ea0a598a4cb5 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderNoOutdir/amd/sourceRootAbsolutePathModuleMultifolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderNoOutdir/amd/sourceRootAbsolutePathModuleMultifolderNoOutdir.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_module_multifolder_ref/m2.js.map",
         "../outputdir_module_multifolder_ref/m2.js",
-        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderNoOutdir/node/sourceRootAbsolutePathModuleMultifolderNoOutdir.json b/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderNoOutdir/node/sourceRootAbsolutePathModuleMultifolderNoOutdir.json
index 9e98d46666fa0..7ea0a598a4cb5 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderNoOutdir/node/sourceRootAbsolutePathModuleMultifolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderNoOutdir/node/sourceRootAbsolutePathModuleMultifolderNoOutdir.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_module_multifolder_ref/m2.js.map",
         "../outputdir_module_multifolder_ref/m2.js",
-        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputDirectory/amd/sourceRootAbsolutePathModuleMultifolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputDirectory/amd/sourceRootAbsolutePathModuleMultifolderSpecifyOutputDirectory.json
index d96a3e5f83237..0a51dd1134b34 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputDirectory/amd/sourceRootAbsolutePathModuleMultifolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputDirectory/amd/sourceRootAbsolutePathModuleMultifolderSpecifyOutputDirectory.json
@@ -19,12 +19,12 @@
     "emittedFiles": [
         "outdir/simple/outputdir_module_multifolder/ref/m1.js.map",
         "outdir/simple/outputdir_module_multifolder/ref/m1.js",
-        "outdir/simple/outputdir_module_multifolder/ref/m1.d.ts",
         "outdir/simple/outputdir_module_multifolder_ref/m2.js.map",
         "outdir/simple/outputdir_module_multifolder_ref/m2.js",
-        "outdir/simple/outputdir_module_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_module_multifolder/test.js.map",
         "outdir/simple/outputdir_module_multifolder/test.js",
+        "outdir/simple/outputdir_module_multifolder/ref/m1.d.ts",
+        "outdir/simple/outputdir_module_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_module_multifolder/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputDirectory/node/sourceRootAbsolutePathModuleMultifolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputDirectory/node/sourceRootAbsolutePathModuleMultifolderSpecifyOutputDirectory.json
index d96a3e5f83237..0a51dd1134b34 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputDirectory/node/sourceRootAbsolutePathModuleMultifolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputDirectory/node/sourceRootAbsolutePathModuleMultifolderSpecifyOutputDirectory.json
@@ -19,12 +19,12 @@
     "emittedFiles": [
         "outdir/simple/outputdir_module_multifolder/ref/m1.js.map",
         "outdir/simple/outputdir_module_multifolder/ref/m1.js",
-        "outdir/simple/outputdir_module_multifolder/ref/m1.d.ts",
         "outdir/simple/outputdir_module_multifolder_ref/m2.js.map",
         "outdir/simple/outputdir_module_multifolder_ref/m2.js",
-        "outdir/simple/outputdir_module_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_module_multifolder/test.js.map",
         "outdir/simple/outputdir_module_multifolder/test.js",
+        "outdir/simple/outputdir_module_multifolder/ref/m1.d.ts",
+        "outdir/simple/outputdir_module_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_module_multifolder/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile.json b/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile.json
index b3e80123c047c..65c9c11c72939 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile.json
@@ -19,15 +19,15 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_module_multifolder_ref/m2.js.map",
         "../outputdir_module_multifolder_ref/m2.js",
-        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m1.d.ts",
+        "../outputdir_module_multifolder_ref/m2.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/node/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile.json b/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/node/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile.json
index b3e80123c047c..65c9c11c72939 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/node/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/node/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile.json
@@ -19,15 +19,15 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_module_multifolder_ref/m2.js.map",
         "../outputdir_module_multifolder_ref/m2.js",
-        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m1.d.ts",
+        "../outputdir_module_multifolder_ref/m2.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathModuleSimpleNoOutdir/amd/sourceRootAbsolutePathModuleSimpleNoOutdir.json b/tests/baselines/reference/project/sourceRootAbsolutePathModuleSimpleNoOutdir/amd/sourceRootAbsolutePathModuleSimpleNoOutdir.json
index 6e1f133ef6486..a2b183aadc7a8 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathModuleSimpleNoOutdir/amd/sourceRootAbsolutePathModuleSimpleNoOutdir.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathModuleSimpleNoOutdir/amd/sourceRootAbsolutePathModuleSimpleNoOutdir.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
+        "m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathModuleSimpleNoOutdir/node/sourceRootAbsolutePathModuleSimpleNoOutdir.json b/tests/baselines/reference/project/sourceRootAbsolutePathModuleSimpleNoOutdir/node/sourceRootAbsolutePathModuleSimpleNoOutdir.json
index 6e1f133ef6486..a2b183aadc7a8 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathModuleSimpleNoOutdir/node/sourceRootAbsolutePathModuleSimpleNoOutdir.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathModuleSimpleNoOutdir/node/sourceRootAbsolutePathModuleSimpleNoOutdir.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
+        "m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathModuleSimpleSpecifyOutputDirectory/amd/sourceRootAbsolutePathModuleSimpleSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourceRootAbsolutePathModuleSimpleSpecifyOutputDirectory/amd/sourceRootAbsolutePathModuleSimpleSpecifyOutputDirectory.json
index c15e91877ae5c..cf1a67ff03522 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathModuleSimpleSpecifyOutputDirectory/amd/sourceRootAbsolutePathModuleSimpleSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathModuleSimpleSpecifyOutputDirectory/amd/sourceRootAbsolutePathModuleSimpleSpecifyOutputDirectory.json
@@ -18,9 +18,9 @@
     "emittedFiles": [
         "outdir/simple/m1.js.map",
         "outdir/simple/m1.js",
-        "outdir/simple/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathModuleSimpleSpecifyOutputDirectory/node/sourceRootAbsolutePathModuleSimpleSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourceRootAbsolutePathModuleSimpleSpecifyOutputDirectory/node/sourceRootAbsolutePathModuleSimpleSpecifyOutputDirectory.json
index c15e91877ae5c..cf1a67ff03522 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathModuleSimpleSpecifyOutputDirectory/node/sourceRootAbsolutePathModuleSimpleSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathModuleSimpleSpecifyOutputDirectory/node/sourceRootAbsolutePathModuleSimpleSpecifyOutputDirectory.json
@@ -18,9 +18,9 @@
     "emittedFiles": [
         "outdir/simple/m1.js.map",
         "outdir/simple/m1.js",
-        "outdir/simple/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathModuleSimpleSpecifyOutputFile/amd/sourceRootAbsolutePathModuleSimpleSpecifyOutputFile.json b/tests/baselines/reference/project/sourceRootAbsolutePathModuleSimpleSpecifyOutputFile/amd/sourceRootAbsolutePathModuleSimpleSpecifyOutputFile.json
index e2621b2fa52f4..c9ef4df0836d2 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathModuleSimpleSpecifyOutputFile/amd/sourceRootAbsolutePathModuleSimpleSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathModuleSimpleSpecifyOutputFile/amd/sourceRootAbsolutePathModuleSimpleSpecifyOutputFile.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "m1.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathModuleSimpleSpecifyOutputFile/node/sourceRootAbsolutePathModuleSimpleSpecifyOutputFile.json b/tests/baselines/reference/project/sourceRootAbsolutePathModuleSimpleSpecifyOutputFile/node/sourceRootAbsolutePathModuleSimpleSpecifyOutputFile.json
index e2621b2fa52f4..c9ef4df0836d2 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathModuleSimpleSpecifyOutputFile/node/sourceRootAbsolutePathModuleSimpleSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathModuleSimpleSpecifyOutputFile/node/sourceRootAbsolutePathModuleSimpleSpecifyOutputFile.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "m1.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathModuleSubfolderNoOutdir/amd/sourceRootAbsolutePathModuleSubfolderNoOutdir.json b/tests/baselines/reference/project/sourceRootAbsolutePathModuleSubfolderNoOutdir/amd/sourceRootAbsolutePathModuleSubfolderNoOutdir.json
index b65bed6197951..567aadfbfb3b1 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathModuleSubfolderNoOutdir/amd/sourceRootAbsolutePathModuleSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathModuleSubfolderNoOutdir/amd/sourceRootAbsolutePathModuleSubfolderNoOutdir.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathModuleSubfolderNoOutdir/node/sourceRootAbsolutePathModuleSubfolderNoOutdir.json b/tests/baselines/reference/project/sourceRootAbsolutePathModuleSubfolderNoOutdir/node/sourceRootAbsolutePathModuleSubfolderNoOutdir.json
index b65bed6197951..567aadfbfb3b1 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathModuleSubfolderNoOutdir/node/sourceRootAbsolutePathModuleSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathModuleSubfolderNoOutdir/node/sourceRootAbsolutePathModuleSubfolderNoOutdir.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathModuleSubfolderSpecifyOutputDirectory/amd/sourceRootAbsolutePathModuleSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourceRootAbsolutePathModuleSubfolderSpecifyOutputDirectory/amd/sourceRootAbsolutePathModuleSubfolderSpecifyOutputDirectory.json
index a8662e09bf6ea..08183485db0c6 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathModuleSubfolderSpecifyOutputDirectory/amd/sourceRootAbsolutePathModuleSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathModuleSubfolderSpecifyOutputDirectory/amd/sourceRootAbsolutePathModuleSubfolderSpecifyOutputDirectory.json
@@ -18,9 +18,9 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathModuleSubfolderSpecifyOutputDirectory/node/sourceRootAbsolutePathModuleSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourceRootAbsolutePathModuleSubfolderSpecifyOutputDirectory/node/sourceRootAbsolutePathModuleSubfolderSpecifyOutputDirectory.json
index a8662e09bf6ea..08183485db0c6 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathModuleSubfolderSpecifyOutputDirectory/node/sourceRootAbsolutePathModuleSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathModuleSubfolderSpecifyOutputDirectory/node/sourceRootAbsolutePathModuleSubfolderSpecifyOutputDirectory.json
@@ -18,9 +18,9 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathModuleSubfolderSpecifyOutputFile/amd/sourceRootAbsolutePathModuleSubfolderSpecifyOutputFile.json b/tests/baselines/reference/project/sourceRootAbsolutePathModuleSubfolderSpecifyOutputFile/amd/sourceRootAbsolutePathModuleSubfolderSpecifyOutputFile.json
index a43e0f691728e..804a9ff6543b9 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathModuleSubfolderSpecifyOutputFile/amd/sourceRootAbsolutePathModuleSubfolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathModuleSubfolderSpecifyOutputFile/amd/sourceRootAbsolutePathModuleSubfolderSpecifyOutputFile.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m1.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathModuleSubfolderSpecifyOutputFile/node/sourceRootAbsolutePathModuleSubfolderSpecifyOutputFile.json b/tests/baselines/reference/project/sourceRootAbsolutePathModuleSubfolderSpecifyOutputFile/node/sourceRootAbsolutePathModuleSubfolderSpecifyOutputFile.json
index a43e0f691728e..804a9ff6543b9 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathModuleSubfolderSpecifyOutputFile/node/sourceRootAbsolutePathModuleSubfolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathModuleSubfolderSpecifyOutputFile/node/sourceRootAbsolutePathModuleSubfolderSpecifyOutputFile.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m1.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathMultifolderNoOutdir/amd/sourceRootAbsolutePathMultifolderNoOutdir.json b/tests/baselines/reference/project/sourceRootAbsolutePathMultifolderNoOutdir/amd/sourceRootAbsolutePathMultifolderNoOutdir.json
index b84ccc2bc2308..75849f9fbcf6c 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathMultifolderNoOutdir/amd/sourceRootAbsolutePathMultifolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathMultifolderNoOutdir/amd/sourceRootAbsolutePathMultifolderNoOutdir.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_multifolder_ref/m2.js.map",
         "../outputdir_multifolder_ref/m2.js",
-        "../outputdir_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "../outputdir_multifolder_ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathMultifolderNoOutdir/node/sourceRootAbsolutePathMultifolderNoOutdir.json b/tests/baselines/reference/project/sourceRootAbsolutePathMultifolderNoOutdir/node/sourceRootAbsolutePathMultifolderNoOutdir.json
index b84ccc2bc2308..75849f9fbcf6c 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathMultifolderNoOutdir/node/sourceRootAbsolutePathMultifolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathMultifolderNoOutdir/node/sourceRootAbsolutePathMultifolderNoOutdir.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_multifolder_ref/m2.js.map",
         "../outputdir_multifolder_ref/m2.js",
-        "../outputdir_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "../outputdir_multifolder_ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathMultifolderSpecifyOutputDirectory/amd/sourceRootAbsolutePathMultifolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourceRootAbsolutePathMultifolderSpecifyOutputDirectory/amd/sourceRootAbsolutePathMultifolderSpecifyOutputDirectory.json
index 43d3db291ff91..124a922d348e1 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathMultifolderSpecifyOutputDirectory/amd/sourceRootAbsolutePathMultifolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathMultifolderSpecifyOutputDirectory/amd/sourceRootAbsolutePathMultifolderSpecifyOutputDirectory.json
@@ -19,12 +19,12 @@
     "emittedFiles": [
         "outdir/simple/outputdir_multifolder/ref/m1.js.map",
         "outdir/simple/outputdir_multifolder/ref/m1.js",
-        "outdir/simple/outputdir_multifolder/ref/m1.d.ts",
         "outdir/simple/outputdir_multifolder_ref/m2.js.map",
         "outdir/simple/outputdir_multifolder_ref/m2.js",
-        "outdir/simple/outputdir_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_multifolder/test.js.map",
         "outdir/simple/outputdir_multifolder/test.js",
+        "outdir/simple/outputdir_multifolder/ref/m1.d.ts",
+        "outdir/simple/outputdir_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_multifolder/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathMultifolderSpecifyOutputDirectory/node/sourceRootAbsolutePathMultifolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourceRootAbsolutePathMultifolderSpecifyOutputDirectory/node/sourceRootAbsolutePathMultifolderSpecifyOutputDirectory.json
index 43d3db291ff91..124a922d348e1 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathMultifolderSpecifyOutputDirectory/node/sourceRootAbsolutePathMultifolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathMultifolderSpecifyOutputDirectory/node/sourceRootAbsolutePathMultifolderSpecifyOutputDirectory.json
@@ -19,12 +19,12 @@
     "emittedFiles": [
         "outdir/simple/outputdir_multifolder/ref/m1.js.map",
         "outdir/simple/outputdir_multifolder/ref/m1.js",
-        "outdir/simple/outputdir_multifolder/ref/m1.d.ts",
         "outdir/simple/outputdir_multifolder_ref/m2.js.map",
         "outdir/simple/outputdir_multifolder_ref/m2.js",
-        "outdir/simple/outputdir_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_multifolder/test.js.map",
         "outdir/simple/outputdir_multifolder/test.js",
+        "outdir/simple/outputdir_multifolder/ref/m1.d.ts",
+        "outdir/simple/outputdir_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_multifolder/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathSimpleNoOutdir/amd/sourceRootAbsolutePathSimpleNoOutdir.json b/tests/baselines/reference/project/sourceRootAbsolutePathSimpleNoOutdir/amd/sourceRootAbsolutePathSimpleNoOutdir.json
index f57c8110827d0..7d508306f7f51 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathSimpleNoOutdir/amd/sourceRootAbsolutePathSimpleNoOutdir.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathSimpleNoOutdir/amd/sourceRootAbsolutePathSimpleNoOutdir.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
+        "m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathSimpleNoOutdir/node/sourceRootAbsolutePathSimpleNoOutdir.json b/tests/baselines/reference/project/sourceRootAbsolutePathSimpleNoOutdir/node/sourceRootAbsolutePathSimpleNoOutdir.json
index f57c8110827d0..7d508306f7f51 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathSimpleNoOutdir/node/sourceRootAbsolutePathSimpleNoOutdir.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathSimpleNoOutdir/node/sourceRootAbsolutePathSimpleNoOutdir.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
+        "m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathSimpleSpecifyOutputDirectory/amd/sourceRootAbsolutePathSimpleSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourceRootAbsolutePathSimpleSpecifyOutputDirectory/amd/sourceRootAbsolutePathSimpleSpecifyOutputDirectory.json
index 02981610092e3..965fd9bfc2410 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathSimpleSpecifyOutputDirectory/amd/sourceRootAbsolutePathSimpleSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathSimpleSpecifyOutputDirectory/amd/sourceRootAbsolutePathSimpleSpecifyOutputDirectory.json
@@ -18,9 +18,9 @@
     "emittedFiles": [
         "outdir/simple/m1.js.map",
         "outdir/simple/m1.js",
-        "outdir/simple/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathSimpleSpecifyOutputDirectory/node/sourceRootAbsolutePathSimpleSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourceRootAbsolutePathSimpleSpecifyOutputDirectory/node/sourceRootAbsolutePathSimpleSpecifyOutputDirectory.json
index 02981610092e3..965fd9bfc2410 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathSimpleSpecifyOutputDirectory/node/sourceRootAbsolutePathSimpleSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathSimpleSpecifyOutputDirectory/node/sourceRootAbsolutePathSimpleSpecifyOutputDirectory.json
@@ -18,9 +18,9 @@
     "emittedFiles": [
         "outdir/simple/m1.js.map",
         "outdir/simple/m1.js",
-        "outdir/simple/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathSubfolderNoOutdir/amd/sourceRootAbsolutePathSubfolderNoOutdir.json b/tests/baselines/reference/project/sourceRootAbsolutePathSubfolderNoOutdir/amd/sourceRootAbsolutePathSubfolderNoOutdir.json
index 03f06090742ea..34aa3d2cc05fa 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathSubfolderNoOutdir/amd/sourceRootAbsolutePathSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathSubfolderNoOutdir/amd/sourceRootAbsolutePathSubfolderNoOutdir.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathSubfolderNoOutdir/node/sourceRootAbsolutePathSubfolderNoOutdir.json b/tests/baselines/reference/project/sourceRootAbsolutePathSubfolderNoOutdir/node/sourceRootAbsolutePathSubfolderNoOutdir.json
index 03f06090742ea..34aa3d2cc05fa 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathSubfolderNoOutdir/node/sourceRootAbsolutePathSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathSubfolderNoOutdir/node/sourceRootAbsolutePathSubfolderNoOutdir.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathSubfolderSpecifyOutputDirectory/amd/sourceRootAbsolutePathSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourceRootAbsolutePathSubfolderSpecifyOutputDirectory/amd/sourceRootAbsolutePathSubfolderSpecifyOutputDirectory.json
index 08bdabb1c6e3c..8dac264a5660c 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathSubfolderSpecifyOutputDirectory/amd/sourceRootAbsolutePathSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathSubfolderSpecifyOutputDirectory/amd/sourceRootAbsolutePathSubfolderSpecifyOutputDirectory.json
@@ -18,9 +18,9 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootAbsolutePathSubfolderSpecifyOutputDirectory/node/sourceRootAbsolutePathSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourceRootAbsolutePathSubfolderSpecifyOutputDirectory/node/sourceRootAbsolutePathSubfolderSpecifyOutputDirectory.json
index 08bdabb1c6e3c..8dac264a5660c 100644
--- a/tests/baselines/reference/project/sourceRootAbsolutePathSubfolderSpecifyOutputDirectory/node/sourceRootAbsolutePathSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourceRootAbsolutePathSubfolderSpecifyOutputDirectory/node/sourceRootAbsolutePathSubfolderSpecifyOutputDirectory.json
@@ -18,9 +18,9 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathMixedSubfolderNoOutdir/amd/sourceRootRelativePathMixedSubfolderNoOutdir.json b/tests/baselines/reference/project/sourceRootRelativePathMixedSubfolderNoOutdir/amd/sourceRootRelativePathMixedSubfolderNoOutdir.json
index 0e73f218462dd..bc0e7b10aac5c 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathMixedSubfolderNoOutdir/amd/sourceRootRelativePathMixedSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathMixedSubfolderNoOutdir/amd/sourceRootRelativePathMixedSubfolderNoOutdir.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "ref/m2.js.map",
         "ref/m2.js",
-        "ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathMixedSubfolderNoOutdir/node/sourceRootRelativePathMixedSubfolderNoOutdir.json b/tests/baselines/reference/project/sourceRootRelativePathMixedSubfolderNoOutdir/node/sourceRootRelativePathMixedSubfolderNoOutdir.json
index 0e73f218462dd..bc0e7b10aac5c 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathMixedSubfolderNoOutdir/node/sourceRootRelativePathMixedSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathMixedSubfolderNoOutdir/node/sourceRootRelativePathMixedSubfolderNoOutdir.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "ref/m2.js.map",
         "ref/m2.js",
-        "ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathMixedSubfolderSpecifyOutputDirectory/amd/sourceRootRelativePathMixedSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourceRootRelativePathMixedSubfolderSpecifyOutputDirectory/amd/sourceRootRelativePathMixedSubfolderSpecifyOutputDirectory.json
index 99815d5266195..5146ba9078824 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathMixedSubfolderSpecifyOutputDirectory/amd/sourceRootRelativePathMixedSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathMixedSubfolderSpecifyOutputDirectory/amd/sourceRootRelativePathMixedSubfolderSpecifyOutputDirectory.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/ref/m2.js.map",
         "outdir/simple/ref/m2.js",
-        "outdir/simple/ref/m2.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
+        "outdir/simple/ref/m2.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathMixedSubfolderSpecifyOutputDirectory/node/sourceRootRelativePathMixedSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourceRootRelativePathMixedSubfolderSpecifyOutputDirectory/node/sourceRootRelativePathMixedSubfolderSpecifyOutputDirectory.json
index 99815d5266195..5146ba9078824 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathMixedSubfolderSpecifyOutputDirectory/node/sourceRootRelativePathMixedSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathMixedSubfolderSpecifyOutputDirectory/node/sourceRootRelativePathMixedSubfolderSpecifyOutputDirectory.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/ref/m2.js.map",
         "outdir/simple/ref/m2.js",
-        "outdir/simple/ref/m2.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
+        "outdir/simple/ref/m2.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathMixedSubfolderSpecifyOutputFile/amd/sourceRootRelativePathMixedSubfolderSpecifyOutputFile.json b/tests/baselines/reference/project/sourceRootRelativePathMixedSubfolderSpecifyOutputFile/amd/sourceRootRelativePathMixedSubfolderSpecifyOutputFile.json
index 82ef1c7d88290..6990ea44d7dfc 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathMixedSubfolderSpecifyOutputFile/amd/sourceRootRelativePathMixedSubfolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathMixedSubfolderSpecifyOutputFile/amd/sourceRootRelativePathMixedSubfolderSpecifyOutputFile.json
@@ -18,9 +18,9 @@
     "emittedFiles": [
         "ref/m2.js.map",
         "ref/m2.js",
-        "ref/m2.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m2.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathMixedSubfolderSpecifyOutputFile/node/sourceRootRelativePathMixedSubfolderSpecifyOutputFile.json b/tests/baselines/reference/project/sourceRootRelativePathMixedSubfolderSpecifyOutputFile/node/sourceRootRelativePathMixedSubfolderSpecifyOutputFile.json
index 82ef1c7d88290..6990ea44d7dfc 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathMixedSubfolderSpecifyOutputFile/node/sourceRootRelativePathMixedSubfolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathMixedSubfolderSpecifyOutputFile/node/sourceRootRelativePathMixedSubfolderSpecifyOutputFile.json
@@ -18,9 +18,9 @@
     "emittedFiles": [
         "ref/m2.js.map",
         "ref/m2.js",
-        "ref/m2.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m2.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathMixedSubfolderSpecifyOutputFileAndOutputDirectory/amd/sourceRootRelativePathMixedSubfolderSpecifyOutputFileAndOutputDirectory.json b/tests/baselines/reference/project/sourceRootRelativePathMixedSubfolderSpecifyOutputFileAndOutputDirectory/amd/sourceRootRelativePathMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
index d5f4fd9c6546e..67d36627750e1 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathMixedSubfolderSpecifyOutputFileAndOutputDirectory/amd/sourceRootRelativePathMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathMixedSubfolderSpecifyOutputFileAndOutputDirectory/amd/sourceRootRelativePathMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
@@ -19,9 +19,9 @@
     "emittedFiles": [
         "outdir/outAndOutDirFolder/ref/m2.js.map",
         "outdir/outAndOutDirFolder/ref/m2.js",
-        "outdir/outAndOutDirFolder/ref/m2.d.ts",
         "bin/outAndOutDirFile.js.map",
         "bin/outAndOutDirFile.js",
+        "outdir/outAndOutDirFolder/ref/m2.d.ts",
         "bin/outAndOutDirFile.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathMixedSubfolderSpecifyOutputFileAndOutputDirectory/node/sourceRootRelativePathMixedSubfolderSpecifyOutputFileAndOutputDirectory.json b/tests/baselines/reference/project/sourceRootRelativePathMixedSubfolderSpecifyOutputFileAndOutputDirectory/node/sourceRootRelativePathMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
index d5f4fd9c6546e..67d36627750e1 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathMixedSubfolderSpecifyOutputFileAndOutputDirectory/node/sourceRootRelativePathMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathMixedSubfolderSpecifyOutputFileAndOutputDirectory/node/sourceRootRelativePathMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
@@ -19,9 +19,9 @@
     "emittedFiles": [
         "outdir/outAndOutDirFolder/ref/m2.js.map",
         "outdir/outAndOutDirFolder/ref/m2.js",
-        "outdir/outAndOutDirFolder/ref/m2.d.ts",
         "bin/outAndOutDirFile.js.map",
         "bin/outAndOutDirFile.js",
+        "outdir/outAndOutDirFolder/ref/m2.d.ts",
         "bin/outAndOutDirFile.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderNoOutdir/amd/sourceRootRelativePathModuleMultifolderNoOutdir.json b/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderNoOutdir/amd/sourceRootRelativePathModuleMultifolderNoOutdir.json
index 2acbea1cc8dcc..27ac203009956 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderNoOutdir/amd/sourceRootRelativePathModuleMultifolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderNoOutdir/amd/sourceRootRelativePathModuleMultifolderNoOutdir.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_module_multifolder_ref/m2.js.map",
         "../outputdir_module_multifolder_ref/m2.js",
-        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderNoOutdir/node/sourceRootRelativePathModuleMultifolderNoOutdir.json b/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderNoOutdir/node/sourceRootRelativePathModuleMultifolderNoOutdir.json
index 2acbea1cc8dcc..27ac203009956 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderNoOutdir/node/sourceRootRelativePathModuleMultifolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderNoOutdir/node/sourceRootRelativePathModuleMultifolderNoOutdir.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_module_multifolder_ref/m2.js.map",
         "../outputdir_module_multifolder_ref/m2.js",
-        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputDirectory/amd/sourceRootRelativePathModuleMultifolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputDirectory/amd/sourceRootRelativePathModuleMultifolderSpecifyOutputDirectory.json
index 6603e36c2811a..04b89da6c0aea 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputDirectory/amd/sourceRootRelativePathModuleMultifolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputDirectory/amd/sourceRootRelativePathModuleMultifolderSpecifyOutputDirectory.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "outdir/simple/outputdir_module_multifolder/ref/m1.js.map",
         "outdir/simple/outputdir_module_multifolder/ref/m1.js",
-        "outdir/simple/outputdir_module_multifolder/ref/m1.d.ts",
         "outdir/simple/outputdir_module_multifolder_ref/m2.js.map",
         "outdir/simple/outputdir_module_multifolder_ref/m2.js",
-        "outdir/simple/outputdir_module_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_module_multifolder/test.js.map",
         "outdir/simple/outputdir_module_multifolder/test.js",
+        "outdir/simple/outputdir_module_multifolder/ref/m1.d.ts",
+        "outdir/simple/outputdir_module_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_module_multifolder/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputDirectory/node/sourceRootRelativePathModuleMultifolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputDirectory/node/sourceRootRelativePathModuleMultifolderSpecifyOutputDirectory.json
index 6603e36c2811a..04b89da6c0aea 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputDirectory/node/sourceRootRelativePathModuleMultifolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputDirectory/node/sourceRootRelativePathModuleMultifolderSpecifyOutputDirectory.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "outdir/simple/outputdir_module_multifolder/ref/m1.js.map",
         "outdir/simple/outputdir_module_multifolder/ref/m1.js",
-        "outdir/simple/outputdir_module_multifolder/ref/m1.d.ts",
         "outdir/simple/outputdir_module_multifolder_ref/m2.js.map",
         "outdir/simple/outputdir_module_multifolder_ref/m2.js",
-        "outdir/simple/outputdir_module_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_module_multifolder/test.js.map",
         "outdir/simple/outputdir_module_multifolder/test.js",
+        "outdir/simple/outputdir_module_multifolder/ref/m1.d.ts",
+        "outdir/simple/outputdir_module_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_module_multifolder/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/amd/sourceRootRelativePathModuleMultifolderSpecifyOutputFile.json b/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/amd/sourceRootRelativePathModuleMultifolderSpecifyOutputFile.json
index 69a577baffdf8..a832a3f0c1e17 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/amd/sourceRootRelativePathModuleMultifolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/amd/sourceRootRelativePathModuleMultifolderSpecifyOutputFile.json
@@ -18,15 +18,15 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_module_multifolder_ref/m2.js.map",
         "../outputdir_module_multifolder_ref/m2.js",
-        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m1.d.ts",
+        "../outputdir_module_multifolder_ref/m2.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/node/sourceRootRelativePathModuleMultifolderSpecifyOutputFile.json b/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/node/sourceRootRelativePathModuleMultifolderSpecifyOutputFile.json
index 69a577baffdf8..a832a3f0c1e17 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/node/sourceRootRelativePathModuleMultifolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/node/sourceRootRelativePathModuleMultifolderSpecifyOutputFile.json
@@ -18,15 +18,15 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_module_multifolder_ref/m2.js.map",
         "../outputdir_module_multifolder_ref/m2.js",
-        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m1.d.ts",
+        "../outputdir_module_multifolder_ref/m2.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathModuleSimpleNoOutdir/amd/sourceRootRelativePathModuleSimpleNoOutdir.json b/tests/baselines/reference/project/sourceRootRelativePathModuleSimpleNoOutdir/amd/sourceRootRelativePathModuleSimpleNoOutdir.json
index f28c784480f22..fe7b13a367a03 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathModuleSimpleNoOutdir/amd/sourceRootRelativePathModuleSimpleNoOutdir.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathModuleSimpleNoOutdir/amd/sourceRootRelativePathModuleSimpleNoOutdir.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
+        "m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathModuleSimpleNoOutdir/node/sourceRootRelativePathModuleSimpleNoOutdir.json b/tests/baselines/reference/project/sourceRootRelativePathModuleSimpleNoOutdir/node/sourceRootRelativePathModuleSimpleNoOutdir.json
index f28c784480f22..fe7b13a367a03 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathModuleSimpleNoOutdir/node/sourceRootRelativePathModuleSimpleNoOutdir.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathModuleSimpleNoOutdir/node/sourceRootRelativePathModuleSimpleNoOutdir.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
+        "m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathModuleSimpleSpecifyOutputDirectory/amd/sourceRootRelativePathModuleSimpleSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourceRootRelativePathModuleSimpleSpecifyOutputDirectory/amd/sourceRootRelativePathModuleSimpleSpecifyOutputDirectory.json
index 77fa77f5fb05d..6cd3af13e8e99 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathModuleSimpleSpecifyOutputDirectory/amd/sourceRootRelativePathModuleSimpleSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathModuleSimpleSpecifyOutputDirectory/amd/sourceRootRelativePathModuleSimpleSpecifyOutputDirectory.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "outdir/simple/m1.js.map",
         "outdir/simple/m1.js",
-        "outdir/simple/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathModuleSimpleSpecifyOutputDirectory/node/sourceRootRelativePathModuleSimpleSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourceRootRelativePathModuleSimpleSpecifyOutputDirectory/node/sourceRootRelativePathModuleSimpleSpecifyOutputDirectory.json
index 77fa77f5fb05d..6cd3af13e8e99 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathModuleSimpleSpecifyOutputDirectory/node/sourceRootRelativePathModuleSimpleSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathModuleSimpleSpecifyOutputDirectory/node/sourceRootRelativePathModuleSimpleSpecifyOutputDirectory.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "outdir/simple/m1.js.map",
         "outdir/simple/m1.js",
-        "outdir/simple/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathModuleSimpleSpecifyOutputFile/amd/sourceRootRelativePathModuleSimpleSpecifyOutputFile.json b/tests/baselines/reference/project/sourceRootRelativePathModuleSimpleSpecifyOutputFile/amd/sourceRootRelativePathModuleSimpleSpecifyOutputFile.json
index a4a6698d3ca97..f59aacac6561b 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathModuleSimpleSpecifyOutputFile/amd/sourceRootRelativePathModuleSimpleSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathModuleSimpleSpecifyOutputFile/amd/sourceRootRelativePathModuleSimpleSpecifyOutputFile.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "m1.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathModuleSimpleSpecifyOutputFile/node/sourceRootRelativePathModuleSimpleSpecifyOutputFile.json b/tests/baselines/reference/project/sourceRootRelativePathModuleSimpleSpecifyOutputFile/node/sourceRootRelativePathModuleSimpleSpecifyOutputFile.json
index a4a6698d3ca97..f59aacac6561b 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathModuleSimpleSpecifyOutputFile/node/sourceRootRelativePathModuleSimpleSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathModuleSimpleSpecifyOutputFile/node/sourceRootRelativePathModuleSimpleSpecifyOutputFile.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "m1.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathModuleSubfolderNoOutdir/amd/sourceRootRelativePathModuleSubfolderNoOutdir.json b/tests/baselines/reference/project/sourceRootRelativePathModuleSubfolderNoOutdir/amd/sourceRootRelativePathModuleSubfolderNoOutdir.json
index 8a3035f363273..9c4d60ba840f7 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathModuleSubfolderNoOutdir/amd/sourceRootRelativePathModuleSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathModuleSubfolderNoOutdir/amd/sourceRootRelativePathModuleSubfolderNoOutdir.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathModuleSubfolderNoOutdir/node/sourceRootRelativePathModuleSubfolderNoOutdir.json b/tests/baselines/reference/project/sourceRootRelativePathModuleSubfolderNoOutdir/node/sourceRootRelativePathModuleSubfolderNoOutdir.json
index 8a3035f363273..9c4d60ba840f7 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathModuleSubfolderNoOutdir/node/sourceRootRelativePathModuleSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathModuleSubfolderNoOutdir/node/sourceRootRelativePathModuleSubfolderNoOutdir.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathModuleSubfolderSpecifyOutputDirectory/amd/sourceRootRelativePathModuleSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourceRootRelativePathModuleSubfolderSpecifyOutputDirectory/amd/sourceRootRelativePathModuleSubfolderSpecifyOutputDirectory.json
index 9f10fc5e7e05a..0552b112aa9fe 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathModuleSubfolderSpecifyOutputDirectory/amd/sourceRootRelativePathModuleSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathModuleSubfolderSpecifyOutputDirectory/amd/sourceRootRelativePathModuleSubfolderSpecifyOutputDirectory.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathModuleSubfolderSpecifyOutputDirectory/node/sourceRootRelativePathModuleSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourceRootRelativePathModuleSubfolderSpecifyOutputDirectory/node/sourceRootRelativePathModuleSubfolderSpecifyOutputDirectory.json
index 9f10fc5e7e05a..0552b112aa9fe 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathModuleSubfolderSpecifyOutputDirectory/node/sourceRootRelativePathModuleSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathModuleSubfolderSpecifyOutputDirectory/node/sourceRootRelativePathModuleSubfolderSpecifyOutputDirectory.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathModuleSubfolderSpecifyOutputFile/amd/sourceRootRelativePathModuleSubfolderSpecifyOutputFile.json b/tests/baselines/reference/project/sourceRootRelativePathModuleSubfolderSpecifyOutputFile/amd/sourceRootRelativePathModuleSubfolderSpecifyOutputFile.json
index 71896f202b298..115c2b8cdb38b 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathModuleSubfolderSpecifyOutputFile/amd/sourceRootRelativePathModuleSubfolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathModuleSubfolderSpecifyOutputFile/amd/sourceRootRelativePathModuleSubfolderSpecifyOutputFile.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m1.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathModuleSubfolderSpecifyOutputFile/node/sourceRootRelativePathModuleSubfolderSpecifyOutputFile.json b/tests/baselines/reference/project/sourceRootRelativePathModuleSubfolderSpecifyOutputFile/node/sourceRootRelativePathModuleSubfolderSpecifyOutputFile.json
index 71896f202b298..115c2b8cdb38b 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathModuleSubfolderSpecifyOutputFile/node/sourceRootRelativePathModuleSubfolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathModuleSubfolderSpecifyOutputFile/node/sourceRootRelativePathModuleSubfolderSpecifyOutputFile.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m1.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathMultifolderNoOutdir/amd/sourceRootRelativePathMultifolderNoOutdir.json b/tests/baselines/reference/project/sourceRootRelativePathMultifolderNoOutdir/amd/sourceRootRelativePathMultifolderNoOutdir.json
index e7dfb0beff37c..a2c697ba1162e 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathMultifolderNoOutdir/amd/sourceRootRelativePathMultifolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathMultifolderNoOutdir/amd/sourceRootRelativePathMultifolderNoOutdir.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_multifolder_ref/m2.js.map",
         "../outputdir_multifolder_ref/m2.js",
-        "../outputdir_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "../outputdir_multifolder_ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathMultifolderNoOutdir/node/sourceRootRelativePathMultifolderNoOutdir.json b/tests/baselines/reference/project/sourceRootRelativePathMultifolderNoOutdir/node/sourceRootRelativePathMultifolderNoOutdir.json
index e7dfb0beff37c..a2c697ba1162e 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathMultifolderNoOutdir/node/sourceRootRelativePathMultifolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathMultifolderNoOutdir/node/sourceRootRelativePathMultifolderNoOutdir.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_multifolder_ref/m2.js.map",
         "../outputdir_multifolder_ref/m2.js",
-        "../outputdir_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "../outputdir_multifolder_ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathMultifolderSpecifyOutputDirectory/amd/sourceRootRelativePathMultifolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourceRootRelativePathMultifolderSpecifyOutputDirectory/amd/sourceRootRelativePathMultifolderSpecifyOutputDirectory.json
index bfb740034016f..785783f21efd5 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathMultifolderSpecifyOutputDirectory/amd/sourceRootRelativePathMultifolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathMultifolderSpecifyOutputDirectory/amd/sourceRootRelativePathMultifolderSpecifyOutputDirectory.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "outdir/simple/outputdir_multifolder/ref/m1.js.map",
         "outdir/simple/outputdir_multifolder/ref/m1.js",
-        "outdir/simple/outputdir_multifolder/ref/m1.d.ts",
         "outdir/simple/outputdir_multifolder_ref/m2.js.map",
         "outdir/simple/outputdir_multifolder_ref/m2.js",
-        "outdir/simple/outputdir_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_multifolder/test.js.map",
         "outdir/simple/outputdir_multifolder/test.js",
+        "outdir/simple/outputdir_multifolder/ref/m1.d.ts",
+        "outdir/simple/outputdir_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_multifolder/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathMultifolderSpecifyOutputDirectory/node/sourceRootRelativePathMultifolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourceRootRelativePathMultifolderSpecifyOutputDirectory/node/sourceRootRelativePathMultifolderSpecifyOutputDirectory.json
index bfb740034016f..785783f21efd5 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathMultifolderSpecifyOutputDirectory/node/sourceRootRelativePathMultifolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathMultifolderSpecifyOutputDirectory/node/sourceRootRelativePathMultifolderSpecifyOutputDirectory.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "outdir/simple/outputdir_multifolder/ref/m1.js.map",
         "outdir/simple/outputdir_multifolder/ref/m1.js",
-        "outdir/simple/outputdir_multifolder/ref/m1.d.ts",
         "outdir/simple/outputdir_multifolder_ref/m2.js.map",
         "outdir/simple/outputdir_multifolder_ref/m2.js",
-        "outdir/simple/outputdir_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_multifolder/test.js.map",
         "outdir/simple/outputdir_multifolder/test.js",
+        "outdir/simple/outputdir_multifolder/ref/m1.d.ts",
+        "outdir/simple/outputdir_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_multifolder/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathSimpleNoOutdir/amd/sourceRootRelativePathSimpleNoOutdir.json b/tests/baselines/reference/project/sourceRootRelativePathSimpleNoOutdir/amd/sourceRootRelativePathSimpleNoOutdir.json
index 4d33e85e2ba8d..dd7b973b937b9 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathSimpleNoOutdir/amd/sourceRootRelativePathSimpleNoOutdir.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathSimpleNoOutdir/amd/sourceRootRelativePathSimpleNoOutdir.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
+        "m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathSimpleNoOutdir/node/sourceRootRelativePathSimpleNoOutdir.json b/tests/baselines/reference/project/sourceRootRelativePathSimpleNoOutdir/node/sourceRootRelativePathSimpleNoOutdir.json
index 4d33e85e2ba8d..dd7b973b937b9 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathSimpleNoOutdir/node/sourceRootRelativePathSimpleNoOutdir.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathSimpleNoOutdir/node/sourceRootRelativePathSimpleNoOutdir.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
+        "m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathSimpleSpecifyOutputDirectory/amd/sourceRootRelativePathSimpleSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourceRootRelativePathSimpleSpecifyOutputDirectory/amd/sourceRootRelativePathSimpleSpecifyOutputDirectory.json
index bf86309b59a89..e9949c41bc933 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathSimpleSpecifyOutputDirectory/amd/sourceRootRelativePathSimpleSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathSimpleSpecifyOutputDirectory/amd/sourceRootRelativePathSimpleSpecifyOutputDirectory.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "outdir/simple/m1.js.map",
         "outdir/simple/m1.js",
-        "outdir/simple/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathSimpleSpecifyOutputDirectory/node/sourceRootRelativePathSimpleSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourceRootRelativePathSimpleSpecifyOutputDirectory/node/sourceRootRelativePathSimpleSpecifyOutputDirectory.json
index bf86309b59a89..e9949c41bc933 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathSimpleSpecifyOutputDirectory/node/sourceRootRelativePathSimpleSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathSimpleSpecifyOutputDirectory/node/sourceRootRelativePathSimpleSpecifyOutputDirectory.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "outdir/simple/m1.js.map",
         "outdir/simple/m1.js",
-        "outdir/simple/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathSubfolderNoOutdir/amd/sourceRootRelativePathSubfolderNoOutdir.json b/tests/baselines/reference/project/sourceRootRelativePathSubfolderNoOutdir/amd/sourceRootRelativePathSubfolderNoOutdir.json
index ff189067e6755..e171d7fe24a5f 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathSubfolderNoOutdir/amd/sourceRootRelativePathSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathSubfolderNoOutdir/amd/sourceRootRelativePathSubfolderNoOutdir.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathSubfolderNoOutdir/node/sourceRootRelativePathSubfolderNoOutdir.json b/tests/baselines/reference/project/sourceRootRelativePathSubfolderNoOutdir/node/sourceRootRelativePathSubfolderNoOutdir.json
index ff189067e6755..e171d7fe24a5f 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathSubfolderNoOutdir/node/sourceRootRelativePathSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathSubfolderNoOutdir/node/sourceRootRelativePathSubfolderNoOutdir.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathSubfolderSpecifyOutputDirectory/amd/sourceRootRelativePathSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourceRootRelativePathSubfolderSpecifyOutputDirectory/amd/sourceRootRelativePathSubfolderSpecifyOutputDirectory.json
index 8896f911a9998..adcc62b9b4f1a 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathSubfolderSpecifyOutputDirectory/amd/sourceRootRelativePathSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathSubfolderSpecifyOutputDirectory/amd/sourceRootRelativePathSubfolderSpecifyOutputDirectory.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourceRootRelativePathSubfolderSpecifyOutputDirectory/node/sourceRootRelativePathSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourceRootRelativePathSubfolderSpecifyOutputDirectory/node/sourceRootRelativePathSubfolderSpecifyOutputDirectory.json
index 8896f911a9998..adcc62b9b4f1a 100644
--- a/tests/baselines/reference/project/sourceRootRelativePathSubfolderSpecifyOutputDirectory/node/sourceRootRelativePathSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourceRootRelativePathSubfolderSpecifyOutputDirectory/node/sourceRootRelativePathSubfolderSpecifyOutputDirectory.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapMixedSubfolderNoOutdir/amd/sourcemapMixedSubfolderNoOutdir.json b/tests/baselines/reference/project/sourcemapMixedSubfolderNoOutdir/amd/sourcemapMixedSubfolderNoOutdir.json
index 570d129ce2e8c..7ee9bd317c03c 100644
--- a/tests/baselines/reference/project/sourcemapMixedSubfolderNoOutdir/amd/sourcemapMixedSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourcemapMixedSubfolderNoOutdir/amd/sourcemapMixedSubfolderNoOutdir.json
@@ -16,12 +16,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "ref/m2.js.map",
         "ref/m2.js",
-        "ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapMixedSubfolderNoOutdir/node/sourcemapMixedSubfolderNoOutdir.json b/tests/baselines/reference/project/sourcemapMixedSubfolderNoOutdir/node/sourcemapMixedSubfolderNoOutdir.json
index 570d129ce2e8c..7ee9bd317c03c 100644
--- a/tests/baselines/reference/project/sourcemapMixedSubfolderNoOutdir/node/sourcemapMixedSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourcemapMixedSubfolderNoOutdir/node/sourcemapMixedSubfolderNoOutdir.json
@@ -16,12 +16,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "ref/m2.js.map",
         "ref/m2.js",
-        "ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapMixedSubfolderSpecifyOutputDirectory/amd/sourcemapMixedSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourcemapMixedSubfolderSpecifyOutputDirectory/amd/sourcemapMixedSubfolderSpecifyOutputDirectory.json
index 3d39d4b9bf2d0..af995aca00bd9 100644
--- a/tests/baselines/reference/project/sourcemapMixedSubfolderSpecifyOutputDirectory/amd/sourcemapMixedSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourcemapMixedSubfolderSpecifyOutputDirectory/amd/sourcemapMixedSubfolderSpecifyOutputDirectory.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/ref/m2.js.map",
         "outdir/simple/ref/m2.js",
-        "outdir/simple/ref/m2.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
+        "outdir/simple/ref/m2.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapMixedSubfolderSpecifyOutputDirectory/node/sourcemapMixedSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourcemapMixedSubfolderSpecifyOutputDirectory/node/sourcemapMixedSubfolderSpecifyOutputDirectory.json
index 3d39d4b9bf2d0..af995aca00bd9 100644
--- a/tests/baselines/reference/project/sourcemapMixedSubfolderSpecifyOutputDirectory/node/sourcemapMixedSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourcemapMixedSubfolderSpecifyOutputDirectory/node/sourcemapMixedSubfolderSpecifyOutputDirectory.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/ref/m2.js.map",
         "outdir/simple/ref/m2.js",
-        "outdir/simple/ref/m2.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
+        "outdir/simple/ref/m2.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapMixedSubfolderSpecifyOutputFile/amd/sourcemapMixedSubfolderSpecifyOutputFile.json b/tests/baselines/reference/project/sourcemapMixedSubfolderSpecifyOutputFile/amd/sourcemapMixedSubfolderSpecifyOutputFile.json
index 3270fe610aa37..e74f25c4dec42 100644
--- a/tests/baselines/reference/project/sourcemapMixedSubfolderSpecifyOutputFile/amd/sourcemapMixedSubfolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/sourcemapMixedSubfolderSpecifyOutputFile/amd/sourcemapMixedSubfolderSpecifyOutputFile.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "ref/m2.js.map",
         "ref/m2.js",
-        "ref/m2.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m2.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapMixedSubfolderSpecifyOutputFile/node/sourcemapMixedSubfolderSpecifyOutputFile.json b/tests/baselines/reference/project/sourcemapMixedSubfolderSpecifyOutputFile/node/sourcemapMixedSubfolderSpecifyOutputFile.json
index 3270fe610aa37..e74f25c4dec42 100644
--- a/tests/baselines/reference/project/sourcemapMixedSubfolderSpecifyOutputFile/node/sourcemapMixedSubfolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/sourcemapMixedSubfolderSpecifyOutputFile/node/sourcemapMixedSubfolderSpecifyOutputFile.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "ref/m2.js.map",
         "ref/m2.js",
-        "ref/m2.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m2.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapMixedSubfolderSpecifyOutputFileAndOutputDirectory/amd/sourcemapMixedSubfolderSpecifyOutputFileAndOutputDirectory.json b/tests/baselines/reference/project/sourcemapMixedSubfolderSpecifyOutputFileAndOutputDirectory/amd/sourcemapMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
index 3a260af84a077..83a0b065a835e 100644
--- a/tests/baselines/reference/project/sourcemapMixedSubfolderSpecifyOutputFileAndOutputDirectory/amd/sourcemapMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
+++ b/tests/baselines/reference/project/sourcemapMixedSubfolderSpecifyOutputFileAndOutputDirectory/amd/sourcemapMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
@@ -18,9 +18,9 @@
     "emittedFiles": [
         "outdir/outAndOutDirFolder/ref/m2.js.map",
         "outdir/outAndOutDirFolder/ref/m2.js",
-        "outdir/outAndOutDirFolder/ref/m2.d.ts",
         "bin/outAndOutDirFile.js.map",
         "bin/outAndOutDirFile.js",
+        "outdir/outAndOutDirFolder/ref/m2.d.ts",
         "bin/outAndOutDirFile.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapMixedSubfolderSpecifyOutputFileAndOutputDirectory/node/sourcemapMixedSubfolderSpecifyOutputFileAndOutputDirectory.json b/tests/baselines/reference/project/sourcemapMixedSubfolderSpecifyOutputFileAndOutputDirectory/node/sourcemapMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
index 3a260af84a077..83a0b065a835e 100644
--- a/tests/baselines/reference/project/sourcemapMixedSubfolderSpecifyOutputFileAndOutputDirectory/node/sourcemapMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
+++ b/tests/baselines/reference/project/sourcemapMixedSubfolderSpecifyOutputFileAndOutputDirectory/node/sourcemapMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
@@ -18,9 +18,9 @@
     "emittedFiles": [
         "outdir/outAndOutDirFolder/ref/m2.js.map",
         "outdir/outAndOutDirFolder/ref/m2.js",
-        "outdir/outAndOutDirFolder/ref/m2.d.ts",
         "bin/outAndOutDirFile.js.map",
         "bin/outAndOutDirFile.js",
+        "outdir/outAndOutDirFolder/ref/m2.d.ts",
         "bin/outAndOutDirFile.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapModuleMultifolderNoOutdir/amd/sourcemapModuleMultifolderNoOutdir.json b/tests/baselines/reference/project/sourcemapModuleMultifolderNoOutdir/amd/sourcemapModuleMultifolderNoOutdir.json
index 9dcc6a90da3ad..cb8f438ff83c1 100644
--- a/tests/baselines/reference/project/sourcemapModuleMultifolderNoOutdir/amd/sourcemapModuleMultifolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourcemapModuleMultifolderNoOutdir/amd/sourcemapModuleMultifolderNoOutdir.json
@@ -16,12 +16,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_module_multifolder_ref/m2.js.map",
         "../outputdir_module_multifolder_ref/m2.js",
-        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapModuleMultifolderNoOutdir/node/sourcemapModuleMultifolderNoOutdir.json b/tests/baselines/reference/project/sourcemapModuleMultifolderNoOutdir/node/sourcemapModuleMultifolderNoOutdir.json
index 9dcc6a90da3ad..cb8f438ff83c1 100644
--- a/tests/baselines/reference/project/sourcemapModuleMultifolderNoOutdir/node/sourcemapModuleMultifolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourcemapModuleMultifolderNoOutdir/node/sourcemapModuleMultifolderNoOutdir.json
@@ -16,12 +16,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_module_multifolder_ref/m2.js.map",
         "../outputdir_module_multifolder_ref/m2.js",
-        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputDirectory/amd/sourcemapModuleMultifolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputDirectory/amd/sourcemapModuleMultifolderSpecifyOutputDirectory.json
index b63faddd4c721..eb052903c5a21 100644
--- a/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputDirectory/amd/sourcemapModuleMultifolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputDirectory/amd/sourcemapModuleMultifolderSpecifyOutputDirectory.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "outdir/simple/outputdir_module_multifolder/ref/m1.js.map",
         "outdir/simple/outputdir_module_multifolder/ref/m1.js",
-        "outdir/simple/outputdir_module_multifolder/ref/m1.d.ts",
         "outdir/simple/outputdir_module_multifolder_ref/m2.js.map",
         "outdir/simple/outputdir_module_multifolder_ref/m2.js",
-        "outdir/simple/outputdir_module_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_module_multifolder/test.js.map",
         "outdir/simple/outputdir_module_multifolder/test.js",
+        "outdir/simple/outputdir_module_multifolder/ref/m1.d.ts",
+        "outdir/simple/outputdir_module_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_module_multifolder/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputDirectory/node/sourcemapModuleMultifolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputDirectory/node/sourcemapModuleMultifolderSpecifyOutputDirectory.json
index b63faddd4c721..eb052903c5a21 100644
--- a/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputDirectory/node/sourcemapModuleMultifolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputDirectory/node/sourcemapModuleMultifolderSpecifyOutputDirectory.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "outdir/simple/outputdir_module_multifolder/ref/m1.js.map",
         "outdir/simple/outputdir_module_multifolder/ref/m1.js",
-        "outdir/simple/outputdir_module_multifolder/ref/m1.d.ts",
         "outdir/simple/outputdir_module_multifolder_ref/m2.js.map",
         "outdir/simple/outputdir_module_multifolder_ref/m2.js",
-        "outdir/simple/outputdir_module_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_module_multifolder/test.js.map",
         "outdir/simple/outputdir_module_multifolder/test.js",
+        "outdir/simple/outputdir_module_multifolder/ref/m1.d.ts",
+        "outdir/simple/outputdir_module_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_module_multifolder/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/amd/sourcemapModuleMultifolderSpecifyOutputFile.json b/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/amd/sourcemapModuleMultifolderSpecifyOutputFile.json
index 3d2df95ad66d9..223a3b351ff76 100644
--- a/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/amd/sourcemapModuleMultifolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/amd/sourcemapModuleMultifolderSpecifyOutputFile.json
@@ -17,15 +17,15 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_module_multifolder_ref/m2.js.map",
         "../outputdir_module_multifolder_ref/m2.js",
-        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m1.d.ts",
+        "../outputdir_module_multifolder_ref/m2.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/node/sourcemapModuleMultifolderSpecifyOutputFile.json b/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/node/sourcemapModuleMultifolderSpecifyOutputFile.json
index 3d2df95ad66d9..223a3b351ff76 100644
--- a/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/node/sourcemapModuleMultifolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/node/sourcemapModuleMultifolderSpecifyOutputFile.json
@@ -17,15 +17,15 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_module_multifolder_ref/m2.js.map",
         "../outputdir_module_multifolder_ref/m2.js",
-        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m1.d.ts",
+        "../outputdir_module_multifolder_ref/m2.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapModuleSimpleNoOutdir/amd/sourcemapModuleSimpleNoOutdir.json b/tests/baselines/reference/project/sourcemapModuleSimpleNoOutdir/amd/sourcemapModuleSimpleNoOutdir.json
index 348605adb33e9..30bb8a50a7e8c 100644
--- a/tests/baselines/reference/project/sourcemapModuleSimpleNoOutdir/amd/sourcemapModuleSimpleNoOutdir.json
+++ b/tests/baselines/reference/project/sourcemapModuleSimpleNoOutdir/amd/sourcemapModuleSimpleNoOutdir.json
@@ -15,9 +15,9 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
+        "m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapModuleSimpleNoOutdir/node/sourcemapModuleSimpleNoOutdir.json b/tests/baselines/reference/project/sourcemapModuleSimpleNoOutdir/node/sourcemapModuleSimpleNoOutdir.json
index 348605adb33e9..30bb8a50a7e8c 100644
--- a/tests/baselines/reference/project/sourcemapModuleSimpleNoOutdir/node/sourcemapModuleSimpleNoOutdir.json
+++ b/tests/baselines/reference/project/sourcemapModuleSimpleNoOutdir/node/sourcemapModuleSimpleNoOutdir.json
@@ -15,9 +15,9 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
+        "m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapModuleSimpleSpecifyOutputDirectory/amd/sourcemapModuleSimpleSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourcemapModuleSimpleSpecifyOutputDirectory/amd/sourcemapModuleSimpleSpecifyOutputDirectory.json
index 2316c35bde9de..3d34cf12dd0ce 100644
--- a/tests/baselines/reference/project/sourcemapModuleSimpleSpecifyOutputDirectory/amd/sourcemapModuleSimpleSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourcemapModuleSimpleSpecifyOutputDirectory/amd/sourcemapModuleSimpleSpecifyOutputDirectory.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "outdir/simple/m1.js.map",
         "outdir/simple/m1.js",
-        "outdir/simple/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapModuleSimpleSpecifyOutputDirectory/node/sourcemapModuleSimpleSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourcemapModuleSimpleSpecifyOutputDirectory/node/sourcemapModuleSimpleSpecifyOutputDirectory.json
index 2316c35bde9de..3d34cf12dd0ce 100644
--- a/tests/baselines/reference/project/sourcemapModuleSimpleSpecifyOutputDirectory/node/sourcemapModuleSimpleSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourcemapModuleSimpleSpecifyOutputDirectory/node/sourcemapModuleSimpleSpecifyOutputDirectory.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "outdir/simple/m1.js.map",
         "outdir/simple/m1.js",
-        "outdir/simple/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapModuleSimpleSpecifyOutputFile/amd/sourcemapModuleSimpleSpecifyOutputFile.json b/tests/baselines/reference/project/sourcemapModuleSimpleSpecifyOutputFile/amd/sourcemapModuleSimpleSpecifyOutputFile.json
index 9ff29662d406a..4e1feaf5b9e56 100644
--- a/tests/baselines/reference/project/sourcemapModuleSimpleSpecifyOutputFile/amd/sourcemapModuleSimpleSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/sourcemapModuleSimpleSpecifyOutputFile/amd/sourcemapModuleSimpleSpecifyOutputFile.json
@@ -16,12 +16,12 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "m1.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapModuleSimpleSpecifyOutputFile/node/sourcemapModuleSimpleSpecifyOutputFile.json b/tests/baselines/reference/project/sourcemapModuleSimpleSpecifyOutputFile/node/sourcemapModuleSimpleSpecifyOutputFile.json
index 9ff29662d406a..4e1feaf5b9e56 100644
--- a/tests/baselines/reference/project/sourcemapModuleSimpleSpecifyOutputFile/node/sourcemapModuleSimpleSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/sourcemapModuleSimpleSpecifyOutputFile/node/sourcemapModuleSimpleSpecifyOutputFile.json
@@ -16,12 +16,12 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "m1.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapModuleSubfolderNoOutdir/amd/sourcemapModuleSubfolderNoOutdir.json b/tests/baselines/reference/project/sourcemapModuleSubfolderNoOutdir/amd/sourcemapModuleSubfolderNoOutdir.json
index 49ebfda156718..720bbfb59267d 100644
--- a/tests/baselines/reference/project/sourcemapModuleSubfolderNoOutdir/amd/sourcemapModuleSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourcemapModuleSubfolderNoOutdir/amd/sourcemapModuleSubfolderNoOutdir.json
@@ -15,9 +15,9 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapModuleSubfolderNoOutdir/node/sourcemapModuleSubfolderNoOutdir.json b/tests/baselines/reference/project/sourcemapModuleSubfolderNoOutdir/node/sourcemapModuleSubfolderNoOutdir.json
index 49ebfda156718..720bbfb59267d 100644
--- a/tests/baselines/reference/project/sourcemapModuleSubfolderNoOutdir/node/sourcemapModuleSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourcemapModuleSubfolderNoOutdir/node/sourcemapModuleSubfolderNoOutdir.json
@@ -15,9 +15,9 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapModuleSubfolderSpecifyOutputDirectory/amd/sourcemapModuleSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourcemapModuleSubfolderSpecifyOutputDirectory/amd/sourcemapModuleSubfolderSpecifyOutputDirectory.json
index 391942643f563..0c1b3a21d6ada 100644
--- a/tests/baselines/reference/project/sourcemapModuleSubfolderSpecifyOutputDirectory/amd/sourcemapModuleSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourcemapModuleSubfolderSpecifyOutputDirectory/amd/sourcemapModuleSubfolderSpecifyOutputDirectory.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapModuleSubfolderSpecifyOutputDirectory/node/sourcemapModuleSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourcemapModuleSubfolderSpecifyOutputDirectory/node/sourcemapModuleSubfolderSpecifyOutputDirectory.json
index 391942643f563..0c1b3a21d6ada 100644
--- a/tests/baselines/reference/project/sourcemapModuleSubfolderSpecifyOutputDirectory/node/sourcemapModuleSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourcemapModuleSubfolderSpecifyOutputDirectory/node/sourcemapModuleSubfolderSpecifyOutputDirectory.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapModuleSubfolderSpecifyOutputFile/amd/sourcemapModuleSubfolderSpecifyOutputFile.json b/tests/baselines/reference/project/sourcemapModuleSubfolderSpecifyOutputFile/amd/sourcemapModuleSubfolderSpecifyOutputFile.json
index 9d200ef685d29..1a47dcbb4e7d8 100644
--- a/tests/baselines/reference/project/sourcemapModuleSubfolderSpecifyOutputFile/amd/sourcemapModuleSubfolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/sourcemapModuleSubfolderSpecifyOutputFile/amd/sourcemapModuleSubfolderSpecifyOutputFile.json
@@ -16,12 +16,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m1.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapModuleSubfolderSpecifyOutputFile/node/sourcemapModuleSubfolderSpecifyOutputFile.json b/tests/baselines/reference/project/sourcemapModuleSubfolderSpecifyOutputFile/node/sourcemapModuleSubfolderSpecifyOutputFile.json
index 9d200ef685d29..1a47dcbb4e7d8 100644
--- a/tests/baselines/reference/project/sourcemapModuleSubfolderSpecifyOutputFile/node/sourcemapModuleSubfolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/sourcemapModuleSubfolderSpecifyOutputFile/node/sourcemapModuleSubfolderSpecifyOutputFile.json
@@ -16,12 +16,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m1.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapMultifolderNoOutdir/amd/sourcemapMultifolderNoOutdir.json b/tests/baselines/reference/project/sourcemapMultifolderNoOutdir/amd/sourcemapMultifolderNoOutdir.json
index 3d4f5d74f4406..dd6ff601eda95 100644
--- a/tests/baselines/reference/project/sourcemapMultifolderNoOutdir/amd/sourcemapMultifolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourcemapMultifolderNoOutdir/amd/sourcemapMultifolderNoOutdir.json
@@ -16,12 +16,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_multifolder_ref/m2.js.map",
         "../outputdir_multifolder_ref/m2.js",
-        "../outputdir_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "../outputdir_multifolder_ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapMultifolderNoOutdir/node/sourcemapMultifolderNoOutdir.json b/tests/baselines/reference/project/sourcemapMultifolderNoOutdir/node/sourcemapMultifolderNoOutdir.json
index 3d4f5d74f4406..dd6ff601eda95 100644
--- a/tests/baselines/reference/project/sourcemapMultifolderNoOutdir/node/sourcemapMultifolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourcemapMultifolderNoOutdir/node/sourcemapMultifolderNoOutdir.json
@@ -16,12 +16,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_multifolder_ref/m2.js.map",
         "../outputdir_multifolder_ref/m2.js",
-        "../outputdir_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "../outputdir_multifolder_ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapMultifolderSpecifyOutputDirectory/amd/sourcemapMultifolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourcemapMultifolderSpecifyOutputDirectory/amd/sourcemapMultifolderSpecifyOutputDirectory.json
index 1882477e51816..b0359066b12e8 100644
--- a/tests/baselines/reference/project/sourcemapMultifolderSpecifyOutputDirectory/amd/sourcemapMultifolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourcemapMultifolderSpecifyOutputDirectory/amd/sourcemapMultifolderSpecifyOutputDirectory.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "outdir/simple/outputdir_multifolder/ref/m1.js.map",
         "outdir/simple/outputdir_multifolder/ref/m1.js",
-        "outdir/simple/outputdir_multifolder/ref/m1.d.ts",
         "outdir/simple/outputdir_multifolder_ref/m2.js.map",
         "outdir/simple/outputdir_multifolder_ref/m2.js",
-        "outdir/simple/outputdir_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_multifolder/test.js.map",
         "outdir/simple/outputdir_multifolder/test.js",
+        "outdir/simple/outputdir_multifolder/ref/m1.d.ts",
+        "outdir/simple/outputdir_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_multifolder/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapMultifolderSpecifyOutputDirectory/node/sourcemapMultifolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourcemapMultifolderSpecifyOutputDirectory/node/sourcemapMultifolderSpecifyOutputDirectory.json
index 1882477e51816..b0359066b12e8 100644
--- a/tests/baselines/reference/project/sourcemapMultifolderSpecifyOutputDirectory/node/sourcemapMultifolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourcemapMultifolderSpecifyOutputDirectory/node/sourcemapMultifolderSpecifyOutputDirectory.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "outdir/simple/outputdir_multifolder/ref/m1.js.map",
         "outdir/simple/outputdir_multifolder/ref/m1.js",
-        "outdir/simple/outputdir_multifolder/ref/m1.d.ts",
         "outdir/simple/outputdir_multifolder_ref/m2.js.map",
         "outdir/simple/outputdir_multifolder_ref/m2.js",
-        "outdir/simple/outputdir_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_multifolder/test.js.map",
         "outdir/simple/outputdir_multifolder/test.js",
+        "outdir/simple/outputdir_multifolder/ref/m1.d.ts",
+        "outdir/simple/outputdir_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_multifolder/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapSimpleNoOutdir/amd/sourcemapSimpleNoOutdir.json b/tests/baselines/reference/project/sourcemapSimpleNoOutdir/amd/sourcemapSimpleNoOutdir.json
index ad8ebd063703b..66ec3f872a195 100644
--- a/tests/baselines/reference/project/sourcemapSimpleNoOutdir/amd/sourcemapSimpleNoOutdir.json
+++ b/tests/baselines/reference/project/sourcemapSimpleNoOutdir/amd/sourcemapSimpleNoOutdir.json
@@ -15,9 +15,9 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
+        "m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapSimpleNoOutdir/node/sourcemapSimpleNoOutdir.json b/tests/baselines/reference/project/sourcemapSimpleNoOutdir/node/sourcemapSimpleNoOutdir.json
index ad8ebd063703b..66ec3f872a195 100644
--- a/tests/baselines/reference/project/sourcemapSimpleNoOutdir/node/sourcemapSimpleNoOutdir.json
+++ b/tests/baselines/reference/project/sourcemapSimpleNoOutdir/node/sourcemapSimpleNoOutdir.json
@@ -15,9 +15,9 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
+        "m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapSimpleSpecifyOutputDirectory/amd/sourcemapSimpleSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourcemapSimpleSpecifyOutputDirectory/amd/sourcemapSimpleSpecifyOutputDirectory.json
index 8f78a5682d6dc..9762e39bef510 100644
--- a/tests/baselines/reference/project/sourcemapSimpleSpecifyOutputDirectory/amd/sourcemapSimpleSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourcemapSimpleSpecifyOutputDirectory/amd/sourcemapSimpleSpecifyOutputDirectory.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "outdir/simple/m1.js.map",
         "outdir/simple/m1.js",
-        "outdir/simple/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapSimpleSpecifyOutputDirectory/node/sourcemapSimpleSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourcemapSimpleSpecifyOutputDirectory/node/sourcemapSimpleSpecifyOutputDirectory.json
index 8f78a5682d6dc..9762e39bef510 100644
--- a/tests/baselines/reference/project/sourcemapSimpleSpecifyOutputDirectory/node/sourcemapSimpleSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourcemapSimpleSpecifyOutputDirectory/node/sourcemapSimpleSpecifyOutputDirectory.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "outdir/simple/m1.js.map",
         "outdir/simple/m1.js",
-        "outdir/simple/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapSubfolderNoOutdir/amd/sourcemapSubfolderNoOutdir.json b/tests/baselines/reference/project/sourcemapSubfolderNoOutdir/amd/sourcemapSubfolderNoOutdir.json
index 2884f385bb537..883abf2453c5c 100644
--- a/tests/baselines/reference/project/sourcemapSubfolderNoOutdir/amd/sourcemapSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourcemapSubfolderNoOutdir/amd/sourcemapSubfolderNoOutdir.json
@@ -15,9 +15,9 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapSubfolderNoOutdir/node/sourcemapSubfolderNoOutdir.json b/tests/baselines/reference/project/sourcemapSubfolderNoOutdir/node/sourcemapSubfolderNoOutdir.json
index 2884f385bb537..883abf2453c5c 100644
--- a/tests/baselines/reference/project/sourcemapSubfolderNoOutdir/node/sourcemapSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourcemapSubfolderNoOutdir/node/sourcemapSubfolderNoOutdir.json
@@ -15,9 +15,9 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapSubfolderSpecifyOutputDirectory/amd/sourcemapSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourcemapSubfolderSpecifyOutputDirectory/amd/sourcemapSubfolderSpecifyOutputDirectory.json
index 632d71189049b..7aa05fd0970ca 100644
--- a/tests/baselines/reference/project/sourcemapSubfolderSpecifyOutputDirectory/amd/sourcemapSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourcemapSubfolderSpecifyOutputDirectory/amd/sourcemapSubfolderSpecifyOutputDirectory.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcemapSubfolderSpecifyOutputDirectory/node/sourcemapSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourcemapSubfolderSpecifyOutputDirectory/node/sourcemapSubfolderSpecifyOutputDirectory.json
index 632d71189049b..7aa05fd0970ca 100644
--- a/tests/baselines/reference/project/sourcemapSubfolderSpecifyOutputDirectory/node/sourcemapSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourcemapSubfolderSpecifyOutputDirectory/node/sourcemapSubfolderSpecifyOutputDirectory.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlMixedSubfolderNoOutdir/amd/sourcerootUrlMixedSubfolderNoOutdir.json b/tests/baselines/reference/project/sourcerootUrlMixedSubfolderNoOutdir/amd/sourcerootUrlMixedSubfolderNoOutdir.json
index ef5cb2df6335d..68d25fa714e4a 100644
--- a/tests/baselines/reference/project/sourcerootUrlMixedSubfolderNoOutdir/amd/sourcerootUrlMixedSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourcerootUrlMixedSubfolderNoOutdir/amd/sourcerootUrlMixedSubfolderNoOutdir.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "ref/m2.js.map",
         "ref/m2.js",
-        "ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlMixedSubfolderNoOutdir/node/sourcerootUrlMixedSubfolderNoOutdir.json b/tests/baselines/reference/project/sourcerootUrlMixedSubfolderNoOutdir/node/sourcerootUrlMixedSubfolderNoOutdir.json
index ef5cb2df6335d..68d25fa714e4a 100644
--- a/tests/baselines/reference/project/sourcerootUrlMixedSubfolderNoOutdir/node/sourcerootUrlMixedSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourcerootUrlMixedSubfolderNoOutdir/node/sourcerootUrlMixedSubfolderNoOutdir.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "ref/m2.js.map",
         "ref/m2.js",
-        "ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlMixedSubfolderSpecifyOutputDirectory/amd/sourcerootUrlMixedSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourcerootUrlMixedSubfolderSpecifyOutputDirectory/amd/sourcerootUrlMixedSubfolderSpecifyOutputDirectory.json
index a46fe8457105a..b2b82e57fcc25 100644
--- a/tests/baselines/reference/project/sourcerootUrlMixedSubfolderSpecifyOutputDirectory/amd/sourcerootUrlMixedSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourcerootUrlMixedSubfolderSpecifyOutputDirectory/amd/sourcerootUrlMixedSubfolderSpecifyOutputDirectory.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/ref/m2.js.map",
         "outdir/simple/ref/m2.js",
-        "outdir/simple/ref/m2.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
+        "outdir/simple/ref/m2.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlMixedSubfolderSpecifyOutputDirectory/node/sourcerootUrlMixedSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourcerootUrlMixedSubfolderSpecifyOutputDirectory/node/sourcerootUrlMixedSubfolderSpecifyOutputDirectory.json
index a46fe8457105a..b2b82e57fcc25 100644
--- a/tests/baselines/reference/project/sourcerootUrlMixedSubfolderSpecifyOutputDirectory/node/sourcerootUrlMixedSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourcerootUrlMixedSubfolderSpecifyOutputDirectory/node/sourcerootUrlMixedSubfolderSpecifyOutputDirectory.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/ref/m2.js.map",
         "outdir/simple/ref/m2.js",
-        "outdir/simple/ref/m2.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
+        "outdir/simple/ref/m2.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlMixedSubfolderSpecifyOutputFile/amd/sourcerootUrlMixedSubfolderSpecifyOutputFile.json b/tests/baselines/reference/project/sourcerootUrlMixedSubfolderSpecifyOutputFile/amd/sourcerootUrlMixedSubfolderSpecifyOutputFile.json
index 50a4518a1b08c..bb9835b510f0c 100644
--- a/tests/baselines/reference/project/sourcerootUrlMixedSubfolderSpecifyOutputFile/amd/sourcerootUrlMixedSubfolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/sourcerootUrlMixedSubfolderSpecifyOutputFile/amd/sourcerootUrlMixedSubfolderSpecifyOutputFile.json
@@ -18,9 +18,9 @@
     "emittedFiles": [
         "ref/m2.js.map",
         "ref/m2.js",
-        "ref/m2.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m2.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlMixedSubfolderSpecifyOutputFile/node/sourcerootUrlMixedSubfolderSpecifyOutputFile.json b/tests/baselines/reference/project/sourcerootUrlMixedSubfolderSpecifyOutputFile/node/sourcerootUrlMixedSubfolderSpecifyOutputFile.json
index 50a4518a1b08c..bb9835b510f0c 100644
--- a/tests/baselines/reference/project/sourcerootUrlMixedSubfolderSpecifyOutputFile/node/sourcerootUrlMixedSubfolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/sourcerootUrlMixedSubfolderSpecifyOutputFile/node/sourcerootUrlMixedSubfolderSpecifyOutputFile.json
@@ -18,9 +18,9 @@
     "emittedFiles": [
         "ref/m2.js.map",
         "ref/m2.js",
-        "ref/m2.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m2.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory/amd/sourcerootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory.json b/tests/baselines/reference/project/sourcerootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory/amd/sourcerootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
index b6ef6b5bd517d..54ba2779848a2 100644
--- a/tests/baselines/reference/project/sourcerootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory/amd/sourcerootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
+++ b/tests/baselines/reference/project/sourcerootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory/amd/sourcerootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
@@ -19,9 +19,9 @@
     "emittedFiles": [
         "outdir/outAndOutDirFolder/ref/m2.js.map",
         "outdir/outAndOutDirFolder/ref/m2.js",
-        "outdir/outAndOutDirFolder/ref/m2.d.ts",
         "bin/outAndOutDirFile.js.map",
         "bin/outAndOutDirFile.js",
+        "outdir/outAndOutDirFolder/ref/m2.d.ts",
         "bin/outAndOutDirFile.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory/node/sourcerootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory.json b/tests/baselines/reference/project/sourcerootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory/node/sourcerootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
index b6ef6b5bd517d..54ba2779848a2 100644
--- a/tests/baselines/reference/project/sourcerootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory/node/sourcerootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
+++ b/tests/baselines/reference/project/sourcerootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory/node/sourcerootUrlMixedSubfolderSpecifyOutputFileAndOutputDirectory.json
@@ -19,9 +19,9 @@
     "emittedFiles": [
         "outdir/outAndOutDirFolder/ref/m2.js.map",
         "outdir/outAndOutDirFolder/ref/m2.js",
-        "outdir/outAndOutDirFolder/ref/m2.d.ts",
         "bin/outAndOutDirFile.js.map",
         "bin/outAndOutDirFile.js",
+        "outdir/outAndOutDirFolder/ref/m2.d.ts",
         "bin/outAndOutDirFile.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlModuleMultifolderNoOutdir/amd/sourcerootUrlModuleMultifolderNoOutdir.json b/tests/baselines/reference/project/sourcerootUrlModuleMultifolderNoOutdir/amd/sourcerootUrlModuleMultifolderNoOutdir.json
index c2594c0093cb8..2754c26339f75 100644
--- a/tests/baselines/reference/project/sourcerootUrlModuleMultifolderNoOutdir/amd/sourcerootUrlModuleMultifolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourcerootUrlModuleMultifolderNoOutdir/amd/sourcerootUrlModuleMultifolderNoOutdir.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_module_multifolder_ref/m2.js.map",
         "../outputdir_module_multifolder_ref/m2.js",
-        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlModuleMultifolderNoOutdir/node/sourcerootUrlModuleMultifolderNoOutdir.json b/tests/baselines/reference/project/sourcerootUrlModuleMultifolderNoOutdir/node/sourcerootUrlModuleMultifolderNoOutdir.json
index c2594c0093cb8..2754c26339f75 100644
--- a/tests/baselines/reference/project/sourcerootUrlModuleMultifolderNoOutdir/node/sourcerootUrlModuleMultifolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourcerootUrlModuleMultifolderNoOutdir/node/sourcerootUrlModuleMultifolderNoOutdir.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_module_multifolder_ref/m2.js.map",
         "../outputdir_module_multifolder_ref/m2.js",
-        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputDirectory/amd/sourcerootUrlModuleMultifolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputDirectory/amd/sourcerootUrlModuleMultifolderSpecifyOutputDirectory.json
index d2c6956bf8021..d9ecddde98286 100644
--- a/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputDirectory/amd/sourcerootUrlModuleMultifolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputDirectory/amd/sourcerootUrlModuleMultifolderSpecifyOutputDirectory.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "outdir/simple/outputdir_module_multifolder/ref/m1.js.map",
         "outdir/simple/outputdir_module_multifolder/ref/m1.js",
-        "outdir/simple/outputdir_module_multifolder/ref/m1.d.ts",
         "outdir/simple/outputdir_module_multifolder_ref/m2.js.map",
         "outdir/simple/outputdir_module_multifolder_ref/m2.js",
-        "outdir/simple/outputdir_module_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_module_multifolder/test.js.map",
         "outdir/simple/outputdir_module_multifolder/test.js",
+        "outdir/simple/outputdir_module_multifolder/ref/m1.d.ts",
+        "outdir/simple/outputdir_module_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_module_multifolder/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputDirectory/node/sourcerootUrlModuleMultifolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputDirectory/node/sourcerootUrlModuleMultifolderSpecifyOutputDirectory.json
index d2c6956bf8021..d9ecddde98286 100644
--- a/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputDirectory/node/sourcerootUrlModuleMultifolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputDirectory/node/sourcerootUrlModuleMultifolderSpecifyOutputDirectory.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "outdir/simple/outputdir_module_multifolder/ref/m1.js.map",
         "outdir/simple/outputdir_module_multifolder/ref/m1.js",
-        "outdir/simple/outputdir_module_multifolder/ref/m1.d.ts",
         "outdir/simple/outputdir_module_multifolder_ref/m2.js.map",
         "outdir/simple/outputdir_module_multifolder_ref/m2.js",
-        "outdir/simple/outputdir_module_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_module_multifolder/test.js.map",
         "outdir/simple/outputdir_module_multifolder/test.js",
+        "outdir/simple/outputdir_module_multifolder/ref/m1.d.ts",
+        "outdir/simple/outputdir_module_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_module_multifolder/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/amd/sourcerootUrlModuleMultifolderSpecifyOutputFile.json b/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/amd/sourcerootUrlModuleMultifolderSpecifyOutputFile.json
index cc2a6c9b1aa06..b2582dbc0db59 100644
--- a/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/amd/sourcerootUrlModuleMultifolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/amd/sourcerootUrlModuleMultifolderSpecifyOutputFile.json
@@ -18,15 +18,15 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_module_multifolder_ref/m2.js.map",
         "../outputdir_module_multifolder_ref/m2.js",
-        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m1.d.ts",
+        "../outputdir_module_multifolder_ref/m2.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/node/sourcerootUrlModuleMultifolderSpecifyOutputFile.json b/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/node/sourcerootUrlModuleMultifolderSpecifyOutputFile.json
index cc2a6c9b1aa06..b2582dbc0db59 100644
--- a/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/node/sourcerootUrlModuleMultifolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/node/sourcerootUrlModuleMultifolderSpecifyOutputFile.json
@@ -18,15 +18,15 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_module_multifolder_ref/m2.js.map",
         "../outputdir_module_multifolder_ref/m2.js",
-        "../outputdir_module_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m1.d.ts",
+        "../outputdir_module_multifolder_ref/m2.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlModuleSimpleNoOutdir/amd/sourcerootUrlModuleSimpleNoOutdir.json b/tests/baselines/reference/project/sourcerootUrlModuleSimpleNoOutdir/amd/sourcerootUrlModuleSimpleNoOutdir.json
index 4a7cc668a6a86..8f727aef22629 100644
--- a/tests/baselines/reference/project/sourcerootUrlModuleSimpleNoOutdir/amd/sourcerootUrlModuleSimpleNoOutdir.json
+++ b/tests/baselines/reference/project/sourcerootUrlModuleSimpleNoOutdir/amd/sourcerootUrlModuleSimpleNoOutdir.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
+        "m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlModuleSimpleNoOutdir/node/sourcerootUrlModuleSimpleNoOutdir.json b/tests/baselines/reference/project/sourcerootUrlModuleSimpleNoOutdir/node/sourcerootUrlModuleSimpleNoOutdir.json
index 4a7cc668a6a86..8f727aef22629 100644
--- a/tests/baselines/reference/project/sourcerootUrlModuleSimpleNoOutdir/node/sourcerootUrlModuleSimpleNoOutdir.json
+++ b/tests/baselines/reference/project/sourcerootUrlModuleSimpleNoOutdir/node/sourcerootUrlModuleSimpleNoOutdir.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
+        "m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlModuleSimpleSpecifyOutputDirectory/amd/sourcerootUrlModuleSimpleSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourcerootUrlModuleSimpleSpecifyOutputDirectory/amd/sourcerootUrlModuleSimpleSpecifyOutputDirectory.json
index 6766f67eab06d..1c6f2a47b9adb 100644
--- a/tests/baselines/reference/project/sourcerootUrlModuleSimpleSpecifyOutputDirectory/amd/sourcerootUrlModuleSimpleSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourcerootUrlModuleSimpleSpecifyOutputDirectory/amd/sourcerootUrlModuleSimpleSpecifyOutputDirectory.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "outdir/simple/m1.js.map",
         "outdir/simple/m1.js",
-        "outdir/simple/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlModuleSimpleSpecifyOutputDirectory/node/sourcerootUrlModuleSimpleSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourcerootUrlModuleSimpleSpecifyOutputDirectory/node/sourcerootUrlModuleSimpleSpecifyOutputDirectory.json
index 6766f67eab06d..1c6f2a47b9adb 100644
--- a/tests/baselines/reference/project/sourcerootUrlModuleSimpleSpecifyOutputDirectory/node/sourcerootUrlModuleSimpleSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourcerootUrlModuleSimpleSpecifyOutputDirectory/node/sourcerootUrlModuleSimpleSpecifyOutputDirectory.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "outdir/simple/m1.js.map",
         "outdir/simple/m1.js",
-        "outdir/simple/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlModuleSimpleSpecifyOutputFile/amd/sourcerootUrlModuleSimpleSpecifyOutputFile.json b/tests/baselines/reference/project/sourcerootUrlModuleSimpleSpecifyOutputFile/amd/sourcerootUrlModuleSimpleSpecifyOutputFile.json
index 5419c5a822564..21fe48877e86e 100644
--- a/tests/baselines/reference/project/sourcerootUrlModuleSimpleSpecifyOutputFile/amd/sourcerootUrlModuleSimpleSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/sourcerootUrlModuleSimpleSpecifyOutputFile/amd/sourcerootUrlModuleSimpleSpecifyOutputFile.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "m1.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlModuleSimpleSpecifyOutputFile/node/sourcerootUrlModuleSimpleSpecifyOutputFile.json b/tests/baselines/reference/project/sourcerootUrlModuleSimpleSpecifyOutputFile/node/sourcerootUrlModuleSimpleSpecifyOutputFile.json
index 5419c5a822564..21fe48877e86e 100644
--- a/tests/baselines/reference/project/sourcerootUrlModuleSimpleSpecifyOutputFile/node/sourcerootUrlModuleSimpleSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/sourcerootUrlModuleSimpleSpecifyOutputFile/node/sourcerootUrlModuleSimpleSpecifyOutputFile.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "m1.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlModuleSubfolderNoOutdir/amd/sourcerootUrlModuleSubfolderNoOutdir.json b/tests/baselines/reference/project/sourcerootUrlModuleSubfolderNoOutdir/amd/sourcerootUrlModuleSubfolderNoOutdir.json
index d7f99610babea..0038bbba7c053 100644
--- a/tests/baselines/reference/project/sourcerootUrlModuleSubfolderNoOutdir/amd/sourcerootUrlModuleSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourcerootUrlModuleSubfolderNoOutdir/amd/sourcerootUrlModuleSubfolderNoOutdir.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlModuleSubfolderNoOutdir/node/sourcerootUrlModuleSubfolderNoOutdir.json b/tests/baselines/reference/project/sourcerootUrlModuleSubfolderNoOutdir/node/sourcerootUrlModuleSubfolderNoOutdir.json
index d7f99610babea..0038bbba7c053 100644
--- a/tests/baselines/reference/project/sourcerootUrlModuleSubfolderNoOutdir/node/sourcerootUrlModuleSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourcerootUrlModuleSubfolderNoOutdir/node/sourcerootUrlModuleSubfolderNoOutdir.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlModuleSubfolderSpecifyOutputDirectory/amd/sourcerootUrlModuleSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourcerootUrlModuleSubfolderSpecifyOutputDirectory/amd/sourcerootUrlModuleSubfolderSpecifyOutputDirectory.json
index 1e722cb852eb9..4bda53a6479b9 100644
--- a/tests/baselines/reference/project/sourcerootUrlModuleSubfolderSpecifyOutputDirectory/amd/sourcerootUrlModuleSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourcerootUrlModuleSubfolderSpecifyOutputDirectory/amd/sourcerootUrlModuleSubfolderSpecifyOutputDirectory.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlModuleSubfolderSpecifyOutputDirectory/node/sourcerootUrlModuleSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourcerootUrlModuleSubfolderSpecifyOutputDirectory/node/sourcerootUrlModuleSubfolderSpecifyOutputDirectory.json
index 1e722cb852eb9..4bda53a6479b9 100644
--- a/tests/baselines/reference/project/sourcerootUrlModuleSubfolderSpecifyOutputDirectory/node/sourcerootUrlModuleSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourcerootUrlModuleSubfolderSpecifyOutputDirectory/node/sourcerootUrlModuleSubfolderSpecifyOutputDirectory.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlModuleSubfolderSpecifyOutputFile/amd/sourcerootUrlModuleSubfolderSpecifyOutputFile.json b/tests/baselines/reference/project/sourcerootUrlModuleSubfolderSpecifyOutputFile/amd/sourcerootUrlModuleSubfolderSpecifyOutputFile.json
index d80dacb3444d7..b4a34f6395781 100644
--- a/tests/baselines/reference/project/sourcerootUrlModuleSubfolderSpecifyOutputFile/amd/sourcerootUrlModuleSubfolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/sourcerootUrlModuleSubfolderSpecifyOutputFile/amd/sourcerootUrlModuleSubfolderSpecifyOutputFile.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m1.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlModuleSubfolderSpecifyOutputFile/node/sourcerootUrlModuleSubfolderSpecifyOutputFile.json b/tests/baselines/reference/project/sourcerootUrlModuleSubfolderSpecifyOutputFile/node/sourcerootUrlModuleSubfolderSpecifyOutputFile.json
index d80dacb3444d7..b4a34f6395781 100644
--- a/tests/baselines/reference/project/sourcerootUrlModuleSubfolderSpecifyOutputFile/node/sourcerootUrlModuleSubfolderSpecifyOutputFile.json
+++ b/tests/baselines/reference/project/sourcerootUrlModuleSubfolderSpecifyOutputFile/node/sourcerootUrlModuleSubfolderSpecifyOutputFile.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
-        "test.d.ts",
         "bin/test.js.map",
         "bin/test.js",
+        "ref/m1.d.ts",
+        "test.d.ts",
         "bin/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlMultifolderNoOutdir/amd/sourcerootUrlMultifolderNoOutdir.json b/tests/baselines/reference/project/sourcerootUrlMultifolderNoOutdir/amd/sourcerootUrlMultifolderNoOutdir.json
index a68d507bdf3e0..e56d57e9327d7 100644
--- a/tests/baselines/reference/project/sourcerootUrlMultifolderNoOutdir/amd/sourcerootUrlMultifolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourcerootUrlMultifolderNoOutdir/amd/sourcerootUrlMultifolderNoOutdir.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_multifolder_ref/m2.js.map",
         "../outputdir_multifolder_ref/m2.js",
-        "../outputdir_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "../outputdir_multifolder_ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlMultifolderNoOutdir/node/sourcerootUrlMultifolderNoOutdir.json b/tests/baselines/reference/project/sourcerootUrlMultifolderNoOutdir/node/sourcerootUrlMultifolderNoOutdir.json
index a68d507bdf3e0..e56d57e9327d7 100644
--- a/tests/baselines/reference/project/sourcerootUrlMultifolderNoOutdir/node/sourcerootUrlMultifolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourcerootUrlMultifolderNoOutdir/node/sourcerootUrlMultifolderNoOutdir.json
@@ -17,12 +17,12 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "../outputdir_multifolder_ref/m2.js.map",
         "../outputdir_multifolder_ref/m2.js",
-        "../outputdir_multifolder_ref/m2.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
+        "../outputdir_multifolder_ref/m2.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlMultifolderSpecifyOutputDirectory/amd/sourcerootUrlMultifolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourcerootUrlMultifolderSpecifyOutputDirectory/amd/sourcerootUrlMultifolderSpecifyOutputDirectory.json
index 1641625569c29..764e4f3a8ee16 100644
--- a/tests/baselines/reference/project/sourcerootUrlMultifolderSpecifyOutputDirectory/amd/sourcerootUrlMultifolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourcerootUrlMultifolderSpecifyOutputDirectory/amd/sourcerootUrlMultifolderSpecifyOutputDirectory.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "outdir/simple/outputdir_multifolder/ref/m1.js.map",
         "outdir/simple/outputdir_multifolder/ref/m1.js",
-        "outdir/simple/outputdir_multifolder/ref/m1.d.ts",
         "outdir/simple/outputdir_multifolder_ref/m2.js.map",
         "outdir/simple/outputdir_multifolder_ref/m2.js",
-        "outdir/simple/outputdir_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_multifolder/test.js.map",
         "outdir/simple/outputdir_multifolder/test.js",
+        "outdir/simple/outputdir_multifolder/ref/m1.d.ts",
+        "outdir/simple/outputdir_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_multifolder/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlMultifolderSpecifyOutputDirectory/node/sourcerootUrlMultifolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourcerootUrlMultifolderSpecifyOutputDirectory/node/sourcerootUrlMultifolderSpecifyOutputDirectory.json
index 1641625569c29..764e4f3a8ee16 100644
--- a/tests/baselines/reference/project/sourcerootUrlMultifolderSpecifyOutputDirectory/node/sourcerootUrlMultifolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourcerootUrlMultifolderSpecifyOutputDirectory/node/sourcerootUrlMultifolderSpecifyOutputDirectory.json
@@ -18,12 +18,12 @@
     "emittedFiles": [
         "outdir/simple/outputdir_multifolder/ref/m1.js.map",
         "outdir/simple/outputdir_multifolder/ref/m1.js",
-        "outdir/simple/outputdir_multifolder/ref/m1.d.ts",
         "outdir/simple/outputdir_multifolder_ref/m2.js.map",
         "outdir/simple/outputdir_multifolder_ref/m2.js",
-        "outdir/simple/outputdir_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_multifolder/test.js.map",
         "outdir/simple/outputdir_multifolder/test.js",
+        "outdir/simple/outputdir_multifolder/ref/m1.d.ts",
+        "outdir/simple/outputdir_multifolder_ref/m2.d.ts",
         "outdir/simple/outputdir_multifolder/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlSimpleNoOutdir/amd/sourcerootUrlSimpleNoOutdir.json b/tests/baselines/reference/project/sourcerootUrlSimpleNoOutdir/amd/sourcerootUrlSimpleNoOutdir.json
index 9df1fd3922ee8..24bfc485b069b 100644
--- a/tests/baselines/reference/project/sourcerootUrlSimpleNoOutdir/amd/sourcerootUrlSimpleNoOutdir.json
+++ b/tests/baselines/reference/project/sourcerootUrlSimpleNoOutdir/amd/sourcerootUrlSimpleNoOutdir.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
+        "m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlSimpleNoOutdir/node/sourcerootUrlSimpleNoOutdir.json b/tests/baselines/reference/project/sourcerootUrlSimpleNoOutdir/node/sourcerootUrlSimpleNoOutdir.json
index 9df1fd3922ee8..24bfc485b069b 100644
--- a/tests/baselines/reference/project/sourcerootUrlSimpleNoOutdir/node/sourcerootUrlSimpleNoOutdir.json
+++ b/tests/baselines/reference/project/sourcerootUrlSimpleNoOutdir/node/sourcerootUrlSimpleNoOutdir.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "m1.js.map",
         "m1.js",
-        "m1.d.ts",
         "test.js.map",
         "test.js",
+        "m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlSimpleSpecifyOutputDirectory/amd/sourcerootUrlSimpleSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourcerootUrlSimpleSpecifyOutputDirectory/amd/sourcerootUrlSimpleSpecifyOutputDirectory.json
index 1a472ca17eedb..6a760640c7339 100644
--- a/tests/baselines/reference/project/sourcerootUrlSimpleSpecifyOutputDirectory/amd/sourcerootUrlSimpleSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourcerootUrlSimpleSpecifyOutputDirectory/amd/sourcerootUrlSimpleSpecifyOutputDirectory.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "outdir/simple/m1.js.map",
         "outdir/simple/m1.js",
-        "outdir/simple/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlSimpleSpecifyOutputDirectory/node/sourcerootUrlSimpleSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourcerootUrlSimpleSpecifyOutputDirectory/node/sourcerootUrlSimpleSpecifyOutputDirectory.json
index 1a472ca17eedb..6a760640c7339 100644
--- a/tests/baselines/reference/project/sourcerootUrlSimpleSpecifyOutputDirectory/node/sourcerootUrlSimpleSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourcerootUrlSimpleSpecifyOutputDirectory/node/sourcerootUrlSimpleSpecifyOutputDirectory.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "outdir/simple/m1.js.map",
         "outdir/simple/m1.js",
-        "outdir/simple/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlSubfolderNoOutdir/amd/sourcerootUrlSubfolderNoOutdir.json b/tests/baselines/reference/project/sourcerootUrlSubfolderNoOutdir/amd/sourcerootUrlSubfolderNoOutdir.json
index 77912e79790f3..167273463aad3 100644
--- a/tests/baselines/reference/project/sourcerootUrlSubfolderNoOutdir/amd/sourcerootUrlSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourcerootUrlSubfolderNoOutdir/amd/sourcerootUrlSubfolderNoOutdir.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlSubfolderNoOutdir/node/sourcerootUrlSubfolderNoOutdir.json b/tests/baselines/reference/project/sourcerootUrlSubfolderNoOutdir/node/sourcerootUrlSubfolderNoOutdir.json
index 77912e79790f3..167273463aad3 100644
--- a/tests/baselines/reference/project/sourcerootUrlSubfolderNoOutdir/node/sourcerootUrlSubfolderNoOutdir.json
+++ b/tests/baselines/reference/project/sourcerootUrlSubfolderNoOutdir/node/sourcerootUrlSubfolderNoOutdir.json
@@ -16,9 +16,9 @@
     "emittedFiles": [
         "ref/m1.js.map",
         "ref/m1.js",
-        "ref/m1.d.ts",
         "test.js.map",
         "test.js",
+        "ref/m1.d.ts",
         "test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlSubfolderSpecifyOutputDirectory/amd/sourcerootUrlSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourcerootUrlSubfolderSpecifyOutputDirectory/amd/sourcerootUrlSubfolderSpecifyOutputDirectory.json
index 362af3ded0523..9bb091a6809f2 100644
--- a/tests/baselines/reference/project/sourcerootUrlSubfolderSpecifyOutputDirectory/amd/sourcerootUrlSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourcerootUrlSubfolderSpecifyOutputDirectory/amd/sourcerootUrlSubfolderSpecifyOutputDirectory.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/sourcerootUrlSubfolderSpecifyOutputDirectory/node/sourcerootUrlSubfolderSpecifyOutputDirectory.json b/tests/baselines/reference/project/sourcerootUrlSubfolderSpecifyOutputDirectory/node/sourcerootUrlSubfolderSpecifyOutputDirectory.json
index 362af3ded0523..9bb091a6809f2 100644
--- a/tests/baselines/reference/project/sourcerootUrlSubfolderSpecifyOutputDirectory/node/sourcerootUrlSubfolderSpecifyOutputDirectory.json
+++ b/tests/baselines/reference/project/sourcerootUrlSubfolderSpecifyOutputDirectory/node/sourcerootUrlSubfolderSpecifyOutputDirectory.json
@@ -17,9 +17,9 @@
     "emittedFiles": [
         "outdir/simple/ref/m1.js.map",
         "outdir/simple/ref/m1.js",
-        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.js.map",
         "outdir/simple/test.js",
+        "outdir/simple/ref/m1.d.ts",
         "outdir/simple/test.d.ts"
     ]
 }
\ No newline at end of file

From 98cd10784cdff7f7bc3c45a482b1541f874a01a8 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Mon, 20 Jul 2015 22:39:22 -0700
Subject: [PATCH 47/57] Switch to iterative model and clean up error reporting

---
 src/compiler/declarationEmitter.ts            |  99 ++++++++-----
 ...ationVisibilityErrorTypeLiteral.errors.txt |  14 +-
 ...tendsClauseWithVisibilityErrors.errors.txt |   5 +-
 .../privacyAccessorDeclFile.errors.txt        |  70 +---------
 ...CheckTypeOfInvisibleModuleError.errors.txt |   5 +-
 ...ivacyClassExtendsClauseDeclFile.errors.txt |  11 +-
 ...cyClassImplementsClauseDeclFile.errors.txt |  11 +-
 ...rivacyFunctionParameterDeclFile.errors.txt | 130 +-----------------
 ...ivacyFunctionReturnTypeDeclFile.errors.txt | 124 +----------------
 .../reference/privacyGloImport.errors.txt     |  14 +-
 .../privacyGloImportParseErrors.errors.txt    |  14 +-
 .../reference/privacyImport.errors.txt        |  14 +-
 ...yInterfaceExtendsClauseDeclFile.errors.txt |  11 +-
 ...ternalReferenceImportWithExport.errors.txt |  36 +++--
 ...nalReferenceImportWithoutExport.errors.txt |  28 ++--
 ...ternalReferenceImportWithExport.errors.txt |  36 +++--
 ...nalReferenceImportWithoutExport.errors.txt |  28 ++--
 ...TypeParameterOfFunctionDeclFile.errors.txt |  32 +----
 ...cyTypeParametersOfClassDeclFile.errors.txt |   8 +-
 ...peParametersOfInterfaceDeclFile.errors.txt |  35 +----
 .../reference/privacyVarDeclFile.errors.txt   |  70 +---------
 21 files changed, 195 insertions(+), 600 deletions(-)

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index 5b38da85fe1be..83d296c79f97b 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -7,6 +7,7 @@ namespace ts {
         visited?: boolean;
         collected?: boolean;
         hasExportDeclarations?: boolean;
+        errorReported?: boolean;
     }
 
     interface PreprocessResults {
@@ -1039,6 +1040,7 @@ namespace ts {
     function preprocessDeclarations(sourceFiles: SourceFile[], resolver: EmitResolver, diagnostics: Diagnostic[], compilerOptions: CompilerOptions): PreprocessResults {
         let currentSourceFile: SourceFile;
         let nodeLinks: NodeLinks[] = [];
+        let declarationsToProcess: { declaration: Node; errorNode?: Node }[] = [];
 
         for (let sourceFile of sourceFiles) {
             preprocessSourceFile(sourceFile);
@@ -1298,10 +1300,17 @@ namespace ts {
             }
 
             function collectDeclarations(symbol: Symbol, errorNode: Node): void {
-                forEach(symbol.declarations, d => collectDeclaration(d, errorNode));
+                forEach(symbol.declarations, declaration => {
+                    collectDeclatation(declaration, errorNode);
+                });
             }
         }
 
+        function collectDeclatation(declaration:Node, errorNode?: Node) {
+            declarationsToProcess.push({ declaration, errorNode });
+            //preprocessDeclaration(declaration, errorNode);
+        }
+
         function isDeclarationExported(node: Node): boolean {
             if (compilerOptions.stripInternal && isInternal(node)) {
                 // TODO: this is the correct place for this check, enable this 
@@ -1421,31 +1430,31 @@ namespace ts {
          *
          */
         function canWriteDeclaration(node: Node): boolean {
-            if (node.kind === SyntaxKind.VariableDeclaration || node.kind === SyntaxKind.BindingElement) {
-                node = node.parent.parent;
-            }
-
-            // If the declaration is exported from its parent, we can
-            // safelly write a declaration for it
-            if (isDeclarationExported(node)) {
+            if (node.kind === SyntaxKind.SourceFile ||
+                node.kind === SyntaxKind.ImportEqualsDeclaration || node.kind === SyntaxKind.ImportDeclaration) {
                 return true;
             }
 
-            if (node.kind === SyntaxKind.ImportEqualsDeclaration || node.kind === SyntaxKind.ImportDeclaration) {
-                return true;
+            if (node.kind === SyntaxKind.VariableDeclaration || node.kind === SyntaxKind.BindingElement) {
+                node = node.parent.parent;
             }
 
-            // If the parent module has an export declaration  or export
-            // assingment, then the scoping rules change, and only declarations
-            // with export modifier are visible, so we can safely write 
-            // a declaration of a non-exported entity without exposing it
             let parent = getEnclosingDeclaration(node);
-            if (parent) {
-                return (parent.kind === SyntaxKind.ModuleDeclaration || parent.kind === SyntaxKind.SourceFile) &&
-                    hasExportDeclatations(parent);
+
+            if (!isDeclarationExported(node)) {
+                // If the parent module has an export declaration  or export
+                // assingment, then the scoping rules change, and only declarations
+                // with export modifier are visible, so we can safely write 
+                // a declaration of a non-exported entity without exposing it
+                if (!((parent.kind === SyntaxKind.ModuleDeclaration || parent.kind === SyntaxKind.SourceFile) &&
+                    hasExportDeclatations(parent))) {
+                    return false;
+                }
             }
 
-            return false;
+            // The declaration is exported from its parent, or can be written without
+            // an export modifier. Now check if the parent is visible as well.
+            return canWriteDeclaration(parent);
         }
 
         function getNameText(node: ParameterDeclaration|PropertyDeclaration|VariableDeclaration|FunctionDeclaration| AccessorDeclaration| MethodDeclaration): string {
@@ -1597,44 +1606,64 @@ namespace ts {
             Debug.fail("Could not find container node");
         }
 
-        function collectDeclaration(node: Node, errorNode?: Node): void {
-            if (node.kind === SyntaxKind.TypeParameter || node.kind === SyntaxKind.Parameter) {
+        function preprocessDeclaration(declaration: Node, errorNode?: Node): void {
+            if (declaration.kind === SyntaxKind.TypeParameter || declaration.kind === SyntaxKind.Parameter) {
                 return;
             }
 
-            // Make sure this declaration can be emitted, that is it is accessible
-            // and is connected to its parent, or else report a accessibility error
-            ensureDeclarationVisible(node, errorNode);
+            // Always report the error, even if the node was visited before, so that 
+            // diffrent references to the same declaration are flagged
+            if (errorNode && reportDeclarationAccessiblityError(declaration, errorNode)) {
+                return;
+            }
 
             // If this declaration is from a diffrent file, we will get to it later. 
-            if (getSourceFileOfNode(node) !== currentSourceFile) {
+            // Skip it for now.
+            if (getSourceFileOfNode(declaration) !== currentSourceFile) {
                 return;
             }
 
-            let links = getNodeLinks(node);
+            let links = getNodeLinks(declaration);
             if (!links.collected) {
                 links.collected = true;
 
+                // Make sure this declaration can be emitted, that is it is accessible
+                // and is connected to its parent, or else report a accessibility error
+                ensureDeclarationVisible(declaration, errorNode);
+
                 // Collect any dependencies
-                collectReferencedDeclarations(node);
+                collectReferencedDeclarations(declaration);
 
                 // Collect children as well
-                switch (node.kind) {
+                switch (declaration.kind) {
                     case SyntaxKind.ModuleDeclaration:
                     case SyntaxKind.InterfaceDeclaration:
                     case SyntaxKind.ClassDeclaration:
                     case SyntaxKind.EnumDeclaration:
                     case SyntaxKind.VariableStatement:
-                        collectTopLevelChildDeclarations(node);
+                        collectTopLevelChildDeclarations(declaration);
                         break;
                 }
             }
         }
 
+        function reportDeclarationAccessiblityError(declaration: Node, errorNode: Node): boolean {
+            let node = errorNode;
+            while (node.parent.kind === SyntaxKind.QualifiedName || node.parent.kind === SyntaxKind.PropertyAccessExpression) {
+                node = node.parent;
+            }
+            let links = getNodeLinks(node);
+            if (!links.errorReported && !canWriteDeclaration(declaration)) {
+                links.errorReported = true;
+                reportDeclarationAccessiblityMessage(<Declaration>declaration, errorNode);
+            }
+            return links.errorReported;
+        }
+
         function collectTopLevelChildDeclarations(node: Node): void {
             forEachTopLevelDeclaration(node, child => {
                 if (isDeclarationExported(child)) {
-                    collectDeclaration(child);
+                    collectDeclatation(child);
                 }
             });
         }
@@ -1654,13 +1683,6 @@ namespace ts {
                     attachVisibleChild(parent, node);
                 }
             }
-
-            // Always report the error, even if the node was visited before
-            if (errorNode) {
-                if (!canWriteDeclaration(node)) {
-                    reportDeclarationAccessiblityMessage(<Declaration>node, errorNode);
-                }
-            }
         }
 
         function attachVisibleChild(node: Node, child: Node): void {
@@ -1676,6 +1698,11 @@ namespace ts {
 
             // Collect all visible declarations
             collectTopLevelChildDeclarations(sourceFile);
+
+            while (declarationsToProcess.length > 0) {
+                let {declaration, errorNode} = declarationsToProcess.shift();
+                preprocessDeclaration(declaration, errorNode);
+            }
         }
     }
 
diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeLiteral.errors.txt b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeLiteral.errors.txt
index a46adfc2914dc..a3290c6c8ca3d 100644
--- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeLiteral.errors.txt
+++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeLiteral.errors.txt
@@ -4,21 +4,17 @@ tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(13,13):
 tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(14,19): error TS4038: Return type of method 'method' references inaccessible name 'private1'.
 tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(15,22): error TS4049: Return type of index signature references inaccessible name 'private1'.
 tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(16,22): error TS4049: Return type of index signature references inaccessible name 'm2'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(18,16): error TS4025: Type of variable 'x2' references inaccessible name 'm2'.
 tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(18,16): error TS4025: Type of variable 'x2' references inaccessible name 'private1'.
 tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(25,16): error TS4025: Type of variable 'x3' references inaccessible name 'm2'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(25,16): error TS4025: Type of variable 'x3' references inaccessible name 'private1'.
 tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(28,23): error TS4030: Type of parameter 'a' references inaccessible name 'private1'.
 tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(28,36): error TS4025: Type of variable 'y' references inaccessible name 'm2'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(29,16): error TS4025: Type of variable 'y2' references inaccessible name 'm2'.
 tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(29,16): error TS4025: Type of variable 'y2' references inaccessible name 'private1'.
 tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(32,27): error TS4030: Type of parameter 'a' references inaccessible name 'private1'.
 tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(32,40): error TS4025: Type of variable 'z' references inaccessible name 'm2'.
-tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(33,16): error TS4025: Type of variable 'z2' references inaccessible name 'm2'.
 tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(33,16): error TS4025: Type of variable 'z2' references inaccessible name 'private1'.
 
 
-==== tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts (18 errors) ====
+==== tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts (14 errors) ====
     
     module m {
         class private1 {
@@ -50,8 +46,6 @@ tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(33,16):
         };
         export var x2 = {
                    ~~
-!!! error TS4025: Type of variable 'x2' references inaccessible name 'm2'.
-                   ~~
 !!! error TS4025: Type of variable 'x2' references inaccessible name 'private1'.
             x: new private1(),
             y: new m2.public1(),
@@ -62,8 +56,6 @@ tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(33,16):
         export var x3 = x;
                    ~~
 !!! error TS4025: Type of variable 'x3' references inaccessible name 'm2'.
-                   ~~
-!!! error TS4025: Type of variable 'x3' references inaccessible name 'private1'.
     
         // Function type
         export var y: (a: private1) => m2.public1;
@@ -73,8 +65,6 @@ tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(33,16):
 !!! error TS4025: Type of variable 'y' references inaccessible name 'm2'.
         export var y2 = y;
                    ~~
-!!! error TS4025: Type of variable 'y2' references inaccessible name 'm2'.
-                   ~~
 !!! error TS4025: Type of variable 'y2' references inaccessible name 'private1'.
     
         // constructor type
@@ -85,7 +75,5 @@ tests/cases/compiler/declFileTypeAnnotationVisibilityErrorTypeLiteral.ts(33,16):
 !!! error TS4025: Type of variable 'z' references inaccessible name 'm2'.
         export var z2 = z;
                    ~~
-!!! error TS4025: Type of variable 'z2' references inaccessible name 'm2'.
-                   ~~
 !!! error TS4025: Type of variable 'z2' references inaccessible name 'private1'.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/expressionInExtendsClauseWithVisibilityErrors.errors.txt b/tests/baselines/reference/expressionInExtendsClauseWithVisibilityErrors.errors.txt
index cbaa03a3f1ca5..9326dc1304e41 100644
--- a/tests/baselines/reference/expressionInExtendsClauseWithVisibilityErrors.errors.txt
+++ b/tests/baselines/reference/expressionInExtendsClauseWithVisibilityErrors.errors.txt
@@ -1,8 +1,7 @@
 tests/cases/compiler/expressionInExtendsClauseWithVisibilityErrors.ts(16,30): error TS4020: Extends clause references inaccessible name 'C'.
-tests/cases/compiler/expressionInExtendsClauseWithVisibilityErrors.ts(16,30): error TS4020: Extends clause references inaccessible name 'I'.
 
 
-==== tests/cases/compiler/expressionInExtendsClauseWithVisibilityErrors.ts (2 errors) ====
+==== tests/cases/compiler/expressionInExtendsClauseWithVisibilityErrors.ts (1 errors) ====
     
     interface I {
     }
@@ -21,8 +20,6 @@ tests/cases/compiler/expressionInExtendsClauseWithVisibilityErrors.ts(16,30): er
     export class MyClass extends getClass(2) <string, I> {
                                  ~~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS4020: Extends clause references inaccessible name 'C'.
-                                 ~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4020: Extends clause references inaccessible name 'I'.
     }
     
     
\ No newline at end of file
diff --git a/tests/baselines/reference/privacyAccessorDeclFile.errors.txt b/tests/baselines/reference/privacyAccessorDeclFile.errors.txt
index 1f0df4faf6a1c..e205ce1627fe3 100644
--- a/tests/baselines/reference/privacyAccessorDeclFile.errors.txt
+++ b/tests/baselines/reference/privacyAccessorDeclFile.errors.txt
@@ -1,14 +1,3 @@
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(56,48): error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(56,48): error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(62,35): error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(68,24): error TS4043: Return type of property getter 'myPublicStaticMethod1' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(74,17): error TS4043: Return type of property getter 'myPublicMethod1' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(164,52): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(168,39): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(208,48): error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(211,35): error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(223,52): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(225,39): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
 tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(253,44): error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateClass'.
 tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(259,31): error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateClass'.
 tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts(265,20): error TS4043: Return type of property getter 'myPublicStaticMethod1' references inaccessible name 'privateClass'.
@@ -45,20 +34,9 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(369,20): error TS
 tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(372,13): error TS4043: Return type of property getter 'myPublicMethod1' references inaccessible name 'privateModule'.
 tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(378,48): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
 tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(380,35): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(414,44): error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(414,44): error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(420,31): error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(426,20): error TS4043: Return type of property getter 'myPublicStaticMethod1' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(432,13): error TS4043: Return type of property getter 'myPublicMethod1' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(522,48): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(526,35): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(566,44): error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(569,31): error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(581,48): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(583,35): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
 
 
-==== tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts (35 errors) ====
+==== tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts (24 errors) ====
     
     class privateClass {
     }
@@ -521,34 +499,24 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(583,35): error TS
         }
         export class publicClassWithWithPrivateGetAccessorTypes {
             static get myPublicStaticMethod(): privateClass { 
-                                               ~~~~~~~~~~~~
-!!! error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateClass'.
-                                               ~~~~~~~~~~~~
-!!! error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateModule'.
                 return null;
             }
             private static get myPrivateStaticMethod(): privateClass {
                 return null;
             }
             get myPublicMethod(): privateClass { 
-                                  ~~~~~~~~~~~~
-!!! error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateClass'.
                 return null;
             }
             private get myPrivateMethod(): privateClass {
                 return null;
             }
             static get myPublicStaticMethod1() { 
-                       ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4043: Return type of property getter 'myPublicStaticMethod1' references inaccessible name 'privateClass'.
                 return new privateClass();
             }
             private static get myPrivateStaticMethod1() {
                 return new privateClass();
             }
             get myPublicMethod1() { 
-                ~~~~~~~~~~~~~~~
-!!! error TS4043: Return type of property getter 'myPublicMethod1' references inaccessible name 'privateClass'.
                 return new privateClass();
             }
             private get myPrivateMethod1() {
@@ -639,14 +607,10 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(583,35): error TS
     
         export class publicClassWithWithPrivateSetAccessorTypes {
             static set myPublicStaticMethod(param: privateClass) { 
-                                                   ~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
             }
             private static set myPrivateStaticMethod(param: privateClass) {
             }
             set myPublicMethod(param: privateClass) { 
-                                      ~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
             }
             private set myPrivateMethod(param: privateClass) {
             }
@@ -687,13 +651,9 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(583,35): error TS
     
         export class publicClassWithPrivateModuleGetAccessorTypes {
             static get myPublicStaticMethod(): privateModule.publicClass { 
-                                               ~~~~~~~~~~~~~
-!!! error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateModule'.
                 return null;
             }
             get myPublicMethod(): privateModule.publicClass { 
-                                  ~~~~~~~~~~~~~
-!!! error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateModule'.
                 return null;
             }
             static get myPublicStaticMethod1() { 
@@ -706,12 +666,8 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(583,35): error TS
     
         export class publicClassWithPrivateModuleSetAccessorTypes {
             static set myPublicStaticMethod(param: privateModule.publicClass) { 
-                                                   ~~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
             }
             set myPublicMethod(param: privateModule.publicClass) { 
-                                      ~~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
             }
         }
     
@@ -738,7 +694,7 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(583,35): error TS
         }
     }
     
-==== tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts (23 errors) ====
+==== tests/cases/compiler/privacyAccessorDeclFile_GlobalFile.ts (12 errors) ====
     class publicClassInGlobal {
     }
     
@@ -795,34 +751,24 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(583,35): error TS
             }
             export class publicClassWithWithPrivateGetAccessorTypes {
                 static get myPublicStaticMethod(): privateClass {
-                                                   ~~~~~~~~~~~~
-!!! error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateClass'.
-                                                   ~~~~~~~~~~~~
-!!! error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateModule'.
                     return null;
                 }
                 private static get myPrivateStaticMethod(): privateClass {
                     return null;
                 }
                 get myPublicMethod(): privateClass {
-                                      ~~~~~~~~~~~~
-!!! error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateClass'.
                     return null;
                 }
                 private get myPrivateMethod(): privateClass {
                     return null;
                 }
                 static get myPublicStaticMethod1() {
-                           ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4043: Return type of property getter 'myPublicStaticMethod1' references inaccessible name 'privateClass'.
                     return new privateClass();
                 }
                 private static get myPrivateStaticMethod1() {
                     return new privateClass();
                 }
                 get myPublicMethod1() {
-                    ~~~~~~~~~~~~~~~
-!!! error TS4043: Return type of property getter 'myPublicMethod1' references inaccessible name 'privateClass'.
                     return new privateClass();
                 }
                 private get myPrivateMethod1() {
@@ -913,14 +859,10 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(583,35): error TS
     
             export class publicClassWithWithPrivateSetAccessorTypes {
                 static set myPublicStaticMethod(param: privateClass) {
-                                                       ~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
                 }
                 private static set myPrivateStaticMethod(param: privateClass) {
                 }
                 set myPublicMethod(param: privateClass) {
-                                          ~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
                 }
                 private set myPrivateMethod(param: privateClass) {
                 }
@@ -961,13 +903,9 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(583,35): error TS
     
             export class publicClassWithPrivateModuleGetAccessorTypes {
                 static get myPublicStaticMethod(): privateModule.publicClass {
-                                                   ~~~~~~~~~~~~~
-!!! error TS4043: Return type of property getter 'myPublicStaticMethod' references inaccessible name 'privateModule'.
                     return null;
                 }
                 get myPublicMethod(): privateModule.publicClass {
-                                      ~~~~~~~~~~~~~
-!!! error TS4043: Return type of property getter 'myPublicMethod' references inaccessible name 'privateModule'.
                     return null;
                 }
                 static get myPublicStaticMethod1() {
@@ -980,12 +918,8 @@ tests/cases/compiler/privacyAccessorDeclFile_externalModule.ts(583,35): error TS
     
             export class publicClassWithPrivateModuleSetAccessorTypes {
                 static set myPublicStaticMethod(param: privateModule.publicClass) {
-                                                       ~~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
                 }
                 set myPublicMethod(param: privateModule.publicClass) {
-                                          ~~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
                 }
             }
     
diff --git a/tests/baselines/reference/privacyCheckTypeOfInvisibleModuleError.errors.txt b/tests/baselines/reference/privacyCheckTypeOfInvisibleModuleError.errors.txt
index 6c14517002876..2cf65e89a4758 100644
--- a/tests/baselines/reference/privacyCheckTypeOfInvisibleModuleError.errors.txt
+++ b/tests/baselines/reference/privacyCheckTypeOfInvisibleModuleError.errors.txt
@@ -1,13 +1,10 @@
-tests/cases/compiler/privacyCheckTypeOfInvisibleModuleError.ts(3,30): error TS4025: Type of variable 'm' references inaccessible name 'Inner'.
 tests/cases/compiler/privacyCheckTypeOfInvisibleModuleError.ts(6,26): error TS4025: Type of variable 'f' references inaccessible name 'Inner'.
 
 
-==== tests/cases/compiler/privacyCheckTypeOfInvisibleModuleError.ts (2 errors) ====
+==== tests/cases/compiler/privacyCheckTypeOfInvisibleModuleError.ts (1 errors) ====
     module Outer {
         module Inner {
             export var m: typeof Inner;
-                                 ~~~~~
-!!! error TS4025: Type of variable 'm' references inaccessible name 'Inner'.
         }
     
         export var f: typeof Inner;
diff --git a/tests/baselines/reference/privacyClassExtendsClauseDeclFile.errors.txt b/tests/baselines/reference/privacyClassExtendsClauseDeclFile.errors.txt
index dbc7a94ac7853..717540a095367 100644
--- a/tests/baselines/reference/privacyClassExtendsClauseDeclFile.errors.txt
+++ b/tests/baselines/reference/privacyClassExtendsClauseDeclFile.errors.txt
@@ -1,14 +1,11 @@
 tests/cases/compiler/privacyClassExtendsClauseDeclFile_GlobalFile.ts(16,67): error TS4020: Extends clause references inaccessible name 'privateClassInPublicModule'.
 tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(17,67): error TS4020: Extends clause references inaccessible name 'privateClassInPublicModule'.
 tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(22,69): error TS4020: Extends clause references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(41,67): error TS4020: Extends clause references inaccessible name 'privateClassInPrivateModule'.
-tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(41,67): error TS4020: Extends clause references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(46,69): error TS4020: Extends clause references inaccessible name 'privateModule'.
 tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(64,55): error TS4020: Extends clause references inaccessible name 'privateClass'.
 tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(69,65): error TS4020: Extends clause references inaccessible name 'privateModule'.
 
 
-==== tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts (7 errors) ====
+==== tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts (4 errors) ====
     
     export module publicModule {
         export class publicClassInPublicModule {
@@ -54,17 +51,11 @@ tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts(69,65):
         export class publicClassExtendingPublicClassInModule extends publicClassInPrivateModule {
         }
         export class publicClassExtendingPrivateClassInModule extends privateClassInPrivateModule { 
-                                                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4020: Extends clause references inaccessible name 'privateClassInPrivateModule'.
-                                                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4020: Extends clause references inaccessible name 'privateModule'.
         }
     
         class privateClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule {
         }
         export class publicClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule {
-                                                                        ~~~~~~~~~~~~~
-!!! error TS4020: Extends clause references inaccessible name 'privateModule'.
         }
     }
     
diff --git a/tests/baselines/reference/privacyClassImplementsClauseDeclFile.errors.txt b/tests/baselines/reference/privacyClassImplementsClauseDeclFile.errors.txt
index 4e8355aba0187..6ac85ebf58c27 100644
--- a/tests/baselines/reference/privacyClassImplementsClauseDeclFile.errors.txt
+++ b/tests/baselines/reference/privacyClassImplementsClauseDeclFile.errors.txt
@@ -2,14 +2,11 @@ tests/cases/compiler/privacyClassImplementsClauseDeclFile_GlobalFile.ts(14,77):
 tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(15,77): error TS4019: Implements clause references inaccessible name 'privateInterfaceInPublicModule'.
 tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(20,79): error TS4019: Implements clause references inaccessible name 'privateModule'.
 tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(23,78): error TS4019: Implements clause references inaccessible name 'privateInterfaceInPublicModule'.
-tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(41,77): error TS4019: Implements clause references inaccessible name 'privateInterfaceInPrivateModule'.
-tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(41,77): error TS4019: Implements clause references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(46,79): error TS4019: Implements clause references inaccessible name 'privateModule'.
 tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(63,65): error TS4019: Implements clause references inaccessible name 'privateInterface'.
 tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(68,75): error TS4019: Implements clause references inaccessible name 'privateModule'.
 
 
-==== tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts (8 errors) ====
+==== tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts (5 errors) ====
     
     export module publicModule {
         export interface publicInterfaceInPublicModule {
@@ -57,17 +54,11 @@ tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts(68,7
         export class publicClassImplementingPublicInterfaceInModule implements publicInterfaceInPrivateModule {
         }
         export class publicClassImplementingPrivateInterfaceInModule implements privateInterfaceInPrivateModule { 
-                                                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4019: Implements clause references inaccessible name 'privateInterfaceInPrivateModule'.
-                                                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4019: Implements clause references inaccessible name 'privateModule'.
         }
     
         class privateClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule {
         }
         export class publicClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule {
-                                                                                  ~~~~~~~~~~~~~
-!!! error TS4019: Implements clause references inaccessible name 'privateModule'.
         }
     }
     
diff --git a/tests/baselines/reference/privacyFunctionParameterDeclFile.errors.txt b/tests/baselines/reference/privacyFunctionParameterDeclFile.errors.txt
index 7b0b165c79938..5a79b67856916 100644
--- a/tests/baselines/reference/privacyFunctionParameterDeclFile.errors.txt
+++ b/tests/baselines/reference/privacyFunctionParameterDeclFile.errors.txt
@@ -1,24 +1,3 @@
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(39,25): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(39,25): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(40,21): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(41,29): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(63,48): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(67,35): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(71,32): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(71,62): error TS4030: Type of parameter 'param1' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(71,91): error TS4030: Type of parameter 'param2' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(114,71): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(123,86): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(129,25): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(130,21): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(131,29): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(134,48): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(136,35): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(138,32): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(138,75): error TS4030: Type of parameter 'param1' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(138,117): error TS4030: Type of parameter 'param2' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(141,78): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(143,93): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
 tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(164,21): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
 tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(165,17): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
 tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts(166,25): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
@@ -79,30 +58,9 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(240,71):
 tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(240,113): error TS4030: Type of parameter 'param2' references inaccessible name 'privateModule'.
 tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(243,74): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
 tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(245,89): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(274,21): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(274,21): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(275,17): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(276,25): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(298,44): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(302,31): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(306,28): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(306,58): error TS4030: Type of parameter 'param1' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(306,87): error TS4030: Type of parameter 'param2' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(349,67): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(358,82): error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(364,21): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(365,17): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(366,25): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(369,44): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(371,31): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(373,28): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(373,71): error TS4030: Type of parameter 'param1' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(373,113): error TS4030: Type of parameter 'param2' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(376,74): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89): error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
 
 
-==== tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts (61 errors) ====
+==== tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts (40 errors) ====
     
     class privateClass {
     }
@@ -457,16 +415,8 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89):
     
         export interface publicInterfaceWithPrivateParmeterTypes {
             new (param: privateClass): publicClass;
-                        ~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
-                        ~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
             (param: privateClass): publicClass;
-                    ~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
             myMethod(param: privateClass): void;
-                            ~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
         }
     
         export interface publicInterfaceWithPublicParmeterTypes {
@@ -489,24 +439,14 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89):
     
         export class publicClassWithWithPrivateParmeterTypes {
             static myPublicStaticMethod(param: privateClass) {
-                                               ~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
             }
             private static myPrivateStaticMethod(param: privateClass) {
             }
             myPublicMethod(param: privateClass) {
-                                  ~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
             }
             private myPrivateMethod(param: privateClass) {
             }
             constructor(param: privateClass, private param1: privateClass, public param2: privateClass) {
-                               ~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
-                                                             ~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param1' references inaccessible name 'privateClass'.
-                                                                                          ~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param2' references inaccessible name 'privateClass'.
             }
         }
     
@@ -550,8 +490,6 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89):
         }
     
         export function publicFunctionWithPrivateParmeterTypes(param: privateClass) {
-                                                                      ~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
         }
         export function publicFunctionWithPublicParmeterTypes(param: publicClass) {
         }
@@ -561,48 +499,26 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89):
         }
     
         export declare function publicAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void;
-                                                                                     ~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
         export declare function publicAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
         declare function privateAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void;
         declare function privateAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
     
         export interface publicInterfaceWithPrivateModuleParameterTypes {
             new (param: privateModule.publicClass): publicClass;
-                        ~~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
             (param: privateModule.publicClass): publicClass;
-                    ~~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
             myMethod(param: privateModule.publicClass): void;
-                            ~~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
         }
         export class publicClassWithPrivateModuleParameterTypes {
             static myPublicStaticMethod(param: privateModule.publicClass) {
-                                               ~~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
             }
             myPublicMethod(param: privateModule.publicClass) {
-                                  ~~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
             }
             constructor(param: privateModule.publicClass, private param1: privateModule.publicClass, public param2: privateModule.publicClass) {
-                               ~~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
-                                                                          ~~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param1' references inaccessible name 'privateModule'.
-                                                                                                                    ~~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param2' references inaccessible name 'privateModule'.
             }
         }
         export function publicFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass) {
-                                                                             ~~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
         }
         export declare function publicAmbientFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass): void;
-                                                                                            ~~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
     
         interface privateInterfaceWithPrivateModuleParameterTypes {
             new (param: privateModule.publicClass): publicClass;
@@ -622,7 +538,7 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89):
         declare function privateAmbientFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass): void;
     }
     
-==== tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts (41 errors) ====
+==== tests/cases/compiler/privacyFunctionParameterDeclFile_GlobalFile.ts (20 errors) ====
     class publicClassInGlobal {
     }
     interface publicInterfaceWithPublicParmeterTypesInGlobal {
@@ -662,16 +578,8 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89):
     
             export interface publicInterfaceWithPrivateParmeterTypes {
                 new (param: privateClass): publicClass;
-                            ~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
-                            ~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
                 (param: privateClass): publicClass;
-                        ~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
                 myMethod(param: privateClass): void;
-                                ~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
             }
     
             export interface publicInterfaceWithPublicParmeterTypes {
@@ -694,24 +602,14 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89):
     
             export class publicClassWithWithPrivateParmeterTypes {
                 static myPublicStaticMethod(param: privateClass) {
-                                                   ~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
                 }
                 private static myPrivateStaticMethod(param: privateClass) {
                 }
                 myPublicMethod(param: privateClass) {
-                                      ~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
                 }
                 private myPrivateMethod(param: privateClass) {
                 }
                 constructor(param: privateClass, private param1: privateClass, public param2: privateClass) {
-                                   ~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
-                                                                 ~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param1' references inaccessible name 'privateClass'.
-                                                                                              ~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param2' references inaccessible name 'privateClass'.
                 }
             }
     
@@ -755,8 +653,6 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89):
             }
     
             export function publicFunctionWithPrivateParmeterTypes(param: privateClass) {
-                                                                          ~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
             }
             export function publicFunctionWithPublicParmeterTypes(param: publicClass) {
             }
@@ -766,48 +662,26 @@ tests/cases/compiler/privacyFunctionParameterDeclFile_externalModule.ts(378,89):
             }
     
             export declare function publicAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void;
-                                                                                         ~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateClass'.
             export declare function publicAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
             declare function privateAmbientFunctionWithPrivateParmeterTypes(param: privateClass): void;
             declare function privateAmbientFunctionWithPublicParmeterTypes(param: publicClass): void;
     
             export interface publicInterfaceWithPrivateModuleParameterTypes {
                 new (param: privateModule.publicClass): publicClass;
-                            ~~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
                 (param: privateModule.publicClass): publicClass;
-                        ~~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
                 myMethod(param: privateModule.publicClass): void;
-                                ~~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
             }
             export class publicClassWithPrivateModuleParameterTypes {
                 static myPublicStaticMethod(param: privateModule.publicClass) {
-                                                   ~~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
                 }
                 myPublicMethod(param: privateModule.publicClass) {
-                                      ~~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
                 }
                 constructor(param: privateModule.publicClass, private param1: privateModule.publicClass, public param2: privateModule.publicClass) {
-                                   ~~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
-                                                                              ~~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param1' references inaccessible name 'privateModule'.
-                                                                                                                        ~~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param2' references inaccessible name 'privateModule'.
                 }
             }
             export function publicFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass) {
-                                                                                 ~~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
             }
             export declare function publicAmbientFunctionWithPrivateModuleParameterTypes(param: privateModule.publicClass): void;
-                                                                                                ~~~~~~~~~~~~~
-!!! error TS4030: Type of parameter 'param' references inaccessible name 'privateModule'.
     
             interface privateInterfaceWithPrivateModuleParameterTypes {
                 new (param: privateModule.publicClass): publicClass;
diff --git a/tests/baselines/reference/privacyFunctionReturnTypeDeclFile.errors.txt b/tests/baselines/reference/privacyFunctionReturnTypeDeclFile.errors.txt
index d5d5132c61c89..a25db670c1df8 100644
--- a/tests/baselines/reference/privacyFunctionReturnTypeDeclFile.errors.txt
+++ b/tests/baselines/reference/privacyFunctionReturnTypeDeclFile.errors.txt
@@ -1,23 +1,3 @@
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(58,21): error TS4044: Return type of construct signature references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(58,21): error TS4044: Return type of construct signature references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(59,17): error TS4047: Return type of call signature references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(60,26): error TS4049: Return type of index signature references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(61,25): error TS4038: Return type of method 'myMethod' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(86,44): error TS4038: Return type of method 'myPublicStaticMethod' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(92,31): error TS4038: Return type of method 'myPublicMethod' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(98,20): error TS4038: Return type of method 'myPublicStaticMethod1' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(104,13): error TS4038: Return type of method 'myPublicMethod1' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(193,67): error TS4060: Return type of function 'publicFunctionWithPrivateParmeterTypes' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(205,25): error TS4060: Return type of function 'publicFunctionWithPrivateParmeterTypes1' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(218,82): error TS4060: Return type of function 'publicAmbientFunctionWithPrivateParmeterTypes' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(224,21): error TS4044: Return type of construct signature references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(225,17): error TS4047: Return type of call signature references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(226,26): error TS4049: Return type of index signature references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(227,25): error TS4038: Return type of method 'myMethod' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(230,44): error TS4038: Return type of method 'myPublicStaticMethod' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(233,31): error TS4038: Return type of method 'myPublicMethod' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(243,74): error TS4060: Return type of function 'publicFunctionWithPrivateModuleParameterTypes' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(249,89): error TS4060: Return type of function 'publicAmbientFunctionWithPrivateModuleParameterTypes' references inaccessible name 'privateModule'.
 tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(281,17): error TS4044: Return type of construct signature references inaccessible name 'privateClass'.
 tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(282,13): error TS4047: Return type of call signature references inaccessible name 'privateClass'.
 tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts(283,22): error TS4049: Return type of index signature references inaccessible name 'privateClass'.
@@ -84,29 +64,9 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(419,9):
 tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(423,70): error TS4060: Return type of function 'publicFunctionWithPrivateModuleParameterTypes' references inaccessible name 'privateModule'.
 tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(426,21): error TS4060: Return type of function 'publicFunctionWithPrivateModuleParameterTypes1' references inaccessible name 'privateModule'.
 tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(429,85): error TS4060: Return type of function 'publicAmbientFunctionWithPrivateModuleParameterTypes' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(468,17): error TS4044: Return type of construct signature references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(468,17): error TS4044: Return type of construct signature references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(469,13): error TS4047: Return type of call signature references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(470,22): error TS4049: Return type of index signature references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(471,21): error TS4038: Return type of method 'myMethod' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(496,40): error TS4038: Return type of method 'myPublicStaticMethod' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(502,27): error TS4038: Return type of method 'myPublicMethod' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(508,16): error TS4038: Return type of method 'myPublicStaticMethod1' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(514,9): error TS4038: Return type of method 'myPublicMethod1' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(603,63): error TS4060: Return type of function 'publicFunctionWithPrivateParmeterTypes' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(615,21): error TS4060: Return type of function 'publicFunctionWithPrivateParmeterTypes1' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(628,78): error TS4060: Return type of function 'publicAmbientFunctionWithPrivateParmeterTypes' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(634,17): error TS4044: Return type of construct signature references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(635,13): error TS4047: Return type of call signature references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(636,22): error TS4049: Return type of index signature references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(637,21): error TS4038: Return type of method 'myMethod' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(640,40): error TS4038: Return type of method 'myPublicStaticMethod' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(643,27): error TS4038: Return type of method 'myPublicMethod' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(653,70): error TS4060: Return type of function 'publicFunctionWithPrivateModuleParameterTypes' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(659,85): error TS4060: Return type of function 'publicAmbientFunctionWithPrivateModuleParameterTypes' references inaccessible name 'privateModule'.
 
 
-==== tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts (64 errors) ====
+==== tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts (44 errors) ====
     
     class privateClass {
     }
@@ -663,19 +623,9 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(659,85)
     
         export interface publicInterfaceWithPrivateParmeterTypes {
             new (): privateClass; 
-                    ~~~~~~~~~~~~
-!!! error TS4044: Return type of construct signature references inaccessible name 'privateClass'.
-                    ~~~~~~~~~~~~
-!!! error TS4044: Return type of construct signature references inaccessible name 'privateModule'.
             (): privateClass; 
-                ~~~~~~~~~~~~
-!!! error TS4047: Return type of call signature references inaccessible name 'privateClass'.
             [x: number]: privateClass; 
-                         ~~~~~~~~~~~~
-!!! error TS4049: Return type of index signature references inaccessible name 'privateClass'.
             myMethod(): privateClass; 
-                        ~~~~~~~~~~~~
-!!! error TS4038: Return type of method 'myMethod' references inaccessible name 'privateClass'.
         }
     
         export interface publicInterfaceWithPublicParmeterTypes {
@@ -701,32 +651,24 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(659,85)
     
         export class publicClassWithWithPrivateParmeterTypes {
             static myPublicStaticMethod(): privateClass { 
-                                           ~~~~~~~~~~~~
-!!! error TS4038: Return type of method 'myPublicStaticMethod' references inaccessible name 'privateClass'.
                 return null;
             }
             private static myPrivateStaticMethod(): privateClass {
                 return null;
             }
             myPublicMethod(): privateClass { 
-                              ~~~~~~~~~~~~
-!!! error TS4038: Return type of method 'myPublicMethod' references inaccessible name 'privateClass'.
                 return null;
             }
             private myPrivateMethod(): privateClass {
                 return null;
             }
             static myPublicStaticMethod1() { 
-                   ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4038: Return type of method 'myPublicStaticMethod1' references inaccessible name 'privateClass'.
                 return new privateClass();
             }
             private static myPrivateStaticMethod1() {
                 return new privateClass();
             }
             myPublicMethod1() { 
-            ~~~~~~~~~~~~~~~
-!!! error TS4038: Return type of method 'myPublicMethod1' references inaccessible name 'privateClass'.
                 return new privateClass();
             }
             private myPrivateMethod1() {
@@ -816,8 +758,6 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(659,85)
         }
     
         export function publicFunctionWithPrivateParmeterTypes(): privateClass { 
-                                                                  ~~~~~~~~~~~~
-!!! error TS4060: Return type of function 'publicFunctionWithPrivateParmeterTypes' references inaccessible name 'privateClass'.
             return null;
         }
         export function publicFunctionWithPublicParmeterTypes(): publicClass {
@@ -830,8 +770,6 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(659,85)
             return null;
         }
         export function publicFunctionWithPrivateParmeterTypes1() { 
-                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4060: Return type of function 'publicFunctionWithPrivateParmeterTypes1' references inaccessible name 'privateClass'.
             return new privateClass();
         }
         export function publicFunctionWithPublicParmeterTypes1() {
@@ -845,35 +783,21 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(659,85)
         }
     
         export declare function publicAmbientFunctionWithPrivateParmeterTypes(): privateClass; 
-                                                                                 ~~~~~~~~~~~~
-!!! error TS4060: Return type of function 'publicAmbientFunctionWithPrivateParmeterTypes' references inaccessible name 'privateClass'.
         export declare function publicAmbientFunctionWithPublicParmeterTypes(): publicClass;
         declare function privateAmbientFunctionWithPrivateParmeterTypes(): privateClass;
         declare function privateAmbientFunctionWithPublicParmeterTypes(): publicClass;
     
         export interface publicInterfaceWithPrivateModuleParameterTypes {
             new (): privateModule.publicClass;
-                    ~~~~~~~~~~~~~
-!!! error TS4044: Return type of construct signature references inaccessible name 'privateModule'.
             (): privateModule.publicClass;
-                ~~~~~~~~~~~~~
-!!! error TS4047: Return type of call signature references inaccessible name 'privateModule'.
             [x: number]: privateModule.publicClass;
-                         ~~~~~~~~~~~~~
-!!! error TS4049: Return type of index signature references inaccessible name 'privateModule'.
             myMethod(): privateModule.publicClass;
-                        ~~~~~~~~~~~~~
-!!! error TS4038: Return type of method 'myMethod' references inaccessible name 'privateModule'.
         }
         export class publicClassWithPrivateModuleParameterTypes {
             static myPublicStaticMethod(): privateModule.publicClass { 
-                                           ~~~~~~~~~~~~~
-!!! error TS4038: Return type of method 'myPublicStaticMethod' references inaccessible name 'privateModule'.
                 return null;
             }
             myPublicMethod(): privateModule.publicClass { 
-                              ~~~~~~~~~~~~~
-!!! error TS4038: Return type of method 'myPublicMethod' references inaccessible name 'privateModule'.
                 return null;
             }
             static myPublicStaticMethod1() { 
@@ -884,16 +808,12 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(659,85)
             }
         }
         export function publicFunctionWithPrivateModuleParameterTypes(): privateModule.publicClass { 
-                                                                         ~~~~~~~~~~~~~
-!!! error TS4060: Return type of function 'publicFunctionWithPrivateModuleParameterTypes' references inaccessible name 'privateModule'.
             return null;
         }
         export function publicFunctionWithPrivateModuleParameterTypes1() { 
             return new privateModule.publicClass();
         }
         export declare function publicAmbientFunctionWithPrivateModuleParameterTypes(): privateModule.publicClass; 
-                                                                                        ~~~~~~~~~~~~~
-!!! error TS4060: Return type of function 'publicAmbientFunctionWithPrivateModuleParameterTypes' references inaccessible name 'privateModule'.
     
         interface privateInterfaceWithPrivateModuleParameterTypes {
             new (): privateModule.publicClass;
@@ -924,7 +844,7 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(659,85)
         declare function privateAmbientFunctionWithPrivateModuleParameterTypes(): privateModule.publicClass; 
     }
     
-==== tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts (42 errors) ====
+==== tests/cases/compiler/privacyFunctionReturnTypeDeclFile_GlobalFile.ts (22 errors) ====
     class publicClassInGlobal {
     }
     interface publicInterfaceWithPublicParmeterTypesInGlobal {
@@ -983,19 +903,9 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(659,85)
     
             export interface publicInterfaceWithPrivateParmeterTypes {
                 new (): privateClass;
-                        ~~~~~~~~~~~~
-!!! error TS4044: Return type of construct signature references inaccessible name 'privateClass'.
-                        ~~~~~~~~~~~~
-!!! error TS4044: Return type of construct signature references inaccessible name 'privateModule'.
                 (): privateClass;
-                    ~~~~~~~~~~~~
-!!! error TS4047: Return type of call signature references inaccessible name 'privateClass'.
                 [x: number]: privateClass;
-                             ~~~~~~~~~~~~
-!!! error TS4049: Return type of index signature references inaccessible name 'privateClass'.
                 myMethod(): privateClass;
-                            ~~~~~~~~~~~~
-!!! error TS4038: Return type of method 'myMethod' references inaccessible name 'privateClass'.
             }
     
             export interface publicInterfaceWithPublicParmeterTypes {
@@ -1021,32 +931,24 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(659,85)
     
             export class publicClassWithWithPrivateParmeterTypes {
                 static myPublicStaticMethod(): privateClass {
-                                               ~~~~~~~~~~~~
-!!! error TS4038: Return type of method 'myPublicStaticMethod' references inaccessible name 'privateClass'.
                     return null;
                 }
                 private static myPrivateStaticMethod(): privateClass {
                     return null;
                 }
                 myPublicMethod(): privateClass {
-                                  ~~~~~~~~~~~~
-!!! error TS4038: Return type of method 'myPublicMethod' references inaccessible name 'privateClass'.
                     return null;
                 }
                 private myPrivateMethod(): privateClass {
                     return null;
                 }
                 static myPublicStaticMethod1() {
-                       ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4038: Return type of method 'myPublicStaticMethod1' references inaccessible name 'privateClass'.
                     return new privateClass();
                 }
                 private static myPrivateStaticMethod1() {
                     return new privateClass();
                 }
                 myPublicMethod1() {
-                ~~~~~~~~~~~~~~~
-!!! error TS4038: Return type of method 'myPublicMethod1' references inaccessible name 'privateClass'.
                     return new privateClass();
                 }
                 private myPrivateMethod1() {
@@ -1136,8 +1038,6 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(659,85)
             }
     
             export function publicFunctionWithPrivateParmeterTypes(): privateClass {
-                                                                      ~~~~~~~~~~~~
-!!! error TS4060: Return type of function 'publicFunctionWithPrivateParmeterTypes' references inaccessible name 'privateClass'.
                 return null;
             }
             export function publicFunctionWithPublicParmeterTypes(): publicClass {
@@ -1150,8 +1050,6 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(659,85)
                 return null;
             }
             export function publicFunctionWithPrivateParmeterTypes1() {
-                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4060: Return type of function 'publicFunctionWithPrivateParmeterTypes1' references inaccessible name 'privateClass'.
                 return new privateClass();
             }
             export function publicFunctionWithPublicParmeterTypes1() {
@@ -1165,35 +1063,21 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(659,85)
             }
     
             export declare function publicAmbientFunctionWithPrivateParmeterTypes(): privateClass;
-                                                                                     ~~~~~~~~~~~~
-!!! error TS4060: Return type of function 'publicAmbientFunctionWithPrivateParmeterTypes' references inaccessible name 'privateClass'.
             export declare function publicAmbientFunctionWithPublicParmeterTypes(): publicClass;
             declare function privateAmbientFunctionWithPrivateParmeterTypes(): privateClass;
             declare function privateAmbientFunctionWithPublicParmeterTypes(): publicClass;
     
             export interface publicInterfaceWithPrivateModuleParameterTypes {
                 new (): privateModule.publicClass;
-                        ~~~~~~~~~~~~~
-!!! error TS4044: Return type of construct signature references inaccessible name 'privateModule'.
                 (): privateModule.publicClass;
-                    ~~~~~~~~~~~~~
-!!! error TS4047: Return type of call signature references inaccessible name 'privateModule'.
                 [x: number]: privateModule.publicClass;
-                             ~~~~~~~~~~~~~
-!!! error TS4049: Return type of index signature references inaccessible name 'privateModule'.
                 myMethod(): privateModule.publicClass;
-                            ~~~~~~~~~~~~~
-!!! error TS4038: Return type of method 'myMethod' references inaccessible name 'privateModule'.
             }
             export class publicClassWithPrivateModuleParameterTypes {
                 static myPublicStaticMethod(): privateModule.publicClass {
-                                               ~~~~~~~~~~~~~
-!!! error TS4038: Return type of method 'myPublicStaticMethod' references inaccessible name 'privateModule'.
                     return null;
                 }
                 myPublicMethod(): privateModule.publicClass {
-                                  ~~~~~~~~~~~~~
-!!! error TS4038: Return type of method 'myPublicMethod' references inaccessible name 'privateModule'.
                     return null;
                 }
                 static myPublicStaticMethod1() {
@@ -1204,16 +1088,12 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_externalModule.ts(659,85)
                 }
             }
             export function publicFunctionWithPrivateModuleParameterTypes(): privateModule.publicClass {
-                                                                             ~~~~~~~~~~~~~
-!!! error TS4060: Return type of function 'publicFunctionWithPrivateModuleParameterTypes' references inaccessible name 'privateModule'.
                 return null;
             }
             export function publicFunctionWithPrivateModuleParameterTypes1() {
                 return new privateModule.publicClass();
             }
             export declare function publicAmbientFunctionWithPrivateModuleParameterTypes(): privateModule.publicClass;
-                                                                                            ~~~~~~~~~~~~~
-!!! error TS4060: Return type of function 'publicAmbientFunctionWithPrivateModuleParameterTypes' references inaccessible name 'privateModule'.
     
             interface privateInterfaceWithPrivateModuleParameterTypes {
                 new (): privateModule.publicClass;
diff --git a/tests/baselines/reference/privacyGloImport.errors.txt b/tests/baselines/reference/privacyGloImport.errors.txt
index e7410fa03397d..0db062634859c 100644
--- a/tests/baselines/reference/privacyGloImport.errors.txt
+++ b/tests/baselines/reference/privacyGloImport.errors.txt
@@ -1,8 +1,12 @@
 tests/cases/compiler/privacyGloImport.ts(49,29): error TS4000: Import declaration 'm1_im2_private' references inaccessible name 'm1_M2_private'.
+tests/cases/compiler/privacyGloImport.ts(50,16): error TS4025: Type of variable 'm1_im2_private_v1_public' references inaccessible name 'c1'.
+tests/cases/compiler/privacyGloImport.ts(51,16): error TS4025: Type of variable 'm1_im2_private_v2_public' references inaccessible name 'c1'.
+tests/cases/compiler/privacyGloImport.ts(52,16): error TS4025: Type of variable 'm1_im2_private_v3_public' references inaccessible name 'f1'.
+tests/cases/compiler/privacyGloImport.ts(53,16): error TS4025: Type of variable 'm1_im2_private_v4_public' references inaccessible name 'c1'.
 tests/cases/compiler/privacyGloImport.ts(80,35): error TS4000: Import declaration 'm1_im2_public' references inaccessible name 'm1_M2_private'.
 
 
-==== tests/cases/compiler/privacyGloImport.ts (2 errors) ====
+==== tests/cases/compiler/privacyGloImport.ts (6 errors) ====
     module m1 {
         export module m1_M1_public {
             export class c1 {
@@ -55,9 +59,17 @@ tests/cases/compiler/privacyGloImport.ts(80,35): error TS4000: Import declaratio
                                 ~~~~~~~~~~~~~
 !!! error TS4000: Import declaration 'm1_im2_private' references inaccessible name 'm1_M2_private'.
         export var m1_im2_private_v1_public = m1_im2_private.c1;
+                   ~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4025: Type of variable 'm1_im2_private_v1_public' references inaccessible name 'c1'.
         export var m1_im2_private_v2_public = new m1_im2_private.c1();
+                   ~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4025: Type of variable 'm1_im2_private_v2_public' references inaccessible name 'c1'.
         export var m1_im2_private_v3_public = m1_im2_private.f1;
+                   ~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4025: Type of variable 'm1_im2_private_v3_public' references inaccessible name 'f1'.
         export var m1_im2_private_v4_public = m1_im2_private.f1();
+                   ~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4025: Type of variable 'm1_im2_private_v4_public' references inaccessible name 'c1'.
         var m1_im2_private_v1_private = m1_im2_private.c1;
         var m1_im2_private_v2_private = new m1_im2_private.c1();
         var m1_im2_private_v3_private = m1_im2_private.f1;
diff --git a/tests/baselines/reference/privacyGloImportParseErrors.errors.txt b/tests/baselines/reference/privacyGloImportParseErrors.errors.txt
index a97ebf37b3be3..a3e6970e0c9ac 100644
--- a/tests/baselines/reference/privacyGloImportParseErrors.errors.txt
+++ b/tests/baselines/reference/privacyGloImportParseErrors.errors.txt
@@ -1,6 +1,10 @@
 tests/cases/compiler/privacyGloImportParseErrors.ts(22,27): error TS2435: Ambient modules cannot be nested in other modules.
 tests/cases/compiler/privacyGloImportParseErrors.ts(30,20): error TS2435: Ambient modules cannot be nested in other modules.
 tests/cases/compiler/privacyGloImportParseErrors.ts(49,29): error TS4000: Import declaration 'm1_im2_private' references inaccessible name 'm1_M2_private'.
+tests/cases/compiler/privacyGloImportParseErrors.ts(50,16): error TS4025: Type of variable 'm1_im2_private_v1_public' references inaccessible name 'c1'.
+tests/cases/compiler/privacyGloImportParseErrors.ts(51,16): error TS4025: Type of variable 'm1_im2_private_v2_public' references inaccessible name 'c1'.
+tests/cases/compiler/privacyGloImportParseErrors.ts(52,16): error TS4025: Type of variable 'm1_im2_private_v3_public' references inaccessible name 'f1'.
+tests/cases/compiler/privacyGloImportParseErrors.ts(53,16): error TS4025: Type of variable 'm1_im2_private_v4_public' references inaccessible name 'c1'.
 tests/cases/compiler/privacyGloImportParseErrors.ts(59,37): error TS1147: Import declarations in a namespace cannot reference a module.
 tests/cases/compiler/privacyGloImportParseErrors.ts(59,37): error TS2307: Cannot find module 'm1_M3_public'.
 tests/cases/compiler/privacyGloImportParseErrors.ts(69,37): error TS1147: Import declarations in a namespace cannot reference a module.
@@ -18,7 +22,7 @@ tests/cases/compiler/privacyGloImportParseErrors.ts(146,25): error TS1147: Impor
 tests/cases/compiler/privacyGloImportParseErrors.ts(149,29): error TS1147: Import declarations in a namespace cannot reference a module.
 
 
-==== tests/cases/compiler/privacyGloImportParseErrors.ts (18 errors) ====
+==== tests/cases/compiler/privacyGloImportParseErrors.ts (22 errors) ====
     module m1 {
         export module m1_M1_public {
             export class c1 {
@@ -75,9 +79,17 @@ tests/cases/compiler/privacyGloImportParseErrors.ts(149,29): error TS1147: Impor
                                 ~~~~~~~~~~~~~
 !!! error TS4000: Import declaration 'm1_im2_private' references inaccessible name 'm1_M2_private'.
         export var m1_im2_private_v1_public = m1_im2_private.c1;
+                   ~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4025: Type of variable 'm1_im2_private_v1_public' references inaccessible name 'c1'.
         export var m1_im2_private_v2_public = new m1_im2_private.c1();
+                   ~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4025: Type of variable 'm1_im2_private_v2_public' references inaccessible name 'c1'.
         export var m1_im2_private_v3_public = m1_im2_private.f1;
+                   ~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4025: Type of variable 'm1_im2_private_v3_public' references inaccessible name 'f1'.
         export var m1_im2_private_v4_public = m1_im2_private.f1();
+                   ~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4025: Type of variable 'm1_im2_private_v4_public' references inaccessible name 'c1'.
         var m1_im2_private_v1_private = m1_im2_private.c1;
         var m1_im2_private_v2_private = new m1_im2_private.c1();
         var m1_im2_private_v3_private = m1_im2_private.f1;
diff --git a/tests/baselines/reference/privacyImport.errors.txt b/tests/baselines/reference/privacyImport.errors.txt
index a5d2dfd1cd6bf..1493a06d92f76 100644
--- a/tests/baselines/reference/privacyImport.errors.txt
+++ b/tests/baselines/reference/privacyImport.errors.txt
@@ -1,8 +1,12 @@
 tests/cases/compiler/privacyImport.ts(49,29): error TS4000: Import declaration 'm1_im2_private' references inaccessible name 'm1_M2_private'.
+tests/cases/compiler/privacyImport.ts(50,16): error TS4025: Type of variable 'm1_im2_private_v1_public' references inaccessible name 'c1'.
+tests/cases/compiler/privacyImport.ts(51,16): error TS4025: Type of variable 'm1_im2_private_v2_public' references inaccessible name 'c1'.
+tests/cases/compiler/privacyImport.ts(52,16): error TS4025: Type of variable 'm1_im2_private_v3_public' references inaccessible name 'f1'.
+tests/cases/compiler/privacyImport.ts(53,16): error TS4025: Type of variable 'm1_im2_private_v4_public' references inaccessible name 'c1'.
 tests/cases/compiler/privacyImport.ts(80,35): error TS4000: Import declaration 'm1_im2_public' references inaccessible name 'm1_M2_private'.
 
 
-==== tests/cases/compiler/privacyImport.ts (2 errors) ====
+==== tests/cases/compiler/privacyImport.ts (6 errors) ====
     export module m1 {
         export module m1_M1_public {
             export class c1 {
@@ -55,9 +59,17 @@ tests/cases/compiler/privacyImport.ts(80,35): error TS4000: Import declaration '
                                 ~~~~~~~~~~~~~
 !!! error TS4000: Import declaration 'm1_im2_private' references inaccessible name 'm1_M2_private'.
         export var m1_im2_private_v1_public = m1_im2_private.c1;
+                   ~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4025: Type of variable 'm1_im2_private_v1_public' references inaccessible name 'c1'.
         export var m1_im2_private_v2_public = new m1_im2_private.c1();
+                   ~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4025: Type of variable 'm1_im2_private_v2_public' references inaccessible name 'c1'.
         export var m1_im2_private_v3_public = m1_im2_private.f1;
+                   ~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4025: Type of variable 'm1_im2_private_v3_public' references inaccessible name 'f1'.
         export var m1_im2_private_v4_public = m1_im2_private.f1();
+                   ~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4025: Type of variable 'm1_im2_private_v4_public' references inaccessible name 'c1'.
         var m1_im2_private_v1_private = m1_im2_private.c1;
         var m1_im2_private_v2_private = new m1_im2_private.c1();
         var m1_im2_private_v3_private = m1_im2_private.f1;
diff --git a/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.errors.txt b/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.errors.txt
index 1535070e17622..9d7fecc93e22c 100644
--- a/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.errors.txt
+++ b/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.errors.txt
@@ -2,14 +2,11 @@ tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts(14,82):
 tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(15,82): error TS4020: Extends clause references inaccessible name 'privateInterfaceInPublicModule'.
 tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(20,84): error TS4020: Extends clause references inaccessible name 'privateModule'.
 tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(23,83): error TS4020: Extends clause references inaccessible name 'privateInterfaceInPublicModule'.
-tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(41,82): error TS4020: Extends clause references inaccessible name 'privateInterfaceInPrivateModule'.
-tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(41,82): error TS4020: Extends clause references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(46,84): error TS4020: Extends clause references inaccessible name 'privateModule'.
 tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(63,70): error TS4020: Extends clause references inaccessible name 'privateInterface'.
 tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(68,80): error TS4020: Extends clause references inaccessible name 'privateModule'.
 
 
-==== tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts (8 errors) ====
+==== tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts (5 errors) ====
     
     export module publicModule {
         export interface publicInterfaceInPublicModule {
@@ -57,17 +54,11 @@ tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts(68,
         export interface publicInterfaceImplementingPublicInterfaceInModule extends publicInterfaceInPrivateModule {
         }
         export interface publicInterfaceImplementingPrivateInterfaceInModule extends privateInterfaceInPrivateModule {
-                                                                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4020: Extends clause references inaccessible name 'privateInterfaceInPrivateModule'.
-                                                                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4020: Extends clause references inaccessible name 'privateModule'.
         }
     
         interface privateInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule {
         }
         export interface publicInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule {
-                                                                                       ~~~~~~~~~~~~~
-!!! error TS4020: Extends clause references inaccessible name 'privateModule'.
         }
     }
     
diff --git a/tests/baselines/reference/privacyLocalInternalReferenceImportWithExport.errors.txt b/tests/baselines/reference/privacyLocalInternalReferenceImportWithExport.errors.txt
index d307f6499ce6d..befb7533c0630 100644
--- a/tests/baselines/reference/privacyLocalInternalReferenceImportWithExport.errors.txt
+++ b/tests/baselines/reference/privacyLocalInternalReferenceImportWithExport.errors.txt
@@ -1,13 +1,15 @@
-tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts(51,41): error TS4000: Import declaration 'im_public_c_private' references inaccessible name 'm_private'.
-tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts(52,41): error TS4000: Import declaration 'im_public_e_private' references inaccessible name 'm_private'.
-tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts(53,41): error TS4000: Import declaration 'im_public_f_private' references inaccessible name 'm_private'.
-tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts(54,41): error TS4000: Import declaration 'im_public_v_private' references inaccessible name 'm_private'.
-tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts(55,41): error TS4000: Import declaration 'im_public_i_private' references inaccessible name 'm_private'.
-tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts(56,42): error TS4000: Import declaration 'im_public_mi_private' references inaccessible name 'm_private'.
-tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts(57,42): error TS4000: Import declaration 'im_public_mu_private' references inaccessible name 'm_private'.
+tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts(51,41): error TS4000: Import declaration 'im_public_c_private' references inaccessible name 'c_private'.
+tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts(52,41): error TS4000: Import declaration 'im_public_e_private' references inaccessible name 'e_private'.
+tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts(53,41): error TS4000: Import declaration 'im_public_f_private' references inaccessible name 'f_private'.
+tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts(54,41): error TS4000: Import declaration 'im_public_v_private' references inaccessible name 'v_private'.
+tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts(55,41): error TS4000: Import declaration 'im_public_i_private' references inaccessible name 'i_private'.
+tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts(56,42): error TS4000: Import declaration 'im_public_mi_private' references inaccessible name 'mi_private'.
+tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts(57,42): error TS4000: Import declaration 'im_public_mu_private' references inaccessible name 'mu_private'.
+tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts(71,16): error TS4025: Type of variable 'publicUse_im_public_mi_private' references inaccessible name 'c'.
+tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts(73,69): error TS4025: Type of variable 'publicUse_im_public_mu_private' references inaccessible name 'i'.
 
 
-==== tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts (7 errors) ====
+==== tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts (9 errors) ====
     // private elements
     module m_private {
         export class c_private {
@@ -60,25 +62,25 @@ tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts(57,42): er
         // Privacy errors - importing private elements
         export import im_public_c_private = m_private.c_private;
                                             ~~~~~~~~~~~~~~~~~~~
-!!! error TS4000: Import declaration 'im_public_c_private' references inaccessible name 'm_private'.
+!!! error TS4000: Import declaration 'im_public_c_private' references inaccessible name 'c_private'.
         export import im_public_e_private = m_private.e_private;
                                             ~~~~~~~~~~~~~~~~~~~
-!!! error TS4000: Import declaration 'im_public_e_private' references inaccessible name 'm_private'.
+!!! error TS4000: Import declaration 'im_public_e_private' references inaccessible name 'e_private'.
         export import im_public_f_private = m_private.f_private;
                                             ~~~~~~~~~~~~~~~~~~~
-!!! error TS4000: Import declaration 'im_public_f_private' references inaccessible name 'm_private'.
+!!! error TS4000: Import declaration 'im_public_f_private' references inaccessible name 'f_private'.
         export import im_public_v_private = m_private.v_private;
                                             ~~~~~~~~~~~~~~~~~~~
-!!! error TS4000: Import declaration 'im_public_v_private' references inaccessible name 'm_private'.
+!!! error TS4000: Import declaration 'im_public_v_private' references inaccessible name 'v_private'.
         export import im_public_i_private = m_private.i_private;
                                             ~~~~~~~~~~~~~~~~~~~
-!!! error TS4000: Import declaration 'im_public_i_private' references inaccessible name 'm_private'.
+!!! error TS4000: Import declaration 'im_public_i_private' references inaccessible name 'i_private'.
         export import im_public_mi_private = m_private.mi_private;
                                              ~~~~~~~~~~~~~~~~~~~~
-!!! error TS4000: Import declaration 'im_public_mi_private' references inaccessible name 'm_private'.
+!!! error TS4000: Import declaration 'im_public_mi_private' references inaccessible name 'mi_private'.
         export import im_public_mu_private = m_private.mu_private;
                                              ~~~~~~~~~~~~~~~~~~~~
-!!! error TS4000: Import declaration 'im_public_mu_private' references inaccessible name 'm_private'.
+!!! error TS4000: Import declaration 'im_public_mu_private' references inaccessible name 'mu_private'.
     
         // Usage of privacy error imports
         var privateUse_im_public_c_private = new im_public_c_private();
@@ -93,8 +95,12 @@ tests/cases/compiler/privacyLocalInternalReferenceImportWithExport.ts(57,42): er
         export var publicUse_im_public_i_private: im_public_i_private;
         var privateUse_im_public_mi_private = new im_public_mi_private.c();
         export var publicUse_im_public_mi_private = new im_public_mi_private.c();
+                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4025: Type of variable 'publicUse_im_public_mi_private' references inaccessible name 'c'.
         var privateUse_im_public_mu_private: im_public_mu_private.i;
         export var publicUse_im_public_mu_private: im_public_mu_private.i;
+                                                                        ~
+!!! error TS4025: Type of variable 'publicUse_im_public_mu_private' references inaccessible name 'i'.
     
     
         // No Privacy errors - importing public elements
diff --git a/tests/baselines/reference/privacyLocalInternalReferenceImportWithoutExport.errors.txt b/tests/baselines/reference/privacyLocalInternalReferenceImportWithoutExport.errors.txt
index 4f014edd553dc..eebcb80964ce1 100644
--- a/tests/baselines/reference/privacyLocalInternalReferenceImportWithoutExport.errors.txt
+++ b/tests/baselines/reference/privacyLocalInternalReferenceImportWithoutExport.errors.txt
@@ -1,11 +1,13 @@
-tests/cases/compiler/privacyLocalInternalReferenceImportWithoutExport.ts(51,35): error TS4000: Import declaration 'im_private_c_private' references inaccessible name 'm_private'.
-tests/cases/compiler/privacyLocalInternalReferenceImportWithoutExport.ts(52,35): error TS4000: Import declaration 'im_private_e_private' references inaccessible name 'm_private'.
-tests/cases/compiler/privacyLocalInternalReferenceImportWithoutExport.ts(55,35): error TS4000: Import declaration 'im_private_i_private' references inaccessible name 'm_private'.
-tests/cases/compiler/privacyLocalInternalReferenceImportWithoutExport.ts(56,36): error TS4000: Import declaration 'im_private_mi_private' references inaccessible name 'm_private'.
-tests/cases/compiler/privacyLocalInternalReferenceImportWithoutExport.ts(57,36): error TS4000: Import declaration 'im_private_mu_private' references inaccessible name 'm_private'.
+tests/cases/compiler/privacyLocalInternalReferenceImportWithoutExport.ts(51,35): error TS4000: Import declaration 'im_private_c_private' references inaccessible name 'c_private'.
+tests/cases/compiler/privacyLocalInternalReferenceImportWithoutExport.ts(52,35): error TS4000: Import declaration 'im_private_e_private' references inaccessible name 'e_private'.
+tests/cases/compiler/privacyLocalInternalReferenceImportWithoutExport.ts(55,35): error TS4000: Import declaration 'im_private_i_private' references inaccessible name 'i_private'.
+tests/cases/compiler/privacyLocalInternalReferenceImportWithoutExport.ts(56,36): error TS4000: Import declaration 'im_private_mi_private' references inaccessible name 'mi_private'.
+tests/cases/compiler/privacyLocalInternalReferenceImportWithoutExport.ts(57,36): error TS4000: Import declaration 'im_private_mu_private' references inaccessible name 'mu_private'.
+tests/cases/compiler/privacyLocalInternalReferenceImportWithoutExport.ts(71,16): error TS4025: Type of variable 'publicUse_im_private_mi_private' references inaccessible name 'c'.
+tests/cases/compiler/privacyLocalInternalReferenceImportWithoutExport.ts(73,71): error TS4025: Type of variable 'publicUse_im_private_mu_private' references inaccessible name 'i'.
 
 
-==== tests/cases/compiler/privacyLocalInternalReferenceImportWithoutExport.ts (5 errors) ====
+==== tests/cases/compiler/privacyLocalInternalReferenceImportWithoutExport.ts (7 errors) ====
     // private elements
     module m_private {
         export class c_private {
@@ -58,21 +60,21 @@ tests/cases/compiler/privacyLocalInternalReferenceImportWithoutExport.ts(57,36):
         // No Privacy errors - importing private elements
         import im_private_c_private = m_private.c_private;
                                       ~~~~~~~~~~~~~~~~~~~
-!!! error TS4000: Import declaration 'im_private_c_private' references inaccessible name 'm_private'.
+!!! error TS4000: Import declaration 'im_private_c_private' references inaccessible name 'c_private'.
         import im_private_e_private = m_private.e_private;
                                       ~~~~~~~~~~~~~~~~~~~
-!!! error TS4000: Import declaration 'im_private_e_private' references inaccessible name 'm_private'.
+!!! error TS4000: Import declaration 'im_private_e_private' references inaccessible name 'e_private'.
         import im_private_f_private = m_private.f_private;
         import im_private_v_private = m_private.v_private;
         import im_private_i_private = m_private.i_private;
                                       ~~~~~~~~~~~~~~~~~~~
-!!! error TS4000: Import declaration 'im_private_i_private' references inaccessible name 'm_private'.
+!!! error TS4000: Import declaration 'im_private_i_private' references inaccessible name 'i_private'.
         import im_private_mi_private = m_private.mi_private;
                                        ~~~~~~~~~~~~~~~~~~~~
-!!! error TS4000: Import declaration 'im_private_mi_private' references inaccessible name 'm_private'.
+!!! error TS4000: Import declaration 'im_private_mi_private' references inaccessible name 'mi_private'.
         import im_private_mu_private = m_private.mu_private;
                                        ~~~~~~~~~~~~~~~~~~~~
-!!! error TS4000: Import declaration 'im_private_mu_private' references inaccessible name 'm_private'.
+!!! error TS4000: Import declaration 'im_private_mu_private' references inaccessible name 'mu_private'.
     
         // Usage of above decls
         var privateUse_im_private_c_private = new im_private_c_private();
@@ -87,8 +89,12 @@ tests/cases/compiler/privacyLocalInternalReferenceImportWithoutExport.ts(57,36):
         export var publicUse_im_private_i_private: im_private_i_private;
         var privateUse_im_private_mi_private = new im_private_mi_private.c();
         export var publicUse_im_private_mi_private = new im_private_mi_private.c();
+                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4025: Type of variable 'publicUse_im_private_mi_private' references inaccessible name 'c'.
         var privateUse_im_private_mu_private: im_private_mu_private.i;
         export var publicUse_im_private_mu_private: im_private_mu_private.i;
+                                                                          ~
+!!! error TS4025: Type of variable 'publicUse_im_private_mu_private' references inaccessible name 'i'.
     
     
         // No Privacy errors - importing public elements
diff --git a/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithExport.errors.txt b/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithExport.errors.txt
index c082fe2b1c49a..67b299faab820 100644
--- a/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithExport.errors.txt
+++ b/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithExport.errors.txt
@@ -1,13 +1,15 @@
-tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts(50,37): error TS4000: Import declaration 'im_public_c_private' references inaccessible name 'm_private'.
-tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts(51,37): error TS4000: Import declaration 'im_public_e_private' references inaccessible name 'm_private'.
-tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts(52,37): error TS4000: Import declaration 'im_public_f_private' references inaccessible name 'm_private'.
-tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts(53,37): error TS4000: Import declaration 'im_public_v_private' references inaccessible name 'm_private'.
-tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts(54,37): error TS4000: Import declaration 'im_public_i_private' references inaccessible name 'm_private'.
-tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts(55,38): error TS4000: Import declaration 'im_public_mi_private' references inaccessible name 'm_private'.
-tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts(56,38): error TS4000: Import declaration 'im_public_mu_private' references inaccessible name 'm_private'.
+tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts(50,37): error TS4000: Import declaration 'im_public_c_private' references inaccessible name 'c_private'.
+tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts(51,37): error TS4000: Import declaration 'im_public_e_private' references inaccessible name 'e_private'.
+tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts(52,37): error TS4000: Import declaration 'im_public_f_private' references inaccessible name 'f_private'.
+tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts(53,37): error TS4000: Import declaration 'im_public_v_private' references inaccessible name 'v_private'.
+tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts(54,37): error TS4000: Import declaration 'im_public_i_private' references inaccessible name 'i_private'.
+tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts(55,38): error TS4000: Import declaration 'im_public_mi_private' references inaccessible name 'mi_private'.
+tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts(56,38): error TS4000: Import declaration 'im_public_mu_private' references inaccessible name 'mu_private'.
+tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts(70,12): error TS4025: Type of variable 'publicUse_im_public_mi_private' references inaccessible name 'c'.
+tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts(72,65): error TS4025: Type of variable 'publicUse_im_public_mu_private' references inaccessible name 'i'.
 
 
-==== tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts (7 errors) ====
+==== tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts (9 errors) ====
     // private elements
     module m_private {
         export class c_private {
@@ -59,25 +61,25 @@ tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts(56,38):
     // Privacy errors - importing private elements
     export import im_public_c_private = m_private.c_private;
                                         ~~~~~~~~~~~~~~~~~~~
-!!! error TS4000: Import declaration 'im_public_c_private' references inaccessible name 'm_private'.
+!!! error TS4000: Import declaration 'im_public_c_private' references inaccessible name 'c_private'.
     export import im_public_e_private = m_private.e_private;
                                         ~~~~~~~~~~~~~~~~~~~
-!!! error TS4000: Import declaration 'im_public_e_private' references inaccessible name 'm_private'.
+!!! error TS4000: Import declaration 'im_public_e_private' references inaccessible name 'e_private'.
     export import im_public_f_private = m_private.f_private;
                                         ~~~~~~~~~~~~~~~~~~~
-!!! error TS4000: Import declaration 'im_public_f_private' references inaccessible name 'm_private'.
+!!! error TS4000: Import declaration 'im_public_f_private' references inaccessible name 'f_private'.
     export import im_public_v_private = m_private.v_private;
                                         ~~~~~~~~~~~~~~~~~~~
-!!! error TS4000: Import declaration 'im_public_v_private' references inaccessible name 'm_private'.
+!!! error TS4000: Import declaration 'im_public_v_private' references inaccessible name 'v_private'.
     export import im_public_i_private = m_private.i_private;
                                         ~~~~~~~~~~~~~~~~~~~
-!!! error TS4000: Import declaration 'im_public_i_private' references inaccessible name 'm_private'.
+!!! error TS4000: Import declaration 'im_public_i_private' references inaccessible name 'i_private'.
     export import im_public_mi_private = m_private.mi_private;
                                          ~~~~~~~~~~~~~~~~~~~~
-!!! error TS4000: Import declaration 'im_public_mi_private' references inaccessible name 'm_private'.
+!!! error TS4000: Import declaration 'im_public_mi_private' references inaccessible name 'mi_private'.
     export import im_public_mu_private = m_private.mu_private;
                                          ~~~~~~~~~~~~~~~~~~~~
-!!! error TS4000: Import declaration 'im_public_mu_private' references inaccessible name 'm_private'.
+!!! error TS4000: Import declaration 'im_public_mu_private' references inaccessible name 'mu_private'.
     
     // Usage of privacy error imports
     var privateUse_im_public_c_private = new im_public_c_private();
@@ -92,8 +94,12 @@ tests/cases/compiler/privacyTopLevelInternalReferenceImportWithExport.ts(56,38):
     export var publicUse_im_public_i_private: im_public_i_private;
     var privateUse_im_public_mi_private = new im_public_mi_private.c();
     export var publicUse_im_public_mi_private = new im_public_mi_private.c();
+               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4025: Type of variable 'publicUse_im_public_mi_private' references inaccessible name 'c'.
     var privateUse_im_public_mu_private: im_public_mu_private.i;
     export var publicUse_im_public_mu_private: im_public_mu_private.i;
+                                                                    ~
+!!! error TS4025: Type of variable 'publicUse_im_public_mu_private' references inaccessible name 'i'.
     
     
     // No Privacy errors - importing public elements
diff --git a/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithoutExport.errors.txt b/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithoutExport.errors.txt
index 4a8cc701dda47..688cce8b26ad4 100644
--- a/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithoutExport.errors.txt
+++ b/tests/baselines/reference/privacyTopLevelInternalReferenceImportWithoutExport.errors.txt
@@ -1,11 +1,13 @@
-tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(51,31): error TS4000: Import declaration 'im_private_c_private' references inaccessible name 'm_private'.
-tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(52,31): error TS4000: Import declaration 'im_private_e_private' references inaccessible name 'm_private'.
-tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(55,31): error TS4000: Import declaration 'im_private_i_private' references inaccessible name 'm_private'.
-tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(56,32): error TS4000: Import declaration 'im_private_mi_private' references inaccessible name 'm_private'.
-tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(57,32): error TS4000: Import declaration 'im_private_mu_private' references inaccessible name 'm_private'.
+tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(51,31): error TS4000: Import declaration 'im_private_c_private' references inaccessible name 'c_private'.
+tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(52,31): error TS4000: Import declaration 'im_private_e_private' references inaccessible name 'e_private'.
+tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(55,31): error TS4000: Import declaration 'im_private_i_private' references inaccessible name 'i_private'.
+tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(56,32): error TS4000: Import declaration 'im_private_mi_private' references inaccessible name 'mi_private'.
+tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(57,32): error TS4000: Import declaration 'im_private_mu_private' references inaccessible name 'mu_private'.
+tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(71,12): error TS4025: Type of variable 'publicUse_im_private_mi_private' references inaccessible name 'c'.
+tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(73,67): error TS4025: Type of variable 'publicUse_im_private_mu_private' references inaccessible name 'i'.
 
 
-==== tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts (5 errors) ====
+==== tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts (7 errors) ====
     
     // private elements
     module m_private {
@@ -58,21 +60,21 @@ tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(57,3
     // No Privacy errors - importing private elements
     import im_private_c_private = m_private.c_private;
                                   ~~~~~~~~~~~~~~~~~~~
-!!! error TS4000: Import declaration 'im_private_c_private' references inaccessible name 'm_private'.
+!!! error TS4000: Import declaration 'im_private_c_private' references inaccessible name 'c_private'.
     import im_private_e_private = m_private.e_private;
                                   ~~~~~~~~~~~~~~~~~~~
-!!! error TS4000: Import declaration 'im_private_e_private' references inaccessible name 'm_private'.
+!!! error TS4000: Import declaration 'im_private_e_private' references inaccessible name 'e_private'.
     import im_private_f_private = m_private.f_private;
     import im_private_v_private = m_private.v_private;
     import im_private_i_private = m_private.i_private;
                                   ~~~~~~~~~~~~~~~~~~~
-!!! error TS4000: Import declaration 'im_private_i_private' references inaccessible name 'm_private'.
+!!! error TS4000: Import declaration 'im_private_i_private' references inaccessible name 'i_private'.
     import im_private_mi_private = m_private.mi_private;
                                    ~~~~~~~~~~~~~~~~~~~~
-!!! error TS4000: Import declaration 'im_private_mi_private' references inaccessible name 'm_private'.
+!!! error TS4000: Import declaration 'im_private_mi_private' references inaccessible name 'mi_private'.
     import im_private_mu_private = m_private.mu_private;
                                    ~~~~~~~~~~~~~~~~~~~~
-!!! error TS4000: Import declaration 'im_private_mu_private' references inaccessible name 'm_private'.
+!!! error TS4000: Import declaration 'im_private_mu_private' references inaccessible name 'mu_private'.
     
     // Usage of above decls
     var privateUse_im_private_c_private = new im_private_c_private();
@@ -87,8 +89,12 @@ tests/cases/compiler/privacyTopLevelInternalReferenceImportWithoutExport.ts(57,3
     export var publicUse_im_private_i_private: im_private_i_private;
     var privateUse_im_private_mi_private = new im_private_mi_private.c();
     export var publicUse_im_private_mi_private = new im_private_mi_private.c();
+               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS4025: Type of variable 'publicUse_im_private_mi_private' references inaccessible name 'c'.
     var privateUse_im_private_mu_private: im_private_mu_private.i;
     export var publicUse_im_private_mu_private: im_private_mu_private.i;
+                                                                      ~
+!!! error TS4025: Type of variable 'publicUse_im_private_mu_private' references inaccessible name 'i'.
     
     
     // No Privacy errors - importing public elements
diff --git a/tests/baselines/reference/privacyTypeParameterOfFunctionDeclFile.errors.txt b/tests/baselines/reference/privacyTypeParameterOfFunctionDeclFile.errors.txt
index 3eb26acdd0551..b27fab126b342 100644
--- a/tests/baselines/reference/privacyTypeParameterOfFunctionDeclFile.errors.txt
+++ b/tests/baselines/reference/privacyTypeParameterOfFunctionDeclFile.errors.txt
@@ -34,19 +34,9 @@ tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(285,58): error TS
 tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(288,47): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
 tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(290,34): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
 tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(293,78): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(321,24): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(321,24): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(321,41): error TS4044: Return type of construct signature references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(322,20): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(322,37): error TS4047: Return type of call signature references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(323,28): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(323,45): error TS4038: Return type of method 'myMethod' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(345,47): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(349,34): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(388,71): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
 
 
-==== tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts (46 errors) ====
+==== tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts (36 errors) ====
     class privateClass {
     }
     
@@ -440,22 +430,8 @@ tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(388,71): error TS
     
         export interface publicInterfaceWithPrivateTypeParameters {
             new <T extends privateClass>(): privateClass; 
-                           ~~~~~~~~~~~~
-!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
-                           ~~~~~~~~~~~~
-!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
-                                            ~~~~~~~~~~~~
-!!! error TS4044: Return type of construct signature references inaccessible name 'privateClass'.
             <T extends privateClass>(): privateClass;
-                       ~~~~~~~~~~~~
-!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
-                                        ~~~~~~~~~~~~
-!!! error TS4047: Return type of call signature references inaccessible name 'privateClass'.
             myMethod<T extends privateClass>(): privateClass; 
-                               ~~~~~~~~~~~~
-!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
-                                                ~~~~~~~~~~~~
-!!! error TS4038: Return type of method 'myMethod' references inaccessible name 'privateClass'.
         }
     
         export interface publicInterfaceWithPublicTypeParameters {
@@ -478,14 +454,10 @@ tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(388,71): error TS
     
         export class publicClassWithWithPrivateTypeParameters {
             static myPublicStaticMethod<T extends privateClass>() { 
-                                                  ~~~~~~~~~~~~
-!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
             }
             private static myPrivateStaticMethod<T extends privateClass>() {
             }
             myPublicMethod<T extends privateClass>() {  
-                                     ~~~~~~~~~~~~
-!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
             }
             private myPrivateMethod<T extends privateClass>() {
             }
@@ -525,8 +497,6 @@ tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts(388,71): error TS
         }
     
         export function publicFunctionWithPrivateTypeParameters<T extends privateClass>() { 
-                                                                          ~~~~~~~~~~~~
-!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClass'.
         }
     
         export function publicFunctionWithPublicTypeParameters<T extends publicClass>() {
diff --git a/tests/baselines/reference/privacyTypeParametersOfClassDeclFile.errors.txt b/tests/baselines/reference/privacyTypeParametersOfClassDeclFile.errors.txt
index 18c4769381be0..cf04a8176359b 100644
--- a/tests/baselines/reference/privacyTypeParametersOfClassDeclFile.errors.txt
+++ b/tests/baselines/reference/privacyTypeParametersOfClassDeclFile.errors.txt
@@ -2,11 +2,9 @@ tests/cases/compiler/privacyTypeParametersOfClassDeclFile.ts(7,61): error TS4002
 tests/cases/compiler/privacyTypeParametersOfClassDeclFile.ts(43,71): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
 tests/cases/compiler/privacyTypeParametersOfClassDeclFile.ts(62,65): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClassInPublicModule'.
 tests/cases/compiler/privacyTypeParametersOfClassDeclFile.ts(98,75): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyTypeParametersOfClassDeclFile.ts(118,65): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClassInPrivateModule'.
-tests/cases/compiler/privacyTypeParametersOfClassDeclFile.ts(118,65): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
 
 
-==== tests/cases/compiler/privacyTypeParametersOfClassDeclFile.ts (6 errors) ====
+==== tests/cases/compiler/privacyTypeParametersOfClassDeclFile.ts (4 errors) ====
     class privateClass {
     }
     
@@ -133,10 +131,6 @@ tests/cases/compiler/privacyTypeParametersOfClassDeclFile.ts(118,65): error TS40
         }
     
         export class publicClassWithPrivateTypeParameters<T extends privateClassInPrivateModule> {
-                                                                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClassInPrivateModule'.
-                                                                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
             myMethod(val: T): T {
                 return val;
             }
diff --git a/tests/baselines/reference/privacyTypeParametersOfInterfaceDeclFile.errors.txt b/tests/baselines/reference/privacyTypeParametersOfInterfaceDeclFile.errors.txt
index ad66dbef91ca9..54cb4eaad1122 100644
--- a/tests/baselines/reference/privacyTypeParametersOfInterfaceDeclFile.errors.txt
+++ b/tests/baselines/reference/privacyTypeParametersOfInterfaceDeclFile.errors.txt
@@ -18,20 +18,9 @@ tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(91,50): error T
 tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(92,22): error TS4038: Return type of method 'myMethod2' references inaccessible name 'privateClassInPublicModuleT'.
 tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(93,49): error TS4038: Return type of method 'myMethod3' references inaccessible name 'privateClassInPublicModule'.
 tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(125,89): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(145,73): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClassInPrivateModule'.
-tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(145,73): error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(148,22): error TS4038: Return type of method 'myMethod1' references inaccessible name 'privateClassInPrivateModuleT'.
-tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(148,22): error TS4038: Return type of method 'myMethod1' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(148,51): error TS4038: Return type of method 'myMethod1' references inaccessible name 'privateClassInPrivateModule'.
-tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(149,22): error TS4038: Return type of method 'myMethod2' references inaccessible name 'privateClassInPrivateModuleT'.
-tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(150,50): error TS4038: Return type of method 'myMethod3' references inaccessible name 'privateClassInPrivateModule'.
-tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(157,22): error TS4038: Return type of method 'myMethod1' references inaccessible name 'privateClassInPrivateModuleT'.
-tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(157,51): error TS4038: Return type of method 'myMethod1' references inaccessible name 'privateClassInPrivateModule'.
-tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(158,22): error TS4038: Return type of method 'myMethod2' references inaccessible name 'privateClassInPrivateModuleT'.
-tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(159,50): error TS4038: Return type of method 'myMethod3' references inaccessible name 'privateClassInPrivateModule'.
 
 
-==== tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts (31 errors) ====
+==== tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts (20 errors) ====
     class privateClass {
     }
     
@@ -217,25 +206,11 @@ tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(159,50): error
         }
     
         export interface publicInterfaceWithPrivateTypeParameters<T extends privateClassInPrivateModule> {
-                                                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateClassInPrivateModule'.
-                                                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4002: Constraint of type parameter 'T' references inaccessible name 'privateModule'.
             myMethod(val: T): T;
             myMethod0(): publicClassInPrivateModuleT<T>;
             myMethod1(): privateClassInPrivateModuleT<privateClassInPrivateModule>;
-                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4038: Return type of method 'myMethod1' references inaccessible name 'privateClassInPrivateModuleT'.
-                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4038: Return type of method 'myMethod1' references inaccessible name 'privateModule'.
-                                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4038: Return type of method 'myMethod1' references inaccessible name 'privateClassInPrivateModule'.
             myMethod2(): privateClassInPrivateModuleT<publicClassInPrivateModule>;
-                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4038: Return type of method 'myMethod2' references inaccessible name 'privateClassInPrivateModuleT'.
             myMethod3(): publicClassInPrivateModuleT<privateClassInPrivateModule>;
-                                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4038: Return type of method 'myMethod3' references inaccessible name 'privateClassInPrivateModule'.
             myMethod4(): publicClassInPrivateModuleT<publicClassInPrivateModule>;
         }
     
@@ -243,16 +218,8 @@ tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts(159,50): error
             myMethod(val: T): T;
             myMethod0(): publicClassInPrivateModuleT<T>
             myMethod1(): privateClassInPrivateModuleT<privateClassInPrivateModule>;
-                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4038: Return type of method 'myMethod1' references inaccessible name 'privateClassInPrivateModuleT'.
-                                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4038: Return type of method 'myMethod1' references inaccessible name 'privateClassInPrivateModule'.
             myMethod2(): privateClassInPrivateModuleT<publicClassInPrivateModule>;
-                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4038: Return type of method 'myMethod2' references inaccessible name 'privateClassInPrivateModuleT'.
             myMethod3(): publicClassInPrivateModuleT<privateClassInPrivateModule>;
-                                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS4038: Return type of method 'myMethod3' references inaccessible name 'privateClassInPrivateModule'.
             myMethod4(): publicClassInPrivateModuleT<publicClassInPrivateModule>;
         }
     
diff --git a/tests/baselines/reference/privacyVarDeclFile.errors.txt b/tests/baselines/reference/privacyVarDeclFile.errors.txt
index 89d167cfcf8a7..fecca463da296 100644
--- a/tests/baselines/reference/privacyVarDeclFile.errors.txt
+++ b/tests/baselines/reference/privacyVarDeclFile.errors.txt
@@ -1,14 +1,3 @@
-tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(30,25): error TS4028: Type of property 'myProperty' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(30,25): error TS4028: Type of property 'myProperty' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(46,44): error TS4028: Type of property 'myPublicStaticProperty' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(48,31): error TS4028: Type of property 'myPublicProperty' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(73,55): error TS4025: Type of variable 'publicVarWithPrivatePropertyTypes' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(78,70): error TS4025: Type of variable 'publicAmbientVarWithPrivatePropertyTypes' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(84,25): error TS4028: Type of property 'myProperty' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(87,44): error TS4028: Type of property 'myPublicStaticProperty' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(88,31): error TS4028: Type of property 'myPublicProperty' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(90,61): error TS4025: Type of variable 'publicVarWithPrivateModulePropertyTypes' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(91,76): error TS4025: Type of variable 'publicAmbientVarWithPrivateModulePropertyTypes' references inaccessible name 'privateModule'.
 tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(105,21): error TS4028: Type of property 'myProperty' references inaccessible name 'privateClass'.
 tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(121,40): error TS4028: Type of property 'myPublicStaticProperty' references inaccessible name 'privateClass'.
 tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts(123,27): error TS4028: Type of property 'myPublicProperty' references inaccessible name 'privateClass'.
@@ -39,20 +28,9 @@ tests/cases/compiler/privacyVarDeclFile_externalModule.ts(147,40): error TS4028:
 tests/cases/compiler/privacyVarDeclFile_externalModule.ts(148,27): error TS4028: Type of property 'myPublicProperty' references inaccessible name 'privateModule'.
 tests/cases/compiler/privacyVarDeclFile_externalModule.ts(150,57): error TS4025: Type of variable 'publicVarWithPrivateModulePropertyTypes' references inaccessible name 'privateModule'.
 tests/cases/compiler/privacyVarDeclFile_externalModule.ts(151,72): error TS4025: Type of variable 'publicAmbientVarWithPrivateModulePropertyTypes' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyVarDeclFile_externalModule.ts(172,21): error TS4028: Type of property 'myProperty' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyVarDeclFile_externalModule.ts(172,21): error TS4028: Type of property 'myProperty' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyVarDeclFile_externalModule.ts(188,40): error TS4028: Type of property 'myPublicStaticProperty' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyVarDeclFile_externalModule.ts(190,27): error TS4028: Type of property 'myPublicProperty' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyVarDeclFile_externalModule.ts(215,51): error TS4025: Type of variable 'publicVarWithPrivatePropertyTypes' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyVarDeclFile_externalModule.ts(220,66): error TS4025: Type of variable 'publicAmbientVarWithPrivatePropertyTypes' references inaccessible name 'privateClass'.
-tests/cases/compiler/privacyVarDeclFile_externalModule.ts(226,21): error TS4028: Type of property 'myProperty' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyVarDeclFile_externalModule.ts(229,40): error TS4028: Type of property 'myPublicStaticProperty' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyVarDeclFile_externalModule.ts(230,27): error TS4028: Type of property 'myPublicProperty' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyVarDeclFile_externalModule.ts(232,57): error TS4025: Type of variable 'publicVarWithPrivateModulePropertyTypes' references inaccessible name 'privateModule'.
-tests/cases/compiler/privacyVarDeclFile_externalModule.ts(233,72): error TS4025: Type of variable 'publicAmbientVarWithPrivateModulePropertyTypes' references inaccessible name 'privateModule'.
 
 
-==== tests/cases/compiler/privacyVarDeclFile_externalModule.ts (31 errors) ====
+==== tests/cases/compiler/privacyVarDeclFile_externalModule.ts (20 errors) ====
     
     class privateClass {
     }
@@ -265,10 +243,6 @@ tests/cases/compiler/privacyVarDeclFile_externalModule.ts(233,72): error TS4025:
     
         export interface publicInterfaceWithPrivatePropertyTypes {
             myProperty: privateClass;  
-                        ~~~~~~~~~~~~
-!!! error TS4028: Type of property 'myProperty' references inaccessible name 'privateClass'.
-                        ~~~~~~~~~~~~
-!!! error TS4028: Type of property 'myProperty' references inaccessible name 'privateModule'.
         }
     
         export interface publicInterfaceWithPublicPropertyTypes {
@@ -285,12 +259,8 @@ tests/cases/compiler/privacyVarDeclFile_externalModule.ts(233,72): error TS4025:
     
         export class publicClassWithWithPrivatePropertyTypes {
             static myPublicStaticProperty: privateClass; 
-                                           ~~~~~~~~~~~~
-!!! error TS4028: Type of property 'myPublicStaticProperty' references inaccessible name 'privateClass'.
             private static myPrivateStaticProperty: privateClass;
             myPublicProperty: privateClass; 
-                              ~~~~~~~~~~~~
-!!! error TS4028: Type of property 'myPublicProperty' references inaccessible name 'privateClass'.
             private myPrivateProperty: privateClass;
         }
     
@@ -316,38 +286,24 @@ tests/cases/compiler/privacyVarDeclFile_externalModule.ts(233,72): error TS4025:
         }
     
         export var publicVarWithPrivatePropertyTypes: privateClass; 
-                                                      ~~~~~~~~~~~~
-!!! error TS4025: Type of variable 'publicVarWithPrivatePropertyTypes' references inaccessible name 'privateClass'.
         export var publicVarWithPublicPropertyTypes: publicClass;
         var privateVarWithPrivatePropertyTypes: privateClass;
         var privateVarWithPublicPropertyTypes: publicClass;
     
         export declare var publicAmbientVarWithPrivatePropertyTypes: privateClass; 
-                                                                     ~~~~~~~~~~~~
-!!! error TS4025: Type of variable 'publicAmbientVarWithPrivatePropertyTypes' references inaccessible name 'privateClass'.
         export declare var publicAmbientVarWithPublicPropertyTypes: publicClass;
         declare var privateAmbientVarWithPrivatePropertyTypes: privateClass;
         declare var privateAmbientVarWithPublicPropertyTypes: publicClass;
     
         export interface publicInterfaceWithPrivateModulePropertyTypes {
             myProperty: privateModule.publicClass; 
-                        ~~~~~~~~~~~~~
-!!! error TS4028: Type of property 'myProperty' references inaccessible name 'privateModule'.
         }
         export class publicClassWithPrivateModulePropertyTypes {
             static myPublicStaticProperty: privateModule.publicClass; 
-                                           ~~~~~~~~~~~~~
-!!! error TS4028: Type of property 'myPublicStaticProperty' references inaccessible name 'privateModule'.
             myPublicProperty: privateModule.publicClass; 
-                              ~~~~~~~~~~~~~
-!!! error TS4028: Type of property 'myPublicProperty' references inaccessible name 'privateModule'.
         }
         export var publicVarWithPrivateModulePropertyTypes: privateModule.publicClass; 
-                                                            ~~~~~~~~~~~~~
-!!! error TS4025: Type of variable 'publicVarWithPrivateModulePropertyTypes' references inaccessible name 'privateModule'.
         export declare var publicAmbientVarWithPrivateModulePropertyTypes: privateModule.publicClass;
-                                                                           ~~~~~~~~~~~~~
-!!! error TS4025: Type of variable 'publicAmbientVarWithPrivateModulePropertyTypes' references inaccessible name 'privateModule'.
     
         interface privateInterfaceWithPrivateModulePropertyTypes {
             myProperty: privateModule.publicClass;
@@ -360,7 +316,7 @@ tests/cases/compiler/privacyVarDeclFile_externalModule.ts(233,72): error TS4025:
         declare var privateAmbientVarWithPrivateModulePropertyTypes: privateModule.publicClass;
     }
     
-==== tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts (21 errors) ====
+==== tests/cases/compiler/privacyVarDeclFile_GlobalFile.ts (10 errors) ====
     class publicClassInGlobal {
     }
     interface publicInterfaceWithPublicPropertyTypesInGlobal {
@@ -391,10 +347,6 @@ tests/cases/compiler/privacyVarDeclFile_externalModule.ts(233,72): error TS4025:
     
             export interface publicInterfaceWithPrivatePropertyTypes {
                 myProperty: privateClass;
-                            ~~~~~~~~~~~~
-!!! error TS4028: Type of property 'myProperty' references inaccessible name 'privateClass'.
-                            ~~~~~~~~~~~~
-!!! error TS4028: Type of property 'myProperty' references inaccessible name 'privateModule'.
             }
     
             export interface publicInterfaceWithPublicPropertyTypes {
@@ -411,12 +363,8 @@ tests/cases/compiler/privacyVarDeclFile_externalModule.ts(233,72): error TS4025:
     
             export class publicClassWithWithPrivatePropertyTypes {
                 static myPublicStaticProperty: privateClass;
-                                               ~~~~~~~~~~~~
-!!! error TS4028: Type of property 'myPublicStaticProperty' references inaccessible name 'privateClass'.
                 private static myPrivateStaticProperty: privateClass;
                 myPublicProperty: privateClass;
-                                  ~~~~~~~~~~~~
-!!! error TS4028: Type of property 'myPublicProperty' references inaccessible name 'privateClass'.
                 private myPrivateProperty: privateClass;
             }
     
@@ -442,38 +390,24 @@ tests/cases/compiler/privacyVarDeclFile_externalModule.ts(233,72): error TS4025:
             }
     
             export var publicVarWithPrivatePropertyTypes: privateClass;
-                                                          ~~~~~~~~~~~~
-!!! error TS4025: Type of variable 'publicVarWithPrivatePropertyTypes' references inaccessible name 'privateClass'.
             export var publicVarWithPublicPropertyTypes: publicClass;
             var privateVarWithPrivatePropertyTypes: privateClass;
             var privateVarWithPublicPropertyTypes: publicClass;
     
             export declare var publicAmbientVarWithPrivatePropertyTypes: privateClass;
-                                                                         ~~~~~~~~~~~~
-!!! error TS4025: Type of variable 'publicAmbientVarWithPrivatePropertyTypes' references inaccessible name 'privateClass'.
             export declare var publicAmbientVarWithPublicPropertyTypes: publicClass;
             declare var privateAmbientVarWithPrivatePropertyTypes: privateClass;
             declare var privateAmbientVarWithPublicPropertyTypes: publicClass;
     
             export interface publicInterfaceWithPrivateModulePropertyTypes {
                 myProperty: privateModule.publicClass;
-                            ~~~~~~~~~~~~~
-!!! error TS4028: Type of property 'myProperty' references inaccessible name 'privateModule'.
             }
             export class publicClassWithPrivateModulePropertyTypes {
                 static myPublicStaticProperty: privateModule.publicClass;
-                                               ~~~~~~~~~~~~~
-!!! error TS4028: Type of property 'myPublicStaticProperty' references inaccessible name 'privateModule'.
                 myPublicProperty: privateModule.publicClass;
-                                  ~~~~~~~~~~~~~
-!!! error TS4028: Type of property 'myPublicProperty' references inaccessible name 'privateModule'.
             }
             export var publicVarWithPrivateModulePropertyTypes: privateModule.publicClass;
-                                                                ~~~~~~~~~~~~~
-!!! error TS4025: Type of variable 'publicVarWithPrivateModulePropertyTypes' references inaccessible name 'privateModule'.
             export declare var publicAmbientVarWithPrivateModulePropertyTypes: privateModule.publicClass;
-                                                                               ~~~~~~~~~~~~~
-!!! error TS4025: Type of variable 'publicAmbientVarWithPrivateModulePropertyTypes' references inaccessible name 'privateModule'.
     
             interface privateInterfaceWithPrivateModulePropertyTypes {
                 myProperty: privateModule.publicClass;

From bd1347d515c046acded788c3738343718dd9b0b5 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Wed, 22 Jul 2015 12:34:16 -0700
Subject: [PATCH 48/57] handel missing nodes in visitNode

---
 src/compiler/declarationEmitter.ts | 21 ++++++++++++---------
 1 file changed, 12 insertions(+), 9 deletions(-)

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index 83d296c79f97b..8724d1825a09b 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -1115,6 +1115,7 @@ namespace ts {
                         return visitExportAssignment(<ExportAssignment>node);
                     case SyntaxKind.ImportDeclaration:
                     case SyntaxKind.ImportClause:
+                    case SyntaxKind.ImportSpecifier:
                         // Nothing to visit, import declarations are only pulled in if referenced
                         return;
 
@@ -1123,6 +1124,7 @@ namespace ts {
                         return visitNodes((<InterfaceDeclaration|ClassDeclaration>node).typeParameters) ||
                             forEach((<InterfaceDeclaration|ClassDeclaration>node).heritageClauses, visitHeritageClause);
 
+                    case SyntaxKind.VariableStatement:
                     case SyntaxKind.ModuleDeclaration:
                     case SyntaxKind.EnumDeclaration:
                     case SyntaxKind.EnumMember:
@@ -1298,12 +1300,12 @@ namespace ts {
                     collectDeclarations(target, errorNode);
                 }
             }
+        }
 
-            function collectDeclarations(symbol: Symbol, errorNode: Node): void {
-                forEach(symbol.declarations, declaration => {
-                    collectDeclatation(declaration, errorNode);
-                });
-            }
+        function collectDeclarations(symbol: Symbol, errorNode: Node): void {
+            forEach(symbol.declarations, declaration => {
+                collectDeclatation(declaration, errorNode);
+            });
         }
 
         function collectDeclatation(declaration:Node, errorNode?: Node) {
@@ -1677,10 +1679,10 @@ namespace ts {
                 // parent's visible declarations.
                 // also make sure the parent is reachable from a top-level
                 // declaration
-                var parent = getEnclosingDeclaration(node);
-                if (parent) {
+                let parent = getEnclosingDeclaration(node);
+                attachVisibleChild(parent, node);
+                if (parent.kind !== SyntaxKind.SourceFile) {
                     ensureDeclarationVisible(parent, errorNode);
-                    attachVisibleChild(parent, node);
                 }
             }
         }
@@ -1708,6 +1710,7 @@ namespace ts {
 
     function forEachExpectedOutputFile(host: EmitHost, targetSourceFile: SourceFile, action: (name: string, sources: SourceFile[]) => void) {
         let compilerOptions = host.getCompilerOptions();
+
         if (targetSourceFile) {
             // If we have a targetSourceFile (e.g calling emitter from language service to getEmitOutput)
             // only emit the outputs of this file
@@ -1733,7 +1736,7 @@ namespace ts {
             // all these files will emit to a single output file specified by compiler options.out
             let outputFilePath = removeFileExtension(compilerOptions.out) + ".d.ts"
             let sourceFiles = filter(host.getSourceFiles(), sourceFile => !isExternalModuleOrDeclarationFile(sourceFile));
-            action(outputFilePath, sourceFiles);;
+            action(outputFilePath, sourceFiles);
         }
     }
 

From 1f0520e098dfe82d27ce78a8fd3f427f28164d8a Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Wed, 22 Jul 2015 12:59:49 -0700
Subject: [PATCH 49/57] Only check if hasExportDeclarations on external modules

---
 src/compiler/declarationEmitter.ts | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index 8724d1825a09b..db437bc37a761 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -1350,14 +1350,14 @@ namespace ts {
                 case SyntaxKind.InterfaceDeclaration:
                 case SyntaxKind.ModuleDeclaration:
                 case SyntaxKind.TypeAliasDeclaration:
-                    if (node.parent.kind === SyntaxKind.SourceFile && !isExternalModule(<SourceFile>node.parent)) {
+                    if (node.flags & NodeFlags.Export) {
                         return true;
                     }
-                    else if ((node.flags & NodeFlags.Export) !== 0) {
+                    else if (node.parent.kind === SyntaxKind.SourceFile && !isExternalModule(<SourceFile>node.parent)) {
                         return true;
                     }
                     else if (node.parent.kind === SyntaxKind.ModuleBlock && isInAmbientContext(node.parent)) {
-                        return !hasExportDeclatations(node.parent);
+                        return !hasExportDeclatations(node.parent.parent);
                     }
                     break;
             }
@@ -1407,7 +1407,16 @@ namespace ts {
             return undefined;
         }
 
+        function isExternalModuleDeclaration(node: Node) {
+            return (node.kind === SyntaxKind.ModuleDeclaration && (<ModuleDeclaration>node).name.kind === SyntaxKind.StringLiteral) ||
+                (node.kind === SyntaxKind.SourceFile && isExternalModule(<SourceFile>node));
+        }
+
         function hasExportDeclatations(node: Node): boolean {
+            if (!isExternalModuleDeclaration(node)) {
+                return false;
+            }
+
             let links = getNodeLinks(node);
             if (typeof links.hasExportDeclarations === "undefined") {
                 let foundExportDeclarations = false;
@@ -1448,8 +1457,7 @@ namespace ts {
                 // assingment, then the scoping rules change, and only declarations
                 // with export modifier are visible, so we can safely write 
                 // a declaration of a non-exported entity without exposing it
-                if (!((parent.kind === SyntaxKind.ModuleDeclaration || parent.kind === SyntaxKind.SourceFile) &&
-                    hasExportDeclatations(parent))) {
+                if (! hasExportDeclatations(parent)) {
                     return false;
                 }
             }

From 859bd12b78c91a6c5f0064e3d6e62607da02904b Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Wed, 22 Jul 2015 16:11:58 -0700
Subject: [PATCH 50/57] Do not create a new typewriter everytime

---
 src/compiler/declarationEmitter.ts | 56 ++++++++++++++++++------------
 1 file changed, 33 insertions(+), 23 deletions(-)

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index db437bc37a761..2fbf79c74ef86 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -18,7 +18,7 @@ namespace ts {
 
     const emptyHandler = () => { };
 
-    function writeDeclarations(outputFileName: string, preprocessResults: PreprocessResults,  host: EmitHost, diagnostics: Diagnostic[]): void {
+    function writeDeclarations(outputFileName: string, preprocessResults: PreprocessResults, host: EmitHost, diagnostics: Diagnostic[]): void {
         let newLine = host.getNewLine();
         let compilerOptions = host.getCompilerOptions();
         let enclosingDeclaration: Node;
@@ -1042,6 +1042,8 @@ namespace ts {
         let nodeLinks: NodeLinks[] = [];
         let declarationsToProcess: { declaration: Node; errorNode?: Node }[] = [];
 
+        let typeWriter = createVoidSymbolWriter(undefined, undefined);
+
         for (let sourceFile of sourceFiles) {
             preprocessSourceFile(sourceFile);
         }
@@ -1067,11 +1069,35 @@ namespace ts {
             return forEach(getLeadingCommentRanges(currentSourceFile.text, node.pos), hasInternalAnnotation)
         }
 
+
+        function createVoidSymbolWriter(trackTypeSymbol: (s: Symbol) => void, trackInaccesibleSymbol: (s: Symbol) => void): SymbolWriter {
+            return {
+                writeLine: emptyHandler,
+                writeKeyword: emptyHandler,
+                writeOperator: emptyHandler,
+                writePunctuation: emptyHandler,
+                writeSpace: emptyHandler,
+                writeStringLiteral: emptyHandler,
+                writeParameter: emptyHandler,
+                writeSymbol: emptyHandler,
+                decreaseIndent: emptyHandler,
+                increaseIndent: emptyHandler,
+                clear: emptyHandler,
+                trackTypeSymbol,
+                trackInaccesibleSymbol
+            };
+        }
+
         function collectReferencedDeclarations(node: Node): void {
             let currentErrorNode: Node;
-            let typeWriter = createVoidSymbolWriter(trackTypeSymbol, trackInaccesibleSymbol);
+            typeWriter.trackInaccesibleSymbol = trackInaccesibleSymbol;
+            typeWriter.trackTypeSymbol = trackTypeSymbol;
+
+            visitNode(node);
 
-            return visitNode(node);
+            typeWriter.trackInaccesibleSymbol = typeWriter.trackTypeSymbol = undefined;
+
+            return;
 
             function trackTypeSymbol(symbol: Symbol) {
                 if (currentErrorNode) {
@@ -1085,24 +1111,6 @@ namespace ts {
                 }
             }
 
-            function createVoidSymbolWriter(trackTypeSymbol: (s: Symbol) => void, trackInaccesibleSymbol: (s: Symbol) => void): SymbolWriter {
-                return {
-                    writeLine: emptyHandler,
-                    writeKeyword: emptyHandler,
-                    writeOperator: emptyHandler,
-                    writePunctuation: emptyHandler,
-                    writeSpace: emptyHandler,
-                    writeStringLiteral: emptyHandler,
-                    writeParameter: emptyHandler,
-                    writeSymbol: emptyHandler,
-                    decreaseIndent: emptyHandler,
-                    increaseIndent: emptyHandler,
-                    clear: emptyHandler,
-                    trackTypeSymbol,
-                    trackInaccesibleSymbol
-                };
-            }
-
             function visitNode(node: Node): void {
                 if (!node) return;
 
@@ -1698,9 +1706,11 @@ namespace ts {
         function attachVisibleChild(node: Node, child: Node): void {
             let links = getNodeLinks(node);
             if (!links.visibleChildren) {
-                links.visibleChildren = [];
+                links.visibleChildren = [child];
+            }
+            else {
+                links.visibleChildren.push(child);
             }
-            links.visibleChildren.push(child);
         }
 
         function preprocessSourceFile(sourceFile: SourceFile): void {

From ce8090acc440d508fbb3cf2a83ac8aa351362031 Mon Sep 17 00:00:00 2001
From: unknown <mhegazy@mhegazy-3.redmond.corp.microsoft.com>
Date: Mon, 27 Jul 2015 11:03:20 -0700
Subject: [PATCH 51/57] remove unused property

---
 src/compiler/declarationEmitter.ts | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index 2fbf79c74ef86..abad204d8cf73 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -1647,7 +1647,7 @@ namespace ts {
 
                 // Make sure this declaration can be emitted, that is it is accessible
                 // and is connected to its parent, or else report a accessibility error
-                ensureDeclarationVisible(declaration, errorNode);
+                ensureDeclarationVisible(declaration);
 
                 // Collect any dependencies
                 collectReferencedDeclarations(declaration);
@@ -1686,7 +1686,7 @@ namespace ts {
             });
         }
 
-        function ensureDeclarationVisible(node: Node, errorNode: Node): void {
+        function ensureDeclarationVisible(node: Node): void {
             let links = getNodeLinks(node);
             if (!links.visited) {
                 links.visited = true;
@@ -1698,7 +1698,7 @@ namespace ts {
                 let parent = getEnclosingDeclaration(node);
                 attachVisibleChild(parent, node);
                 if (parent.kind !== SyntaxKind.SourceFile) {
-                    ensureDeclarationVisible(parent, errorNode);
+                    ensureDeclarationVisible(parent);
                 }
             }
         }

From fd01a64504e3049a99a9b3b682ea36b3f819055b Mon Sep 17 00:00:00 2001
From: unknown <mhegazy@mhegazy-3.redmond.corp.microsoft.com>
Date: Tue, 28 Jul 2015 12:05:35 -0700
Subject: [PATCH 52/57] Support @internal

---
 src/compiler/declarationEmitter.ts | 40 +++++++++---------------------
 1 file changed, 12 insertions(+), 28 deletions(-)

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index abad204d8cf73..63262aacf765f 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -8,6 +8,7 @@ namespace ts {
         collected?: boolean;
         hasExportDeclarations?: boolean;
         errorReported?: boolean;
+        isInternal?: boolean;
     }
 
     interface PreprocessResults {
@@ -118,16 +119,6 @@ namespace ts {
             }
         }
 
-        function hasInternalAnnotation(range: CommentRange) {
-            let text = currentSourceFile.text;
-            let comment = text.substring(range.pos, range.end);
-            return comment.indexOf("@internal") >= 0;
-        }
-
-        function isInternal(node: Node) {
-            return forEach(getLeadingCommentRanges(currentSourceFile.text, node.pos), hasInternalAnnotation)
-        }
-
         function createNewTextWriterWithSymbolWriter(): EmitTextWriter & SymbolWriter {
             let writer = <EmitTextWriter & SymbolWriter>createTextWriter(newLine);
             writer.writeKeyword = writer.write;
@@ -966,10 +957,6 @@ namespace ts {
         }
 
         function emitNode(node: Node) {
-            if (compilerOptions.stripInternal && isInternal(node)) {
-                return;
-            }
-
             switch (node.kind) {
                 case SyntaxKind.FunctionDeclaration:
                     return emitFunctionDeclaration(<FunctionLikeDeclaration>node);
@@ -1059,17 +1046,18 @@ namespace ts {
             return nodeLinks[nodeId] || (nodeLinks[nodeId] = {});
         }
 
-        function hasInternalAnnotation(range: CommentRange) {
-            let text = currentSourceFile.text;
-            let comment = text.substring(range.pos, range.end);
-            return comment.indexOf("@internal") >= 0;
-        }
-
-        function isInternal(node: Node) {
-            return forEach(getLeadingCommentRanges(currentSourceFile.text, node.pos), hasInternalAnnotation)
+        function isInternal(node: Node): boolean {
+            let links = getNodeLinks(node);
+            if (links.isInternal === undefined) {
+                let sourceText = getSourceFileOfNode(node).text;
+                links.isInternal = forEach(getLeadingCommentRanges(sourceText, node.pos), range => {
+                    let comment = sourceText.substring(range.pos, range.end);
+                    return comment.indexOf("@internal") >= 0;
+                });
+            }
+            return links.isInternal;
         }
 
-
         function createVoidSymbolWriter(trackTypeSymbol: (s: Symbol) => void, trackInaccesibleSymbol: (s: Symbol) => void): SymbolWriter {
             return {
                 writeLine: emptyHandler,
@@ -1318,15 +1306,11 @@ namespace ts {
 
         function collectDeclatation(declaration:Node, errorNode?: Node) {
             declarationsToProcess.push({ declaration, errorNode });
-            //preprocessDeclaration(declaration, errorNode);
         }
 
         function isDeclarationExported(node: Node): boolean {
             if (compilerOptions.stripInternal && isInternal(node)) {
-                // TODO: this is the correct place for this check, enable this 
-                // after updating the code to make internal on local declarations instead
-                // of containers
-                //return false;
+                return false;
             }
 
             switch (node.kind) {

From a876104dfd73fd31aa8cf31df31d1f22baaf70b4 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Tue, 28 Jul 2015 13:43:29 -0700
Subject: [PATCH 53/57] make forEachTopLevelDeclaration generic

---
 src/compiler/declarationEmitter.ts | 28 +++++++++-------------------
 1 file changed, 9 insertions(+), 19 deletions(-)

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index 63262aacf765f..4bfdf58780998 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -1314,7 +1314,6 @@ namespace ts {
             }
 
             switch (node.kind) {
-                case SyntaxKind.SourceFile:
                 case SyntaxKind.PropertySignature:
                 case SyntaxKind.PropertyDeclaration:
                 case SyntaxKind.MethodSignature:
@@ -1357,27 +1356,23 @@ namespace ts {
             return false;
         }
 
-        function forEachTopLevelDeclaration(node: Node, action: (node: Node) => void): void {
+        function forEachTopLevelDeclaration<T>(node: Node, action: (node: Node) => T): T {
             switch (node.kind) {
                 case SyntaxKind.SourceFile:
-                    forEach((<SourceFile>node).statements, action);
-                    break;
+                    return forEach((<SourceFile>node).statements, action);
                 case SyntaxKind.InterfaceDeclaration:
                 case SyntaxKind.EnumDeclaration:
                 case SyntaxKind.ClassDeclaration:
-                    forEach((<InterfaceDeclaration|EnumDeclaration|ClassDeclaration>node).members, action);
-                    break;
+                    return forEach((<InterfaceDeclaration|EnumDeclaration|ClassDeclaration>node).members, action);
                 case SyntaxKind.VariableStatement:
-                    forEach((<VariableStatement>node).declarationList.declarations, action);
-                    break;
+                    return forEach((<VariableStatement>node).declarationList.declarations, action);
                 case SyntaxKind.ModuleDeclaration:
                     if ((<ModuleDeclaration>node).body.kind === SyntaxKind.ModuleBlock) {
-                        forEach((<ModuleBlock>(<ModuleDeclaration>node).body).statements, action);
+                        return forEach((<ModuleBlock>(<ModuleDeclaration>node).body).statements, action);
                     }
                     else {
-                        action((<ModuleDeclaration>node).body);
+                        return action((<ModuleDeclaration>node).body);
                     }
-                    break;
             }
         }
 
@@ -1410,15 +1405,10 @@ namespace ts {
             }
 
             let links = getNodeLinks(node);
-            if (typeof links.hasExportDeclarations === "undefined") {
-                let foundExportDeclarations = false;
-                /// TODO: swithc this to return a value if truthy
-                forEachTopLevelDeclaration(node, n => {
-                    if (n.kind === SyntaxKind.ExportAssignment || n.kind === SyntaxKind.ExportDeclaration) {
-                        foundExportDeclarations = true;
-                    }
+            if (links.hasExportDeclarations === undefined) {
+                links.hasExportDeclarations = !!forEachTopLevelDeclaration(node, n => {
+                    return (n.kind === SyntaxKind.ExportAssignment || n.kind === SyntaxKind.ExportDeclaration);
                 });
-                links.hasExportDeclarations = foundExportDeclarations
             }
             return links.hasExportDeclarations;
         }

From ab4259531d5fac3cf9e2fa2e1291bf0ce8f26a1e Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Tue, 28 Jul 2015 14:30:27 -0700
Subject: [PATCH 54/57] Fix #3912: emit declaration for binding elements
 correctelly

---
 src/compiler/declarationEmitter.ts            |  5 +----
 .../paramterDestrcuturingDeclaration.js       | 20 +++++++++++++++++++
 .../paramterDestrcuturingDeclaration.symbols  | 14 +++++++++++++
 .../paramterDestrcuturingDeclaration.types    | 14 +++++++++++++
 .../paramterDestrcuturingDeclaration.ts       |  6 ++++++
 5 files changed, 55 insertions(+), 4 deletions(-)
 create mode 100644 tests/baselines/reference/paramterDestrcuturingDeclaration.js
 create mode 100644 tests/baselines/reference/paramterDestrcuturingDeclaration.symbols
 create mode 100644 tests/baselines/reference/paramterDestrcuturingDeclaration.types
 create mode 100644 tests/cases/compiler/paramterDestrcuturingDeclaration.ts

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index 4bfdf58780998..62b3bf3d27274 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -925,11 +925,8 @@ namespace ts {
                         //      emit    : declare function foo({y: [a, b, c]}: { y: [any, any, any] }) void;
                         writeTextOfNode(currentSourceFile, bindingElement.propertyName);
                         write(": ");
-
-                        // If bindingElement has propertyName property, then its name must be another bindingPattern of SyntaxKind.ObjectBindingPattern
-                        emitBindingPattern(<BindingPattern>bindingElement.name);
                     }
-                    else if (bindingElement.name) {
+                    if (bindingElement.name) {
                         if (isBindingPattern(bindingElement.name)) {
                             // If it is a nested binding pattern, we will recursively descend into each element and emit each one separately.
                             // In the case of rest element, we will omit rest element.
diff --git a/tests/baselines/reference/paramterDestrcuturingDeclaration.js b/tests/baselines/reference/paramterDestrcuturingDeclaration.js
new file mode 100644
index 0000000000000..6920f22b0d404
--- /dev/null
+++ b/tests/baselines/reference/paramterDestrcuturingDeclaration.js
@@ -0,0 +1,20 @@
+//// [paramterDestrcuturingDeclaration.ts]
+
+interface C {
+    ({p: name}): any;
+    new ({p: boolean}): any;
+}
+
+
+//// [paramterDestrcuturingDeclaration.js]
+
+
+//// [paramterDestrcuturingDeclaration.d.ts]
+interface C {
+    ({p: name}: {
+        p: any;
+    }): any;
+    new ({p: boolean}: {
+        p: any;
+    }): any;
+}
diff --git a/tests/baselines/reference/paramterDestrcuturingDeclaration.symbols b/tests/baselines/reference/paramterDestrcuturingDeclaration.symbols
new file mode 100644
index 0000000000000..dd11b302eea31
--- /dev/null
+++ b/tests/baselines/reference/paramterDestrcuturingDeclaration.symbols
@@ -0,0 +1,14 @@
+=== tests/cases/compiler/paramterDestrcuturingDeclaration.ts ===
+
+interface C {
+>C : Symbol(C, Decl(paramterDestrcuturingDeclaration.ts, 0, 0))
+
+    ({p: name}): any;
+>p : Symbol(p)
+>name : Symbol(name, Decl(paramterDestrcuturingDeclaration.ts, 2, 6))
+
+    new ({p: boolean}): any;
+>p : Symbol(p)
+>boolean : Symbol(boolean, Decl(paramterDestrcuturingDeclaration.ts, 3, 10))
+}
+
diff --git a/tests/baselines/reference/paramterDestrcuturingDeclaration.types b/tests/baselines/reference/paramterDestrcuturingDeclaration.types
new file mode 100644
index 0000000000000..4b49ce22035c7
--- /dev/null
+++ b/tests/baselines/reference/paramterDestrcuturingDeclaration.types
@@ -0,0 +1,14 @@
+=== tests/cases/compiler/paramterDestrcuturingDeclaration.ts ===
+
+interface C {
+>C : C
+
+    ({p: name}): any;
+>p : any
+>name : any
+
+    new ({p: boolean}): any;
+>p : any
+>boolean : any
+}
+
diff --git a/tests/cases/compiler/paramterDestrcuturingDeclaration.ts b/tests/cases/compiler/paramterDestrcuturingDeclaration.ts
new file mode 100644
index 0000000000000..d05d6076bf066
--- /dev/null
+++ b/tests/cases/compiler/paramterDestrcuturingDeclaration.ts
@@ -0,0 +1,6 @@
+// @declaration: true
+
+interface C {
+    ({p: name}): any;
+    new ({p: boolean}): any;
+}

From ed2e5d98058562308ebc598edc835dc795ebec62 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Tue, 28 Jul 2015 21:46:22 -0700
Subject: [PATCH 55/57] move getLocalTargetOfAliasDeclaration back to the
 emitter

---
 src/compiler/checker.ts                       | 43 +++----------------
 src/compiler/declarationEmitter.ts            | 15 ++++++-
 src/compiler/types.ts                         |  2 +-
 .../reference/acceptableAlias1.symbols        |  2 +-
 .../amdImportNotAsPrimaryExpression.symbols   |  2 +-
 .../reference/chainedImportAlias.symbols      |  2 +-
 ...mmonJSImportNotAsPrimaryExpression.symbols |  2 +-
 .../declFileForExportedImport.symbols         |  2 +-
 ...lFileImportChainInExportAssignment.symbols |  2 +-
 .../declarationEmit_nameConflicts.symbols     |  2 +-
 .../dependencyViaImportAlias.symbols          |  2 +-
 ...edImportInIndirectExportAssignment.symbols |  2 +-
 ...alModuleReferenceDoubleUnderscore1.symbols |  2 +-
 .../import_reference-exported-alias.symbols   |  4 +-
 .../import_reference-to-type-alias.symbols    |  2 +-
 .../importedAliasesInTypePositions.symbols    |  2 +-
 16 files changed, 35 insertions(+), 53 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 3250e7341e1f9..71d34d00c6a28 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -784,37 +784,6 @@ namespace ts {
             }
         }
 
-
-        // TODO: this needs to be rewriteen
-        function getLocalTargetOfAliasDeclaration(node: Declaration): Symbol {
-            switch (node.kind) {
-                case SyntaxKind.ImportEqualsDeclaration:
-                    //return ((<ImportEqualsDeclaration>node).moduleReference.kind === SyntaxKind.ExternalModuleReference) ? undefined :
-                    //    getSymbolOfPartOfRightHandSideOfImportEquals(, <ImportEqualsDeclaration>node);
-
-                    let entityName = <EntityName>(<ImportEqualsDeclaration>node).moduleReference
-                    if (entityName.kind === SyntaxKind.Identifier && isRightSideOfQualifiedNameOrPropertyAccess(entityName)) {
-                        entityName = <QualifiedName>entityName.parent;
-                    }
-                    // Check for case 1 and 3 in the above example
-                    if (entityName.kind === SyntaxKind.Identifier || entityName.parent.kind === SyntaxKind.QualifiedName) {
-                        return resolveEntityName(entityName, SymbolFlags.Namespace | SymbolFlags.Alias);
-                    }
-                    else {
-                        // Case 2 in above example
-                        // entityName.kind could be a QualifiedName or a Missing identifier
-                        Debug.assert(entityName.parent.kind === SyntaxKind.ImportEqualsDeclaration);
-                        return resolveEntityName(entityName, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace | SymbolFlags.Alias);
-                    }
-
-                case SyntaxKind.ExportSpecifier:
-                    return (<ExportDeclaration>(<ExportSpecifier>node).parent.parent).moduleSpecifier ? undefined :
-                        resolveEntityName((<ExportSpecifier>node).propertyName || (<ExportSpecifier>node).name, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace | SymbolFlags.Alias);
-                case SyntaxKind.ExportAssignment:
-                    return resolveEntityName(<Identifier>(<ExportAssignment>node).expression, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace | SymbolFlags.Alias);
-            }
-        }
-
         function resolveSymbol(symbol: Symbol): Symbol {
             return symbol && symbol.flags & SymbolFlags.Alias && !(symbol.flags & (SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace)) ? resolveAlias(symbol) : symbol;
         }
@@ -877,7 +846,7 @@ namespace ts {
         }
 
         // This function is only for imports with entity names
-        function getSymbolOfPartOfRightHandSideOfImportEquals(entityName: EntityName, importDeclaration?: ImportEqualsDeclaration): Symbol {
+        function getSymbolOfPartOfRightHandSideOfImportEquals(entityName: EntityName, importDeclaration?: ImportEqualsDeclaration, includeAliases?: boolean): Symbol {
             if (!importDeclaration) {
                 importDeclaration = <ImportEqualsDeclaration>getAncestor(entityName, SyntaxKind.ImportEqualsDeclaration);
                 Debug.assert(importDeclaration !== undefined);
@@ -893,13 +862,13 @@ namespace ts {
             }
             // Check for case 1 and 3 in the above example
             if (entityName.kind === SyntaxKind.Identifier || entityName.parent.kind === SyntaxKind.QualifiedName) {
-                return resolveEntityName(entityName, SymbolFlags.Namespace);
+                return resolveEntityName(entityName, SymbolFlags.Namespace | (includeAliases ? SymbolFlags.Alias : SymbolFlags.None));
             }
             else {
-                // Case 2 in above example
+                // Case 2 in above example 
                 // entityName.kind could be a QualifiedName or a Missing identifier
                 Debug.assert(entityName.parent.kind === SyntaxKind.ImportEqualsDeclaration);
-                return resolveEntityName(entityName, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace);
+                return resolveEntityName(entityName, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace | (includeAliases ? SymbolFlags.Alias : SymbolFlags.None));
             }
         }
 
@@ -13581,7 +13550,7 @@ namespace ts {
                 if (isInRightSideOfImportOrExportAssignment(<Identifier>node)) {
                     return node.parent.kind === SyntaxKind.ExportAssignment
                         ? getSymbolOfEntityNameOrPropertyAccessExpression(<Identifier>node)
-                        : getSymbolOfPartOfRightHandSideOfImportEquals(<Identifier>node);
+                        : getSymbolOfPartOfRightHandSideOfImportEquals(<Identifier>node, /*importDeclaration*/ undefined, /*includeAliases*/ true);
                 }
                 else if (node.parent.kind === SyntaxKind.BindingElement &&
                         node.parent.parent.kind === SyntaxKind.ObjectBindingPattern &&
@@ -14087,7 +14056,7 @@ namespace ts {
                 getReferencedValueDeclaration,
                 getTypeReferenceSerializationKind,
                 getSymbolAtLocation,
-                getLocalTargetOfAliasDeclaration,
+                getAliasedSymbol: resolveAlias,
             };
         }
 
diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index 62b3bf3d27274..deab0368448f8 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -1288,11 +1288,24 @@ namespace ts {
             }
 
             function collectAliasDeclaration(node: ImportOrExportSpecifier|ImportEqualsDeclaration|ExportAssignment, errorNode: Node) {
-                let target = resolver.getLocalTargetOfAliasDeclaration(node);
+                let target = getLocalTargetOfAliasDeclaration(node);
                 if (target) {
                     collectDeclarations(target, errorNode);
                 }
             }
+
+            function getLocalTargetOfAliasDeclaration(node: Declaration): Symbol {
+                switch (node.kind) {
+                    case SyntaxKind.ImportEqualsDeclaration:
+                        return resolver.getSymbolAtLocation((<ImportEqualsDeclaration>node).moduleReference);
+                    case SyntaxKind.ExportSpecifier:
+                        let target = (<ExportDeclaration>(<ExportSpecifier>node).parent.parent).moduleSpecifier ? undefined :
+                            resolver.getSymbolAtLocation((<ExportSpecifier>node).propertyName || (<ExportSpecifier>node).name);
+                        return target && resolver.getAliasedSymbol(target);
+                    case SyntaxKind.ExportAssignment:
+                        return resolver.getSymbolAtLocation(<Identifier>(<ExportAssignment>node).expression);
+                }
+            }
         }
 
         function collectDeclarations(symbol: Symbol, errorNode: Node): void {
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index b063faeb61e4e..dc23bbacc3e2b 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -1551,7 +1551,7 @@ namespace ts {
         getReferencedValueDeclaration(reference: Identifier): Declaration;
         getTypeReferenceSerializationKind(node: TypeReferenceNode): TypeReferenceSerializationKind;
         getSymbolAtLocation(node: Node): Symbol;
-        getLocalTargetOfAliasDeclaration(node: Declaration): Symbol;
+        getAliasedSymbol(s: Symbol): Symbol;
     }
 
     export const enum SymbolFlags {
diff --git a/tests/baselines/reference/acceptableAlias1.symbols b/tests/baselines/reference/acceptableAlias1.symbols
index cffbc70290fe8..31679fb6a525b 100644
--- a/tests/baselines/reference/acceptableAlias1.symbols
+++ b/tests/baselines/reference/acceptableAlias1.symbols
@@ -13,5 +13,5 @@ module M {
 import r = M.X;
 >r : Symbol(r, Decl(acceptableAlias1.ts, 4, 1))
 >M : Symbol(M, Decl(acceptableAlias1.ts, 0, 0))
->X : Symbol(r, Decl(acceptableAlias1.ts, 0, 10))
+>X : Symbol(M.X, Decl(acceptableAlias1.ts, 2, 5))
 
diff --git a/tests/baselines/reference/amdImportNotAsPrimaryExpression.symbols b/tests/baselines/reference/amdImportNotAsPrimaryExpression.symbols
index 68a852c6165aa..ab1e7d14bd98f 100644
--- a/tests/baselines/reference/amdImportNotAsPrimaryExpression.symbols
+++ b/tests/baselines/reference/amdImportNotAsPrimaryExpression.symbols
@@ -5,7 +5,7 @@ import foo = require("./foo_0");
 // None of the below should cause a runtime dependency on foo_0
 import f = foo.M1;
 >f : Symbol(f, Decl(foo_1.ts, 0, 32))
->foo : Symbol(foo, Decl(foo_0.ts, 0, 0))
+>foo : Symbol(foo, Decl(foo_1.ts, 0, 0))
 >M1 : Symbol(foo.M1, Decl(foo_0.ts, 8, 1))
 
 var i: f.I2;
diff --git a/tests/baselines/reference/chainedImportAlias.symbols b/tests/baselines/reference/chainedImportAlias.symbols
index 3aebb4502f8f4..d3a589a9d4dee 100644
--- a/tests/baselines/reference/chainedImportAlias.symbols
+++ b/tests/baselines/reference/chainedImportAlias.symbols
@@ -4,7 +4,7 @@ import x = require('chainedImportAlias_file0');
 
 import y = x;
 >y : Symbol(y, Decl(chainedImportAlias_file1.ts, 0, 47))
->x : Symbol(x, Decl(chainedImportAlias_file0.ts, 0, 0))
+>x : Symbol(x, Decl(chainedImportAlias_file1.ts, 0, 0))
 
 y.m.foo();
 >y.m.foo : Symbol(x.m.foo, Decl(chainedImportAlias_file0.ts, 0, 17))
diff --git a/tests/baselines/reference/commonJSImportNotAsPrimaryExpression.symbols b/tests/baselines/reference/commonJSImportNotAsPrimaryExpression.symbols
index 68a852c6165aa..ab1e7d14bd98f 100644
--- a/tests/baselines/reference/commonJSImportNotAsPrimaryExpression.symbols
+++ b/tests/baselines/reference/commonJSImportNotAsPrimaryExpression.symbols
@@ -5,7 +5,7 @@ import foo = require("./foo_0");
 // None of the below should cause a runtime dependency on foo_0
 import f = foo.M1;
 >f : Symbol(f, Decl(foo_1.ts, 0, 32))
->foo : Symbol(foo, Decl(foo_0.ts, 0, 0))
+>foo : Symbol(foo, Decl(foo_1.ts, 0, 0))
 >M1 : Symbol(foo.M1, Decl(foo_0.ts, 8, 1))
 
 var i: f.I2;
diff --git a/tests/baselines/reference/declFileForExportedImport.symbols b/tests/baselines/reference/declFileForExportedImport.symbols
index fb7b7cd343fcd..af0a392813c90 100644
--- a/tests/baselines/reference/declFileForExportedImport.symbols
+++ b/tests/baselines/reference/declFileForExportedImport.symbols
@@ -11,7 +11,7 @@ var y = a.x;
 
 export import b = a;
 >b : Symbol(b, Decl(declFileForExportedImport_1.ts, 2, 12))
->a : Symbol(a, Decl(declFileForExportedImport_0.ts, 0, 0))
+>a : Symbol(a, Decl(declFileForExportedImport_1.ts, 0, 0))
 
 var z = b.x;
 >z : Symbol(z, Decl(declFileForExportedImport_1.ts, 5, 3))
diff --git a/tests/baselines/reference/declFileImportChainInExportAssignment.symbols b/tests/baselines/reference/declFileImportChainInExportAssignment.symbols
index 12e05bed75af1..a47db44a02eed 100644
--- a/tests/baselines/reference/declFileImportChainInExportAssignment.symbols
+++ b/tests/baselines/reference/declFileImportChainInExportAssignment.symbols
@@ -17,7 +17,7 @@ import a = m.c;
 
 import b = a;
 >b : Symbol(b, Decl(declFileImportChainInExportAssignment.ts, 6, 15))
->a : Symbol(a, Decl(declFileImportChainInExportAssignment.ts, 0, 10))
+>a : Symbol(a, Decl(declFileImportChainInExportAssignment.ts, 5, 1))
 
 export = b;
 >b : Symbol(b, Decl(declFileImportChainInExportAssignment.ts, 6, 15))
diff --git a/tests/baselines/reference/declarationEmit_nameConflicts.symbols b/tests/baselines/reference/declarationEmit_nameConflicts.symbols
index a626ed05b1588..68ea054c35539 100644
--- a/tests/baselines/reference/declarationEmit_nameConflicts.symbols
+++ b/tests/baselines/reference/declarationEmit_nameConflicts.symbols
@@ -37,7 +37,7 @@ export module M {
 
     export import d = im;
 >d : Symbol(d, Decl(declarationEmit_nameConflicts_0.ts, 11, 24))
->im : Symbol(d, Decl(declarationEmit_nameConflicts_1.ts, 0, 0))
+>im : Symbol(im, Decl(declarationEmit_nameConflicts_0.ts, 0, 0))
 }
 
 export module M.P {
diff --git a/tests/baselines/reference/dependencyViaImportAlias.symbols b/tests/baselines/reference/dependencyViaImportAlias.symbols
index 8855b8d64518f..04c0a9a1a132d 100644
--- a/tests/baselines/reference/dependencyViaImportAlias.symbols
+++ b/tests/baselines/reference/dependencyViaImportAlias.symbols
@@ -4,7 +4,7 @@ import a = require('A');
 
 import A = a.A;
 >A : Symbol(A, Decl(B.ts, 0, 24))
->a : Symbol(a, Decl(A.ts, 0, 0))
+>a : Symbol(a, Decl(B.ts, 0, 0))
 >A : Symbol(a.A, Decl(A.ts, 0, 0))
 
 export = A;
diff --git a/tests/baselines/reference/es6ImportNamedImportInIndirectExportAssignment.symbols b/tests/baselines/reference/es6ImportNamedImportInIndirectExportAssignment.symbols
index 2598735d6d85d..22420a083417e 100644
--- a/tests/baselines/reference/es6ImportNamedImportInIndirectExportAssignment.symbols
+++ b/tests/baselines/reference/es6ImportNamedImportInIndirectExportAssignment.symbols
@@ -14,7 +14,7 @@ import { a } from "es6ImportNamedImportInIndirectExportAssignment_0";
 
 import x = a;
 >x : Symbol(x, Decl(es6ImportNamedImportInIndirectExportAssignment_1.ts, 0, 69))
->a : Symbol(a, Decl(es6ImportNamedImportInIndirectExportAssignment_0.ts, 0, 0))
+>a : Symbol(a, Decl(es6ImportNamedImportInIndirectExportAssignment_1.ts, 0, 8))
 
 export = x;
 >x : Symbol(x, Decl(es6ImportNamedImportInIndirectExportAssignment_1.ts, 0, 69))
diff --git a/tests/baselines/reference/externalModuleReferenceDoubleUnderscore1.symbols b/tests/baselines/reference/externalModuleReferenceDoubleUnderscore1.symbols
index 02e5e6cfc5a44..d4b995af6b2bb 100644
--- a/tests/baselines/reference/externalModuleReferenceDoubleUnderscore1.symbols
+++ b/tests/baselines/reference/externalModuleReferenceDoubleUnderscore1.symbols
@@ -5,7 +5,7 @@ declare module 'timezonecomplete' {
 
     export import TimeUnit = basics.TimeUnit;
 >TimeUnit : Symbol(TimeUnit, Decl(externalModuleReferenceDoubleUnderscore1.ts, 1, 57))
->basics : Symbol(basics, Decl(externalModuleReferenceDoubleUnderscore1.ts, 3, 1))
+>basics : Symbol(basics, Decl(externalModuleReferenceDoubleUnderscore1.ts, 0, 35))
 >TimeUnit : Symbol(basics.TimeUnit, Decl(externalModuleReferenceDoubleUnderscore1.ts, 5, 44))
 }
 
diff --git a/tests/baselines/reference/import_reference-exported-alias.symbols b/tests/baselines/reference/import_reference-exported-alias.symbols
index 424bb4bc8b4b1..478edb8401279 100644
--- a/tests/baselines/reference/import_reference-exported-alias.symbols
+++ b/tests/baselines/reference/import_reference-exported-alias.symbols
@@ -4,12 +4,12 @@ import appJs = require("file1");
 
 import Services = appJs.Services;
 >Services : Symbol(Services, Decl(file2.ts, 0, 32))
->appJs : Symbol(appJs, Decl(file1.ts, 0, 0))
+>appJs : Symbol(appJs, Decl(file2.ts, 0, 0))
 >Services : Symbol(appJs.Services, Decl(file1.ts, 0, 12))
 
 import UserServices = Services.UserServices;
 >UserServices : Symbol(UserServices, Decl(file2.ts, 1, 33))
->Services : Symbol(appJs.Services, Decl(file1.ts, 0, 12))
+>Services : Symbol(Services, Decl(file2.ts, 0, 32))
 >UserServices : Symbol(Services.UserServices, Decl(file1.ts, 1, 28))
 
 var x = new UserServices().getUserName();
diff --git a/tests/baselines/reference/import_reference-to-type-alias.symbols b/tests/baselines/reference/import_reference-to-type-alias.symbols
index 2fef0714a3ad1..118f34d3dc129 100644
--- a/tests/baselines/reference/import_reference-to-type-alias.symbols
+++ b/tests/baselines/reference/import_reference-to-type-alias.symbols
@@ -4,7 +4,7 @@ import appJs = require("file1");
 
 import Services = appJs.App.Services;
 >Services : Symbol(Services, Decl(file2.ts, 0, 32))
->appJs : Symbol(appJs, Decl(file1.ts, 0, 0))
+>appJs : Symbol(appJs, Decl(file2.ts, 0, 0))
 >App : Symbol(appJs.App, Decl(file1.ts, 0, 0))
 >Services : Symbol(Services, Decl(file1.ts, 0, 19))
 
diff --git a/tests/baselines/reference/importedAliasesInTypePositions.symbols b/tests/baselines/reference/importedAliasesInTypePositions.symbols
index 50a6b582655c3..005487732c847 100644
--- a/tests/baselines/reference/importedAliasesInTypePositions.symbols
+++ b/tests/baselines/reference/importedAliasesInTypePositions.symbols
@@ -4,7 +4,7 @@ import RT_ALIAS = require("file1");
 
 import ReferredTo = RT_ALIAS.elaborate.nested.mod.name.ReferredTo;
 >ReferredTo : Symbol(ReferredTo, Decl(file2.ts, 0, 35))
->RT_ALIAS : Symbol(RT_ALIAS, Decl(file1.ts, 0, 0))
+>RT_ALIAS : Symbol(RT_ALIAS, Decl(file2.ts, 0, 0))
 >elaborate : Symbol(RT_ALIAS.elaborate, Decl(file1.ts, 0, 0))
 >nested : Symbol(RT_ALIAS.elaborate.nested, Decl(file1.ts, 0, 24))
 >mod : Symbol(RT_ALIAS.elaborate.nested.mod, Decl(file1.ts, 0, 31))

From 4ec081c39194a2ff8c1b5fd51354568fe09f7335 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Tue, 28 Jul 2015 22:47:07 -0700
Subject: [PATCH 56/57] rever sourceRoot change to tsconfig.json

---
 src/compiler/tsconfig.json | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/compiler/tsconfig.json b/src/compiler/tsconfig.json
index 81e807b105355..393530bdc663a 100644
--- a/src/compiler/tsconfig.json
+++ b/src/compiler/tsconfig.json
@@ -5,8 +5,7 @@
         "removeComments": true,
         "preserveConstEnums": true,
         "out": "../../built/local/tsc.js",
-        "sourceMap": true,
-        "mapRoot": "file:///C:\\ts\\built\\local"
+        "sourceMap": true
     },
     "files": [
         "core.ts",

From 9ebf18296ff0af30883fd963a10a09160bc5ddd9 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Mon, 21 Sep 2015 15:47:26 -0700
Subject: [PATCH 57/57] handel outFile flag

---
 src/compiler/declarationEmitter.ts | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index 14b9d1c00b22f..a8b16f0b68ed0 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -86,7 +86,7 @@ namespace ts {
                         // we know there is going to be a .d.ts file matching it. Emit that reference
                         shouldEmitRefrence = true;
                     }
-                    else if (compilerOptions.out && !addedGlobalFileReference && isExternalModule(sourceFile)) {
+                    else if ((compilerOptions.out || compilerOptions.outFile) && !addedGlobalFileReference && isExternalModule(sourceFile)) {
                         // This is a reference to a file in the global island, since out is on, all files
                         // in the global island will be merged into one. so keep only one of these references
                         addedGlobalFileReference = true;
@@ -105,7 +105,7 @@ namespace ts {
                     ? referencedFile.fileName // Declaration file, use declaration file name
                     : shouldEmitToOwnFile(referencedFile, compilerOptions)
                         ? getOwnEmitOutputFilePath(referencedFile, host, ".d.ts") // Own output file so get the .d.ts file
-                        : removeFileExtension(compilerOptions.out) + ".d.ts"; // Global out file
+                        : removeFileExtension(compilerOptions.outFile || compilerOptions.out) + ".d.ts"; // Global out file
 
                 declFileName = getRelativePathToDirectoryOrUrl(
                     getDirectoryPath(normalizeSlashes(outputFileName)),
@@ -1740,10 +1740,10 @@ namespace ts {
             }
         }
 
-        if (compilerOptions.out) {
+        if (compilerOptions.outFile || compilerOptions.out) {
             // Emit any files that did not have their own output file
             // all these files will emit to a single output file specified by compiler options.out
-            let outputFilePath = removeFileExtension(compilerOptions.out) + ".d.ts"
+            let outputFilePath = removeFileExtension(compilerOptions.outFile || compilerOptions.out) + ".d.ts"
             let sourceFiles = filter(host.getSourceFiles(), sourceFile => !isExternalModuleOrDeclarationFile(sourceFile));
             action(outputFilePath, sourceFiles);
         }