Add implementation for getTypeDefinitionAtPosition

Author: mhegazy

src/harness/fourslash.ts

@@ -1570,6 +1570,27 @@ module FourSlash {
             this.currentCaretPosition = definition.textSpan.start;
         }
 
+        public goToTypeDefinition(definitionIndex: number) {
+            if (definitionIndex === 0) {
+                this.scenarioActions.push('<GoToTypeDefinition />');
+            } else {
+                this.taoInvalidReason = 'GoToTypeDefinition not supported for non-zero definition indices';
+            }
+
+            var definitions = this.languageService.getTypeDefinitionAtPosition(this.activeFile.fileName, this.currentCaretPosition);
+            if (!definitions || !definitions.length) {
+                this.raiseError('goToTypeDefinition failed - expected to at least one definition location but got 0');
+            }
+
+            if (definitionIndex >= definitions.length) {
+                this.raiseError('goToTypeDefinition failed - definitionIndex value (' + definitionIndex + ') exceeds definition list size (' + definitions.length + ')');
+            }
+
+            var definition = definitions[definitionIndex];
+            this.openFile(definition.fileName);
+            this.currentCaretPosition = definition.textSpan.start;
+        }
+
         public verifyDefinitionLocationExists(negative: boolean) {
             this.taoInvalidReason = 'verifyDefinitionLocationExists NYI';
 

src/harness/harnessLanguageService.ts

@@ -333,6 +333,9 @@ module Harness.LanguageService {
         getDefinitionAtPosition(fileName: string, position: number): ts.DefinitionInfo[] {
             return unwrapJSONCallResult(this.shim.getDefinitionAtPosition(fileName, position));
         }
+        getTypeDefinitionAtPosition(fileName: string, position: number): ts.DefinitionInfo[]{
+            return unwrapJSONCallResult(this.shim.getTypeDefinitionAtPosition(fileName, position));
+        }
         getReferencesAtPosition(fileName: string, position: number): ts.ReferenceEntry[] {
             return unwrapJSONCallResult(this.shim.getReferencesAtPosition(fileName, position));
         }

src/server/client.ts

@@ -300,6 +300,10 @@ module ts.server {
             });
         }
 
