Merge pull request #7532 from Microsoft/declarationEmitFixes2

Remove members from getAccessibleSymbolChain walk
2025-11-18 17:21:48 +00:00 · 2016-03-17 15:50:27 -07:00
parent 51e8f7dd7a 59f4687cab
commit f0b3ff16e3
1194 changed files with 7253 additions and 6911 deletions
@@ -1444,12 +1444,6 @@ namespace ts {
                            return result;
                        }
                        break;
-                    case SyntaxKind.ClassDeclaration:
-                    case SyntaxKind.InterfaceDeclaration:
-                        if (result = callback(getSymbolOfNode(location).members)) {
-                            return result;
-                        }
-                        break;
                }
            }

@@ -1515,7 +1509,9 @@ namespace ts {
            }

            if (symbol) {
-                return forEachSymbolTableInScope(enclosingDeclaration, getAccessibleSymbolChainFromSymbolTable);
+                if (!(isPropertyOrMethodDeclarationSymbol(symbol))) {
+                    return forEachSymbolTableInScope(enclosingDeclaration, getAccessibleSymbolChainFromSymbolTable);
+                }
            }
        }

@@ -1548,6 +1544,24 @@ namespace ts {
            return qualify;
        }

+        function isPropertyOrMethodDeclarationSymbol(symbol: Symbol) {
+            if (symbol.declarations && symbol.declarations.length) {
+                for (const declaration of symbol.declarations) {
+                    switch (declaration.kind) {
+                        case SyntaxKind.PropertyDeclaration:
+                        case SyntaxKind.MethodDeclaration:
+                        case SyntaxKind.GetAccessor:
+                        case SyntaxKind.SetAccessor:
+                            continue;
+                        default:
+                            return false;
+                    }
+                }
+                return true;
+            }
+            return false;
+        }
+
        function isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessibilityResult {
            if (symbol && enclosingDeclaration && !(symbol.flags & SymbolFlags.TypeParameter)) {
                const initialSymbol = symbol;
@@ -7,28 +7,28 @@ class Ship {
 >Ship : Symbol(Ship, Decl(2dArrays.ts, 1, 1))

    isSunk: boolean;
->isSunk : Symbol(isSunk, Decl(2dArrays.ts, 3, 12))
+>isSunk : Symbol(Ship.isSunk, Decl(2dArrays.ts, 3, 12))
 }

 class Board {
 >Board : Symbol(Board, Decl(2dArrays.ts, 5, 1))

    ships: Ship[];
->ships : Symbol(ships, Decl(2dArrays.ts, 7, 13))
+>ships : Symbol(Board.ships, Decl(2dArrays.ts, 7, 13))
 >Ship : Symbol(Ship, Decl(2dArrays.ts, 1, 1))

    cells: Cell[];
->cells : Symbol(cells, Decl(2dArrays.ts, 8, 18))
+>cells : Symbol(Board.cells, Decl(2dArrays.ts, 8, 18))
 >Cell : Symbol(Cell, Decl(2dArrays.ts, 0, 0))

    private allShipsSunk() {
->allShipsSunk : Symbol(allShipsSunk, Decl(2dArrays.ts, 9, 18))
+>allShipsSunk : Symbol(Board.allShipsSunk, Decl(2dArrays.ts, 9, 18))

        return this.ships.every(function (val) { return val.isSunk; });
 >this.ships.every : Symbol(Array.every, Decl(lib.d.ts, --, --))
->this.ships : Symbol(ships, Decl(2dArrays.ts, 7, 13))
+>this.ships : Symbol(Board.ships, Decl(2dArrays.ts, 7, 13))
 >this : Symbol(Board, Decl(2dArrays.ts, 5, 1))
->ships : Symbol(ships, Decl(2dArrays.ts, 7, 13))
+>ships : Symbol(Board.ships, Decl(2dArrays.ts, 7, 13))
 >every : Symbol(Array.every, Decl(lib.d.ts, --, --))
 >val : Symbol(val, Decl(2dArrays.ts, 12, 42))
 >val.isSunk : Symbol(Ship.isSunk, Decl(2dArrays.ts, 3, 12))
@@ -29,10 +29,10 @@ declare module A {
 >y : Symbol(y, Decl(class.d.ts, 2, 30))

        x: number;
->x : Symbol(x, Decl(class.d.ts, 2, 42))
+>x : Symbol(Point.x, Decl(class.d.ts, 2, 42))

        y: number;
->y : Symbol(y, Decl(class.d.ts, 3, 18))
+>y : Symbol(Point.y, Decl(class.d.ts, 3, 18))
    }
 }

@@ -25,8 +25,8 @@ module A {
 >Point : Symbol(Point, Decl(module.d.ts, 0, 18), Decl(classPoint.ts, 0, 10))

        constructor(public x: number, public y: number) { }
->x : Symbol(x, Decl(classPoint.ts, 2, 20))
->y : Symbol(y, Decl(classPoint.ts, 2, 37))
+>x : Symbol(Point.x, Decl(classPoint.ts, 2, 20))
+>y : Symbol(Point.y, Decl(classPoint.ts, 2, 37))
    }
 }

@@ -3,8 +3,8 @@ class Point {
 >Point : Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 0, 0), Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 4, 1))

    constructor(public x: number, public y: number) { }
->x : Symbol(x, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 1, 16))
->y : Symbol(y, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 1, 33))
+>x : Symbol(Point.x, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 1, 16))
+>y : Symbol(Point.y, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 1, 33))

    static Origin(): Point { return { x: 0, y: 0 }; }
 >Origin : Symbol(Point.Origin, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 1, 55))
@@ -28,8 +28,8 @@ module A {
 >Point : Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 11, 10), Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 16, 5))

        constructor(public x: number, public y: number) { }
->x : Symbol(x, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 13, 20))
->y : Symbol(y, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 13, 37))
+>x : Symbol(Point.x, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 13, 20))
+>y : Symbol(Point.y, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 13, 37))

        static Origin(): Point { return { x: 0, y: 0 }; }
 >Origin : Symbol(Point.Origin, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 13, 59))
@@ -3,8 +3,8 @@ class Point {
 >Point : Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 0, 0), Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 4, 1))

    constructor(public x: number, public y: number) { }
->x : Symbol(x, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 1, 16))
->y : Symbol(y, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 1, 33))
+>x : Symbol(Point.x, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 1, 16))
+>y : Symbol(Point.y, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 1, 33))

    static Origin: Point = { x: 0, y: 0 };
 >Origin : Symbol(Point.Origin, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 1, 55))
@@ -28,8 +28,8 @@ module A {
 >Point : Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 11, 10), Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 16, 5))

        constructor(public x: number, public y: number) { }
->x : Symbol(x, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 13, 20))
->y : Symbol(y, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 13, 37))
+>x : Symbol(Point.x, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 13, 20))
+>y : Symbol(Point.y, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 13, 37))

        static Origin: Point = { x: 0, y: 0 };
 >Origin : Symbol(Point.Origin, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 13, 59))
@@ -3,8 +3,8 @@ class C {
 >C : Symbol(C, Decl(ClassDeclarationWithInvalidConstOnPropertyDeclaration2.ts, 0, 0))

    const
->const : Symbol(const, Decl(ClassDeclarationWithInvalidConstOnPropertyDeclaration2.ts, 0, 9))
+>const : Symbol(C.const, Decl(ClassDeclarationWithInvalidConstOnPropertyDeclaration2.ts, 0, 9))

    x = 10;
->x : Symbol(x, Decl(ClassDeclarationWithInvalidConstOnPropertyDeclaration2.ts, 1, 9))
+>x : Symbol(C.x, Decl(ClassDeclarationWithInvalidConstOnPropertyDeclaration2.ts, 1, 9))
 }
@@ -14,8 +14,8 @@ module enumdule {
 >Point : Symbol(Point, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 4, 17))

        constructor(public x: number, public y: number) { }
->x : Symbol(x, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 7, 20))
->y : Symbol(y, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 7, 37))
+>x : Symbol(Point.x, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 7, 20))
+>y : Symbol(Point.y, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 7, 37))
    }
 }

@@ -6,13 +6,13 @@ module A {
 >Point : Symbol(Point, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 0, 10))

        x: number;
->x : Symbol(x, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 2, 21))
+>x : Symbol(Point.x, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 2, 21))

        y: number;
->y : Symbol(y, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 3, 18))
+>y : Symbol(Point.y, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 3, 18))

        fromOrigin(p: Point): number;
->fromOrigin : Symbol(fromOrigin, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 4, 18))
+>fromOrigin : Symbol(Point.fromOrigin, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 4, 18))
 >p : Symbol(p, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 6, 19))
 >Point : Symbol(Point, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 0, 10))
    }
@@ -22,11 +22,11 @@ module A {
 >Point : Symbol(Point, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 0, 10))

        constructor(public x: number, public y: number) { }
->x : Symbol(x, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 10, 20))
->y : Symbol(y, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 10, 37))
+>x : Symbol(Point2d.x, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 10, 20))
+>y : Symbol(Point2d.y, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 10, 37))

        fromOrigin(p: Point) {
->fromOrigin : Symbol(fromOrigin, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 10, 59))
+>fromOrigin : Symbol(Point2d.fromOrigin, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 10, 59))
 >p : Symbol(p, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 12, 19))
 >Point : Symbol(Point, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 0, 10))

@@ -6,10 +6,10 @@ module A {
 >Point : Symbol(Point, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 0, 10))

        x: number;
->x : Symbol(x, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 2, 24))
+>x : Symbol(Point.x, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 2, 24))

        y: number;
->y : Symbol(y, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 3, 18))
+>y : Symbol(Point.y, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 3, 18))
    }

    export var Origin: Point = { x: 0, y: 0 };
@@ -23,7 +23,7 @@ module A {
 >Point : Symbol(Point, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 0, 10))

        z: number;
->z : Symbol(z, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 9, 40))
+>z : Symbol(Point3d.z, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 9, 40))
    }

    export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
@@ -39,9 +39,9 @@ module A {
 >Point : Symbol(Point, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 0, 10))

        constructor(public start: TPoint, public end: TPoint) { }
->start : Symbol(start, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 16, 20))
+>start : Symbol(Line.start, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 16, 20))
 >TPoint : Symbol(TPoint, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 15, 22))
->end : Symbol(end, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 16, 41))
+>end : Symbol(Line.end, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 16, 41))
 >TPoint : Symbol(TPoint, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 15, 22))
    }
 }
@@ -6,10 +6,10 @@ module A {
 >Point : Symbol(Point, Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts, 0, 10))

        x: number;
->x : Symbol(x, Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts, 2, 17))
+>x : Symbol(Point.x, Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts, 2, 17))

        y: number;
->y : Symbol(y, Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts, 3, 18))
+>y : Symbol(Point.y, Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts, 3, 18))
    }

    export class points {
@@ -6,10 +6,10 @@ module A {
 >Point : Symbol(Point, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 0, 10))

        x: number;
->x : Symbol(x, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 2, 17))
+>x : Symbol(Point.x, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 2, 17))

        y: number;
->y : Symbol(y, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 3, 18))
+>y : Symbol(Point.y, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 3, 18))
    }

    export var Origin: Point = { x: 0, y: 0 };
@@ -23,7 +23,7 @@ module A {
 >Point : Symbol(Point, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 0, 10))

        z: number;
->z : Symbol(z, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 9, 40))
+>z : Symbol(Point3d.z, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 9, 40))
    }

    export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
@@ -39,9 +39,9 @@ module A {
 >Point : Symbol(Point, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 0, 10))

        constructor(public start: TPoint, public end: TPoint) { }
->start : Symbol(start, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 16, 20))
+>start : Symbol(Line.start, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 16, 20))
 >TPoint : Symbol(TPoint, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 15, 22))
->end : Symbol(end, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 16, 41))
+>end : Symbol(Line.end, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 16, 41))
 >TPoint : Symbol(TPoint, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 15, 22))

        static fromorigin2d(p: Point): Line<Point>{
@@ -6,19 +6,19 @@ module A {
 >Point : Symbol(Point, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 0, 10))

        x: number;
->x : Symbol(x, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 2, 24))
+>x : Symbol(Point.x, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 2, 24))

        y: number;
->y : Symbol(y, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 3, 18))
+>y : Symbol(Point.y, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 3, 18))
    }

    export class Line {
 >Line : Symbol(Line, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 5, 5))

        constructor(public start: Point, public end: Point) { }
->start : Symbol(start, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 8, 20))
+>start : Symbol(Line.start, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 8, 20))
 >Point : Symbol(Point, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 0, 10))
->end : Symbol(end, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 8, 40))
+>end : Symbol(Line.end, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 8, 40))
 >Point : Symbol(Point, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 0, 10))
    }

@@ -6,19 +6,19 @@ module A {
 >Point : Symbol(Point, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 0, 10))

        x: number;
->x : Symbol(x, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 2, 17))
+>x : Symbol(Point.x, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 2, 17))

        y: number;
->y : Symbol(y, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 3, 18))
+>y : Symbol(Point.y, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 3, 18))
    }

    export class Line {
 >Line : Symbol(Line, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 5, 5))

        constructor(public start: Point, public end: Point) { }
->start : Symbol(start, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 8, 20))
+>start : Symbol(Line.start, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 8, 20))
 >Point : Symbol(Point, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 0, 10))
->end : Symbol(end, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 8, 40))
+>end : Symbol(Line.end, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 8, 40))
 >Point : Symbol(Point, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 0, 10))
    }

@@ -6,19 +6,19 @@ module A {
 >Point : Symbol(Point, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 0, 10))

        x: number;
->x : Symbol(x, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 2, 24))
+>x : Symbol(Point.x, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 2, 24))

        y: number;
->y : Symbol(y, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 3, 18))
+>y : Symbol(Point.y, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 3, 18))
    }

    class Line {
 >Line : Symbol(Line, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 5, 5))

        constructor(public start: Point, public end: Point) { }
->start : Symbol(start, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 8, 20))
+>start : Symbol(Line.start, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 8, 20))
 >Point : Symbol(Point, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 0, 10))
->end : Symbol(end, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 8, 40))
+>end : Symbol(Line.end, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 8, 40))
 >Point : Symbol(Point, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 0, 10))
    }

@@ -6,10 +6,10 @@ module A {
 >Point : Symbol(Point, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 0, 10))

        x: number;
->x : Symbol(x, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 2, 28))
+>x : Symbol(Point.x, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 2, 28))

        y: number;
->y : Symbol(y, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 3, 18))
+>y : Symbol(Point.y, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 3, 18))
    }

    export var Origin: Point = { x: 0, y: 0 };
@@ -23,7 +23,7 @@ module A {
 >Point : Symbol(Point, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 0, 10))

        z: number;
->z : Symbol(z, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 9, 44))
+>z : Symbol(Point3d.z, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 9, 44))
    }

    export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
@@ -45,11 +45,11 @@ module A {
 >TPoint : Symbol(TPoint, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 15, 26))

        start: TPoint;
->start : Symbol(start, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 16, 41))
+>start : Symbol(Line.start, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 16, 41))
 >TPoint : Symbol(TPoint, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 15, 26))

        end: TPoint;
->end : Symbol(end, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 17, 22))
+>end : Symbol(Line.end, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 17, 22))
 >TPoint : Symbol(TPoint, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 15, 26))
    }
 }
@@ -6,10 +6,10 @@ module A {
 >Point : Symbol(Point, Decl(ExportInterfaceWithInaccessibleTypeInIndexerTypeAnnotations.ts, 0, 10))

        x: number;
->x : Symbol(x, Decl(ExportInterfaceWithInaccessibleTypeInIndexerTypeAnnotations.ts, 2, 21))
+>x : Symbol(Point.x, Decl(ExportInterfaceWithInaccessibleTypeInIndexerTypeAnnotations.ts, 2, 21))

        y: number;
->y : Symbol(y, Decl(ExportInterfaceWithInaccessibleTypeInIndexerTypeAnnotations.ts, 3, 18))
+>y : Symbol(Point.y, Decl(ExportInterfaceWithInaccessibleTypeInIndexerTypeAnnotations.ts, 3, 18))
    }

    export interface points {
@@ -6,10 +6,10 @@ module A {
 >Point : Symbol(Point, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 0, 10))

        x: number;
->x : Symbol(x, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 2, 21))
+>x : Symbol(Point.x, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 2, 21))

        y: number;
->y : Symbol(y, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 3, 18))
+>y : Symbol(Point.y, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 3, 18))
    }

    export var Origin: Point = { x: 0, y: 0 };
@@ -23,7 +23,7 @@ module A {
 >Point : Symbol(Point, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 0, 10))

        z: number;
->z : Symbol(z, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 9, 44))
+>z : Symbol(Point3d.z, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 9, 44))
    }

    export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
@@ -45,11 +45,11 @@ module A {
 >TPoint : Symbol(TPoint, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 15, 26))

        start: TPoint;
->start : Symbol(start, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 16, 41))
+>start : Symbol(Line.start, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 16, 41))
 >TPoint : Symbol(TPoint, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 15, 26))

        end: TPoint;
->end : Symbol(end, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 18, 22))
+>end : Symbol(Line.end, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 18, 22))
 >TPoint : Symbol(TPoint, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 15, 26))
    }
 }
@@ -6,8 +6,8 @@ module A {
 >Point : Symbol(Point, Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts, 0, 10))

        constructor(public x: number, public y: number) { }
->x : Symbol(x, Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts, 3, 20))
->y : Symbol(y, Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts, 3, 37))
+>x : Symbol(Point.x, Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts, 3, 20))
+>y : Symbol(Point.y, Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts, 3, 37))
    }

    export module B {
@@ -6,8 +6,8 @@ module A {
 >Point : Symbol(Point, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 0, 10))

        constructor(public x: number, public y: number) { }
->x : Symbol(x, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 3, 20))
->y : Symbol(y, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 3, 37))
+>x : Symbol(Point.x, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 3, 20))
+>y : Symbol(Point.y, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 3, 37))
    }

    export var Origin: Point = { x: 0, y: 0 };
@@ -6,8 +6,8 @@ module A {
 >Point : Symbol(Point, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts, 0, 10))

        constructor(public x: number, public y: number) { }
->x : Symbol(x, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts, 3, 20))
->y : Symbol(y, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts, 3, 37))
+>x : Symbol(Point.x, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts, 3, 20))
+>y : Symbol(Point.y, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts, 3, 37))
    }

    export var UnitSquare : {
@@ -6,7 +6,7 @@ module A {
 >B : Symbol(B, Decl(ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.ts, 0, 10))

        id: number;
->id : Symbol(id, Decl(ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.ts, 1, 13))
+>id : Symbol(B.id, Decl(ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.ts, 1, 13))
    }

    export var beez: Array<B>;
@@ -6,10 +6,10 @@ module A {
 >Point : Symbol(Point, Decl(ExportVariableWithAccessibleTypeInTypeAnnotation.ts, 0, 10))

        x: number;
->x : Symbol(x, Decl(ExportVariableWithAccessibleTypeInTypeAnnotation.ts, 2, 28))
+>x : Symbol(Point.x, Decl(ExportVariableWithAccessibleTypeInTypeAnnotation.ts, 2, 28))

        y: number;
->y : Symbol(y, Decl(ExportVariableWithAccessibleTypeInTypeAnnotation.ts, 3, 18))
+>y : Symbol(Point.y, Decl(ExportVariableWithAccessibleTypeInTypeAnnotation.ts, 3, 18))
    }

    // valid since Point is exported
@@ -6,10 +6,10 @@ module A {
 >Point : Symbol(Point, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 0, 10))

        x: number;
->x : Symbol(x, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 2, 28))
+>x : Symbol(Point.x, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 2, 28))

        y: number;
