Support goto-definition for index signatures

Author: Andy Hanson

src/services/goToDefinition.ts

@@ -1,6 +1,6 @@
 /* @internal */
 namespace ts.GoToDefinition {
-    export function getDefinitionAtPosition(program: Program, sourceFile: SourceFile, position: number): DefinitionInfo[] {
+    export function getDefinitionAtPosition(program: Program, sourceFile: SourceFile, position: number): DefinitionInfo[] | undefined {
         const reference = getReferenceAtPosition(sourceFile, position, program);
         if (reference) {
             return [getDefinitionInfoForFileReference(reference.fileName, reference.file.fileName)];
@@ -29,7 +29,7 @@ namespace ts.GoToDefinition {
         // Could not find a symbol e.g. node is string or number keyword,
         // or the symbol was an internal symbol and does not have a declaration e.g. undefined symbol
         if (!symbol) {
-            return undefined;
+            return getDefinitionInfoForIndexSignatures(node, typeChecker);
         }
 
         // If this is an alias, and the request came at the declaration location
@@ -157,6 +157,29 @@ namespace ts.GoToDefinition {
         return { definitions, textSpan };
     }
 
+    // At 'x.foo', see if the type of 'x' has an index signature, and if so find its declarations.
+    function getDefinitionInfoForIndexSignatures(node: Node, checker: TypeChecker): DefinitionInfo[] | undefined {
+        if (!isPropertyAccessExpression(node.parent) || node.parent.name !== node) return;
+        const type = checker.getTypeAtLocation(node.parent.expression);
+        if (!type.getStringIndexType()) return undefined;
+        const result: DefinitionInfo[] = [];
+        for (const root of getRootSymbolsOfType(type, checker)) {
+            for (const decl of root.declarations) {
+                if (!isObjectTypeDeclaration(decl)) continue;
+                for (const member of decl.members) {
+                    if (isIndexSignatureDeclaration(member)) {
+                        result.push(createDefinitionFromSignatureDeclaration(checker, member));
+                    }
+                }
+            }
+        }
+        return result;
+    }
+
+    function getRootSymbolsOfType(type: Type, checker: TypeChecker): ReadonlyArray<Symbol> {
+        return flatMap(type.isUnionOrIntersection() ? type.types : [type], t => t.symbol ? checker.getRootSymbols(t.symbol) : emptyArray);
+    }
+
     // Go to the original declaration for cases:
     //
     //   (1) when the aliased symbol was declared in the location(parent).

tests/cases/fourslash/goToDefinitionIndexSignature.ts

@@ -0,0 +1,15 @@
+/// <reference path='fourslash.ts'/>
+
+////interface I {
+////    /*defI*/[x: string]: boolean;
+////}
+////interface J {
+////    /*defJ*/[x: string]: number;
+////}
+////declare const i: I;
+////i.[|/*useI*/foo|];
+////declare const ij: I | J;
+////ij.[|/*useIJ*/foo|];
+
+verify.goToDefinition("useI", ["defI"]);
+verify.goToDefinition("useIJ", ["defI", "defJ"]);

tests/cases/fourslash/goToDefinitionRest.ts

@@ -8,5 +8,5 @@
 ////let t: Gen;
 ////var { x, ...rest } = t;
 ////rest.[|/*2*/parent|];
-const ranges = test.ranges();
+
 verify.goToDefinition('2', [ '1' ]);