Support getReferences on rightside of export assignment and import statements

Author: mhegazy

src/compiler/checker.ts

@@ -6850,10 +6850,16 @@ module ts {
 
         function getSymbolInfo(node: Node) {
             if (isDeclarationOrFunctionExpressionOrCatchVariableName(node)) {
-                // In this case, we call getSymbolOfNode instead of getSymbolInfo because it is a declaration
+                // This is a declaration, call getSymbolOfNode
                 return getSymbolOfNode(node.parent);
             }
 
+            if (isInRightSideOfImportOrExportAssignment(node)) {
+                return node.parent.kind === SyntaxKind.ExportAssignment
+                    ? getSymbolOfEntityName(<Identifier>node)
+                    : getSymbolOfPartOfRightHandSideOfImport(node);
+            }
+
             switch (node.kind) {
                 case SyntaxKind.Identifier:
                 case SyntaxKind.PropertyAccess:
@@ -6874,27 +6880,22 @@ module ts {
                     return undefined;
 
                 case SyntaxKind.StringLiteral:
-                case SyntaxKind.NumericLiteral:
-                    switch (node.parent.kind) {
-                        // index access
-                        case SyntaxKind.IndexedAccess:
-                            if ((<IndexedAccess>node.parent).index === node) {
-                                var objectType = checkExpression((<IndexedAccess>node.parent).object);
-                                if (objectType === unknownType) return undefined;
-                                var apparentType = getApparentType(objectType);
-                                if (<Type>apparentType === unknownType) return undefined;
-                                return getPropertyOfApparentType(apparentType, (<LiteralExpression>node).text);
-                            }
-                            break;
+                    // External module name in an import declaration
+                    if (node.parent.kind === SyntaxKind.ImportDeclaration && (<ImportDeclaration>node.parent).externalModuleName === node) {
+                        var importSymbol = getSymbolOfNode(node.parent);
+                        var moduleType = getTypeOfSymbol(importSymbol);
+                        return moduleType ? moduleType.symbol : undefined;
+                    }
 
-                        // External module name in an import declaration
-                        case SyntaxKind.ImportDeclaration:
-                            if ((<ImportDeclaration>node.parent).externalModuleName === node) {
-                                var importSymbol = getSymbolOfNode(node.parent);
-                                var moduleType = getTypeOfSymbol(importSymbol);
-                                return moduleType ? moduleType.symbol : undefined;
-                            }
-                            break;
+                // Intentinal fallthrough
+                case SyntaxKind.NumericLiteral:
+                    // index access
+                    if (node.parent.kind == SyntaxKind.IndexedAccess && (<IndexedAccess>node.parent).index === node) {
+                        var objectType = checkExpression((<IndexedAccess>node.parent).object);
+                        if (objectType === unknownType) return undefined;
+                        var apparentType = getApparentType(objectType);
+                        if (<Type>apparentType === unknownType) return undefined;
+                        return getPropertyOfApparentType(apparentType, (<LiteralExpression>node).text);
                     }
                     break;
             }

src/services/services.ts

@@ -2485,8 +2485,37 @@ module ts {
                 return root.parent.kind === SyntaxKind.TypeReference && !isLastClause;
             }
 
+            function isInRightSideOfImport(node: EntityName) {
+                while (node.parent.kind === SyntaxKind.QualifiedName) {
+                    node = node.parent;
+                }
+
+                return node.parent.kind === SyntaxKind.ImportDeclaration && (<ImportDeclaration>node.parent).entityName === node;
+            }
+
+            function getMeaningFromRightHandSideOfImport(node: Node) {
+                Debug.assert(node.kind === SyntaxKind.Identifier);
+
+                //     import a = |b|; // Namespace
+                //     import a = |b.c|; // Value, type, namespace
+                //     import a = |b.c|.d; // Namespace
+
+                if (node.parent.kind === SyntaxKind.QualifiedName &&
+                    (<QualifiedName>node.parent).right === node &&
+                    node.parent.parent.kind === SyntaxKind.ImportDeclaration) {
+                    return SearchMeaning.Value | SearchMeaning.Type | SearchMeaning.Namespace;
+                }
+                return SearchMeaning.Namespace;
+            }
+
             function getMeaningFromLocation(node: Node): SearchMeaning {
-                if (isDeclarationIdentifier(<Identifier>node)) {
+                if (node.parent.kind === SyntaxKind.ExportAssignment) {
+                    return SearchMeaning.Value | SearchMeaning.Type | SearchMeaning.Namespace;
+                }
+                else if (isInRightSideOfImport(node)) {
+                    return getMeaningFromRightHandSideOfImport(node);
+                }
+                else if (isDeclarationIdentifier(<Identifier>node)) {
                     return getMeaningFromDeclaration(node.parent);
                 }
                 else if (isTypeReference(node)) {

tests/cases/fourslash/referencesForMergedDeclarations5.ts

@@ -0,0 +1,10 @@
+/// <reference path='fourslash.ts'/>
+
+////interface Foo { }
+////module Foo { export interface Bar { } }
+////function Foo() { }
+////
+////export = /*1*/Foo;
+
+goTo.marker("1");
+verify.referencesCountIs(4);

tests/cases/fourslash/referencesForMergedDeclarations6.ts

@@ -0,0 +1,14 @@
+/// <reference path='fourslash.ts'/>
+
+////interface Foo { }
+////module Foo {
+////    export interface Bar { }
+////    export module Bar { export interface Baz { } }
+////    export function Bar() { }
+////}
+////
+////// module
+////import a1 = /*1*/Foo;
+
+goTo.marker("1");
+verify.referencesCountIs(2);

tests/cases/fourslash/referencesForMergedDeclarations7.ts

@@ -0,0 +1,14 @@
+/// <reference path='fourslash.ts'/>
+
+////interface Foo { }
+////module Foo {
+////    export interface Bar { }
+////    export module Bar { export interface Baz { } }
+////    export function Bar() { }
+////}
+////
+////// module, value and type
+////import a2 = Foo./*1*/Bar;
+
+goTo.marker("1");
+verify.referencesCountIs(4);

tests/cases/fourslash/referencesForMergedDeclarations8.ts

@@ -0,0 +1,14 @@
+/// <reference path='fourslash.ts'/>
+
+////interface Foo { }
+////module Foo {
+////    export interface Bar { }
+////    export module Bar { export interface Baz { } }
+////    export function Bar() { }
+////}
+////
+////// module
+////import a3 = Foo./*1*/Bar.Baz;
+
+goTo.marker("1");
+verify.referencesCountIs(2);