Merge pull request microsoft#9148 from Microsoft/add-isDefinition-to-references

Add isDefinition to references

Author: sandersn

src/harness/fourslash.ts

@@ -730,7 +730,7 @@ namespace FourSlash {
             }
         }
 
-        public verifyReferencesAtPositionListContains(fileName: string, start: number, end: number, isWriteAccess?: boolean) {
+        public verifyReferencesAtPositionListContains(fileName: string, start: number, end: number, isWriteAccess?: boolean, isDefinition?: boolean) {
             const references = this.getReferencesAtCaret();
 
             if (!references || references.length === 0) {
@@ -743,11 +743,14 @@ namespace FourSlash {
                     if (typeof isWriteAccess !== "undefined" && reference.isWriteAccess !== isWriteAccess) {
                         this.raiseError(`verifyReferencesAtPositionListContains failed - item isWriteAccess value does not match, actual: ${reference.isWriteAccess}, expected: ${isWriteAccess}.`);
                     }
+                    if (typeof isDefinition !== "undefined" && reference.isDefinition !== isDefinition) {
+                        this.raiseError(`verifyReferencesAtPositionListContains failed - item isDefinition value does not match, actual: ${reference.isDefinition}, expected: ${isDefinition}.`);
+                    }
                     return;
                 }
             }
 
-            const missingItem = { fileName: fileName, start: start, end: end, isWriteAccess: isWriteAccess };
+            const missingItem = { fileName, start, end, isWriteAccess, isDefinition };
             this.raiseError(`verifyReferencesAtPositionListContains failed - could not find the item: ${stringify(missingItem)} in the returned list: (${stringify(references)})`);
         }
 
@@ -2837,8 +2840,8 @@ namespace FourSlashInterface {
             this.state.verifyReferencesCountIs(count, /*localFilesOnly*/ false);
         }
 
-        public referencesAtPositionContains(range: FourSlash.Range, isWriteAccess?: boolean) {
-            this.state.verifyReferencesAtPositionListContains(range.fileName, range.start, range.end, isWriteAccess);
+        public referencesAtPositionContains(range: FourSlash.Range, isWriteAccess?: boolean, isDefinition?: boolean) {
+            this.state.verifyReferencesAtPositionListContains(range.fileName, range.start, range.end, isWriteAccess, isDefinition);
         }
 
         public signatureHelpPresent() {

src/server/client.ts

@@ -376,6 +376,7 @@ namespace ts.server {
                     fileName: fileName,
                     textSpan: ts.createTextSpanFromBounds(start, end),
                     isWriteAccess: entry.isWriteAccess,
+                    isDefinition: entry.isDefinition,
                 };
             });
         }
@@ -536,6 +537,7 @@ namespace ts.server {
                     fileName,
                     textSpan: ts.createTextSpanFromBounds(start, end),
                     isWriteAccess: entry.isWriteAccess,
+                    isDefinition: false
                 };
             });
         }

src/server/protocol.d.ts