+        getTypeDefinitionAtPosition(fileName: string, position: number): DefinitionInfo[] {
+            throw new Error("Not Implemented Yet.");
+        }
+
         findReferences(fileName: string, position: number): ReferencedSymbol[]{
             // Not yet implemented.
             return [];

src/services/services.ts

@@ -987,6 +987,8 @@ module ts {
         findRenameLocations(fileName: string, position: number, findInStrings: boolean, findInComments: boolean): RenameLocation[];
 
         getDefinitionAtPosition(fileName: string, position: number): DefinitionInfo[];
+        getTypeDefinitionAtPosition(fileName: string, position: number): DefinitionInfo[];
+
         getReferencesAtPosition(fileName: string, position: number): ReferenceEntry[];
         findReferences(fileName: string, position: number): ReferencedSymbol[];
         getDocumentHighlights(fileName: string, position: number, filesToSearch: string[]): DocumentHighlights[];
@@ -4017,6 +4019,46 @@ module ts {
             return getDefintionFromSymbol(symbol, node);
         }
 
+        /// Goto type
+        function getTypeDefinitionAtPosition(fileName: string, position: number): DefinitionInfo[] {
+            synchronizeHostData();
+
+            let sourceFile = getValidSourceFile(fileName);
+
+            let node = getTouchingPropertyName(sourceFile, position);
+            if (!node) {
+                return undefined;
+            }
+
+            let typeChecker = program.getTypeChecker();
+
+            let symbol = typeChecker.getSymbolAtLocation(node);
+            if (!symbol) {
+                return undefined;
+            }
+
+            let type = typeChecker.getTypeOfSymbolAtLocation(symbol, node);
+            if (!type) {
+                return undefined;
+            }
+
+            if (type.flags & TypeFlags.Union) {
+                var result: DefinitionInfo[] = [];
+                forEach((<UnionType>type).types, t => {
+                    if (t.symbol) {
+                        result.push(...getDefintionFromSymbol(t.symbol, node));
+                    }
+                });
+                return result;
+            }
+
+            if (!type.symbol) {
+                return undefined;
+            }
+
+            return getDefintionFromSymbol(type.symbol, node);
+        }
+
         function getOccurrencesAtPosition(fileName: string, position: number): ReferenceEntry[] {
             let results = getOccurrencesAtPositionCore(fileName, position);
 
@@ -6403,6 +6445,7 @@ module ts {
             getSignatureHelpItems,
             getQuickInfoAtPosition,
             getDefinitionAtPosition,
+            getTypeDefinitionAtPosition,
             getReferencesAtPosition,
             findReferences,
             getOccurrencesAtPosition,

src/services/shims.ts

@@ -130,6 +130,14 @@ module ts {
          */
         getDefinitionAtPosition(fileName: string, position: number): string;
 
+        /**
+         * Returns a JSON-encoded value of the type:
+         * { fileName: string; textSpan: { start: number; length: number}; kind: string; name: string; containerKind: string; containerName: string }
+         *
+         * Or undefined value if no definition can be found.
+         */
+        getTypeDefinitionAtPosition(fileName: string, position: number): string;
+
         /**
          * Returns a JSON-encoded value of the type:
          * { fileName: string; textSpan: { start: number; length: number}; isWriteAccess: boolean }[]
@@ -557,6 +565,20 @@ module ts {
                 });
         }
 
+        /// GOTO Type
+
+        /**
+         * Computes the definition location of the type of the symbol
+         * at the requested position. 
+         */
+        public getTypeDefinitionAtPosition(fileName: string, position: number): string {
+            return this.forwardJSONCall(
+                "getTypeDefinitionAtPosition('" + fileName + "', " + position + ")",
+                () => {
+                    return this.languageService.getTypeDefinitionAtPosition(fileName, position);
+                });
+        }
+
         public getRenameInfo(fileName: string, position: number): string {
             return this.forwardJSONCall(
                 "getRenameInfo('" + fileName + "', " + position + ")",

tests/cases/fourslash/fourslash.ts

@@ -119,6 +119,10 @@ module FourSlashInterface {
             FourSlash.currentTestState.goToDefinition(definitionIndex);
         }
 
+        public type(definitionIndex: number = 0) {
+            FourSlash.currentTestState.goToTypeDefinition(definitionIndex);
+        }
+
         public position(position: number, fileIndex?: number);
         public position(position: number, fileName?: string);
         public position(position: number, fileNameOrIndex?: any) {

tests/cases/fourslash/goToTypeDefinition.ts

@@ -0,0 +1,14 @@
+/// <reference path='fourslash.ts' />
+
+// @Filename: goToTypeDefinition_Definition.ts
+/////*definition*/class C {
+////    p;
+////}
+////var c: C;
+
+// @Filename: goToTypeDefinition_Consumption.ts
+/////*reference*/c = undefined;
+
+goTo.marker('reference');
+goTo.type();
+verify.caretAtMarker('definition');

tests/cases/fourslash/goToTypeDefinition2.ts

@@ -0,0 +1,18 @@
+/// <reference path='fourslash.ts' />
+
+// @Filename: goToTypeDefinition2_Definition.ts
+/////*definition*/interface I1 {
+////    p;
+////}
+////type propertyType = I1;
+////interface I2 {
+////    property: propertyType;
+////}
+
+// @Filename: goToTypeDefinition2_Consumption.ts
+////var i2: I2;
+////i2.prop/*reference*/erty;
+
+goTo.marker('reference');
+goTo.type();
+verify.caretAtMarker('definition');

tests/cases/fourslash/goToTypeDefinitionAliases.ts

@@ -0,0 +1,24 @@
+/// <reference path='fourslash.ts' />
+
+// @Filename: goToTypeDefinitioAliases_module1.ts
+/////*definition*/interface I {
+////    p;
+////}
+////export {I as I2};
+
+// @Filename: goToTypeDefinitioAliases_module2.ts
+////import {I2 as I3} from "goToTypeDefinitioAliases_module1";
+////var v1: I3;
+////export {v1 as v2};
+
+// @Filename: goToTypeDefinitioAliases_module3.ts
+////import {/*reference1*/v2 as v3} from "goToTypeDefinitioAliases_module2";
+/////*reference2*/v3;
+
+goTo.marker('reference1');
+goTo.type();
+verify.caretAtMarker('definition');
+
+goTo.marker('reference2');
+goTo.type();
+verify.caretAtMarker('definition');

tests/cases/fourslash/goToTypeDefinitionEnumMembers.ts

@@ -0,0 +1,13 @@
+/// <reference path='fourslash.ts' />
+
+/////*definition*/enum E {
+////    value1,
+////    value2
+////}
+////var x = E.value2;
+////
+/////*reference*/x;
+
+goTo.marker('reference');
+goTo.type();
+verify.caretAtMarker('definition');

tests/cases/fourslash/goToTypeDefinitionUnionType.ts

@@ -0,0 +1,31 @@
+/// <reference path='fourslash.ts' />
+
+/////*definition0*/class C {
+////    p;
+////}
+////
+/////*definition1*/interface I {
+////    x;
+////}
+////
+////module M {
+////    /*definition2*/export interface I {
+////        y;
+////    }
+////}
+////
+////var x: C | I | M.I;
+////
+/////*reference*/x;
+
+goTo.marker('reference');
+goTo.type(0);
+verify.caretAtMarker('definition0');
+
+goTo.marker('reference');
+goTo.type(1);
+verify.caretAtMarker('definition1');
+
+goTo.marker('reference');
+goTo.type(2);
+verify.caretAtMarker('definition2');