->y : Symbol(y, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 3, 18))
+>y : Symbol(Point.y, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 3, 18))
    }

    // valid since Point is exported
@@ -24,7 +24,7 @@ module A {
 >Point : Symbol(Point, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 0, 10))

        z: number;
->z : Symbol(z, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 10, 37))
+>z : Symbol(Point3d.z, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 10, 37))
    }

    // invalid Point3d is not exported
@@ -6,8 +6,8 @@ module enumdule {
 >Point : Symbol(Point, Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts, 0, 17))

        constructor(public x: number, public y: number) { }
->x : Symbol(x, Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts, 3, 20))
->y : Symbol(y, Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts, 3, 37))
+>x : Symbol(Point.x, Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts, 3, 20))
+>y : Symbol(Point.y, Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts, 3, 37))
    }
 }

@@ -3,8 +3,8 @@ interface I {
 >I : Symbol(I, Decl(Protected8.ts, 0, 0))

   protected
->protected : Symbol(protected, Decl(Protected8.ts, 0, 13))
+>protected : Symbol(I.protected, Decl(Protected8.ts, 0, 13))

   p
->p : Symbol(p, Decl(Protected8.ts, 1, 12))
+>p : Symbol(I.p, Decl(Protected8.ts, 1, 12))
 }
@@ -3,5 +3,5 @@ class C {
 >C : Symbol(C, Decl(Protected9.ts, 0, 0))

   constructor(protected p) { }
->p : Symbol(p, Decl(Protected9.ts, 1, 15))
+>p : Symbol(C.p, Decl(Protected9.ts, 1, 15))
 }
@@ -6,10 +6,10 @@ module A {
 >Point : Symbol(Point, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 0, 10))

        x: number;
->x : Symbol(x, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 1, 24))
+>x : Symbol(Point.x, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 1, 24))

        y: number;
->y : Symbol(y, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 2, 18))
+>y : Symbol(Point.y, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 2, 18))
    }
 }

@@ -20,7 +20,7 @@ module A {
 >Point : Symbol(Point, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 7, 10))

        fromCarthesian(p: A.Point) {
->fromCarthesian : Symbol(fromCarthesian, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 8, 17))
+>fromCarthesian : Symbol(Point.fromCarthesian, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 8, 17))
 >p : Symbol(p, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 9, 23))
 >A : Symbol(A, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 0, 0), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 5, 1))
 >Point : Symbol(Point, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 0, 10))
@@ -58,7 +58,7 @@ module X.Y.Z {
 >Line : Symbol(Line, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 19, 14))

        length: number;
->length : Symbol(length, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 20, 23))
+>length : Symbol(Line.length, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 20, 23))
    }
 }

@@ -75,7 +75,7 @@ module X {
 >Line : Symbol(Line, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 27, 25))

                name: string;
->name : Symbol(name, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 28, 24))
+>name : Symbol(Line.name, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 28, 24))
            }
        }
    }
@@ -6,13 +6,13 @@ module A {
 >Point : Symbol(Point, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 0, 10))

        x: number;
->x : Symbol(x, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 1, 28))
+>x : Symbol(Point.x, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 1, 28))

        y: number;
->y : Symbol(y, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 2, 18))
+>y : Symbol(Point.y, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 2, 18))

        toCarth(): Point;
->toCarth : Symbol(toCarth, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 3, 18))
+>toCarth : Symbol(Point.toCarth, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 3, 18))
 >Point : Symbol(Point, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 0, 10))
    }
 }
@@ -24,7 +24,7 @@ module A {
 >Point : Symbol(Point, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 8, 10))

        fromCarth(): Point;
->fromCarth : Symbol(fromCarth, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 9, 21))
+>fromCarth : Symbol(Point.fromCarth, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 9, 21))
 >Point : Symbol(Point, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 8, 10))
    }
 }
@@ -72,12 +72,12 @@ module X {
 >Line : Symbol(Line, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 25, 23))

            start: A.Point;
->start : Symbol(start, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 26, 24))
+>start : Symbol(Line.start, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 26, 24))
 >A : Symbol(A, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 0, 0), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 6, 1))
 >Point : Symbol(A.Point, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 0, 10))

            end: A.Point;
->end : Symbol(end, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 27, 27))
+>end : Symbol(Line.end, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 27, 27))
 >A : Symbol(A, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 0, 0), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 6, 1))
 >Point : Symbol(A.Point, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 0, 10))
        }
@@ -6,10 +6,10 @@ module A {
 >Point : Symbol(Point, Decl(part1.ts, 0, 10))

        x: number;
->x : Symbol(x, Decl(part1.ts, 1, 28))
+>x : Symbol(Point.x, Decl(part1.ts, 1, 28))

        y: number;
->y : Symbol(y, Decl(part1.ts, 2, 18))
+>y : Symbol(Point.y, Decl(part1.ts, 2, 18))
    }

    export module Utils {
@@ -55,9 +55,9 @@ module A {
 >Plane : Symbol(Plane, Decl(part2.ts, 4, 25))

            constructor(public tl: Point, public br: Point) { }
->tl : Symbol(tl, Decl(part2.ts, 6, 24))
+>tl : Symbol(Plane.tl, Decl(part2.ts, 6, 24))
 >Point : Symbol(Point, Decl(part1.ts, 0, 10))
->br : Symbol(br, Decl(part2.ts, 6, 41))
+>br : Symbol(Plane.br, Decl(part2.ts, 6, 41))
 >Point : Symbol(Point, Decl(part1.ts, 0, 10))
        }
    }
@@ -6,13 +6,13 @@ module A {
 >Point : Symbol(Point, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 0, 10), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 8, 10))

        x: number;
->x : Symbol(x, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 1, 28))
+>x : Symbol(Point.x, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 1, 28))

        y: number;
->y : Symbol(y, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 2, 18))
+>y : Symbol(Point.y, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 2, 18))

        toCarth(): Point;
->toCarth : Symbol(toCarth, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 3, 18))
+>toCarth : Symbol(Point.toCarth, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 3, 18))
 >Point : Symbol(Point, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 0, 10), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 8, 10))
    }
 }
@@ -24,7 +24,7 @@ module A {
 >Point : Symbol(Point, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 0, 10), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 8, 10))

        fromCarth(): Point;
->fromCarth : Symbol(fromCarth, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 9, 28))
+>fromCarth : Symbol(Point.fromCarth, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 9, 28))
 >Point : Symbol(Point, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 0, 10), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 8, 10))
    }
 }
@@ -75,12 +75,12 @@ module X {
 >Line : Symbol(Line, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 18, 14), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 25, 23))

            start: A.Point;
->start : Symbol(start, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 26, 31))
+>start : Symbol(Line.start, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 26, 31))
 >A : Symbol(A, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 0, 0), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 6, 1))
 >Point : Symbol(A.Point, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 0, 10), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 8, 10))

            end: A.Point;
->end : Symbol(end, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 27, 27))
+>end : Symbol(Line.end, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 27, 27))
 >A : Symbol(A, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 0, 0), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 6, 1))
 >Point : Symbol(A.Point, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 0, 10), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 8, 10))
        }
@@ -39,7 +39,7 @@ module X.Y.Z {
 >Line : Symbol(Line, Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 14, 14))

        length: number;
->length : Symbol(length, Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 15, 23))
+>length : Symbol(Line.length, Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 15, 23))
    }
 }

@@ -56,7 +56,7 @@ module X {
 >Line : Symbol(Line, Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 22, 18))

                name: string;
->name : Symbol(name, Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 23, 31))
+>name : Symbol(Line.name, Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 23, 31))
            }
        }
    }
@@ -9,10 +9,10 @@ module Root {
 >Point : Symbol(Point, Decl(part1.ts, 1, 21))

            x: number;
->x : Symbol(x, Decl(part1.ts, 2, 32))
+>x : Symbol(Point.x, Decl(part1.ts, 2, 32))

            y: number;
->y : Symbol(y, Decl(part1.ts, 3, 22))
+>y : Symbol(Point.y, Decl(part1.ts, 3, 22))
        }

        export module Utils {
@@ -62,11 +62,11 @@ module otherRoot {
 >Plane : Symbol(Plane, Decl(part2.ts, 5, 29))

                constructor(public tl: Root.A.Point, public br: Root.A.Point) { }
->tl : Symbol(tl, Decl(part2.ts, 7, 28))
+>tl : Symbol(Plane.tl, Decl(part2.ts, 7, 28))
 >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))
->br : Symbol(br, Decl(part2.ts, 7, 52))
+>br : Symbol(Plane.br, Decl(part2.ts, 7, 52))
 >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))
@@ -6,10 +6,10 @@ module A {
 >Point : Symbol(Point, Decl(part1.ts, 0, 10))

        x: number;
->x : Symbol(x, Decl(part1.ts, 1, 28))
+>x : Symbol(Point.x, Decl(part1.ts, 1, 28))

        y: number;
->y : Symbol(y, Decl(part1.ts, 2, 18))
+>y : Symbol(Point.y, Decl(part1.ts, 2, 18))
    }

    export module Utils {
@@ -52,9 +52,9 @@ module A {
 >Plane : Symbol(Plane, Decl(part2.ts, 3, 25))

            constructor(public tl: Point, public br: Point) { }
->tl : Symbol(tl, Decl(part2.ts, 5, 24))
+>tl : Symbol(Plane.tl, Decl(part2.ts, 5, 24))
 >Point : Symbol(Point, Decl(part1.ts, 0, 10))
->br : Symbol(br, Decl(part2.ts, 5, 41))
+>br : Symbol(Plane.br, Decl(part2.ts, 5, 41))
 >Point : Symbol(Point, Decl(part1.ts, 0, 10))
        }
    }
@@ -3,7 +3,7 @@ class Message {
 >Message : Symbol(Message, Decl(TypeGuardWithArrayUnion.ts, 0, 0))

    value: string;
->value : Symbol(value, Decl(TypeGuardWithArrayUnion.ts, 0, 15))
+>value : Symbol(Message.value, Decl(TypeGuardWithArrayUnion.ts, 0, 15))
 }

 function saySize(message: Message | Message[]) {
@@ -4,6 +4,6 @@ interface abstract {
 >abstract : Symbol(abstract, Decl(abstractInterfaceIdentifierName.ts, 0, 0))

    abstract(): void;
->abstract : Symbol(abstract, Decl(abstractInterfaceIdentifierName.ts, 1, 20))
+>abstract : Symbol(abstract.abstract, Decl(abstractInterfaceIdentifierName.ts, 1, 20))
 }

@@ -3,57 +3,57 @@ interface A {
 >A : Symbol(A, Decl(abstractProperty.ts, 0, 0))

    prop: string;
->prop : Symbol(prop, Decl(abstractProperty.ts, 0, 13))
+>prop : Symbol(A.prop, Decl(abstractProperty.ts, 0, 13))

    raw: string;
->raw : Symbol(raw, Decl(abstractProperty.ts, 1, 17))
+>raw : Symbol(A.raw, Decl(abstractProperty.ts, 1, 17))

    m(): void;
->m : Symbol(m, Decl(abstractProperty.ts, 2, 16))
+>m : Symbol(A.m, Decl(abstractProperty.ts, 2, 16))
 }
 abstract class B implements A {
 >B : Symbol(B, Decl(abstractProperty.ts, 4, 1))
 >A : Symbol(A, Decl(abstractProperty.ts, 0, 0))

    abstract prop: string;
->prop : Symbol(prop, Decl(abstractProperty.ts, 5, 31))
+>prop : Symbol(B.prop, Decl(abstractProperty.ts, 5, 31))

    abstract raw: string;
->raw : Symbol(raw, Decl(abstractProperty.ts, 6, 26))
+>raw : Symbol(B.raw, Decl(abstractProperty.ts, 6, 26))

    abstract readonly ro: string;
->ro : Symbol(ro, Decl(abstractProperty.ts, 7, 25))
+>ro : Symbol(B.ro, Decl(abstractProperty.ts, 7, 25))

    abstract get readonlyProp(): string;
->readonlyProp : Symbol(readonlyProp, Decl(abstractProperty.ts, 8, 33), Decl(abstractProperty.ts, 9, 40))
+>readonlyProp : Symbol(B.readonlyProp, Decl(abstractProperty.ts, 8, 33), Decl(abstractProperty.ts, 9, 40))

    abstract set readonlyProp(val: string);
->readonlyProp : Symbol(readonlyProp, Decl(abstractProperty.ts, 8, 33), Decl(abstractProperty.ts, 9, 40))
+>readonlyProp : Symbol(B.readonlyProp, Decl(abstractProperty.ts, 8, 33), Decl(abstractProperty.ts, 9, 40))
 >val : Symbol(val, Decl(abstractProperty.ts, 10, 30))

    abstract m(): void;
->m : Symbol(m, Decl(abstractProperty.ts, 10, 43))
+>m : Symbol(B.m, Decl(abstractProperty.ts, 10, 43))
 }
 class C extends B {
 >C : Symbol(C, Decl(abstractProperty.ts, 12, 1))
 >B : Symbol(B, Decl(abstractProperty.ts, 4, 1))

    get prop() { return "foo"; }
->prop : Symbol(prop, Decl(abstractProperty.ts, 13, 19), Decl(abstractProperty.ts, 14, 32))
+>prop : Symbol(C.prop, Decl(abstractProperty.ts, 13, 19), Decl(abstractProperty.ts, 14, 32))

    set prop(v) { }
->prop : Symbol(prop, Decl(abstractProperty.ts, 13, 19), Decl(abstractProperty.ts, 14, 32))
+>prop : Symbol(C.prop, Decl(abstractProperty.ts, 13, 19), Decl(abstractProperty.ts, 14, 32))
 >v : Symbol(v, Decl(abstractProperty.ts, 15, 13))

    raw = "edge";
->raw : Symbol(raw, Decl(abstractProperty.ts, 15, 19))
+>raw : Symbol(C.raw, Decl(abstractProperty.ts, 15, 19))

    readonly ro = "readonly please";
->ro : Symbol(ro, Decl(abstractProperty.ts, 16, 17))
+>ro : Symbol(C.ro, Decl(abstractProperty.ts, 16, 17))

    readonlyProp: string; // don't have to give a value, in fact
->readonlyProp : Symbol(readonlyProp, Decl(abstractProperty.ts, 17, 36))
+>readonlyProp : Symbol(C.readonlyProp, Decl(abstractProperty.ts, 17, 36))

    m() { }
->m : Symbol(m, Decl(abstractProperty.ts, 18, 25))
+>m : Symbol(C.m, Decl(abstractProperty.ts, 18, 25))
 }
@@ -3,19 +3,19 @@ class Point {
 >Point : Symbol(Point, Decl(accessOverriddenBaseClassMember1.ts, 0, 0))

    constructor(public x: number, public y: number) { }
->x : Symbol(x, Decl(accessOverriddenBaseClassMember1.ts, 1, 16))
->y : Symbol(y, Decl(accessOverriddenBaseClassMember1.ts, 1, 33))
+>x : Symbol(Point.x, Decl(accessOverriddenBaseClassMember1.ts, 1, 16))
+>y : Symbol(Point.y, Decl(accessOverriddenBaseClassMember1.ts, 1, 33))

    public toString() {
->toString : Symbol(toString, Decl(accessOverriddenBaseClassMember1.ts, 1, 55))
+>toString : Symbol(Point.toString, Decl(accessOverriddenBaseClassMember1.ts, 1, 55))

        return "x=" + this.x + " y=" + this.y;
->this.x : Symbol(x, Decl(accessOverriddenBaseClassMember1.ts, 1, 16))
+>this.x : Symbol(Point.x, Decl(accessOverriddenBaseClassMember1.ts, 1, 16))
 >this : Symbol(Point, Decl(accessOverriddenBaseClassMember1.ts, 0, 0))
->x : Symbol(x, Decl(accessOverriddenBaseClassMember1.ts, 1, 16))
->this.y : Symbol(y, Decl(accessOverriddenBaseClassMember1.ts, 1, 33))
+>x : Symbol(Point.x, Decl(accessOverriddenBaseClassMember1.ts, 1, 16))
+>this.y : Symbol(Point.y, Decl(accessOverriddenBaseClassMember1.ts, 1, 33))
 >this : Symbol(Point, Decl(accessOverriddenBaseClassMember1.ts, 0, 0))
->y : Symbol(y, Decl(accessOverriddenBaseClassMember1.ts, 1, 33))
+>y : Symbol(Point.y, Decl(accessOverriddenBaseClassMember1.ts, 1, 33))
    }
 }
 class ColoredPoint extends Point {
@@ -25,7 +25,7 @@ class ColoredPoint extends Point {
    constructor(x: number, y: number, public color: string) {
 >x : Symbol(x, Decl(accessOverriddenBaseClassMember1.ts, 7, 16))
 >y : Symbol(y, Decl(accessOverriddenBaseClassMember1.ts, 7, 26))
->color : Symbol(color, Decl(accessOverriddenBaseClassMember1.ts, 7, 37))
+>color : Symbol(ColoredPoint.color, Decl(accessOverriddenBaseClassMember1.ts, 7, 37))

        super(x, y);
 >super : Symbol(Point, Decl(accessOverriddenBaseClassMember1.ts, 0, 0))
@@ -33,15 +33,15 @@ class ColoredPoint extends Point {
 >y : Symbol(y, Decl(accessOverriddenBaseClassMember1.ts, 7, 26))
    }
    public toString() {
->toString : Symbol(toString, Decl(accessOverriddenBaseClassMember1.ts, 9, 5))
+>toString : Symbol(ColoredPoint.toString, Decl(accessOverriddenBaseClassMember1.ts, 9, 5))

        return super.toString() + " color=" + this.color;
 >super.toString : Symbol(Point.toString, Decl(accessOverriddenBaseClassMember1.ts, 1, 55))
 >super : Symbol(Point, Decl(accessOverriddenBaseClassMember1.ts, 0, 0))
 >toString : Symbol(Point.toString, Decl(accessOverriddenBaseClassMember1.ts, 1, 55))
->this.color : Symbol(color, Decl(accessOverriddenBaseClassMember1.ts, 7, 37))
+>this.color : Symbol(ColoredPoint.color, Decl(accessOverriddenBaseClassMember1.ts, 7, 37))
 >this : Symbol(ColoredPoint, Decl(accessOverriddenBaseClassMember1.ts, 5, 1))
->color : Symbol(color, Decl(accessOverriddenBaseClassMember1.ts, 7, 37))
+>color : Symbol(ColoredPoint.color, Decl(accessOverriddenBaseClassMember1.ts, 7, 37))
    }
 }

@@ -4,7 +4,7 @@ class C {
 >C : Symbol(C, Decl(accessorWithES5.ts, 0, 0))

    get x() {
->x : Symbol(x, Decl(accessorWithES5.ts, 1, 9))
+>x : Symbol(C.x, Decl(accessorWithES5.ts, 1, 9))

        return 1;
    }
@@ -14,7 +14,7 @@ class D {
 >D : Symbol(D, Decl(accessorWithES5.ts, 5, 1))

    set x(v) {
->x : Symbol(x, Decl(accessorWithES5.ts, 7, 9))
+>x : Symbol(D.x, Decl(accessorWithES5.ts, 7, 9))
 >v : Symbol(v, Decl(accessorWithES5.ts, 8, 10))
    }
 }
@@ -6,7 +6,7 @@ class C {
 >C : Symbol(C, Decl(additionOperatorWithAnyAndEveryType.ts, 0, 18))

    public a: string;
->a : Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 1, 9))
+>a : Symbol(C.a, Decl(additionOperatorWithAnyAndEveryType.ts, 1, 9))

    static foo() { }
 >foo : Symbol(C.foo, Decl(additionOperatorWithAnyAndEveryType.ts, 2, 21))
@@ -9,7 +9,7 @@ interface IHasVisualizationModel {
 >IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsage1_main.ts, 1, 50))

    VisualizationModel: typeof Backbone.Model;
->VisualizationModel : Symbol(VisualizationModel, Decl(aliasUsage1_main.ts, 2, 34))
+>VisualizationModel : Symbol(IHasVisualizationModel.VisualizationModel, Decl(aliasUsage1_main.ts, 2, 34))
 >Backbone.Model : Symbol(Backbone.Model, Decl(aliasUsage1_backbone.ts, 0, 0))
 >Backbone : Symbol(Backbone, Decl(aliasUsage1_main.ts, 0, 0))
 >Model : Symbol(Backbone.Model, Decl(aliasUsage1_backbone.ts, 0, 0))
@@ -18,19 +18,19 @@ class C2 {
 >C2 : Symbol(C2, Decl(aliasUsage1_main.ts, 4, 1))

    x: IHasVisualizationModel;
->x : Symbol(x, Decl(aliasUsage1_main.ts, 5, 10))
+>x : Symbol(C2.x, Decl(aliasUsage1_main.ts, 5, 10))
 >IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsage1_main.ts, 1, 50))

    get A() {
->A : Symbol(A, Decl(aliasUsage1_main.ts, 6, 30), Decl(aliasUsage1_main.ts, 9, 5))
+>A : Symbol(C2.A, Decl(aliasUsage1_main.ts, 6, 30), Decl(aliasUsage1_main.ts, 9, 5))

        return this.x;
->this.x : Symbol(x, Decl(aliasUsage1_main.ts, 5, 10))
+>this.x : Symbol(C2.x, Decl(aliasUsage1_main.ts, 5, 10))
 >this : Symbol(C2, Decl(aliasUsage1_main.ts, 4, 1))
->x : Symbol(x, Decl(aliasUsage1_main.ts, 5, 10))
+>x : Symbol(C2.x, Decl(aliasUsage1_main.ts, 5, 10))
    }
    set A(x) {
->A : Symbol(A, Decl(aliasUsage1_main.ts, 6, 30), Decl(aliasUsage1_main.ts, 9, 5))
+>A : Symbol(C2.A, Decl(aliasUsage1_main.ts, 6, 30), Decl(aliasUsage1_main.ts, 9, 5))
 >x : Symbol(x, Decl(aliasUsage1_main.ts, 10, 10))

        x = moduleA;
@@ -43,7 +43,7 @@ export class Model {
 >Model : Symbol(Model, Decl(aliasUsage1_backbone.ts, 0, 0))

    public someData: string;
->someData : Symbol(someData, Decl(aliasUsage1_backbone.ts, 0, 20))
+>someData : Symbol(Model.someData, Decl(aliasUsage1_backbone.ts, 0, 20))
 }

 === tests/cases/compiler/aliasUsage1_moduleA.ts ===
@@ -9,7 +9,7 @@ interface IHasVisualizationModel {
 >IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInArray_main.ts, 1, 56))

    VisualizationModel: typeof Backbone.Model;
->VisualizationModel : Symbol(VisualizationModel, Decl(aliasUsageInArray_main.ts, 2, 34))
+>VisualizationModel : Symbol(IHasVisualizationModel.VisualizationModel, Decl(aliasUsageInArray_main.ts, 2, 34))
 >Backbone.Model : Symbol(Backbone.Model, Decl(aliasUsageInArray_backbone.ts, 0, 0))
 >Backbone : Symbol(Backbone, Decl(aliasUsageInArray_main.ts, 0, 0))
 >Model : Symbol(Backbone.Model, Decl(aliasUsageInArray_backbone.ts, 0, 0))
@@ -30,7 +30,7 @@ export class Model {
 >Model : Symbol(Model, Decl(aliasUsageInArray_backbone.ts, 0, 0))

    public someData: string;
->someData : Symbol(someData, Decl(aliasUsageInArray_backbone.ts, 0, 20))
+>someData : Symbol(Model.someData, Decl(aliasUsageInArray_backbone.ts, 0, 20))
 }

 === tests/cases/compiler/aliasUsageInArray_moduleA.ts ===
@@ -9,7 +9,7 @@ interface IHasVisualizationModel {
 >IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInFunctionExpression_main.ts, 1, 69))

    VisualizationModel: typeof Backbone.Model;