@@ -304,6 +304,11 @@ declare namespace ts.server.protocol {
           * True if reference is a write location, false otherwise.
           */
         isWriteAccess: boolean;
+
+        /**
+         * True if reference is a definition, false otherwise.
+         */
+        isDefinition: boolean;
     }
 
     /**

src/server/session.ts

@@ -379,7 +379,7 @@ namespace ts.server {
                     start,
                     end,
                     file: fileName,
-                    isWriteAccess
+                    isWriteAccess,
                 };
             });
         }
@@ -555,7 +555,8 @@ namespace ts.server {
                             start: start,
                             lineText: lineText,
                             end: compilerService.host.positionToLineOffset(ref.fileName, ts.textSpanEnd(ref.textSpan)),
-                            isWriteAccess: ref.isWriteAccess
+                            isWriteAccess: ref.isWriteAccess,
+                            isDefinition: ref.isDefinition
                         };
                     });
                 },

src/services/services.ts

@@ -1209,6 +1209,7 @@ namespace ts {
         textSpan: TextSpan;
         fileName: string;
         isWriteAccess: boolean;
+        isDefinition: boolean;
     }
 
     export interface DocumentHighlights {
@@ -5753,7 +5754,8 @@ namespace ts {
                         result.push({
                             fileName: entry.fileName,
                             textSpan: highlightSpan.textSpan,
-                            isWriteAccess: highlightSpan.kind === HighlightSpanKind.writtenReference
+                            isWriteAccess: highlightSpan.kind === HighlightSpanKind.writtenReference,
+                            isDefinition: false
                         });
                     }
                 }
@@ -6187,7 +6189,8 @@ namespace ts {
                                     references: [{
                                         fileName: sourceFile.fileName,
                                         textSpan: createTextSpan(position, searchText.length),
-                                        isWriteAccess: false
+                                        isWriteAccess: false,
+                                        isDefinition: false
                                     }]
                                 });
                             }
@@ -6741,7 +6744,8 @@ namespace ts {
             return {
                 fileName: node.getSourceFile().fileName,
                 textSpan: createTextSpanFromBounds(start, end),
-                isWriteAccess: isWriteAccess(node)
+                isWriteAccess: isWriteAccess(node),
+                isDefinition: isDeclarationName(node) || isLiteralComputedPropertyDeclarationName(node)
             };
         }
 

src/services/shims.ts

@@ -164,7 +164,7 @@ namespace ts {
 
         /**
          * Returns a JSON-encoded value of the type:
-         * { fileName: string; textSpan: { start: number; length: number}; isWriteAccess: boolean }[]
+         * { fileName: string; textSpan: { start: number; length: number}; isWriteAccess: boolean, isDefinition?: boolean }[]
          */
         getReferencesAtPosition(fileName: string, position: number): string;
 
@@ -1141,4 +1141,4 @@ namespace TypeScript.Services {
 /* @internal */
 const toolsVersion = "1.9";
 
-/* tslint:enable:no-unused-variable */
+/* tslint:enable:no-unused-variable */

tests/cases/fourslash/fourslash.ts

@@ -125,7 +125,7 @@ declare namespace FourSlashInterface {
         completionListAllowsNewIdentifier(): void;
         memberListIsEmpty(): void;
         referencesCountIs(count: number): void;
-        referencesAtPositionContains(range: Range, isWriteAccess?: boolean): void;
+        referencesAtPositionContains(range: Range, isWriteAccess?: boolean, isDefinition?: boolean): void;
         signatureHelpPresent(): void;
         errorExistsBetweenMarkers(startMarker: string, endMarker: string): void;
         errorExistsAfterMarker(markerName?: string): void;

tests/cases/fourslash/getOccurrencesIsDefinitionOfArrowFunction.ts

@@ -0,0 +1,8 @@
+/// <reference path='fourslash.ts' />
+////var [|{| "isDefinition": true |}f|] = x => x + 1;
+////[|{| "isDefinition": false |}f|](12);
+var firstRange = test.ranges()[0];
+goTo.position(firstRange.start, firstRange.fileName);
+test.ranges().forEach(range => {
+    verify.referencesAtPositionContains(range, undefined, range.marker.data.isDefinition);
+});

tests/cases/fourslash/getOccurrencesIsDefinitionOfBindingPattern.ts

@@ -0,0 +1,8 @@
+/// <reference path='fourslash.ts' />
+////const { [|{| "isDefinition": true |}x|], y } = { x: 1, y: 2 };
+////const z = [|{| "isDefinition": false |}x|];
+var firstRange = test.ranges()[0];
+goTo.position(firstRange.start, firstRange.fileName);
+test.ranges().forEach(range => {
+    verify.referencesAtPositionContains(range, undefined, range.marker.data.isDefinition);
+});

tests/cases/fourslash/getOccurrencesIsDefinitionOfClass.ts

@@ -0,0 +1,13 @@
+/// <reference path='fourslash.ts' />
+////class [|{| "isDefinition": true |}C|] {
+////    n: number;
+////    constructor() {
+////        this.n = 12;
+////    }
+////}
+////let c = new [|{| "isDefinition": false |}C|]();
+var firstRange = test.ranges()[0];
+goTo.position(firstRange.start, firstRange.fileName);
+test.ranges().forEach(range => {
+    verify.referencesAtPositionContains(range, undefined, range.marker.data.isDefinition);
+});