Simplify go-to-definition tests

Author: Andy Hanson

src/harness/fourslash.ts

@@ -525,6 +525,56 @@ namespace FourSlash {
             }
         }
 
+        public verifyGoToDefinitionIs(endMarker: string | string[]) {
+            this.verifyGoToDefinitionWorker(endMarker instanceof Array ? endMarker : [endMarker]);
+        }
+
+        public verifyGoToDefinition(startsAndEnds: (string | string[])[]) {
+            if (startsAndEnds.length % 2) {
+                throw new Error("verify.goToDefinition needs an even number of arguments.");
+            }
+
+            for (let i = 0; i < startsAndEnds.length; i += 2) {
+                const start = startsAndEnds[i];
+                const end = startsAndEnds[i + 1];
+
+                if (start instanceof Array) {
+                    for (const s of start) {
+                        this.verifyGoToDefinitionSingle(s, end);
+                    }
+                }
+                else {
+                    this.verifyGoToDefinitionSingle(start, end);
+                }
+            }
+        }
+
+        public verifyGoToDefinitionForMarkers(markerNames: string[]) {
+            for (const markerName of markerNames) {
+                this.verifyGoToDefinitionSingle(`${markerName}Reference`, `${markerName}Definition`);
+            }
+        }
+
+        private verifyGoToDefinitionSingle(start: string, end: string | string[]) {
+            this.goToMarker(start);
+            this.verifyGoToDefinitionWorker(end instanceof Array ? end : [end]);
+        }
+
+        private verifyGoToDefinitionWorker(endMarkers: string[]) {
+            const definitions = this.languageService.getDefinitionAtPosition(this.activeFile.fileName, this.currentCaretPosition) || [];
+
+            if (endMarkers.length !== definitions.length) {
+                this.raiseError(`goToDefinitions failed - expected to find ${endMarkers.length} definitions but got ${definitions.length}`);
+            }
+
+            for (let i = 0; i < endMarkers.length; i++) {
+                const marker = this.getMarkerByName(endMarkers[i]), definition = definitions[i];
+                if (marker.fileName !== definition.fileName || marker.position !== definition.textSpan.start) {
+                    this.raiseError(`goToDefinition failed for definition ${i}: expected ${marker.fileName} at ${marker.position}, got ${definition.fileName} at ${definition.textSpan.start}`);
+                }
+            }
+        }
+
         public verifyGetEmitOutputForCurrentFile(expected: string): void {
             const emit = this.languageService.getEmitOutput(this.activeFile.fileName);
             if (emit.outputFiles.length !== 1) {
@@ -1561,21 +1611,6 @@ namespace FourSlash {
             this.goToPosition(len);
         }
 
-        public goToDefinition(definitionIndex: number) {
-            const definitions = this.languageService.getDefinitionAtPosition(this.activeFile.fileName, this.currentCaretPosition);
-            if (!definitions || !definitions.length) {
-                this.raiseError("goToDefinition failed - expected to find at least one definition location but got 0");
-            }
-
-            if (definitionIndex >= definitions.length) {
-                this.raiseError(`goToDefinition failed - definitionIndex value (${definitionIndex}) exceeds definition list size (${definitions.length})`);
-            }
-
-            const definition = definitions[definitionIndex];
-            this.openFile(definition.fileName);
-            this.currentCaretPosition = definition.textSpan.start;
-        }
-
         public goToTypeDefinition(definitionIndex: number) {
             const definitions = this.languageService.getTypeDefinitionAtPosition(this.activeFile.fileName, this.currentCaretPosition);
             if (!definitions || !definitions.length) {
@@ -1591,28 +1626,6 @@ namespace FourSlash {
             this.currentCaretPosition = definition.textSpan.start;
         }
 
-        public verifyDefinitionLocationExists(negative: boolean) {
-            const definitions = this.languageService.getDefinitionAtPosition(this.activeFile.fileName, this.currentCaretPosition);
-
-            const foundDefinitions = definitions && definitions.length;
-
-            if (foundDefinitions && negative) {
-                this.raiseError(`goToDefinition - expected to 0 definition locations but got ${definitions.length}`);
-            }
-            else if (!foundDefinitions && !negative) {
-                this.raiseError("goToDefinition - expected to find at least one definition location but got 0");
-            }
-        }
-
-        public verifyDefinitionsCount(negative: boolean, expectedCount: number) {
-            const assertFn = negative ? assert.notEqual : assert.equal;
-
-            const definitions = this.languageService.getDefinitionAtPosition(this.activeFile.fileName, this.currentCaretPosition);
-            const actualCount = definitions && definitions.length || 0;
-
-            assertFn(actualCount, expectedCount, this.messageAtLastKnownMarker("Definitions Count"));
-        }
-
         public verifyTypeDefinitionsCount(negative: boolean, expectedCount: number) {
             const assertFn = negative ? assert.notEqual : assert.equal;
 
@@ -1622,25 +1635,23 @@ namespace FourSlash {
             assertFn(actualCount, expectedCount, this.messageAtLastKnownMarker("Type definitions Count"));
         }
 
-        public verifyDefinitionsName(negative: boolean, expectedName: string, expectedContainerName: string) {
+        public verifyGoToDefinitionName(expectedName: string, expectedContainerName: string) {
             const definitions = this.languageService.getDefinitionAtPosition(this.activeFile.fileName, this.currentCaretPosition);
             const actualDefinitionName = definitions && definitions.length ? definitions[0].name : "";
             const actualDefinitionContainerName = definitions && definitions.length ? definitions[0].containerName : "";
-            if (negative) {
-                assert.notEqual(actualDefinitionName, expectedName, this.messageAtLastKnownMarker("Definition Info Name"));
-                assert.notEqual(actualDefinitionContainerName, expectedContainerName, this.messageAtLastKnownMarker("Definition Info Container Name"));
-            }
-            else {
-                assert.equal(actualDefinitionName, expectedName, this.messageAtLastKnownMarker("Definition Info Name"));
-                assert.equal(actualDefinitionContainerName, expectedContainerName, this.messageAtLastKnownMarker("Definition Info Container Name"));
-            }
+            assert.equal(actualDefinitionName, expectedName, this.messageAtLastKnownMarker("Definition Info Name"));
+            assert.equal(actualDefinitionContainerName, expectedContainerName, this.messageAtLastKnownMarker("Definition Info Container Name"));
         }
 
         public getMarkers(): Marker[] {
             //  Return a copy of the list
             return this.testData.markers.slice(0);
         }
 
+        public getMarkerNames(): string[] {
+            return Object.keys(this.testData.markerPositions);
+        }
+
         public getRanges(): Range[] {
             return this.testData.ranges;
         }
@@ -2742,6 +2753,10 @@ namespace FourSlashInterface {
             return this.state.getMarkers();
         }
 
+        public markerNames(): string[] {
+            return this.state.getMarkerNames();
+        }
+
         public marker(name?: string): FourSlash.Marker {
             return this.state.getMarkerByName(name);
         }
@@ -2777,10 +2792,6 @@ namespace FourSlashInterface {
             this.state.goToEOF();
         }
 
-        public definition(definitionIndex = 0) {
-            this.state.goToDefinition(definitionIndex);
-        }
-
         public type(definitionIndex = 0) {
             this.state.goToTypeDefinition(definitionIndex);
         }
@@ -2885,22 +2896,10 @@ namespace FourSlashInterface {
             this.state.verifyQuickInfoExists(this.negative);
         }
 
-        public definitionCountIs(expectedCount: number) {
-            this.state.verifyDefinitionsCount(this.negative, expectedCount);
-        }
-
         public typeDefinitionCountIs(expectedCount: number) {
             this.state.verifyTypeDefinitionsCount(this.negative, expectedCount);
         }
 
-        public definitionLocationExists() {
-            this.state.verifyDefinitionLocationExists(this.negative);
-        }
-
-        public verifyDefinitionsName(name: string, containerName: string) {
-            this.state.verifyDefinitionsName(this.negative, name, containerName);
-        }
-
         public isValidBraceCompletionAtPosition(openingBrace: string) {
             this.state.verifyBraceCompletionAtPosition(this.negative, openingBrace);
         }
@@ -2944,6 +2943,22 @@ namespace FourSlashInterface {
             this.state.verifyCurrentFileContent(text);
         }
 
+        public goToDefinitionIs(endMarkers: string | string[]) {
+            this.state.verifyGoToDefinitionIs(endMarkers);
+        }
+
+        public goToDefinition(...startsAndEnds: (string | string[])[]) {
+            this.state.verifyGoToDefinition(startsAndEnds);
+        }
+
+        public goToDefinitionForMarkers(...markerNames: string[]) {
+            this.state.verifyGoToDefinitionForMarkers(markerNames);
+        }
+
+        public goToDefinitionName(name: string, containerName: string) {
+            this.state.verifyGoToDefinitionName(name, containerName);
+        }
+
         public verifyGetEmitOutputForCurrentFile(expected: string): void {
             this.state.verifyGetEmitOutputForCurrentFile(expected);
         }

tests/cases/fourslash/ambientShorthandGotoDefinition.ts

@@ -12,28 +12,22 @@
 
 goTo.marker("useFoo");
 verify.quickInfoIs("import foo");
-goTo.definition();
-verify.caretAtMarker("importFoo");
-goTo.definition();
-verify.caretAtMarker("module");
+verify.goToDefinition(
+    "useFoo", "importFoo",
+    "importFoo", "module");
 
 goTo.marker("useBar");
 verify.quickInfoIs("import bar");
-goTo.definition();
-verify.caretAtMarker("module");
+verify.goToDefinition("useBar", "module");
 
 goTo.marker("useBaz");
 verify.quickInfoIs("import baz");
-goTo.definition();
-verify.caretAtMarker("importBaz");
-goTo.marker("idBaz");
-goTo.definition();
-verify.caretAtMarker("module");
+verify.goToDefinition(
+    "useBaz", "importBaz",
+    "idBaz", "module");
 
 goTo.marker("useBang");
 verify.quickInfoIs("import bang = require(\"jquery\")");
-goTo.definition();
-verify.caretAtMarker("importBang");
-goTo.marker("idBang");
-goTo.definition();
-verify.caretAtMarker("module");
+verify.goToDefinition(
+    "useBang", "importBang",
+    "idBang", "module");

tests/cases/fourslash/definition.ts

@@ -7,6 +7,4 @@
 // @Filename: a.ts
 //// /*2*/export class Foo {}
 
-goTo.marker('1');
-goTo.definition();
-verify.caretAtMarker('2');
+verify.goToDefinition("1", "2");

tests/cases/fourslash/definitionNameOnEnumMember.ts

@@ -8,4 +8,4 @@
 ////var enumMember = e./*1*/thirdMember;
 
 goTo.marker("1");
-verify.verifyDefinitionsName("thirdMember", "e");
+verify.goToDefinitionName("thirdMember", "e");

tests/cases/fourslash/fourslash.ts

@@ -99,6 +99,7 @@ declare namespace FourSlashInterface {
     }
     class test_ {
         markers(): Marker[];
+        markerNames(): string[];
         marker(name?: string): Marker;
         ranges(): Range[];
         rangesByText(): { [text: string]: Range[] };
@@ -108,7 +109,6 @@ declare namespace FourSlashInterface {
         marker(name?: string): void;
         bof(): void;
         eof(): void;
-        definition(definitionIndex?: number): void;
         type(definitionIndex?: number): void;
         position(position: number, fileIndex?: number): any;
         position(position: number, fileName?: string): any;
@@ -132,10 +132,7 @@ declare namespace FourSlashInterface {
         errorExistsBeforeMarker(markerName?: string): void;
         quickInfoIs(expectedText?: string, expectedDocumentation?: string): void;
         quickInfoExists(): void;
-        definitionCountIs(expectedCount: number): void;
         typeDefinitionCountIs(expectedCount: number): void;
-        definitionLocationExists(): void;
-        verifyDefinitionsName(name: string, containerName: string): void;
         isValidBraceCompletionAtPosition(openingBrace?: string): void;
     }
     class verify extends verifyNegatable {
@@ -152,6 +149,18 @@ declare namespace FourSlashInterface {
         eval(expr: string, value: any): void;
         currentLineContentIs(text: string): void;
         currentFileContentIs(text: string): void;
+        /** Verifies that goToDefinition at the current position would take you to `endMarker`. */
+        goToDefinitionIs(endMarkers: string | string[]): void;
+        goToDefinitionName(name: string, containerName: string): void;
+        /**
+         * `verify.goToDefinition("a", "b");` verifies that go-to-definition at marker "a" takes you to marker "b".
+         * `verify.goToDefinition(["a", "aa"], "b");` verifies that markers "a" and "aa" have the same definition "b".
+         * `verify.goToDefinition("a", ["b", "bb"]);` verifies that "a" has multiple definitions available.
+         * Finally, `verify.goToDefinition("a", "b", "c", "d");` is just `verify.goToDefinition("a", "b"); verify.goToDefinition("c", "d");`.
+         */
+        goToDefinition(...startsAndEnds: (string | string[])[]): void;
+        /** Verifies goToDefinition for each `${markerName}Reference` -> `${markerName}Definition` */
+        goToDefinitionForMarkers(...markerNames: string[]): void;
         verifyGetEmitOutputForCurrentFile(expected: string): void;
         verifyGetEmitOutputContentsForCurrentFile(expected: ts.OutputFile[]): void;
         /**

tests/cases/fourslash/goToDeclarationDecoratorOverloads.ts

@@ -13,10 +13,6 @@
 ////    @/*useDecSymbol*/dec [s]() {}
 ////}
 
-goTo.marker("useDecString");
-goTo.definition();
-verify.caretAtMarker("defDecString");
-
-goTo.marker("useDecSymbol");
-goTo.definition();
-verify.caretAtMarker("defDecSymbol");
+verify.goToDefinition(
+    "useDecString", "defDecString",
+    "useDecSymbol", "defDecSymbol");

tests/cases/fourslash/goToDefinitionAcrossMultipleProjects.ts

@@ -1,17 +1,14 @@
 /// <reference path="fourslash.ts" />
 
 //@Filename: a.ts
-////var x: number;
+////var /*def1*/x: number;
 
 //@Filename: b.ts
-////var x: number;
+////var /*def2*/x: number;
 
 //@Filename: c.ts
 /////// <reference path="a.ts" />
 /////// <reference path="b.ts" />
-/////**/x++;
+/////*use*/x++;
 
-goTo.file("c.ts");
-goTo.marker();
-
-verify.definitionCountIs(2);
+verify.goToDefinition("use", ["def1", "def2"]);

tests/cases/fourslash/goToDefinitionAlias.ts

@@ -23,20 +23,6 @@
 ////    x;
 ////}
 
-
-goTo.marker('alias1Type');
-goTo.definition();
-verify.caretAtMarker('alias1Definition');
-
-goTo.marker('alias2Type');
-goTo.definition();
-verify.caretAtMarker('alias2Definition');
-
-
-goTo.marker('alias1Value');
-goTo.definition();
-verify.caretAtMarker('alias1Definition');
-
-goTo.marker('alias2Value');
-goTo.definition();
-verify.caretAtMarker('alias2Definition');
+verify.goToDefinition(
+    ["alias1Type", "alias1Value"], "alias1Definition",
+    ["alias2Type", "alias2Value"], "alias2Definition");

tests/cases/fourslash/goToDefinitionAmbiants.ts

@@ -14,16 +14,4 @@
 ////ambientClass./*staticMethodReference*/method();
 ////ambientClassVariable./*instanceMethodReference*/method();
 
-var markerList = [
-    "ambientVariable",
-    "ambientFunction",
-    "constructor",
-    "staticMethod",
-    "instanceMethod",
-];
-
-markerList.forEach((marker) => {
-    goTo.marker(marker + 'Reference');
-    goTo.definition();
-    verify.caretAtMarker(marker + 'Definition');
-});
+verify.goToDefinitionForMarkers("ambientVariable", "ambientFunction", "constructor", "staticMethod", "instanceMethod");