->VisualizationModel : Symbol(VisualizationModel, Decl(aliasUsageInFunctionExpression_main.ts, 2, 34))
+>VisualizationModel : Symbol(IHasVisualizationModel.VisualizationModel, Decl(aliasUsageInFunctionExpression_main.ts, 2, 34))
 >Backbone.Model : Symbol(Backbone.Model, Decl(aliasUsageInFunctionExpression_backbone.ts, 0, 0))
 >Backbone : Symbol(Backbone, Decl(aliasUsageInFunctionExpression_main.ts, 0, 0))
 >Model : Symbol(Backbone.Model, Decl(aliasUsageInFunctionExpression_backbone.ts, 0, 0))
@@ -30,7 +30,7 @@ export class Model {
 >Model : Symbol(Model, Decl(aliasUsageInFunctionExpression_backbone.ts, 0, 0))

    public someData: string;
->someData : Symbol(someData, Decl(aliasUsageInFunctionExpression_backbone.ts, 0, 20))
+>someData : Symbol(Model.someData, Decl(aliasUsageInFunctionExpression_backbone.ts, 0, 20))
 }

 === tests/cases/compiler/aliasUsageInFunctionExpression_moduleA.ts ===
@@ -9,7 +9,7 @@ interface IHasVisualizationModel {
 >IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInGenericFunction_main.ts, 1, 66))

    VisualizationModel: typeof Backbone.Model;
->VisualizationModel : Symbol(VisualizationModel, Decl(aliasUsageInGenericFunction_main.ts, 2, 34))
+>VisualizationModel : Symbol(IHasVisualizationModel.VisualizationModel, Decl(aliasUsageInGenericFunction_main.ts, 2, 34))
 >Backbone.Model : Symbol(Backbone.Model, Decl(aliasUsageInGenericFunction_backbone.ts, 0, 0))
 >Backbone : Symbol(Backbone, Decl(aliasUsageInGenericFunction_main.ts, 0, 0))
 >Model : Symbol(Backbone.Model, Decl(aliasUsageInGenericFunction_backbone.ts, 0, 0))
@@ -42,7 +42,7 @@ export class Model {
 >Model : Symbol(Model, Decl(aliasUsageInGenericFunction_backbone.ts, 0, 0))

    public someData: string;
->someData : Symbol(someData, Decl(aliasUsageInGenericFunction_backbone.ts, 0, 20))
+>someData : Symbol(Model.someData, Decl(aliasUsageInGenericFunction_backbone.ts, 0, 20))
 }

 === tests/cases/compiler/aliasUsageInGenericFunction_moduleA.ts ===
@@ -9,7 +9,7 @@ interface IHasVisualizationModel {
 >IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInIndexerOfClass_main.ts, 1, 65))

    VisualizationModel: typeof Backbone.Model;
->VisualizationModel : Symbol(VisualizationModel, Decl(aliasUsageInIndexerOfClass_main.ts, 2, 34))
+>VisualizationModel : Symbol(IHasVisualizationModel.VisualizationModel, Decl(aliasUsageInIndexerOfClass_main.ts, 2, 34))
 >Backbone.Model : Symbol(Backbone.Model, Decl(aliasUsageInIndexerOfClass_backbone.ts, 0, 0))
 >Backbone : Symbol(Backbone, Decl(aliasUsageInIndexerOfClass_main.ts, 0, 0))
 >Model : Symbol(Backbone.Model, Decl(aliasUsageInIndexerOfClass_backbone.ts, 0, 0))
@@ -22,7 +22,7 @@ class N {
 >IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInIndexerOfClass_main.ts, 1, 65))

    x = moduleA;
->x : Symbol(x, Decl(aliasUsageInIndexerOfClass_main.ts, 6, 41))
+>x : Symbol(N.x, Decl(aliasUsageInIndexerOfClass_main.ts, 6, 41))
 >moduleA : Symbol(moduleA, Decl(aliasUsageInIndexerOfClass_main.ts, 0, 67))
 }
 class N2 {
@@ -33,7 +33,7 @@ class N2 {
 >moduleA : Symbol(moduleA, Decl(aliasUsageInIndexerOfClass_main.ts, 0, 67))

    x: IHasVisualizationModel;
->x : Symbol(x, Decl(aliasUsageInIndexerOfClass_main.ts, 10, 33))
+>x : Symbol(N2.x, Decl(aliasUsageInIndexerOfClass_main.ts, 10, 33))
 >IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInIndexerOfClass_main.ts, 1, 65))
 }
 === tests/cases/compiler/aliasUsageInIndexerOfClass_backbone.ts ===
@@ -41,7 +41,7 @@ export class Model {
 >Model : Symbol(Model, Decl(aliasUsageInIndexerOfClass_backbone.ts, 0, 0))

    public someData: string;
->someData : Symbol(someData, Decl(aliasUsageInIndexerOfClass_backbone.ts, 0, 20))
+>someData : Symbol(Model.someData, Decl(aliasUsageInIndexerOfClass_backbone.ts, 0, 20))
 }

 === tests/cases/compiler/aliasUsageInIndexerOfClass_moduleA.ts ===
@@ -9,7 +9,7 @@ interface IHasVisualizationModel {
 >IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInObjectLiteral_main.ts, 1, 64))

    VisualizationModel: typeof Backbone.Model;
->VisualizationModel : Symbol(VisualizationModel, Decl(aliasUsageInObjectLiteral_main.ts, 2, 34))
+>VisualizationModel : Symbol(IHasVisualizationModel.VisualizationModel, Decl(aliasUsageInObjectLiteral_main.ts, 2, 34))
 >Backbone.Model : Symbol(Backbone.Model, Decl(aliasUsageInObjectLiteral_backbone.ts, 0, 0))
 >Backbone : Symbol(Backbone, Decl(aliasUsageInObjectLiteral_main.ts, 0, 0))
 >Model : Symbol(Backbone.Model, Decl(aliasUsageInObjectLiteral_backbone.ts, 0, 0))
@@ -42,7 +42,7 @@ export class Model {
 >Model : Symbol(Model, Decl(aliasUsageInObjectLiteral_backbone.ts, 0, 0))

    public someData: string;
->someData : Symbol(someData, Decl(aliasUsageInObjectLiteral_backbone.ts, 0, 20))
+>someData : Symbol(Model.someData, Decl(aliasUsageInObjectLiteral_backbone.ts, 0, 20))
 }

 === tests/cases/compiler/aliasUsageInObjectLiteral_moduleA.ts ===
@@ -9,7 +9,7 @@ interface IHasVisualizationModel {
 >IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInOrExpression_main.ts, 1, 63))

    VisualizationModel: typeof Backbone.Model;
->VisualizationModel : Symbol(VisualizationModel, Decl(aliasUsageInOrExpression_main.ts, 2, 34))
+>VisualizationModel : Symbol(IHasVisualizationModel.VisualizationModel, Decl(aliasUsageInOrExpression_main.ts, 2, 34))
 >Backbone.Model : Symbol(Backbone.Model, Decl(aliasUsageInOrExpression_backbone.ts, 0, 0))
 >Backbone : Symbol(Backbone, Decl(aliasUsageInOrExpression_main.ts, 0, 0))
 >Model : Symbol(Backbone.Model, Decl(aliasUsageInOrExpression_backbone.ts, 0, 0))
@@ -58,7 +58,7 @@ export class Model {
 >Model : Symbol(Model, Decl(aliasUsageInOrExpression_backbone.ts, 0, 0))

    public someData: string;
->someData : Symbol(someData, Decl(aliasUsageInOrExpression_backbone.ts, 0, 20))
+>someData : Symbol(Model.someData, Decl(aliasUsageInOrExpression_backbone.ts, 0, 20))
 }

 === tests/cases/compiler/aliasUsageInOrExpression_moduleA.ts ===
@@ -9,7 +9,7 @@ interface IHasVisualizationModel {
 >IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts, 1, 78))

    VisualizationModel: typeof Backbone.Model;
->VisualizationModel : Symbol(VisualizationModel, Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts, 2, 34))
+>VisualizationModel : Symbol(IHasVisualizationModel.VisualizationModel, Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts, 2, 34))
 >Backbone.Model : Symbol(Backbone.Model, Decl(aliasUsageInTypeArgumentOfExtendsClause_backbone.ts, 0, 0))
 >Backbone : Symbol(Backbone, Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts, 0, 0))
 >Model : Symbol(Backbone.Model, Decl(aliasUsageInTypeArgumentOfExtendsClause_backbone.ts, 0, 0))
@@ -20,7 +20,7 @@ class C<T extends IHasVisualizationModel> {
 >IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts, 1, 78))

    x: T;
->x : Symbol(x, Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts, 5, 43))
+>x : Symbol(C.x, Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts, 5, 43))
 >T : Symbol(T, Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts, 5, 8))
 }
 class D extends C<IHasVisualizationModel> {
@@ -29,7 +29,7 @@ class D extends C<IHasVisualizationModel> {
 >IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts, 1, 78))

    x = moduleA;
->x : Symbol(x, Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts, 8, 43))
+>x : Symbol(D.x, Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts, 8, 43))
 >moduleA : Symbol(moduleA, Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts, 0, 80))
 }
 === tests/cases/compiler/aliasUsageInTypeArgumentOfExtendsClause_backbone.ts ===
@@ -37,7 +37,7 @@ export class Model {
 >Model : Symbol(Model, Decl(aliasUsageInTypeArgumentOfExtendsClause_backbone.ts, 0, 0))

    public someData: string;
->someData : Symbol(someData, Decl(aliasUsageInTypeArgumentOfExtendsClause_backbone.ts, 0, 20))
+>someData : Symbol(Model.someData, Decl(aliasUsageInTypeArgumentOfExtendsClause_backbone.ts, 0, 20))
 }

 === tests/cases/compiler/aliasUsageInTypeArgumentOfExtendsClause_moduleA.ts ===
@@ -9,7 +9,7 @@ interface IHasVisualizationModel {
 >IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInVarAssignment_main.ts, 1, 64))

    VisualizationModel: typeof Backbone.Model;
->VisualizationModel : Symbol(VisualizationModel, Decl(aliasUsageInVarAssignment_main.ts, 2, 34))
+>VisualizationModel : Symbol(IHasVisualizationModel.VisualizationModel, Decl(aliasUsageInVarAssignment_main.ts, 2, 34))
 >Backbone.Model : Symbol(Backbone.Model, Decl(aliasUsageInVarAssignment_backbone.ts, 0, 0))
 >Backbone : Symbol(Backbone, Decl(aliasUsageInVarAssignment_main.ts, 0, 0))
 >Model : Symbol(Backbone.Model, Decl(aliasUsageInVarAssignment_backbone.ts, 0, 0))
@@ -28,7 +28,7 @@ export class Model {
 >Model : Symbol(Model, Decl(aliasUsageInVarAssignment_backbone.ts, 0, 0))

    public someData: string;
->someData : Symbol(someData, Decl(aliasUsageInVarAssignment_backbone.ts, 0, 20))
+>someData : Symbol(Model.someData, Decl(aliasUsageInVarAssignment_backbone.ts, 0, 20))
 }

 === tests/cases/compiler/aliasUsageInVarAssignment_moduleA.ts ===
@@ -13,6 +13,6 @@ export class Foo {
 >Foo : Symbol(Foo, Decl(b.ts, 0, 0))

 	member: string;
->member : Symbol(member, Decl(b.ts, 0, 18))
+>member : Symbol(Foo.member, Decl(b.ts, 0, 18))
 }

@@ -13,5 +13,5 @@ export class Foo {
 >Foo : Symbol(Foo, Decl(b.ts, 0, 0))

 	member: string;
->member : Symbol(member, Decl(b.ts, 0, 18))
+>member : Symbol(Foo.member, Decl(b.ts, 0, 18))
 }
@@ -3,7 +3,7 @@ declare class Foo {
 >Foo : Symbol(Foo, Decl(b.d.ts, 0, 0))

 	member: string;
->member : Symbol(member, Decl(b.d.ts, 0, 19))
+>member : Symbol(Foo.member, Decl(b.d.ts, 0, 19))
 }
 export = Foo;
 >Foo : Symbol(Foo, Decl(b.d.ts, 0, 0))
@@ -3,7 +3,7 @@ declare class Foo {
 >Foo : Symbol(Foo, Decl(b.d.ts, 0, 0))

 	member: string;
->member : Symbol(member, Decl(b.d.ts, 0, 19))
+>member : Symbol(Foo.member, Decl(b.d.ts, 0, 19))
 }
 export = Foo;
 >Foo : Symbol(Foo, Decl(b.d.ts, 0, 0))
@@ -10,7 +10,7 @@ declare class C {
 >C : Symbol(C, Decl(ambientClassDeclarationExtends_singleFile.ts, 1, 29))

    public foo;
->foo : Symbol(foo, Decl(ambientClassDeclarationExtends_singleFile.ts, 3, 17))
+>foo : Symbol(C.foo, Decl(ambientClassDeclarationExtends_singleFile.ts, 3, 17))
 }
 namespace D { var x; }
 >D : Symbol(D, Decl(ambientClassDeclarationExtends_singleFile.ts, 5, 1), Decl(ambientClassDeclarationExtends_singleFile.ts, 6, 22))
@@ -31,7 +31,7 @@ declare class E {
 >E : Symbol(E, Decl(ambientClassDeclarationExtends_file1.ts, 0, 0))

    public bar;
->bar : Symbol(bar, Decl(ambientClassDeclarationExtends_file1.ts, 1, 17))
+>bar : Symbol(E.bar, Decl(ambientClassDeclarationExtends_file1.ts, 1, 17))
 }
 namespace F { var y; }
 >F : Symbol(F, Decl(ambientClassDeclarationExtends_file1.ts, 3, 1), Decl(ambientClassDeclarationExtends_file2.ts, 0, 0))
@@ -3,20 +3,20 @@ declare class C {
 >C : Symbol(C, Decl(ambientClassMergesOverloadsWithInterface.ts, 0, 0), Decl(ambientClassMergesOverloadsWithInterface.ts, 3, 1))

    baz(): any;
->baz : Symbol(baz, Decl(ambientClassMergesOverloadsWithInterface.ts, 0, 17))
+>baz : Symbol(C.baz, Decl(ambientClassMergesOverloadsWithInterface.ts, 0, 17))

    foo(n: number): any;
->foo : Symbol(foo, Decl(ambientClassMergesOverloadsWithInterface.ts, 1, 15), Decl(ambientClassMergesOverloadsWithInterface.ts, 4, 13))
+>foo : Symbol(C.foo, Decl(ambientClassMergesOverloadsWithInterface.ts, 1, 15), Decl(ambientClassMergesOverloadsWithInterface.ts, 4, 13))
 >n : Symbol(n, Decl(ambientClassMergesOverloadsWithInterface.ts, 2, 8))
 }
 interface C {
 >C : Symbol(C, Decl(ambientClassMergesOverloadsWithInterface.ts, 0, 0), Decl(ambientClassMergesOverloadsWithInterface.ts, 3, 1))

    foo(n: number): any;
->foo : Symbol(foo, Decl(ambientClassMergesOverloadsWithInterface.ts, 1, 15), Decl(ambientClassMergesOverloadsWithInterface.ts, 4, 13))
+>foo : Symbol(C.foo, Decl(ambientClassMergesOverloadsWithInterface.ts, 1, 15), Decl(ambientClassMergesOverloadsWithInterface.ts, 4, 13))
 >n : Symbol(n, Decl(ambientClassMergesOverloadsWithInterface.ts, 5, 8))

    bar(): any;
->bar : Symbol(bar, Decl(ambientClassMergesOverloadsWithInterface.ts, 5, 24))
+>bar : Symbol(C.bar, Decl(ambientClassMergesOverloadsWithInterface.ts, 5, 24))
 }

@@ -63,7 +63,7 @@ declare class cls {

    constructor();
    method(): cls;
->method : Symbol(method, Decl(ambientDeclarations.ts, 26, 18))
+>method : Symbol(cls.method, Decl(ambientDeclarations.ts, 26, 18))
 >cls : Symbol(cls, Decl(ambientDeclarations.ts, 22, 36))

    static static(p): number;
@@ -74,7 +74,7 @@ declare class cls {
 >q : Symbol(cls.q, Decl(ambientDeclarations.ts, 28, 29))

    private fn();
->fn : Symbol(fn, Decl(ambientDeclarations.ts, 29, 13))
+>fn : Symbol(cls.fn, Decl(ambientDeclarations.ts, 29, 13))

    private static fns();
 >fns : Symbol(cls.fns, Decl(ambientDeclarations.ts, 30, 17))
@@ -19,7 +19,7 @@ declare module 'M' {
 >C : Symbol(C, Decl(ambientExternalModuleWithInternalImportDeclaration_0.ts, 0, 20), Decl(ambientExternalModuleWithInternalImportDeclaration_0.ts, 3, 5))

        foo(): void;
->foo : Symbol(foo, Decl(ambientExternalModuleWithInternalImportDeclaration_0.ts, 4, 13))
+>foo : Symbol(C.foo, Decl(ambientExternalModuleWithInternalImportDeclaration_0.ts, 4, 13))
    }
    import X = C;
 >X : Symbol(X, Decl(ambientExternalModuleWithInternalImportDeclaration_0.ts, 6, 5))
@@ -19,7 +19,7 @@ declare module 'M' {
 >C : Symbol(C, Decl(ambientExternalModuleWithoutInternalImportDeclaration_0.ts, 0, 20), Decl(ambientExternalModuleWithoutInternalImportDeclaration_0.ts, 3, 5))

        foo(): void;
->foo : Symbol(foo, Decl(ambientExternalModuleWithoutInternalImportDeclaration_0.ts, 4, 13))
+>foo : Symbol(C.foo, Decl(ambientExternalModuleWithoutInternalImportDeclaration_0.ts, 4, 13))
    }
    export = C;
 >C : Symbol(C, Decl(ambientExternalModuleWithoutInternalImportDeclaration_0.ts, 0, 20), Decl(ambientExternalModuleWithoutInternalImportDeclaration_0.ts, 3, 5))
@@ -3,35 +3,35 @@ class TestClass {
 >TestClass : Symbol(TestClass, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 0, 0))

    public bar(x: string): void;
->bar : Symbol(bar, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 0, 17), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 1, 32), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 2, 34))
+>bar : Symbol(TestClass.bar, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 0, 17), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 1, 32), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 2, 34))
 >x : Symbol(x, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 1, 15))

    public bar(x: string[]): void;
->bar : Symbol(bar, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 0, 17), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 1, 32), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 2, 34))
+>bar : Symbol(TestClass.bar, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 0, 17), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 1, 32), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 2, 34))
 >x : Symbol(x, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 2, 15))

    public bar(x: any): void {
->bar : Symbol(bar, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 0, 17), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 1, 32), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 2, 34))
+>bar : Symbol(TestClass.bar, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 0, 17), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 1, 32), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 2, 34))
 >x : Symbol(x, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 3, 15))
        
    }
 
    public foo(x: string): void;
->foo : Symbol(foo, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 5, 5), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 7, 32), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 8, 34))
+>foo : Symbol(TestClass.foo, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 5, 5), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 7, 32), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 8, 34))
 >x : Symbol(x, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 7, 15))

    public foo(x: string[]): void;
->foo : Symbol(foo, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 5, 5), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 7, 32), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 8, 34))
+>foo : Symbol(TestClass.foo, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 5, 5), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 7, 32), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 8, 34))
 >x : Symbol(x, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 8, 15))

    public foo(x: any): void {
->foo : Symbol(foo, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 5, 5), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 7, 32), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 8, 34))
+>foo : Symbol(TestClass.foo, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 5, 5), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 7, 32), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 8, 34))
 >x : Symbol(x, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 9, 15))

        this.bar(x); // should not error
->this.bar : Symbol(bar, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 0, 17), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 1, 32), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 2, 34))
+>this.bar : Symbol(TestClass.bar, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 0, 17), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 1, 32), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 2, 34))
 >this : Symbol(TestClass, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 0, 0))
->bar : Symbol(bar, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 0, 17), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 1, 32), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 2, 34))
+>bar : Symbol(TestClass.bar, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 0, 17), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 1, 32), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 2, 34))
 >x : Symbol(x, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 9, 15))
    }
 }
@@ -40,36 +40,36 @@ class TestClass2 {
 >TestClass2 : Symbol(TestClass2, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 12, 1))

    public bar(x: string): number;
->bar : Symbol(bar, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 14, 18), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 15, 34), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 16, 36))
+>bar : Symbol(TestClass2.bar, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 14, 18), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 15, 34), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 16, 36))
 >x : Symbol(x, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 15, 15))

    public bar(x: string[]): number;
->bar : Symbol(bar, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 14, 18), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 15, 34), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 16, 36))
+>bar : Symbol(TestClass2.bar, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 14, 18), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 15, 34), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 16, 36))
 >x : Symbol(x, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 16, 15))

    public bar(x: any): number {
->bar : Symbol(bar, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 14, 18), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 15, 34), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 16, 36))
+>bar : Symbol(TestClass2.bar, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 14, 18), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 15, 34), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 16, 36))
 >x : Symbol(x, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 17, 15))

        return 0;
    }
 
    public foo(x: string): number;
->foo : Symbol(foo, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 19, 5), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 21, 34), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 22, 36))
+>foo : Symbol(TestClass2.foo, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 19, 5), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 21, 34), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 22, 36))
 >x : Symbol(x, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 21, 15))

    public foo(x: string[]): number;
->foo : Symbol(foo, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 19, 5), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 21, 34), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 22, 36))
+>foo : Symbol(TestClass2.foo, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 19, 5), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 21, 34), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 22, 36))
 >x : Symbol(x, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 22, 15))

    public foo(x: any): number {
->foo : Symbol(foo, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 19, 5), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 21, 34), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 22, 36))
+>foo : Symbol(TestClass2.foo, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 19, 5), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 21, 34), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 22, 36))
 >x : Symbol(x, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 23, 15))

        return this.bar(x); // should not error
->this.bar : Symbol(bar, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 14, 18), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 15, 34), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 16, 36))
+>this.bar : Symbol(TestClass2.bar, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 14, 18), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 15, 34), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 16, 36))
 >this : Symbol(TestClass2, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 12, 1))
->bar : Symbol(bar, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 14, 18), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 15, 34), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 16, 36))
+>bar : Symbol(TestClass2.bar, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 14, 18), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 15, 34), Decl(ambiguousCallsWhereReturnTypesAgree.ts, 16, 36))
 >x : Symbol(x, Decl(ambiguousCallsWhereReturnTypesAgree.ts, 23, 15))
    }
 }
@@ -5,7 +5,7 @@ class A { }
 class B extends A { x: number; }
 >B : Symbol(B, Decl(ambiguousOverloadResolution.ts, 0, 11))
 >A : Symbol(A, Decl(ambiguousOverloadResolution.ts, 0, 0))
->x : Symbol(x, Decl(ambiguousOverloadResolution.ts, 1, 19))
+>x : Symbol(B.x, Decl(ambiguousOverloadResolution.ts, 1, 19))

 declare function f(p: A, q: B): number;
 >f : Symbol(f, Decl(ambiguousOverloadResolution.ts, 1, 32), Decl(ambiguousOverloadResolution.ts, 3, 39))
@@ -43,7 +43,7 @@ export class C1 {
 >C1 : Symbol(C1, Decl(foo_0.ts, 0, 0))

 	m1 = 42;
->m1 : Symbol(m1, Decl(foo_0.ts, 0, 17))
+>m1 : Symbol(C1.m1, Decl(foo_0.ts, 0, 17))

 	static s1 = true;
 >s1 : Symbol(C1.s1, Decl(foo_0.ts, 1, 9))
@@ -53,10 +53,10 @@ export interface I1 {
 >I1 : Symbol(I1, Decl(foo_0.ts, 3, 1))

 	name: string;
->name : Symbol(name, Decl(foo_0.ts, 5, 21))
+>name : Symbol(I1.name, Decl(foo_0.ts, 5, 21))

 	age: number;
->age : Symbol(age, Decl(foo_0.ts, 6, 14))
+>age : Symbol(I1.age, Decl(foo_0.ts, 6, 14))
 }

 export module M1 {
@@ -66,7 +66,7 @@ export module M1 {
 >I2 : Symbol(I2, Decl(foo_0.ts, 10, 18))

 		foo: string;
->foo : Symbol(foo, Decl(foo_0.ts, 11, 22))
+>foo : Symbol(I2.foo, Decl(foo_0.ts, 11, 22))
 	}
 }

@@ -4,13 +4,13 @@ class Foo {
 >Foo : Symbol(Foo, Decl(amdModuleName1.ts, 0, 0))

    x: number;
->x : Symbol(x, Decl(amdModuleName1.ts, 1, 11))
+>x : Symbol(Foo.x, Decl(amdModuleName1.ts, 1, 11))

    constructor() {
        this.x = 5;
->this.x : Symbol(x, Decl(amdModuleName1.ts, 1, 11))
+>this.x : Symbol(Foo.x, Decl(amdModuleName1.ts, 1, 11))
 >this : Symbol(Foo, Decl(amdModuleName1.ts, 0, 0))
->x : Symbol(x, Decl(amdModuleName1.ts, 1, 11))
+>x : Symbol(Foo.x, Decl(amdModuleName1.ts, 1, 11))
    }
 }
 export = Foo;
@@ -6,7 +6,7 @@ module M {
 >C : Symbol(C, Decl(anonterface.ts, 0, 10))

        m(fn:{ (n:number):string; },n2:number):string {
->m : Symbol(m, Decl(anonterface.ts, 1, 20))
+>m : Symbol(C.m, Decl(anonterface.ts, 1, 20))
 >fn : Symbol(fn, Decl(anonterface.ts, 2, 10))
 >n : Symbol(n, Decl(anonterface.ts, 2, 16))
 >n2 : Symbol(n2, Decl(anonterface.ts, 2, 36))
@@ -8,7 +8,7 @@ interface I {
 >x : Symbol(x, Decl(anyAssignabilityInInheritance.ts, 3, 5))

    foo: any; // ok, any identical to itself
->foo : Symbol(foo, Decl(anyAssignabilityInInheritance.ts, 3, 21))
+>foo : Symbol(I.foo, Decl(anyAssignabilityInInheritance.ts, 3, 21))
 }

 var a: any;
@@ -113,7 +113,7 @@ var r3 = foo3(a); // any

 interface I8 { foo: string }
 >I8 : Symbol(I8, Decl(anyAssignabilityInInheritance.ts, 35, 17))
->foo : Symbol(foo, Decl(anyAssignabilityInInheritance.ts, 37, 14))
+>foo : Symbol(I8.foo, Decl(anyAssignabilityInInheritance.ts, 37, 14))

 declare function foo9(x: I8): I8;
 >foo9 : Symbol(foo9, Decl(anyAssignabilityInInheritance.ts, 37, 28), Decl(anyAssignabilityInInheritance.ts, 38, 33))
@@ -132,7 +132,7 @@ var r3 = foo3(a); // any

 class A { foo: number; }
 >A : Symbol(A, Decl(anyAssignabilityInInheritance.ts, 40, 17))
->foo : Symbol(foo, Decl(anyAssignabilityInInheritance.ts, 42, 9))
+>foo : Symbol(A.foo, Decl(anyAssignabilityInInheritance.ts, 42, 9))

 declare function foo10(x: A): A;
 >foo10 : Symbol(foo10, Decl(anyAssignabilityInInheritance.ts, 42, 24), Decl(anyAssignabilityInInheritance.ts, 43, 32))
@@ -152,7 +152,7 @@ var r3 = foo3(a); // any
 class A2<T> { foo: T; }
 >A2 : Symbol(A2, Decl(anyAssignabilityInInheritance.ts, 45, 17))
 >T : Symbol(T, Decl(anyAssignabilityInInheritance.ts, 47, 9))
->foo : Symbol(foo, Decl(anyAssignabilityInInheritance.ts, 47, 13))
+>foo : Symbol(A2.foo, Decl(anyAssignabilityInInheritance.ts, 47, 13))
 >T : Symbol(T, Decl(anyAssignabilityInInheritance.ts, 47, 9))

 declare function foo11(x: A2<string>): A2<string>;
@@ -251,7 +251,7 @@ var r3 = foo3(a); // any

 class CC { baz: string }
 >CC : Symbol(CC, Decl(anyAssignabilityInInheritance.ts, 71, 17), Decl(anyAssignabilityInInheritance.ts, 73, 24))
->baz : Symbol(baz, Decl(anyAssignabilityInInheritance.ts, 73, 10))
+>baz : Symbol(CC.baz, Decl(anyAssignabilityInInheritance.ts, 73, 10))

 module CC {
 >CC : Symbol(CC, Decl(anyAssignabilityInInheritance.ts, 71, 17), Decl(anyAssignabilityInInheritance.ts, 73, 24))
@@ -6,7 +6,7 @@ class C {
 >C : Symbol(C, Decl(anyAssignableToEveryType.ts, 0, 11))

    foo: string;
->foo : Symbol(foo, Decl(anyAssignableToEveryType.ts, 2, 9))
+>foo : Symbol(C.foo, Decl(anyAssignableToEveryType.ts, 2, 9))
 }
 var ac: C;
 >ac : Symbol(ac, Decl(anyAssignableToEveryType.ts, 5, 3))
@@ -16,7 +16,7 @@ interface I {
 >I : Symbol(I, Decl(anyAssignableToEveryType.ts, 5, 10))

    foo: string;
->foo : Symbol(foo, Decl(anyAssignableToEveryType.ts, 6, 13))
+>foo : Symbol(I.foo, Decl(anyAssignableToEveryType.ts, 6, 13))
 }
 var ai: I;
 >ai : Symbol(ai, Decl(anyAssignableToEveryType.ts, 9, 3))
@@ -8,7 +8,7 @@ interface I {
 >x : Symbol(x, Decl(anyAssignableToEveryType2.ts, 3, 5))

    foo: any; // ok, any identical to itself
->foo : Symbol(foo, Decl(anyAssignableToEveryType2.ts, 3, 21))
+>foo : Symbol(I.foo, Decl(anyAssignableToEveryType2.ts, 3, 21))
 }


@@ -19,7 +19,7 @@ interface I2 {
 >x : Symbol(x, Decl(anyAssignableToEveryType2.ts, 9, 5))

    foo: any;
->foo : Symbol(foo, Decl(anyAssignableToEveryType2.ts, 9, 24))
+>foo : Symbol(I2.foo, Decl(anyAssignableToEveryType2.ts, 9, 24))
 }


@@ -30,7 +30,7 @@ interface I3 {
 >x : Symbol(x, Decl(anyAssignableToEveryType2.ts, 15, 5))

    foo: any;
->foo : Symbol(foo, Decl(anyAssignableToEveryType2.ts, 15, 24))
+>foo : Symbol(I3.foo, Decl(anyAssignableToEveryType2.ts, 15, 24))
 }


@@ -41,7 +41,7 @@ interface I4 {
 >x : Symbol(x, Decl(anyAssignableToEveryType2.ts, 21, 5))

    foo: any;
->foo : Symbol(foo, Decl(anyAssignableToEveryType2.ts, 21, 25))
+>foo : Symbol(I4.foo, Decl(anyAssignableToEveryType2.ts, 21, 25))
 }


@@ -53,7 +53,7 @@ interface I5 {
 >Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))

    foo: any;
->foo : Symbol(foo, Decl(anyAssignableToEveryType2.ts, 27, 22))
+>foo : Symbol(I5.foo, Decl(anyAssignableToEveryType2.ts, 27, 22))
 }


@@ -65,7 +65,7 @@ interface I6 {
 >RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))

    foo: any;
->foo : Symbol(foo, Decl(anyAssignableToEveryType2.ts, 33, 24))
+>foo : Symbol(I6.foo, Decl(anyAssignableToEveryType2.ts, 33, 24))
 }


@@ -77,7 +77,7 @@ interface I7 {
 >bar : Symbol(bar, Decl(anyAssignableToEveryType2.ts, 39, 18))

    foo: any;
->foo : Symbol(foo, Decl(anyAssignableToEveryType2.ts, 39, 33))
+>foo : Symbol(I7.foo, Decl(anyAssignableToEveryType2.ts, 39, 33))
 }


@@ -88,7 +88,7 @@ interface I8 {
 >x : Symbol(x, Decl(anyAssignableToEveryType2.ts, 45, 5))

    foo: any;
->foo : Symbol(foo, Decl(anyAssignableToEveryType2.ts, 45, 26))
+>foo : Symbol(I8.foo, Decl(anyAssignableToEveryType2.ts, 45, 26))
 }


@@ -100,12 +100,12 @@ interface I9 {
 >I8 : Symbol(I8, Decl(anyAssignableToEveryType2.ts, 41, 1))

    foo: any;
->foo : Symbol(foo, Decl(anyAssignableToEveryType2.ts, 51, 20))
+>foo : Symbol(I9.foo, Decl(anyAssignableToEveryType2.ts, 51, 20))
 }

 class A { foo: number; }
 >A : Symbol(A, Decl(anyAssignableToEveryType2.ts, 53, 1))
->foo : Symbol(foo, Decl(anyAssignableToEveryType2.ts, 55, 9))
+>foo : Symbol(A.foo, Decl(anyAssignableToEveryType2.ts, 55, 9))

 interface I10 {
 >I10 : Symbol(I10, Decl(anyAssignableToEveryType2.ts, 55, 24))
@@ -115,13 +115,13 @@ interface I10 {
 >A : Symbol(A, Decl(anyAssignableToEveryType2.ts, 53, 1))

    foo: any;
->foo : Symbol(foo, Decl(anyAssignableToEveryType2.ts, 57, 19))
+>foo : Symbol(I10.foo, Decl(anyAssignableToEveryType2.ts, 57, 19))
 }

 class A2<T> { foo: T; }
 >A2 : Symbol(A2, Decl(anyAssignableToEveryType2.ts, 59, 1))
 >T : Symbol(T, Decl(anyAssignableToEveryType2.ts, 61, 9))
->foo : Symbol(foo, Decl(anyAssignableToEveryType2.ts, 61, 13))
+>foo : Symbol(A2.foo, Decl(anyAssignableToEveryType2.ts, 61, 13))
 >T : Symbol(T, Decl(anyAssignableToEveryType2.ts, 61, 9))

 interface I11 {
@@ -132,7 +132,7 @@ interface I11 {
 >A2 : Symbol(A2, Decl(anyAssignableToEveryType2.ts, 59, 1))

    foo: any;
->foo : Symbol(foo, Decl(anyAssignableToEveryType2.ts, 63, 28))
+>foo : Symbol(I11.foo, Decl(anyAssignableToEveryType2.ts, 63, 28))
 }


@@ -144,7 +144,7 @@ interface I12 {
 >x : Symbol(x, Decl(anyAssignableToEveryType2.ts, 69, 18))

    foo: any;
->foo : Symbol(foo, Decl(anyAssignableToEveryType2.ts, 69, 31))
+>foo : Symbol(I12.foo, Decl(anyAssignableToEveryType2.ts, 69, 31))
 }


@@ -159,7 +159,7 @@ interface I13 {
 >T : Symbol(T, Decl(anyAssignableToEveryType2.ts, 75, 18))

    foo: any;
->foo : Symbol(foo, Decl(anyAssignableToEveryType2.ts, 75, 32))
+>foo : Symbol(I13.foo, Decl(anyAssignableToEveryType2.ts, 75, 32))
 }


@@ -175,7 +175,7 @@ interface I14 {
 >E : Symbol(E, Decl(anyAssignableToEveryType2.ts, 77, 1))

    foo: any;
->foo : Symbol(foo, Decl(anyAssignableToEveryType2.ts, 82, 19))
+>foo : Symbol(I14.foo, Decl(anyAssignableToEveryType2.ts, 82, 19))
 }


@@ -196,13 +196,13 @@ interface I15 {
 >f : Symbol(f, Decl(anyAssignableToEveryType2.ts, 84, 1), Decl(anyAssignableToEveryType2.ts, 87, 16))

    foo: any;
->foo : Symbol(foo, Decl(anyAssignableToEveryType2.ts, 92, 26))
+>foo : Symbol(I15.foo, Decl(anyAssignableToEveryType2.ts, 92, 26))
 }


 class c { baz: string }
 >c : Symbol(c, Decl(anyAssignableToEveryType2.ts, 94, 1), Decl(anyAssignableToEveryType2.ts, 97, 23))
->baz : Symbol(baz, Decl(anyAssignableToEveryType2.ts, 97, 9))
+>baz : Symbol(c.baz, Decl(anyAssignableToEveryType2.ts, 97, 9))

 module c {
 >c : Symbol(c, Decl(anyAssignableToEveryType2.ts, 94, 1), Decl(anyAssignableToEveryType2.ts, 97, 23))
@@ -218,7 +218,7 @@ interface I16 {
 >c : Symbol(c, Decl(anyAssignableToEveryType2.ts, 94, 1), Decl(anyAssignableToEveryType2.ts, 97, 23))

    foo: any;
->foo : Symbol(foo, Decl(anyAssignableToEveryType2.ts, 102, 26))
+>foo : Symbol(I16.foo, Decl(anyAssignableToEveryType2.ts, 102, 26))
 }


@@ -231,7 +231,7 @@ interface I17<T> {
 >T : Symbol(T, Decl(anyAssignableToEveryType2.ts, 107, 14))

    foo: any;
->foo : Symbol(foo, Decl(anyAssignableToEveryType2.ts, 108, 19))
+>foo : Symbol(I17.foo, Decl(anyAssignableToEveryType2.ts, 108, 19))
 }


@@ -246,7 +246,7 @@ interface I18<T, U extends T> {
 >U : Symbol(U, Decl(anyAssignableToEveryType2.ts, 113, 16))

    foo: any;
->foo : Symbol(foo, Decl(anyAssignableToEveryType2.ts, 114, 19))
+>foo : Symbol(I18.foo, Decl(anyAssignableToEveryType2.ts, 114, 19))
 }


@@ -258,7 +258,7 @@ interface I19 {
 >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))

    foo: any;
->foo : Symbol(foo, Decl(anyAssignableToEveryType2.ts, 120, 24))
+>foo : Symbol(I19.foo, Decl(anyAssignableToEveryType2.ts, 120, 24))
 }


@@ -269,6 +269,6 @@ interface I20 {
 >x : Symbol(x, Decl(anyAssignableToEveryType2.ts, 126, 5))

    foo: any;
->foo : Symbol(foo, Decl(anyAssignableToEveryType2.ts, 126, 20))
+>foo : Symbol(I20.foo, Decl(anyAssignableToEveryType2.ts, 126, 20))
 }

@@ -3,7 +3,7 @@ interface P {
 >P : Symbol(P, Decl(anyIsAssignableToObject.ts, 0, 0))

    p: {};
->p : Symbol(p, Decl(anyIsAssignableToObject.ts, 0, 13))
+>p : Symbol(P.p, Decl(anyIsAssignableToObject.ts, 0, 13))
 }

 interface Q extends P { // Check assignability here. Any is assignable to {}
@@ -11,5 +11,5 @@ interface Q extends P { // Check assignability here. Any is assignable to {}
 >P : Symbol(P, Decl(anyIsAssignableToObject.ts, 0, 0))

    p: any;
->p : Symbol(p, Decl(anyIsAssignableToObject.ts, 4, 23))
+>p : Symbol(Q.p, Decl(anyIsAssignableToObject.ts, 4, 23))
 }
@@ -3,7 +3,7 @@ interface P {
 >P : Symbol(P, Decl(anyIsAssignableToVoid.ts, 0, 0))

    p: void;
->p : Symbol(p, Decl(anyIsAssignableToVoid.ts, 0, 13))
+>p : Symbol(P.p, Decl(anyIsAssignableToVoid.ts, 0, 13))
 }

 interface Q extends P { // check assignability here. any is assignable to void.
@@ -11,5 +11,5 @@ interface Q extends P { // check assignability here. any is assignable to void.
 >P : Symbol(P, Decl(anyIsAssignableToVoid.ts, 0, 0))

    p: any;
->p : Symbol(p, Decl(anyIsAssignableToVoid.ts, 4, 23))
+>p : Symbol(Q.p, Decl(anyIsAssignableToVoid.ts, 4, 23))
 }
@@ -3,7 +3,7 @@ class C {
 >C : Symbol(C, Decl(argsInScope.ts, 0, 0))

    P(ii:number, j:number, k:number) {
->P : Symbol(P, Decl(argsInScope.ts, 0, 9))
+>P : Symbol(C.P, Decl(argsInScope.ts, 0, 9))
 >ii : Symbol(ii, Decl(argsInScope.ts, 1, 6))
 >j : Symbol(j, Decl(argsInScope.ts, 1, 16))
 >k : Symbol(k, Decl(argsInScope.ts, 1, 26))
@@ -9,24 +9,24 @@ module Test {
 >IToken : Symbol(IToken, Decl(arrayAssignmentTest6.ts, 2, 5))

        startIndex: number;
->startIndex : Symbol(startIndex, Decl(arrayAssignmentTest6.ts, 3, 22))
+>startIndex : Symbol(IToken.startIndex, Decl(arrayAssignmentTest6.ts, 3, 22))
    }
    interface ILineTokens {
 >ILineTokens : Symbol(ILineTokens, Decl(arrayAssignmentTest6.ts, 5, 5))

        tokens: IToken[];
->tokens : Symbol(tokens, Decl(arrayAssignmentTest6.ts, 6, 27))
+>tokens : Symbol(ILineTokens.tokens, Decl(arrayAssignmentTest6.ts, 6, 27))
 >IToken : Symbol(IToken, Decl(arrayAssignmentTest6.ts, 2, 5))

        endState: IState;
->endState : Symbol(endState, Decl(arrayAssignmentTest6.ts, 7, 25))
+>endState : Symbol(ILineTokens.endState, Decl(arrayAssignmentTest6.ts, 7, 25))
 >IState : Symbol(IState, Decl(arrayAssignmentTest6.ts, 0, 13))
    }
    interface IMode {
 >IMode : Symbol(IMode, Decl(arrayAssignmentTest6.ts, 9, 5))

        tokenize(line:string, state:IState, includeStates:boolean):ILineTokens;
->tokenize : Symbol(tokenize, Decl(arrayAssignmentTest6.ts, 10, 21))
+>tokenize : Symbol(IMode.tokenize, Decl(arrayAssignmentTest6.ts, 10, 21))
 >line : Symbol(line, Decl(arrayAssignmentTest6.ts, 11, 17))
 >state : Symbol(state, Decl(arrayAssignmentTest6.ts, 11, 29))
 >IState : Symbol(IState, Decl(arrayAssignmentTest6.ts, 0, 13))
@@ -38,7 +38,7 @@ module Test {
 >IMode : Symbol(IMode, Decl(arrayAssignmentTest6.ts, 9, 5))

        public tokenize(line:string, tokens:IToken[], includeStates:boolean):ILineTokens {
->tokenize : Symbol(tokenize, Decl(arrayAssignmentTest6.ts, 13, 39))
+>tokenize : Symbol(Bug.tokenize, Decl(arrayAssignmentTest6.ts, 13, 39))
 >line : Symbol(line, Decl(arrayAssignmentTest6.ts, 14, 24))
 >tokens : Symbol(tokens, Decl(arrayAssignmentTest6.ts, 14, 36))
 >IToken : Symbol(IToken, Decl(arrayAssignmentTest6.ts, 2, 5))
@@ -4,7 +4,7 @@ interface Array<T> {
 >T : Symbol(T, Decl(lib.d.ts, --, --), Decl(arrayAugment.ts, 0, 16))

    split: (parts: number) => T[][];
->split : Symbol(split, Decl(arrayAugment.ts, 0, 20))
+>split : Symbol(Array.split, Decl(arrayAugment.ts, 0, 20))
 >parts : Symbol(parts, Decl(arrayAugment.ts, 1, 12))
 >T : Symbol(T, Decl(lib.d.ts, --, --), Decl(arrayAugment.ts, 0, 16))
 }
@@ -22,98 +22,98 @@ module EmptyTypes {
 >f : Symbol(f, Decl(arrayBestCommonTypes.ts, 4, 34))

        public voidIfAny(x: boolean, y?: boolean): number;
->voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
+>voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 8, 25))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 8, 36))

        public voidIfAny(x: string, y?: boolean): number;
->voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
+>voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 9, 25))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 9, 35))

        public voidIfAny(x: number, y?: boolean): number;
->voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
+>voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 10, 25))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 10, 35))

        public voidIfAny(x: any, y = false): any { return null; }
->voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
+>voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 11, 25))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 11, 32))

        public x() {
->x : Symbol(x, Decl(arrayBestCommonTypes.ts, 11, 65))
+>x : Symbol(f.x, Decl(arrayBestCommonTypes.ts, 11, 65))

            <number>(this.voidIfAny([4, 2][0]));
->this.voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
+>this.voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
 >this : Symbol(f, Decl(arrayBestCommonTypes.ts, 4, 34))
->voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
+>voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))

            <number>(this.voidIfAny([4, 2, undefined][0]));
->this.voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
+>this.voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
 >this : Symbol(f, Decl(arrayBestCommonTypes.ts, 4, 34))
->voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
+>voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
 >undefined : Symbol(undefined)

            <number>(this.voidIfAny([undefined, 2, 4][0]));
->this.voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
+>this.voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
 >this : Symbol(f, Decl(arrayBestCommonTypes.ts, 4, 34))
->voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
+>voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
 >undefined : Symbol(undefined)

            <number>(this.voidIfAny([null, 2, 4][0]));
->this.voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
+>this.voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
 >this : Symbol(f, Decl(arrayBestCommonTypes.ts, 4, 34))
->voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
+>voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))

            <number>(this.voidIfAny([2, 4, null][0]));
->this.voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
+>this.voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
 >this : Symbol(f, Decl(arrayBestCommonTypes.ts, 4, 34))
->voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
+>voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))

            <number>(this.voidIfAny([undefined, 4, null][0]));
->this.voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
+>this.voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
 >this : Symbol(f, Decl(arrayBestCommonTypes.ts, 4, 34))
->voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
+>voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
 >undefined : Symbol(undefined)

            <number>(this.voidIfAny(['', "q"][0]));
->this.voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
+>this.voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
 >this : Symbol(f, Decl(arrayBestCommonTypes.ts, 4, 34))
->voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
+>voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))

            <number>(this.voidIfAny(['', "q", undefined][0]));
->this.voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
+>this.voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
 >this : Symbol(f, Decl(arrayBestCommonTypes.ts, 4, 34))
->voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
+>voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
 >undefined : Symbol(undefined)

            <number>(this.voidIfAny([undefined, "q", ''][0]));
->this.voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
+>this.voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
 >this : Symbol(f, Decl(arrayBestCommonTypes.ts, 4, 34))
->voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
+>voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
 >undefined : Symbol(undefined)

            <number>(this.voidIfAny([null, "q", ''][0]));
->this.voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
+>this.voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
 >this : Symbol(f, Decl(arrayBestCommonTypes.ts, 4, 34))
->voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
+>voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))

            <number>(this.voidIfAny(["q", '', null][0]));
->this.voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
+>this.voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
 >this : Symbol(f, Decl(arrayBestCommonTypes.ts, 4, 34))
->voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
+>voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))

            <number>(this.voidIfAny([undefined, '', null][0]));
->this.voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
+>this.voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
 >this : Symbol(f, Decl(arrayBestCommonTypes.ts, 4, 34))
->voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
+>voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
 >undefined : Symbol(undefined)

            <number>(this.voidIfAny([[3, 4], [null]][0][0]));
->this.voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
+>this.voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
 >this : Symbol(f, Decl(arrayBestCommonTypes.ts, 4, 34))
->voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))
+>voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 7, 13), Decl(arrayBestCommonTypes.ts, 8, 58), Decl(arrayBestCommonTypes.ts, 9, 57), Decl(arrayBestCommonTypes.ts, 10, 57))


            var t1: { x: number; y: base; }[] = [{ x: 7, y: new derived() }, { x: 5, y: new base() }];
@@ -231,122 +231,122 @@ module NonEmptyTypes {

    interface iface { x: string; }
 >iface : Symbol(iface, Decl(arrayBestCommonTypes.ts, 53, 22))
->x : Symbol(x, Decl(arrayBestCommonTypes.ts, 54, 21))
+>x : Symbol(iface.x, Decl(arrayBestCommonTypes.ts, 54, 21))

    class base implements iface { x: string; y: string; }
 >base : Symbol(base, Decl(arrayBestCommonTypes.ts, 54, 34))
 >iface : Symbol(iface, Decl(arrayBestCommonTypes.ts, 53, 22))
->x : Symbol(x, Decl(arrayBestCommonTypes.ts, 55, 33))
->y : Symbol(y, Decl(arrayBestCommonTypes.ts, 55, 44))
+>x : Symbol(base.x, Decl(arrayBestCommonTypes.ts, 55, 33))
+>y : Symbol(base.y, Decl(arrayBestCommonTypes.ts, 55, 44))

    class base2 implements iface { x: string; z: string; }
 >base2 : Symbol(base2, Decl(arrayBestCommonTypes.ts, 55, 57))
 >iface : Symbol(iface, Decl(arrayBestCommonTypes.ts, 53, 22))
->x : Symbol(x, Decl(arrayBestCommonTypes.ts, 56, 34))
->z : Symbol(z, Decl(arrayBestCommonTypes.ts, 56, 45))
+>x : Symbol(base2.x, Decl(arrayBestCommonTypes.ts, 56, 34))
+>z : Symbol(base2.z, Decl(arrayBestCommonTypes.ts, 56, 45))

    class derived extends base { a: string; }
 >derived : Symbol(derived, Decl(arrayBestCommonTypes.ts, 56, 58))
 >base : Symbol(base, Decl(arrayBestCommonTypes.ts, 54, 34))
->a : Symbol(a, Decl(arrayBestCommonTypes.ts, 57, 32))
+>a : Symbol(derived.a, Decl(arrayBestCommonTypes.ts, 57, 32))


    class f {
 >f : Symbol(f, Decl(arrayBestCommonTypes.ts, 57, 45))

        public voidIfAny(x: boolean, y?: boolean): number;
->voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
+>voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 61, 25))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 61, 36))

        public voidIfAny(x: string, y?: boolean): number;
->voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
+>voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 62, 25))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 62, 35))

        public voidIfAny(x: number, y?: boolean): number;
->voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
+>voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 63, 25))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 63, 35))

        public voidIfAny(x: any, y = false): any { return null; }
->voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
+>voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
 >x : Symbol(x, Decl(arrayBestCommonTypes.ts, 64, 25))
 >y : Symbol(y, Decl(arrayBestCommonTypes.ts, 64, 32))

        public x() {
->x : Symbol(x, Decl(arrayBestCommonTypes.ts, 64, 65))
+>x : Symbol(f.x, Decl(arrayBestCommonTypes.ts, 64, 65))

            <number>(this.voidIfAny([4, 2][0]));
->this.voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
+>this.voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
 >this : Symbol(f, Decl(arrayBestCommonTypes.ts, 57, 45))
->voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
+>voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))

            <number>(this.voidIfAny([4, 2, undefined][0]));
->this.voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
+>this.voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
 >this : Symbol(f, Decl(arrayBestCommonTypes.ts, 57, 45))
->voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
+>voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
 >undefined : Symbol(undefined)

            <number>(this.voidIfAny([undefined, 2, 4][0]));
->this.voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
+>this.voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
 >this : Symbol(f, Decl(arrayBestCommonTypes.ts, 57, 45))
->voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
+>voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
 >undefined : Symbol(undefined)

            <number>(this.voidIfAny([null, 2, 4][0]));
->this.voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
+>this.voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
 >this : Symbol(f, Decl(arrayBestCommonTypes.ts, 57, 45))
->voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
+>voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))

            <number>(this.voidIfAny([2, 4, null][0]));
->this.voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
+>this.voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
 >this : Symbol(f, Decl(arrayBestCommonTypes.ts, 57, 45))
->voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
+>voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))

            <number>(this.voidIfAny([undefined, 4, null][0]));
->this.voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
+>this.voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
 >this : Symbol(f, Decl(arrayBestCommonTypes.ts, 57, 45))
->voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
+>voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
 >undefined : Symbol(undefined)

            <number>(this.voidIfAny(['', "q"][0]));
->this.voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
+>this.voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
 >this : Symbol(f, Decl(arrayBestCommonTypes.ts, 57, 45))
->voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
+>voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))

            <number>(this.voidIfAny(['', "q", undefined][0]));
->this.voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
+>this.voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
 >this : Symbol(f, Decl(arrayBestCommonTypes.ts, 57, 45))
->voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
+>voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
 >undefined : Symbol(undefined)

            <number>(this.voidIfAny([undefined, "q", ''][0]));
->this.voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
+>this.voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
 >this : Symbol(f, Decl(arrayBestCommonTypes.ts, 57, 45))
->voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
+>voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
 >undefined : Symbol(undefined)

            <number>(this.voidIfAny([null, "q", ''][0]));
->this.voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
+>this.voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
 >this : Symbol(f, Decl(arrayBestCommonTypes.ts, 57, 45))
->voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
+>voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))

            <number>(this.voidIfAny(["q", '', null][0]));
->this.voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
+>this.voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
 >this : Symbol(f, Decl(arrayBestCommonTypes.ts, 57, 45))
->voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
+>voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))

            <number>(this.voidIfAny([undefined, '', null][0]));
->this.voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
+>this.voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
 >this : Symbol(f, Decl(arrayBestCommonTypes.ts, 57, 45))
->voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
+>voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
 >undefined : Symbol(undefined)

            <number>(this.voidIfAny([[3, 4], [null]][0][0]));
->this.voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
+>this.voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
 >this : Symbol(f, Decl(arrayBestCommonTypes.ts, 57, 45))
->voidIfAny : Symbol(voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))
+>voidIfAny : Symbol(f.voidIfAny, Decl(arrayBestCommonTypes.ts, 60, 13), Decl(arrayBestCommonTypes.ts, 61, 58), Decl(arrayBestCommonTypes.ts, 62, 57), Decl(arrayBestCommonTypes.ts, 63, 57))


            var t1: { x: number; y: base; }[] = [{ x: 7, y: new derived() }, { x: 5, y: new base() }];
@@ -3,27 +3,27 @@ interface IAnimal {
 >IAnimal : Symbol(IAnimal, Decl(arrayLiteralContextualType.ts, 0, 0))

    name: string;
->name : Symbol(name, Decl(arrayLiteralContextualType.ts, 0, 19))
+>name : Symbol(IAnimal.name, Decl(arrayLiteralContextualType.ts, 0, 19))
 }

 class Giraffe {
 >Giraffe : Symbol(Giraffe, Decl(arrayLiteralContextualType.ts, 2, 1))

    name = "Giraffe";
->name : Symbol(name, Decl(arrayLiteralContextualType.ts, 4, 15))
+>name : Symbol(Giraffe.name, Decl(arrayLiteralContextualType.ts, 4, 15))

    neckLength = "3m";
->neckLength : Symbol(neckLength, Decl(arrayLiteralContextualType.ts, 5, 21))
+>neckLength : Symbol(Giraffe.neckLength, Decl(arrayLiteralContextualType.ts, 5, 21))
 }

 class Elephant {
 >Elephant : Symbol(Elephant, Decl(arrayLiteralContextualType.ts, 7, 1))

    name = "Elephant";
->name : Symbol(name, Decl(arrayLiteralContextualType.ts, 9, 16))
+>name : Symbol(Elephant.name, Decl(arrayLiteralContextualType.ts, 9, 16))

    trunkDiameter = "20cm";
->trunkDiameter : Symbol(trunkDiameter, Decl(arrayLiteralContextualType.ts, 10, 22))
+>trunkDiameter : Symbol(Elephant.trunkDiameter, Decl(arrayLiteralContextualType.ts, 10, 22))
 }

 function foo(animals: IAnimal[]) { }
@@ -4,11 +4,11 @@ class List<T> {
 >T : Symbol(T, Decl(arrayLiteralsWithRecursiveGenerics.ts, 0, 11))

    data: T;
->data : Symbol(data, Decl(arrayLiteralsWithRecursiveGenerics.ts, 0, 15))
+>data : Symbol(List.data, Decl(arrayLiteralsWithRecursiveGenerics.ts, 0, 15))
 >T : Symbol(T, Decl(arrayLiteralsWithRecursiveGenerics.ts, 0, 11))

    next: List<List<T>>;
->next : Symbol(next, Decl(arrayLiteralsWithRecursiveGenerics.ts, 1, 12))
+>next : Symbol(List.next, Decl(arrayLiteralsWithRecursiveGenerics.ts, 1, 12))
 >List : Symbol(List, Decl(arrayLiteralsWithRecursiveGenerics.ts, 0, 0))
 >List : Symbol(List, Decl(arrayLiteralsWithRecursiveGenerics.ts, 0, 0))
 >T : Symbol(T, Decl(arrayLiteralsWithRecursiveGenerics.ts, 0, 11))
@@ -21,7 +21,7 @@ class DerivedList<U> extends List<U> {
 >U : Symbol(U, Decl(arrayLiteralsWithRecursiveGenerics.ts, 5, 18))

    foo: U;
->foo : Symbol(foo, Decl(arrayLiteralsWithRecursiveGenerics.ts, 5, 38))
+>foo : Symbol(DerivedList.foo, Decl(arrayLiteralsWithRecursiveGenerics.ts, 5, 38))
 >U : Symbol(U, Decl(arrayLiteralsWithRecursiveGenerics.ts, 5, 18))

    // next: List<List<U>>
@@ -32,11 +32,11 @@ class MyList<T> {
 >T : Symbol(T, Decl(arrayLiteralsWithRecursiveGenerics.ts, 10, 13))

    data: T;
->data : Symbol(data, Decl(arrayLiteralsWithRecursiveGenerics.ts, 10, 17))
+>data : Symbol(MyList.data, Decl(arrayLiteralsWithRecursiveGenerics.ts, 10, 17))
 >T : Symbol(T, Decl(arrayLiteralsWithRecursiveGenerics.ts, 10, 13))

    next: MyList<MyList<T>>;
->next : Symbol(next, Decl(arrayLiteralsWithRecursiveGenerics.ts, 11, 12))
+>next : Symbol(MyList.next, Decl(arrayLiteralsWithRecursiveGenerics.ts, 11, 12))
 >MyList : Symbol(MyList, Decl(arrayLiteralsWithRecursiveGenerics.ts, 8, 1))
 >MyList : Symbol(MyList, Decl(arrayLiteralsWithRecursiveGenerics.ts, 8, 1))
 >T : Symbol(T, Decl(arrayLiteralsWithRecursiveGenerics.ts, 10, 13))
@@ -7,18 +7,18 @@ class Road {
 >Road : Symbol(Road, Decl(arrayOfExportedClass_1.ts, 1, 49))

    public cars: Car[];
->cars : Symbol(cars, Decl(arrayOfExportedClass_1.ts, 3, 12))
+>cars : Symbol(Road.cars, Decl(arrayOfExportedClass_1.ts, 3, 12))
 >Car : Symbol(Car, Decl(arrayOfExportedClass_1.ts, 0, 0))

    public AddCars(cars: Car[]) {
->AddCars : Symbol(AddCars, Decl(arrayOfExportedClass_1.ts, 5, 23))
+>AddCars : Symbol(Road.AddCars, Decl(arrayOfExportedClass_1.ts, 5, 23))
 >cars : Symbol(cars, Decl(arrayOfExportedClass_1.ts, 7, 19))
 >Car : Symbol(Car, Decl(arrayOfExportedClass_1.ts, 0, 0))

        this.cars = cars;
->this.cars : Symbol(cars, Decl(arrayOfExportedClass_1.ts, 3, 12))
+>this.cars : Symbol(Road.cars, Decl(arrayOfExportedClass_1.ts, 3, 12))
 >this : Symbol(Road, Decl(arrayOfExportedClass_1.ts, 1, 49))
->cars : Symbol(cars, Decl(arrayOfExportedClass_1.ts, 3, 12))
+>cars : Symbol(Road.cars, Decl(arrayOfExportedClass_1.ts, 3, 12))
 >cars : Symbol(cars, Decl(arrayOfExportedClass_1.ts, 7, 19))
    }
 }
@@ -31,7 +31,7 @@ class Car {
 >Car : Symbol(Car, Decl(arrayOfExportedClass_0.ts, 0, 0))

    foo: string;
->foo : Symbol(foo, Decl(arrayOfExportedClass_0.ts, 0, 11))
+>foo : Symbol(Car.foo, Decl(arrayOfExportedClass_0.ts, 0, 11))
 }

 export = Car;
@@ -12,7 +12,7 @@ class C {
 >C : Symbol(C, Decl(arrayOfFunctionTypes3.ts, 3, 16))

    foo: string;
->foo : Symbol(foo, Decl(arrayOfFunctionTypes3.ts, 5, 9))
+>foo : Symbol(C.foo, Decl(arrayOfFunctionTypes3.ts, 5, 9))
 }
 var y = [C, C];
 >y : Symbol(y, Decl(arrayOfFunctionTypes3.ts, 8, 3))
@@ -7,7 +7,7 @@ declare module WinJS {
 >T : Symbol(T, Decl(arrayTypeInSignatureOfInterfaceAndClass.ts, 1, 18))

        then<U>(success?: (value: T) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>;
->then : Symbol(then, Decl(arrayTypeInSignatureOfInterfaceAndClass.ts, 1, 22))
+>then : Symbol(Promise.then, Decl(arrayTypeInSignatureOfInterfaceAndClass.ts, 1, 22))
 >U : Symbol(U, Decl(arrayTypeInSignatureOfInterfaceAndClass.ts, 2, 13))
 >success : Symbol(success, Decl(arrayTypeInSignatureOfInterfaceAndClass.ts, 2, 16))
 >value : Symbol(value, Decl(arrayTypeInSignatureOfInterfaceAndClass.ts, 2, 27))
@@ -32,29 +32,29 @@ declare module Data {
 >T : Symbol(T, Decl(arrayTypeInSignatureOfInterfaceAndClass.ts, 6, 31))

        itemIndex: number;
->itemIndex : Symbol(itemIndex, Decl(arrayTypeInSignatureOfInterfaceAndClass.ts, 6, 35))
+>itemIndex : Symbol(IListItem.itemIndex, Decl(arrayTypeInSignatureOfInterfaceAndClass.ts, 6, 35))

        key: any;
->key : Symbol(key, Decl(arrayTypeInSignatureOfInterfaceAndClass.ts, 7, 26))
+>key : Symbol(IListItem.key, Decl(arrayTypeInSignatureOfInterfaceAndClass.ts, 7, 26))

        data: T;
->data : Symbol(data, Decl(arrayTypeInSignatureOfInterfaceAndClass.ts, 8, 17))
+>data : Symbol(IListItem.data, Decl(arrayTypeInSignatureOfInterfaceAndClass.ts, 8, 17))
 >T : Symbol(T, Decl(arrayTypeInSignatureOfInterfaceAndClass.ts, 6, 31))

        group: any;
->group : Symbol(group, Decl(arrayTypeInSignatureOfInterfaceAndClass.ts, 9, 16))
+>group : Symbol(IListItem.group, Decl(arrayTypeInSignatureOfInterfaceAndClass.ts, 9, 16))

        isHeader: boolean;
->isHeader : Symbol(isHeader, Decl(arrayTypeInSignatureOfInterfaceAndClass.ts, 10, 19))
+>isHeader : Symbol(IListItem.isHeader, Decl(arrayTypeInSignatureOfInterfaceAndClass.ts, 10, 19))

        cached: boolean;
->cached : Symbol(cached, Decl(arrayTypeInSignatureOfInterfaceAndClass.ts, 11, 26))
+>cached : Symbol(IListItem.cached, Decl(arrayTypeInSignatureOfInterfaceAndClass.ts, 11, 26))

        isNonSourceData: boolean;
->isNonSourceData : Symbol(isNonSourceData, Decl(arrayTypeInSignatureOfInterfaceAndClass.ts, 12, 24))
+>isNonSourceData : Symbol(IListItem.isNonSourceData, Decl(arrayTypeInSignatureOfInterfaceAndClass.ts, 12, 24))

        preventAugmentation: boolean;
->preventAugmentation : Symbol(preventAugmentation, Decl(arrayTypeInSignatureOfInterfaceAndClass.ts, 13, 33))
+>preventAugmentation : Symbol(IListItem.preventAugmentation, Decl(arrayTypeInSignatureOfInterfaceAndClass.ts, 13, 33))
    }
    export interface IVirtualList<T> {
 >IVirtualList : Symbol(IVirtualList, Decl(arrayTypeInSignatureOfInterfaceAndClass.ts, 15, 5))
@@ -62,7 +62,7 @@ declare module Data {

        //removeIndices: WinJS.Promise<IListItem<T>[]>;
        removeIndices(indices: number[], options?: any): WinJS.Promise<IListItem<T>[]>;
->removeIndices : Symbol(removeIndices, Decl(arrayTypeInSignatureOfInterfaceAndClass.ts, 16, 38))
+>removeIndices : Symbol(IVirtualList.removeIndices, Decl(arrayTypeInSignatureOfInterfaceAndClass.ts, 16, 38))
 >indices : Symbol(indices, Decl(arrayTypeInSignatureOfInterfaceAndClass.ts, 18, 22))
 >options : Symbol(options, Decl(arrayTypeInSignatureOfInterfaceAndClass.ts, 18, 40))
 >WinJS : Symbol(WinJS, Decl(arrayTypeInSignatureOfInterfaceAndClass.ts, 0, 0))
@@ -78,7 +78,7 @@ declare module Data {

        //removeIndices: WinJS.Promise<IListItem<T>[]>;
        public removeIndices(indices: number[], options?: any): WinJS.Promise<IListItem<T>[]>;
->removeIndices : Symbol(removeIndices, Decl(arrayTypeInSignatureOfInterfaceAndClass.ts, 20, 60))
+>removeIndices : Symbol(VirtualList.removeIndices, Decl(arrayTypeInSignatureOfInterfaceAndClass.ts, 20, 60))
 >indices : Symbol(indices, Decl(arrayTypeInSignatureOfInterfaceAndClass.ts, 22, 29))
 >options : Symbol(options, Decl(arrayTypeInSignatureOfInterfaceAndClass.ts, 22, 47))
 >WinJS : Symbol(WinJS, Decl(arrayTypeInSignatureOfInterfaceAndClass.ts, 0, 0))
@@ -3,46 +3,46 @@ interface IOptions {
 >IOptions : Symbol(IOptions, Decl(arrayconcat.ts, 0, 0))

    name?: string;
->name : Symbol(name, Decl(arrayconcat.ts, 0, 20))
+>name : Symbol(IOptions.name, Decl(arrayconcat.ts, 0, 20))

    flag?: boolean;
->flag : Symbol(flag, Decl(arrayconcat.ts, 1, 18))
+>flag : Symbol(IOptions.flag, Decl(arrayconcat.ts, 1, 18))

    short?: string;
->short : Symbol(short, Decl(arrayconcat.ts, 2, 19))
+>short : Symbol(IOptions.short, Decl(arrayconcat.ts, 2, 19))

    usage?: string;
->usage : Symbol(usage, Decl(arrayconcat.ts, 3, 19))
+>usage : Symbol(IOptions.usage, Decl(arrayconcat.ts, 3, 19))

    set?: (s: string) => void;
->set : Symbol(set, Decl(arrayconcat.ts, 4, 19))
+>set : Symbol(IOptions.set, Decl(arrayconcat.ts, 4, 19))
 >s : Symbol(s, Decl(arrayconcat.ts, 5, 11))

    type?: string;
->type : Symbol(type, Decl(arrayconcat.ts, 5, 30))
+>type : Symbol(IOptions.type, Decl(arrayconcat.ts, 5, 30))

    experimental?: boolean;
->experimental : Symbol(experimental, Decl(arrayconcat.ts, 6, 18))
+>experimental : Symbol(IOptions.experimental, Decl(arrayconcat.ts, 6, 18))
 }

 class parser {
 >parser : Symbol(parser, Decl(arrayconcat.ts, 8, 1))

 	public options: IOptions[];
->options : Symbol(options, Decl(arrayconcat.ts, 10, 14))
+>options : Symbol(parser.options, Decl(arrayconcat.ts, 10, 14))
 >IOptions : Symbol(IOptions, Decl(arrayconcat.ts, 0, 0))

 	public m() {
->m : Symbol(m, Decl(arrayconcat.ts, 11, 28))
+>m : Symbol(parser.m, Decl(arrayconcat.ts, 11, 28))

 		this.options = this.options.sort(function(a, b) {
->this.options : Symbol(options, Decl(arrayconcat.ts, 10, 14))
+>this.options : Symbol(parser.options, Decl(arrayconcat.ts, 10, 14))
 >this : Symbol(parser, Decl(arrayconcat.ts, 8, 1))
->options : Symbol(options, Decl(arrayconcat.ts, 10, 14))
+>options : Symbol(parser.options, Decl(arrayconcat.ts, 10, 14))
 >this.options.sort : Symbol(Array.sort, Decl(lib.d.ts, --, --))
->this.options : Symbol(options, Decl(arrayconcat.ts, 10, 14))
+>this.options : Symbol(parser.options, Decl(arrayconcat.ts, 10, 14))
 >this : Symbol(parser, Decl(arrayconcat.ts, 8, 1))
->options : Symbol(options, Decl(arrayconcat.ts, 10, 14))
+>options : Symbol(parser.options, Decl(arrayconcat.ts, 10, 14))
 >sort : Symbol(Array.sort, Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(arrayconcat.ts, 14, 44))
 >b : Symbol(b, Decl(arrayconcat.ts, 14, 46))
@@ -94,18 +94,18 @@ class MyClass {
 >MyClass : Symbol(MyClass, Decl(arrowFunctionExpressions.ts, 24, 37))

    m = (n) => n + 1;
->m : Symbol(m, Decl(arrowFunctionExpressions.ts, 28, 15))
+>m : Symbol(MyClass.m, Decl(arrowFunctionExpressions.ts, 28, 15))
 >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))
+>p : Symbol(MyClass.p, Decl(arrowFunctionExpressions.ts, 29, 21))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 30, 9))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 30, 9))
 >this : Symbol(MyClass, Decl(arrowFunctionExpressions.ts, 24, 37))

    fn() {
->fn : Symbol(fn, Decl(arrowFunctionExpressions.ts, 30, 25))
+>fn : Symbol(MyClass.fn, Decl(arrowFunctionExpressions.ts, 30, 25))

        var m = (n) => n + 1;
 >m : Symbol(m, Decl(arrowFunctionExpressions.ts, 33, 11))
@@ -5,7 +5,7 @@ class Foo {
 

    defaults = {
->defaults : Symbol(defaults, Decl(asiInES6Classes.ts, 0, 11))
+>defaults : Symbol(Foo.defaults, Decl(asiInES6Classes.ts, 0, 11))

        done: false
 >done : Symbol(done, Decl(asiInES6Classes.ts, 4, 16))
@@ -15,7 +15,7 @@ class Foo {
 

    bar() {
->bar : Symbol(bar, Decl(asiInES6Classes.ts, 8, 5))
+>bar : Symbol(Foo.bar, Decl(asiInES6Classes.ts, 8, 5))

        return 3;

@@ -6,10 +6,10 @@ module M {
 >I : Symbol(I, Decl(assign1.ts, 0, 10))

        salt:number;
->salt : Symbol(salt, Decl(assign1.ts, 1, 17))
+>salt : Symbol(I.salt, Decl(assign1.ts, 1, 17))

        pepper:number;
->pepper : Symbol(pepper, Decl(assign1.ts, 2, 20))
+>pepper : Symbol(I.pepper, Decl(assign1.ts, 2, 20))
    }

    var x:I={salt:2,pepper:0};
@@ -84,7 +84,7 @@ interface I {
 >I : Symbol(I, Decl(assignEveryTypeToAny.ts, 31, 6))

    foo: string;
->foo : Symbol(foo, Decl(assignEveryTypeToAny.ts, 33, 13))
+>foo : Symbol(I.foo, Decl(assignEveryTypeToAny.ts, 33, 13))
 }

 var g: I;
@@ -99,7 +99,7 @@ class C {
 >C : Symbol(C, Decl(assignEveryTypeToAny.ts, 38, 6))

    bar: string;
->bar : Symbol(bar, Decl(assignEveryTypeToAny.ts, 40, 9))
+>bar : Symbol(C.bar, Decl(assignEveryTypeToAny.ts, 40, 9))
 }

 var h: C;
@@ -3,7 +3,7 @@ declare class Point {
 >Point : Symbol(Point, Decl(assignToPrototype1.ts, 0, 0))

  add(dx: number, dy: number): void;
->add : Symbol(add, Decl(assignToPrototype1.ts, 0, 21))
+>add : Symbol(Point.add, Decl(assignToPrototype1.ts, 0, 21))
 >dx : Symbol(dx, Decl(assignToPrototype1.ts, 1, 6))
 >dy : Symbol(dy, Decl(assignToPrototype1.ts, 1, 17))
 }
@@ -3,22 +3,22 @@

 class Base { foo: string; }
 >Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures3.ts, 0, 0))
->foo : Symbol(foo, Decl(assignmentCompatWithCallSignatures3.ts, 2, 12))
+>foo : Symbol(Base.foo, Decl(assignmentCompatWithCallSignatures3.ts, 2, 12))

 class Derived extends Base { bar: string; }
 >Derived : Symbol(Derived, Decl(assignmentCompatWithCallSignatures3.ts, 2, 27))
 >Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures3.ts, 0, 0))
->bar : Symbol(bar, Decl(assignmentCompatWithCallSignatures3.ts, 3, 28))
+>bar : Symbol(Derived.bar, Decl(assignmentCompatWithCallSignatures3.ts, 3, 28))

 class Derived2 extends Derived { baz: string; }
 >Derived2 : Symbol(Derived2, Decl(assignmentCompatWithCallSignatures3.ts, 3, 43))
 >Derived : Symbol(Derived, Decl(assignmentCompatWithCallSignatures3.ts, 2, 27))
->baz : Symbol(baz, Decl(assignmentCompatWithCallSignatures3.ts, 4, 32))
+>baz : Symbol(Derived2.baz, Decl(assignmentCompatWithCallSignatures3.ts, 4, 32))

 class OtherDerived extends Base { bing: string; }
 >OtherDerived : Symbol(OtherDerived, Decl(assignmentCompatWithCallSignatures3.ts, 4, 47))
 >Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures3.ts, 0, 0))
->bing : Symbol(bing, Decl(assignmentCompatWithCallSignatures3.ts, 5, 33))
+>bing : Symbol(OtherDerived.bing, Decl(assignmentCompatWithCallSignatures3.ts, 5, 33))

 var a: (x: number) => number[];
 >a : Symbol(a, Decl(assignmentCompatWithCallSignatures3.ts, 7, 3))
@@ -3,22 +3,22 @@

 class Base { foo: string; }
 >Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures5.ts, 0, 0))
->foo : Symbol(foo, Decl(assignmentCompatWithCallSignatures5.ts, 2, 12))
+>foo : Symbol(Base.foo, Decl(assignmentCompatWithCallSignatures5.ts, 2, 12))

 class Derived extends Base { bar: string; }
 >Derived : Symbol(Derived, Decl(assignmentCompatWithCallSignatures5.ts, 2, 27))
 >Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures5.ts, 0, 0))
->bar : Symbol(bar, Decl(assignmentCompatWithCallSignatures5.ts, 3, 28))
+>bar : Symbol(Derived.bar, Decl(assignmentCompatWithCallSignatures5.ts, 3, 28))

 class Derived2 extends Derived { baz: string; }
 >Derived2 : Symbol(Derived2, Decl(assignmentCompatWithCallSignatures5.ts, 3, 43))
 >Derived : Symbol(Derived, Decl(assignmentCompatWithCallSignatures5.ts, 2, 27))
->baz : Symbol(baz, Decl(assignmentCompatWithCallSignatures5.ts, 4, 32))
+>baz : Symbol(Derived2.baz, Decl(assignmentCompatWithCallSignatures5.ts, 4, 32))

 class OtherDerived extends Base { bing: string; }
 >OtherDerived : Symbol(OtherDerived, Decl(assignmentCompatWithCallSignatures5.ts, 4, 47))
 >Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures5.ts, 0, 0))
->bing : Symbol(bing, Decl(assignmentCompatWithCallSignatures5.ts, 5, 33))
+>bing : Symbol(OtherDerived.bing, Decl(assignmentCompatWithCallSignatures5.ts, 5, 33))

 var a: <T>(x: T) => T[];
 >a : Symbol(a, Decl(assignmentCompatWithCallSignatures5.ts, 7, 3))
@@ -3,47 +3,47 @@

 class Base { foo: string; }
 >Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures6.ts, 0, 0))
->foo : Symbol(foo, Decl(assignmentCompatWithCallSignatures6.ts, 2, 12))
+>foo : Symbol(Base.foo, Decl(assignmentCompatWithCallSignatures6.ts, 2, 12))

 class Derived extends Base { bar: string; }
 >Derived : Symbol(Derived, Decl(assignmentCompatWithCallSignatures6.ts, 2, 27))
 >Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures6.ts, 0, 0))
->bar : Symbol(bar, Decl(assignmentCompatWithCallSignatures6.ts, 3, 28))
+>bar : Symbol(Derived.bar, Decl(assignmentCompatWithCallSignatures6.ts, 3, 28))

 class Derived2 extends Derived { baz: string; }
 >Derived2 : Symbol(Derived2, Decl(assignmentCompatWithCallSignatures6.ts, 3, 43))
 >Derived : Symbol(Derived, Decl(assignmentCompatWithCallSignatures6.ts, 2, 27))
->baz : Symbol(baz, Decl(assignmentCompatWithCallSignatures6.ts, 4, 32))
+>baz : Symbol(Derived2.baz, Decl(assignmentCompatWithCallSignatures6.ts, 4, 32))

 class OtherDerived extends Base { bing: string; }
 >OtherDerived : Symbol(OtherDerived, Decl(assignmentCompatWithCallSignatures6.ts, 4, 47))
 >Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures6.ts, 0, 0))
->bing : Symbol(bing, Decl(assignmentCompatWithCallSignatures6.ts, 5, 33))
+>bing : Symbol(OtherDerived.bing, Decl(assignmentCompatWithCallSignatures6.ts, 5, 33))

 interface A {
 >A : Symbol(A, Decl(assignmentCompatWithCallSignatures6.ts, 5, 49))

    a: <T>(x: T) => T[];
->a : Symbol(a, Decl(assignmentCompatWithCallSignatures6.ts, 7, 13))
+>a : Symbol(A.a, Decl(assignmentCompatWithCallSignatures6.ts, 7, 13))
 >T : Symbol(T, Decl(assignmentCompatWithCallSignatures6.ts, 8, 8))
 >x : Symbol(x, Decl(assignmentCompatWithCallSignatures6.ts, 8, 11))
 >T : Symbol(T, Decl(assignmentCompatWithCallSignatures6.ts, 8, 8))
 >T : Symbol(T, Decl(assignmentCompatWithCallSignatures6.ts, 8, 8))

    a2: <T>(x: T) => string[];
->a2 : Symbol(a2, Decl(assignmentCompatWithCallSignatures6.ts, 8, 24))
+>a2 : Symbol(A.a2, Decl(assignmentCompatWithCallSignatures6.ts, 8, 24))
 >T : Symbol(T, Decl(assignmentCompatWithCallSignatures6.ts, 9, 9))
 >x : Symbol(x, Decl(assignmentCompatWithCallSignatures6.ts, 9, 12))
 >T : Symbol(T, Decl(assignmentCompatWithCallSignatures6.ts, 9, 9))

    a3: <T>(x: T) => void;
->a3 : Symbol(a3, Decl(assignmentCompatWithCallSignatures6.ts, 9, 30))
+>a3 : Symbol(A.a3, Decl(assignmentCompatWithCallSignatures6.ts, 9, 30))
 >T : Symbol(T, Decl(assignmentCompatWithCallSignatures6.ts, 10, 9))
 >x : Symbol(x, Decl(assignmentCompatWithCallSignatures6.ts, 10, 12))
 >T : Symbol(T, Decl(assignmentCompatWithCallSignatures6.ts, 10, 9))

    a4: <T,U>(x: T, y: U) => string;
->a4 : Symbol(a4, Decl(assignmentCompatWithCallSignatures6.ts, 10, 26))
+>a4 : Symbol(A.a4, Decl(assignmentCompatWithCallSignatures6.ts, 10, 26))
 >T : Symbol(T, Decl(assignmentCompatWithCallSignatures6.ts, 11, 9))
 >U : Symbol(U, Decl(assignmentCompatWithCallSignatures6.ts, 11, 11))
 >x : Symbol(x, Decl(assignmentCompatWithCallSignatures6.ts, 11, 14))
@@ -52,7 +52,7 @@ interface A {
 >U : Symbol(U, Decl(assignmentCompatWithCallSignatures6.ts, 11, 11))

    a5: <T,U>(x: (arg: T) => U) => T;
->a5 : Symbol(a5, Decl(assignmentCompatWithCallSignatures6.ts, 11, 36))
+>a5 : Symbol(A.a5, Decl(assignmentCompatWithCallSignatures6.ts, 11, 36))
 >T : Symbol(T, Decl(assignmentCompatWithCallSignatures6.ts, 12, 9))
 >U : Symbol(U, Decl(assignmentCompatWithCallSignatures6.ts, 12, 11))
 >x : Symbol(x, Decl(assignmentCompatWithCallSignatures6.ts, 12, 14))
@@ -62,7 +62,7 @@ interface A {
 >T : Symbol(T, Decl(assignmentCompatWithCallSignatures6.ts, 12, 9))

    a6: <T extends Base>(x: (arg: T) => Derived) => T;
->a6 : Symbol(a6, Decl(assignmentCompatWithCallSignatures6.ts, 12, 37))
+>a6 : Symbol(A.a6, Decl(assignmentCompatWithCallSignatures6.ts, 12, 37))
 >T : Symbol(T, Decl(assignmentCompatWithCallSignatures6.ts, 13, 9))
 >Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures6.ts, 0, 0))
 >x : Symbol(x, Decl(assignmentCompatWithCallSignatures6.ts, 13, 25))
@@ -72,7 +72,7 @@ interface A {
 >T : Symbol(T, Decl(assignmentCompatWithCallSignatures6.ts, 13, 9))

    a11: <T>(x: { foo: T }, y: { foo: T; bar: T }) => Base;
->a11 : Symbol(a11, Decl(assignmentCompatWithCallSignatures6.ts, 13, 54))
+>a11 : Symbol(A.a11, Decl(assignmentCompatWithCallSignatures6.ts, 13, 54))
 >T : Symbol(T, Decl(assignmentCompatWithCallSignatures6.ts, 14, 10))
 >x : Symbol(x, Decl(assignmentCompatWithCallSignatures6.ts, 14, 13))
 >foo : Symbol(foo, Decl(assignmentCompatWithCallSignatures6.ts, 14, 17))
@@ -85,7 +85,7 @@ interface A {
 >Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures6.ts, 0, 0))

    a15: <T>(x: { a: T; b: T }) => T[];
->a15 : Symbol(a15, Decl(assignmentCompatWithCallSignatures6.ts, 14, 59))
+>a15 : Symbol(A.a15, Decl(assignmentCompatWithCallSignatures6.ts, 14, 59))
 >T : Symbol(T, Decl(assignmentCompatWithCallSignatures6.ts, 15, 10))
 >x : Symbol(x, Decl(assignmentCompatWithCallSignatures6.ts, 15, 13))
 >a : Symbol(a, Decl(assignmentCompatWithCallSignatures6.ts, 15, 17))
@@ -95,7 +95,7 @@ interface A {
 >T : Symbol(T, Decl(assignmentCompatWithCallSignatures6.ts, 15, 10))

    a16: <T extends Base>(x: { a: T; b: T }) => T[];
->a16 : Symbol(a16, Decl(assignmentCompatWithCallSignatures6.ts, 15, 39))
+>a16 : Symbol(A.a16, Decl(assignmentCompatWithCallSignatures6.ts, 15, 39))
 >T : Symbol(T, Decl(assignmentCompatWithCallSignatures6.ts, 16, 10))
 >Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures6.ts, 0, 0))
 >x : Symbol(x, Decl(assignmentCompatWithCallSignatures6.ts, 16, 26))
@@ -3,22 +3,22 @@

 class Base { foo: string; }
 >Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures3.ts, 0, 0))
->foo : Symbol(foo, Decl(assignmentCompatWithConstructSignatures3.ts, 2, 12))
+>foo : Symbol(Base.foo, Decl(assignmentCompatWithConstructSignatures3.ts, 2, 12))

 class Derived extends Base { bar: string; }
 >Derived : Symbol(Derived, Decl(assignmentCompatWithConstructSignatures3.ts, 2, 27))
 >Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures3.ts, 0, 0))
->bar : Symbol(bar, Decl(assignmentCompatWithConstructSignatures3.ts, 3, 28))
+>bar : Symbol(Derived.bar, Decl(assignmentCompatWithConstructSignatures3.ts, 3, 28))

 class Derived2 extends Derived { baz: string; }
 >Derived2 : Symbol(Derived2, Decl(assignmentCompatWithConstructSignatures3.ts, 3, 43))
 >Derived : Symbol(Derived, Decl(assignmentCompatWithConstructSignatures3.ts, 2, 27))
->baz : Symbol(baz, Decl(assignmentCompatWithConstructSignatures3.ts, 4, 32))
+>baz : Symbol(Derived2.baz, Decl(assignmentCompatWithConstructSignatures3.ts, 4, 32))

 class OtherDerived extends Base { bing: string; }
 >OtherDerived : Symbol(OtherDerived, Decl(assignmentCompatWithConstructSignatures3.ts, 4, 47))
 >Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures3.ts, 0, 0))
->bing : Symbol(bing, Decl(assignmentCompatWithConstructSignatures3.ts, 5, 33))
+>bing : Symbol(OtherDerived.bing, Decl(assignmentCompatWithConstructSignatures3.ts, 5, 33))

 var a: new (x: number) => number[];
 >a : Symbol(a, Decl(assignmentCompatWithConstructSignatures3.ts, 7, 3))
@@ -3,22 +3,22 @@

 class Base { foo: string; }
 >Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures5.ts, 0, 0))
->foo : Symbol(foo, Decl(assignmentCompatWithConstructSignatures5.ts, 2, 12))
+>foo : Symbol(Base.foo, Decl(assignmentCompatWithConstructSignatures5.ts, 2, 12))

 class Derived extends Base { bar: string; }
 >Derived : Symbol(Derived, Decl(assignmentCompatWithConstructSignatures5.ts, 2, 27))
 >Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures5.ts, 0, 0))
->bar : Symbol(bar, Decl(assignmentCompatWithConstructSignatures5.ts, 3, 28))
+>bar : Symbol(Derived.bar, Decl(assignmentCompatWithConstructSignatures5.ts, 3, 28))

 class Derived2 extends Derived { baz: string; }
 >Derived2 : Symbol(Derived2, Decl(assignmentCompatWithConstructSignatures5.ts, 3, 43))
 >Derived : Symbol(Derived, Decl(assignmentCompatWithConstructSignatures5.ts, 2, 27))
->baz : Symbol(baz, Decl(assignmentCompatWithConstructSignatures5.ts, 4, 32))
+>baz : Symbol(Derived2.baz, Decl(assignmentCompatWithConstructSignatures5.ts, 4, 32))

 class OtherDerived extends Base { bing: string; }
 >OtherDerived : Symbol(OtherDerived, Decl(assignmentCompatWithConstructSignatures5.ts, 4, 47))
 >Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures5.ts, 0, 0))
->bing : Symbol(bing, Decl(assignmentCompatWithConstructSignatures5.ts, 5, 33))
+>bing : Symbol(OtherDerived.bing, Decl(assignmentCompatWithConstructSignatures5.ts, 5, 33))

 var a: new <T>(x: T) => T[];
 >a : Symbol(a, Decl(assignmentCompatWithConstructSignatures5.ts, 7, 3))
@@ -3,47 +3,47 @@

 class Base { foo: string; }
 >Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures6.ts, 0, 0))
->foo : Symbol(foo, Decl(assignmentCompatWithConstructSignatures6.ts, 2, 12))
+>foo : Symbol(Base.foo, Decl(assignmentCompatWithConstructSignatures6.ts, 2, 12))

 class Derived extends Base { bar: string; }
 >Derived : Symbol(Derived, Decl(assignmentCompatWithConstructSignatures6.ts, 2, 27))
 >Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures6.ts, 0, 0))
->bar : Symbol(bar, Decl(assignmentCompatWithConstructSignatures6.ts, 3, 28))
+>bar : Symbol(Derived.bar, Decl(assignmentCompatWithConstructSignatures6.ts, 3, 28))

 class Derived2 extends Derived { baz: string; }
 >Derived2 : Symbol(Derived2, Decl(assignmentCompatWithConstructSignatures6.ts, 3, 43))
 >Derived : Symbol(Derived, Decl(assignmentCompatWithConstructSignatures6.ts, 2, 27))
->baz : Symbol(baz, Decl(assignmentCompatWithConstructSignatures6.ts, 4, 32))
+>baz : Symbol(Derived2.baz, Decl(assignmentCompatWithConstructSignatures6.ts, 4, 32))

 class OtherDerived extends Base { bing: string; }
 >OtherDerived : Symbol(OtherDerived, Decl(assignmentCompatWithConstructSignatures6.ts, 4, 47))
 >Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures6.ts, 0, 0))
->bing : Symbol(bing, Decl(assignmentCompatWithConstructSignatures6.ts, 5, 33))
+>bing : Symbol(OtherDerived.bing, Decl(assignmentCompatWithConstructSignatures6.ts, 5, 33))

 interface A {
 >A : Symbol(A, Decl(assignmentCompatWithConstructSignatures6.ts, 5, 49))

    a: new <T>(x: T) => T[];
->a : Symbol(a, Decl(assignmentCompatWithConstructSignatures6.ts, 7, 13))
+>a : Symbol(A.a, Decl(assignmentCompatWithConstructSignatures6.ts, 7, 13))
 >T : Symbol(T, Decl(assignmentCompatWithConstructSignatures6.ts, 8, 12))
 >x : Symbol(x, Decl(assignmentCompatWithConstructSignatures6.ts, 8, 15))
 >T : Symbol(T, Decl(assignmentCompatWithConstructSignatures6.ts, 8, 12))
 >T : Symbol(T, Decl(assignmentCompatWithConstructSignatures6.ts, 8, 12))

    a2: new <T>(x: T) => string[];
->a2 : Symbol(a2, Decl(assignmentCompatWithConstructSignatures6.ts, 8, 28))
+>a2 : Symbol(A.a2, Decl(assignmentCompatWithConstructSignatures6.ts, 8, 28))
 >T : Symbol(T, Decl(assignmentCompatWithConstructSignatures6.ts, 9, 13))
 >x : Symbol(x, Decl(assignmentCompatWithConstructSignatures6.ts, 9, 16))
 >T : Symbol(T, Decl(assignmentCompatWithConstructSignatures6.ts, 9, 13))

    a3: new <T>(x: T) => void;
->a3 : Symbol(a3, Decl(assignmentCompatWithConstructSignatures6.ts, 9, 34))
+>a3 : Symbol(A.a3, Decl(assignmentCompatWithConstructSignatures6.ts, 9, 34))
 >T : Symbol(T, Decl(assignmentCompatWithConstructSignatures6.ts, 10, 13))
 >x : Symbol(x, Decl(assignmentCompatWithConstructSignatures6.ts, 10, 16))
 >T : Symbol(T, Decl(assignmentCompatWithConstructSignatures6.ts, 10, 13))

    a4: new <T, U>(x: T, y: U) => string;
->a4 : Symbol(a4, Decl(assignmentCompatWithConstructSignatures6.ts, 10, 30))
+>a4 : Symbol(A.a4, Decl(assignmentCompatWithConstructSignatures6.ts, 10, 30))
 >T : Symbol(T, Decl(assignmentCompatWithConstructSignatures6.ts, 11, 13))
 >U : Symbol(U, Decl(assignmentCompatWithConstructSignatures6.ts, 11, 15))
 >x : Symbol(x, Decl(assignmentCompatWithConstructSignatures6.ts, 11, 19))
@@ -52,7 +52,7 @@ interface A {
 >U : Symbol(U, Decl(assignmentCompatWithConstructSignatures6.ts, 11, 15))

    a5: new <T, U>(x: (arg: T) => U) => T;
->a5 : Symbol(a5, Decl(assignmentCompatWithConstructSignatures6.ts, 11, 41))
+>a5 : Symbol(A.a5, Decl(assignmentCompatWithConstructSignatures6.ts, 11, 41))
 >T : Symbol(T, Decl(assignmentCompatWithConstructSignatures6.ts, 12, 13))
 >U : Symbol(U, Decl(assignmentCompatWithConstructSignatures6.ts, 12, 15))
 >x : Symbol(x, Decl(assignmentCompatWithConstructSignatures6.ts, 12, 19))
@@ -62,7 +62,7 @@ interface A {
 >T : Symbol(T, Decl(assignmentCompatWithConstructSignatures6.ts, 12, 13))

    a6: new <T extends Base>(x: (arg: T) => Derived) => T;
->a6 : Symbol(a6, Decl(assignmentCompatWithConstructSignatures6.ts, 12, 42))
+>a6 : Symbol(A.a6, Decl(assignmentCompatWithConstructSignatures6.ts, 12, 42))
 >T : Symbol(T, Decl(assignmentCompatWithConstructSignatures6.ts, 13, 13))
 >Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures6.ts, 0, 0))
 >x : Symbol(x, Decl(assignmentCompatWithConstructSignatures6.ts, 13, 29))
@@ -72,7 +72,7 @@ interface A {
 >T : Symbol(T, Decl(assignmentCompatWithConstructSignatures6.ts, 13, 13))

    a11: new <T>(x: { foo: T }, y: { foo: T; bar: T }) => Base;
->a11 : Symbol(a11, Decl(assignmentCompatWithConstructSignatures6.ts, 13, 58))
+>a11 : Symbol(A.a11, Decl(assignmentCompatWithConstructSignatures6.ts, 13, 58))
 >T : Symbol(T, Decl(assignmentCompatWithConstructSignatures6.ts, 14, 14))
 >x : Symbol(x, Decl(assignmentCompatWithConstructSignatures6.ts, 14, 17))
 >foo : Symbol(foo, Decl(assignmentCompatWithConstructSignatures6.ts, 14, 21))
@@ -85,7 +85,7 @@ interface A {
 >Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures6.ts, 0, 0))

    a15: new <T>(x: { a: T; b: T }) => T[];
->a15 : Symbol(a15, Decl(assignmentCompatWithConstructSignatures6.ts, 14, 63))
+>a15 : Symbol(A.a15, Decl(assignmentCompatWithConstructSignatures6.ts, 14, 63))
 >T : Symbol(T, Decl(assignmentCompatWithConstructSignatures6.ts, 15, 14))
 >x : Symbol(x, Decl(assignmentCompatWithConstructSignatures6.ts, 15, 17))
 >a : Symbol(a, Decl(assignmentCompatWithConstructSignatures6.ts, 15, 21))
@@ -95,7 +95,7 @@ interface A {
 >T : Symbol(T, Decl(assignmentCompatWithConstructSignatures6.ts, 15, 14))

    a16: new <T extends Base>(x: { a: T; b: T }) => T[];
->a16 : Symbol(a16, Decl(assignmentCompatWithConstructSignatures6.ts, 15, 43))
+>a16 : Symbol(A.a16, Decl(assignmentCompatWithConstructSignatures6.ts, 15, 43))
 >T : Symbol(T, Decl(assignmentCompatWithConstructSignatures6.ts, 16, 14))
 >Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures6.ts, 0, 0))
 >x : Symbol(x, Decl(assignmentCompatWithConstructSignatures6.ts, 16, 30))
@@ -6,7 +6,7 @@ interface I2<T> {
 >T : Symbol(T, Decl(assignmentCompatWithGenericCallSignatures4.ts, 2, 13))

    p: T
->p : Symbol(p, Decl(assignmentCompatWithGenericCallSignatures4.ts, 2, 17))
+>p : Symbol(I2.p, Decl(assignmentCompatWithGenericCallSignatures4.ts, 2, 17))
 >T : Symbol(T, Decl(assignmentCompatWithGenericCallSignatures4.ts, 2, 13))
 }

@@ -7,11 +7,11 @@ module SimpleTypes {

    class S { foo: string; }
 >S : Symbol(S, Decl(assignmentCompatWithObjectMembers.ts, 3, 20))
->foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers.ts, 4, 13))
+>foo : Symbol(S.foo, Decl(assignmentCompatWithObjectMembers.ts, 4, 13))

    class T { foo: string; }
 >T : Symbol(T, Decl(assignmentCompatWithObjectMembers.ts, 4, 28))
->foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers.ts, 5, 13))
+>foo : Symbol(T.foo, Decl(assignmentCompatWithObjectMembers.ts, 5, 13))

    var s: S;
 >s : Symbol(s, Decl(assignmentCompatWithObjectMembers.ts, 6, 7))
@@ -23,11 +23,11 @@ module SimpleTypes {

    interface S2 { foo: string; }
 >S2 : Symbol(S2, Decl(assignmentCompatWithObjectMembers.ts, 7, 13))
->foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers.ts, 9, 18))
+>foo : Symbol(S2.foo, Decl(assignmentCompatWithObjectMembers.ts, 9, 18))

    interface T2 { foo: string; }
 >T2 : Symbol(T2, Decl(assignmentCompatWithObjectMembers.ts, 9, 33))
->foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers.ts, 10, 18))
+>foo : Symbol(T2.foo, Decl(assignmentCompatWithObjectMembers.ts, 10, 18))

    var s2: S2;
 >s2 : Symbol(s2, Decl(assignmentCompatWithObjectMembers.ts, 11, 7))
@@ -135,12 +135,12 @@ module ObjectTypes {

    class S { foo: S; }
 >S : Symbol(S, Decl(assignmentCompatWithObjectMembers.ts, 44, 20))
->foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers.ts, 45, 13))
+>foo : Symbol(S.foo, Decl(assignmentCompatWithObjectMembers.ts, 45, 13))
 >S : Symbol(S, Decl(assignmentCompatWithObjectMembers.ts, 44, 20))

    class T { foo: T; }
 >T : Symbol(T, Decl(assignmentCompatWithObjectMembers.ts, 45, 23))
->foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers.ts, 46, 13))
+>foo : Symbol(T.foo, Decl(assignmentCompatWithObjectMembers.ts, 46, 13))
 >T : Symbol(T, Decl(assignmentCompatWithObjectMembers.ts, 45, 23))

    var s: S;
@@ -153,12 +153,12 @@ module ObjectTypes {

    interface S2 { foo: S2; }
 >S2 : Symbol(S2, Decl(assignmentCompatWithObjectMembers.ts, 48, 13))
->foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers.ts, 50, 18))
+>foo : Symbol(S2.foo, Decl(assignmentCompatWithObjectMembers.ts, 50, 18))
 >S2 : Symbol(S2, Decl(assignmentCompatWithObjectMembers.ts, 48, 13))

    interface T2 { foo: T2; }
 >T2 : Symbol(T2, Decl(assignmentCompatWithObjectMembers.ts, 50, 29))
->foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers.ts, 51, 18))
+>foo : Symbol(T2.foo, Decl(assignmentCompatWithObjectMembers.ts, 51, 18))
 >T2 : Symbol(T2, Decl(assignmentCompatWithObjectMembers.ts, 50, 29))

    var s2: S2;
@@ -4,11 +4,11 @@

 class S { foo: string; }
 >S : Symbol(S, Decl(assignmentCompatWithObjectMembers2.ts, 0, 0))
->foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers2.ts, 3, 9))
+>foo : Symbol(S.foo, Decl(assignmentCompatWithObjectMembers2.ts, 3, 9))

 class T { foo: string; }
 >T : Symbol(T, Decl(assignmentCompatWithObjectMembers2.ts, 3, 24))
->foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers2.ts, 4, 9))
+>foo : Symbol(T.foo, Decl(assignmentCompatWithObjectMembers2.ts, 4, 9))

 var s: S;
 >s : Symbol(s, Decl(assignmentCompatWithObjectMembers2.ts, 5, 3))
@@ -20,13 +20,13 @@ var t: T;

 interface S2 { foo: string; bar?: string }
 >S2 : Symbol(S2, Decl(assignmentCompatWithObjectMembers2.ts, 6, 9))
->foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers2.ts, 8, 14))
->bar : Symbol(bar, Decl(assignmentCompatWithObjectMembers2.ts, 8, 27))
+>foo : Symbol(S2.foo, Decl(assignmentCompatWithObjectMembers2.ts, 8, 14))
+>bar : Symbol(S2.bar, Decl(assignmentCompatWithObjectMembers2.ts, 8, 27))

 interface T2 { foo: string; baz?: string }
 >T2 : Symbol(T2, Decl(assignmentCompatWithObjectMembers2.ts, 8, 42))
->foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers2.ts, 9, 14))
->baz : Symbol(baz, Decl(assignmentCompatWithObjectMembers2.ts, 9, 27))
+>foo : Symbol(T2.foo, Decl(assignmentCompatWithObjectMembers2.ts, 9, 14))
+>baz : Symbol(T2.baz, Decl(assignmentCompatWithObjectMembers2.ts, 9, 27))

 var s2: S2;
 >s2 : Symbol(s2, Decl(assignmentCompatWithObjectMembers2.ts, 10, 3))
@@ -5,12 +5,12 @@
 class S implements S2 { foo: string; }
 >S : Symbol(S, Decl(assignmentCompatWithObjectMembers3.ts, 0, 0))
 >S2 : Symbol(S2, Decl(assignmentCompatWithObjectMembers3.ts, 6, 9))
->foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers3.ts, 3, 23))
+>foo : Symbol(S.foo, Decl(assignmentCompatWithObjectMembers3.ts, 3, 23))

 class T implements T2 { foo: string; }
 >T : Symbol(T, Decl(assignmentCompatWithObjectMembers3.ts, 3, 38))
 >T2 : Symbol(T2, Decl(assignmentCompatWithObjectMembers3.ts, 8, 42))
->foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers3.ts, 4, 23))
+>foo : Symbol(T.foo, Decl(assignmentCompatWithObjectMembers3.ts, 4, 23))

 var s: S;
 >s : Symbol(s, Decl(assignmentCompatWithObjectMembers3.ts, 5, 3))
@@ -22,13 +22,13 @@ var t: T;

 interface S2 { foo: string; bar?: string }
 >S2 : Symbol(S2, Decl(assignmentCompatWithObjectMembers3.ts, 6, 9))
->foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers3.ts, 8, 14))
->bar : Symbol(bar, Decl(assignmentCompatWithObjectMembers3.ts, 8, 27))
+>foo : Symbol(S2.foo, Decl(assignmentCompatWithObjectMembers3.ts, 8, 14))
+>bar : Symbol(S2.bar, Decl(assignmentCompatWithObjectMembers3.ts, 8, 27))

 interface T2 { foo: string; baz?: string }
 >T2 : Symbol(T2, Decl(assignmentCompatWithObjectMembers3.ts, 8, 42))
->foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers3.ts, 9, 14))
->baz : Symbol(baz, Decl(assignmentCompatWithObjectMembers3.ts, 9, 27))
+>foo : Symbol(T2.foo, Decl(assignmentCompatWithObjectMembers3.ts, 9, 14))
+>baz : Symbol(T2.baz, Decl(assignmentCompatWithObjectMembers3.ts, 9, 27))

 var s2: S2;
 >s2 : Symbol(s2, Decl(assignmentCompatWithObjectMembers3.ts, 10, 3))
@@ -18,11 +18,11 @@ var t: T;

 interface S2 { 1: string; bar?: string }
 >S2 : Symbol(S2, Decl(assignmentCompatWithObjectMembersNumericNames.ts, 6, 9))
->bar : Symbol(bar, Decl(assignmentCompatWithObjectMembersNumericNames.ts, 8, 25))
+>bar : Symbol(S2.bar, Decl(assignmentCompatWithObjectMembersNumericNames.ts, 8, 25))

 interface T2 { 1.0: string; baz?: string }
 >T2 : Symbol(T2, Decl(assignmentCompatWithObjectMembersNumericNames.ts, 8, 40))
->baz : Symbol(baz, Decl(assignmentCompatWithObjectMembersNumericNames.ts, 9, 27))
+>baz : Symbol(T2.baz, Decl(assignmentCompatWithObjectMembersNumericNames.ts, 9, 27))

 var s2: S2;
 >s2 : Symbol(s2, Decl(assignmentCompatWithObjectMembersNumericNames.ts, 10, 3))
@@ -6,9 +6,9 @@ module __test1__ {
 >interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability1.ts, 0, 18))
 >T : Symbol(T, Decl(assignmentCompatability1.ts, 1, 52))
 >U : Symbol(U, Decl(assignmentCompatability1.ts, 1, 54))
->one : Symbol(one, Decl(assignmentCompatability1.ts, 1, 58))
+>one : Symbol(interfaceWithPublicAndOptional.one, Decl(assignmentCompatability1.ts, 1, 58))
 >T : Symbol(T, Decl(assignmentCompatability1.ts, 1, 52))
->two : Symbol(two, Decl(assignmentCompatability1.ts, 1, 66))
+>two : Symbol(interfaceWithPublicAndOptional.two, Decl(assignmentCompatability1.ts, 1, 66))
 >U : Symbol(U, Decl(assignmentCompatability1.ts, 1, 54))
 >obj4 : Symbol(obj4, Decl(assignmentCompatability1.ts, 1, 83))
 >interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability1.ts, 0, 18))
@@ -6,9 +6,9 @@ module __test1__ {
 >interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability2.ts, 0, 18))
 >T : Symbol(T, Decl(assignmentCompatability2.ts, 1, 52))
 >U : Symbol(U, Decl(assignmentCompatability2.ts, 1, 54))
->one : Symbol(one, Decl(assignmentCompatability2.ts, 1, 58))
+>one : Symbol(interfaceWithPublicAndOptional.one, Decl(assignmentCompatability2.ts, 1, 58))
 >T : Symbol(T, Decl(assignmentCompatability2.ts, 1, 52))
->two : Symbol(two, Decl(assignmentCompatability2.ts, 1, 66))
+>two : Symbol(interfaceWithPublicAndOptional.two, Decl(assignmentCompatability2.ts, 1, 66))
 >U : Symbol(U, Decl(assignmentCompatability2.ts, 1, 54))
 >obj4 : Symbol(obj4, Decl(assignmentCompatability2.ts, 1, 83))
 >interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability2.ts, 0, 18))
@@ -6,9 +6,9 @@ module __test1__ {
 >interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability3.ts, 0, 18))
 >T : Symbol(T, Decl(assignmentCompatability3.ts, 1, 52))
 >U : Symbol(U, Decl(assignmentCompatability3.ts, 1, 54))
->one : Symbol(one, Decl(assignmentCompatability3.ts, 1, 58))
+>one : Symbol(interfaceWithPublicAndOptional.one, Decl(assignmentCompatability3.ts, 1, 58))
 >T : Symbol(T, Decl(assignmentCompatability3.ts, 1, 52))
->two : Symbol(two, Decl(assignmentCompatability3.ts, 1, 66))
+>two : Symbol(interfaceWithPublicAndOptional.two, Decl(assignmentCompatability3.ts, 1, 66))
 >U : Symbol(U, Decl(assignmentCompatability3.ts, 1, 54))
 >obj4 : Symbol(obj4, Decl(assignmentCompatability3.ts, 1, 83))
 >interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability3.ts, 0, 18))
@@ -6,9 +6,9 @@ module __test1__ {
 >interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability36.ts, 0, 18))
 >T : Symbol(T, Decl(assignmentCompatability36.ts, 1, 52))
 >U : Symbol(U, Decl(assignmentCompatability36.ts, 1, 54))
->one : Symbol(one, Decl(assignmentCompatability36.ts, 1, 58))
+>one : Symbol(interfaceWithPublicAndOptional.one, Decl(assignmentCompatability36.ts, 1, 58))
 >T : Symbol(T, Decl(assignmentCompatability36.ts, 1, 52))
->two : Symbol(two, Decl(assignmentCompatability36.ts, 1, 66))
+>two : Symbol(interfaceWithPublicAndOptional.two, Decl(assignmentCompatability36.ts, 1, 66))
 >U : Symbol(U, Decl(assignmentCompatability36.ts, 1, 54))
 >obj4 : Symbol(obj4, Decl(assignmentCompatability36.ts, 1, 83))
 >interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability36.ts, 0, 18))
@@ -6,9 +6,9 @@ module __test1__ {
 >interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability4.ts, 0, 18))
 >T : Symbol(T, Decl(assignmentCompatability4.ts, 1, 52))
 >U : Symbol(U, Decl(assignmentCompatability4.ts, 1, 54))
->one : Symbol(one, Decl(assignmentCompatability4.ts, 1, 58))
+>one : Symbol(interfaceWithPublicAndOptional.one, Decl(assignmentCompatability4.ts, 1, 58))
 >T : Symbol(T, Decl(assignmentCompatability4.ts, 1, 52))
->two : Symbol(two, Decl(assignmentCompatability4.ts, 1, 66))
+>two : Symbol(interfaceWithPublicAndOptional.two, Decl(assignmentCompatability4.ts, 1, 66))
 >U : Symbol(U, Decl(assignmentCompatability4.ts, 1, 54))
 >obj4 : Symbol(obj4, Decl(assignmentCompatability4.ts, 1, 83))
 >interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability4.ts, 0, 18))
--- a/Show More
+++ b/Show More