Change find-all-references tests to test for groups

* Also always test for isWriteAccess and isDefinition

src/harness/fourslash.ts

@@ -452,7 +452,8 @@ namespace FourSlash {
         }
 
         private messageAtLastKnownMarker(message: string) {
-            return "Marker: " + this.lastKnownMarker + "\n" + message;
+            const locationDescription = this.lastKnownMarker ? this.lastKnownMarker : this.getLineColStringAtPosition(this.currentCaretPosition);
+            return `At ${locationDescription}: ${message}`;
         }
 
         private assertionMessageAtLastKnownMarker(msg: string) {
@@ -562,7 +563,7 @@ namespace FourSlash {
         }
 
         public verifyGoToDefinitionIs(endMarker: string | string[]) {
-            this.verifyGoToXWorker(endMarker instanceof Array ? endMarker : [endMarker], () => this.getGoToDefinition());
+            this.verifyGoToXWorker(toArray(endMarker), () => this.getGoToDefinition());
         }
 
         public verifyGoToDefinition(arg0: any, endMarkerNames?: string | string[]) {
@@ -582,7 +583,7 @@ namespace FourSlash {
             if (endMarkerNames) {
                 this.verifyGoToXPlain(arg0, endMarkerNames, getDefs);
             }
-            else if (arg0 instanceof Array) {
+            else if (ts.isArray(arg0)) {
                 const pairs: [string | string[], string | string[]][] = arg0;
                 for (const [start, end] of pairs) {
                     this.verifyGoToXPlain(start, end, getDefs);
@@ -599,13 +600,8 @@ namespace FourSlash {
         }
 
         private verifyGoToXPlain(startMarkerNames: string | string[], endMarkerNames: string | string[], getDefs: () => ts.DefinitionInfo[] | undefined) {
-            if (startMarkerNames instanceof Array) {
+            for (const start of toArray(startMarkerNames)) {
-                for (const start of startMarkerNames) {
+                this.verifyGoToXSingle(start, endMarkerNames, getDefs);
-                    this.verifyGoToXSingle(start, endMarkerNames, getDefs);
-                }
-            }
-            else {
-                this.verifyGoToXSingle(startMarkerNames, endMarkerNames, getDefs);
             }
         }
 
@@ -617,7 +613,7 @@ namespace FourSlash {
 
         private verifyGoToXSingle(startMarkerName: string, endMarkerNames: string | string[], getDefs: () => ts.DefinitionInfo[] | undefined) {
             this.goToMarker(startMarkerName);
-            this.verifyGoToXWorker(endMarkerNames instanceof Array ? endMarkerNames : [endMarkerNames], getDefs);
+            this.verifyGoToXWorker(toArray(endMarkerNames), getDefs);
         }
 
         private verifyGoToXWorker(endMarkers: string[], getDefs: () => ts.DefinitionInfo[] | undefined) {
@@ -899,8 +895,74 @@ namespace FourSlash {
             }
         }
 
-        public verifyRangesWithSameTextReferenceEachOther() {
+        public verifyReferenceGroups(startRanges: Range | Range[], parts: Array<{ definition: string, ranges: Range[] }>): void {
-            this.rangesByText().forEach(ranges => this.verifyRangesReferenceEachOther(ranges));
+            interface ReferenceJson { definition: string; ranges: ts.ReferenceEntry[]; }
+            type ReferencesJson = ReferenceJson[];
+            const fullExpected = parts.map<ReferenceJson>(({ definition, ranges }) => ({ definition, ranges: ranges.map(rangeToReferenceEntry) }));
+
+            for (const startRange of toArray(startRanges)) {
+                this.goToRangeStart(startRange);
+                const fullActual = this.findReferencesAtCaret().map<ReferenceJson>(({ definition, references }) => ({
+                    definition: definition.displayParts.map(d => d.text).join(""),
+                    ranges: references
+                }));
+                this.assertObjectsEqual<ReferencesJson>(fullActual, fullExpected);
+            }
+
+            function rangeToReferenceEntry(r: Range) {
+                let { isWriteAccess, isDefinition } = (r.marker && r.marker.data) || { isWriteAccess: false, isDefinition: false };
+                isWriteAccess = isWriteAccess || false; isDefinition = isDefinition || false;
+                return { fileName: r.fileName, textSpan: { start: r.start, length: r.end - r.start }, isWriteAccess, isDefinition }
+            }
+        }
+
+        public verifyNoReferences(markerNameOrRange?: string | Range) {
+            if (markerNameOrRange) {
+                if (typeof markerNameOrRange === "string") {
+                    this.goToMarker(markerNameOrRange);
+                }
+                else {
+                    this.goToRangeStart(markerNameOrRange);
+                }
+            }
+
+            const refs = this.getReferencesAtCaret();
+            if (refs && refs.length) {
+                console.log(refs);
+                this.raiseError("Expected getReferences to fail");
+            }
+        }
+
+        public verifySingleReferenceGroup(definition: string, ranges?: Range[]) {
+            ranges = ranges || this.getRanges();
+            this.verifyReferenceGroups(ranges, [{ definition, ranges }]);
+        }
+
+        private assertObjectsEqual<T>(fullActual: T, fullExpected: T, msgPrefix = ""): void {
+            const recur = <U>(actual: U, expected: U, path: string) => {
+                const fail = (msg: string) => {
+                    console.log("Expected:", stringify(fullExpected));
+                    console.log("Actual: ", stringify(fullActual));
+                    this.raiseError(`${msgPrefix}At ${path}: ${msg}`);
+                };
+
+                for (const key in actual) if (ts.hasProperty(actual as any, key)) {
+                    const ak = actual[key], ek = expected[key];
+                    if (typeof ak === "object" && typeof ek === "object") {
+                        recur(ak, ek, path ? path + "." + key : key);
+                    }
+                    else if (ak !== ek) {
+                        fail(`Expected '${key}' to be '${ek}', got '${ak}'`);
+                    }
+                }
+                for (const key in expected) if (ts.hasProperty(expected as any, key)) {
+                    if (!ts.hasProperty(actual as any, key)) {
+                        fail(`${msgPrefix}Missing property '${key}'`);
+                    }
+                }
+            };
+            recur(fullActual, fullExpected, "");
+
         }
 
         public verifyDisplayPartsOfReferencedSymbol(expected: ts.SymbolDisplayPart[]) {
@@ -974,7 +1036,7 @@ namespace FourSlash {
         public verifyQuickInfos(namesAndTexts: { [name: string]: string | [string, string] }) {
             for (const name in namesAndTexts) if (ts.hasProperty(namesAndTexts, name)) {
                 const text = namesAndTexts[name];
-                if (text instanceof Array) {
+                if (ts.isArray(text)) {
                     assert(text.length === 2);
                     const [expectedText, expectedDocumentation] = text;
                     this.verifyQuickInfoAt(name, expectedText, expectedDocumentation);
@@ -1411,13 +1473,6 @@ namespace FourSlash {
             Harness.IO.log(membersString);
         }
 
-        public printReferences() {
-            const references = this.getReferencesAtCaret();
-            ts.forEach(references, entry => {
-                Harness.IO.log(stringify(entry));
-            });
-        }
-
         public printContext() {
             ts.forEach(this.languageServiceAdapterHost.getFilenames(), Harness.IO.log);
         }
@@ -3082,6 +3137,10 @@ ${code}
         }
         return ts.arrayFrom(set.keys());
     }
+
+    function toArray<T>(x: T | T[]): T[] {
+        return ts.isArray(x) ? x : [x];
+    }
 }
 
 namespace FourSlashInterface {
@@ -3346,6 +3405,18 @@ namespace FourSlashInterface {
             this.state.verifyReferencesOf(start, references);
         }
 
+        public referenceGroups(startRanges: FourSlash.Range[], parts: Array<{ definition: string, ranges: FourSlash.Range[] }>) {
+            this.state.verifyReferenceGroups(startRanges, parts);
+        }
+
+        public noReferences(markerNameOrRange?: string | FourSlash.Range) {
+            this.state.verifyNoReferences(markerNameOrRange);
+        }
+
+        public singleReferenceGroup(definition: string, ranges?: FourSlash.Range[]) {
+            this.state.verifySingleReferenceGroup(definition, ranges);
+        }
+
         public rangesReferenceEachOther(ranges?: FourSlash.Range[]) {
             this.state.verifyRangesReferenceEachOther(ranges);
         }
@@ -3354,10 +3425,6 @@ namespace FourSlashInterface {
             this.state.verifyDisplayPartsOfReferencedSymbol(expected);
         }
 
-        public rangesWithSameTextReferenceEachOther() {
-            this.state.verifyRangesWithSameTextReferenceEachOther();
-        }
-
         public currentParameterHelpArgumentNameIs(name: string) {
             this.state.verifyCurrentParameterHelpName(name);
         }
@@ -3660,10 +3727,6 @@ namespace FourSlashInterface {
             this.state.printNavigationBar();
         }
 
-        public printReferences() {
-            this.state.printReferences();
-        }
-
         public printContext() {
             this.state.printContext();
         }

src/services/findAllReferences.ts

@@ -5,6 +5,10 @@ namespace ts.FindAllReferences {
         return getReferencedSymbolsForNode(typeChecker, cancellationToken, node, sourceFiles, findInStrings, findInComments, isForRename);
     }
 
+    export function convertReferences(referenceSymbols: ReferencedSymbol[]): ReferenceEntry[] {
+        return referenceSymbols && flatMap(referenceSymbols, r => r.references);
+    }
+
     export function getReferencedSymbolsForNode(typeChecker: TypeChecker, cancellationToken: CancellationToken, node: Node, sourceFiles: SourceFile[], findInStrings?: boolean, findInComments?: boolean, isForRename?: boolean, implementations?: boolean): ReferencedSymbol[] | undefined {
         if (!implementations) {
             const special = getReferencedSymbolsSpecial(node, sourceFiles, typeChecker, cancellationToken);
@@ -411,7 +415,6 @@ namespace ts.FindAllReferences {
             textSpan: createTextSpan(0, 1),
             displayParts: [{ text: name, kind: ScriptElementKind.keyword }]
         }
-
         const references: ReferenceEntry[] = [];
         for (const sourceFile of sourceFiles) {
             cancellationToken.throwIfCancellationRequested();
@@ -1316,20 +1319,6 @@ namespace ts.FindAllReferences {
         return meaning;
     }
 
-    export function convertReferences(referenceSymbols: ReferencedSymbol[]): ReferenceEntry[] {
-        if (!referenceSymbols) {
-            return undefined;
-        }
-
-        const referenceEntries: ReferenceEntry[] = [];
-
-        for (const referenceSymbol of referenceSymbols) {
-            addRange(referenceEntries, referenceSymbol.references);
-        }
-
-        return referenceEntries;
-    }
-
     function isImplementation(node: Node): boolean {
         if (!node) {
             return false;

src/services/services.ts

@@ -1415,7 +1415,6 @@ namespace ts {
 
         function findReferences(fileName: string, position: number): ReferencedSymbol[] {
             const referencedSymbols = findReferencedSymbols(fileName, position, /*findInStrings*/ false, /*findInComments*/ false, /*isForRename*/false);
-
             // Only include referenced symbols that have a valid definition.
             return filter(referencedSymbols, rs => !!rs.definition);
         }
@@ -2015,9 +2014,5 @@ namespace ts {
         throw new Error("getDefaultLibFilePath is only supported when consumed as a node module. ");
     }
 
-    function initializeServices() {
+    objectAllocator = getServicesObjectAllocator();
-        objectAllocator = getServicesObjectAllocator();
-    }
-
-    initializeServices();
 }

tests/cases/fourslash/ambientShorthandFindAllRefs.ts

@@ -4,9 +4,18 @@
 ////declare module "jquery";
 
 // @Filename: user.ts
-////import {[|x|]} from "jquery";
+////import {[|{| "isWriteAccess": true, "isDefinition": true |}x|]} from "jquery";
 
 // @Filename: user2.ts
-////import {[|x|]} from "jquery";
+////import {[|{| "isWriteAccess": true, "isDefinition": true |}x|]} from "jquery";
 
-verify.rangesReferenceEachOther();
+const ranges = test.ranges();
+const [r0, r1] = ranges;
+verify.referenceGroups(r0, [
+    { definition: "import x", ranges: [r0] },
+    { definition: 'module "jquery"', ranges: [r1] }
+]);
+verify.referenceGroups(r1, [
+    { definition: 'module "jquery"', ranges: [r0] },
+    { definition: "import x", ranges: [r1] }
+]);

tests/cases/fourslash/cancellationWhenfindingAllRefsOnDefinition.ts

@@ -7,7 +7,7 @@
 ////
 ////    }
 ////
-////    public /**/[|start|](){
+////    public /**/[|{| "isWriteAccess": true, "isDefinition": true |}start|](){
 ////        return this;
 ////    }
 ////
@@ -23,11 +23,21 @@
 ////second.[|start|]();
 ////second.stop();
 
-verify.rangesReferenceEachOther();
+checkRefs();
 
 cancellation.setCancelled();
-verifyOperationIsCancelled(() => verify.rangesReferenceEachOther());
+verifyOperationIsCancelled(checkRefs);
 
 // verify that internal state is still correct
 cancellation.resetCancelled();
-verify.rangesReferenceEachOther();
+checkRefs();
+
+function checkRefs() {
+    const ranges = test.ranges();
+    const [r0, r1] = ranges;
+    verify.referenceGroups(r0, [{ definition: "(method) Test.start(): this", ranges }]);
+    verify.referenceGroups(r1, [
+        { definition: "(method) Second.Test.start(): Second.Test", ranges: [r0] },
+        { definition: "(method) Second.Test.start(): Second.Test", ranges: [r1] }
+    ]);
+}

tests/cases/fourslash/findAllReferencesOfConstructor.ts

@@ -41,6 +41,6 @@
 ////class d extends a.C { constructor() { [|super|](); }
 
 const ranges = test.ranges();
-for (const ctr of ranges.slice(0, 3)) {
+const [r0, r1, r2] = ranges;
-    verify.referencesOf(ctr, ranges);
+verify.referenceGroups([r0, r2], [{ definition: "constructor C(n: number): C (+1 overload)", ranges }]);
-}
+verify.referenceGroups(r1, [{ definition: "constructor C(): C (+1 overload)", ranges }]);

tests/cases/fourslash/findAllReferencesOfConstructor_badOverload.ts

@@ -5,4 +5,4 @@
 ////    [|constructor|](){}
 ////}
 
-verify.rangesReferenceEachOther();
+verify.singleReferenceGroup("constructor C(n: number): C");

tests/cases/fourslash/findAllRefsForComputedProperties.ts

@@ -1,16 +1,26 @@
 /// <reference path='fourslash.ts'/>
 
-
 ////interface I {
-////    ["[|prop1|]"]: () => void;
+////    ["[|{| "isDefinition": true |}prop1|]"]: () => void;
 ////}
 ////
 ////class C implements I {
-////    ["[|prop1|]"]: any;
+////    ["[|{| "isDefinition": true |}prop1|]"]: any;
 ////}
 ////
 ////var x: I = {
-////    ["[|prop1|]"]: function () { },
+////    ["[|{| "isDefinition": true |}prop1|]"]: function () { },
 ////}
 
-verify.rangesReferenceEachOther();
+const ranges = test.ranges();
+const [r0, r1, r2] = ranges;
+verify.referenceGroups(r0, [{ definition: '(property) I[["prop1"]]: () => void', ranges }]);
+verify.referenceGroups(r1, [
+    { definition: '(property) I[["prop1"]]: () => void', ranges: [r0, r2] },
+    { definition: '(property) C[["prop1"]]: any', ranges: [r1] }
+]);
+verify.referenceGroups(r2, [
+    { definition: '(property) I[["prop1"]]: () => void', ranges: [r0, r1] },
+    { definition: '(property) ["prop1"]: () => void', ranges: [r2] }
+]);
+

tests/cases/fourslash/findAllRefsForComputedProperties2.ts

@@ -1,15 +1,25 @@
 /// <reference path='fourslash.ts'/>
 
 ////interface I {
-////    [[|42|]](): void;
+////    [[|{| "isDefinition": true |}42|]](): void;
 ////}
 ////
 ////class C implements I {
-////    [[|42|]]: any;
+////    [[|{| "isDefinition": true |}42|]]: any;
 ////}
 ////
 ////var x: I = {
-////    ["[|42|]"]: function () { }
+////    ["[|{| "isDefinition": true |}42|]"]: function () { }
 ////}
 
-verify.rangesReferenceEachOther();
+const ranges = test.ranges();
+const [r0, r1, r2] = ranges;
+verify.referenceGroups(r0, [{ definition: "(method) I[[42]](): void", ranges }]);
+verify.referenceGroups(r1, [
+    { definition: "(method) I[[42]](): void", ranges: [r0, r2] },
+    { definition:  "(property) C[[42]]: any", ranges: [r1] }
+]);
+verify.referenceGroups(r2, [
+    { definition: "(method) I[[42]](): void", ranges: [r0, r1] },
+    { definition: '(property) ["42"]: () => void', ranges: [r2] }
+]);

tests/cases/fourslash/findAllRefsForDefaultExport.ts

@@ -1,11 +1,11 @@
 /// <reference path="fourslash.ts" />
 
 // @Filename: a.ts
-////export default function /*def*/[|f|]() {}
+////export default function /*def*/[|{| "isWriteAccess": true, "isDefinition": true |}f|]() {}
 
 // @Filename: b.ts
-////import [|g|] from "./a";
+////import [|{| "isWriteAccess": true, "isDefinition": true |}g|] from "./a";
 /////*ref*/[|g|]();
 
-verify.rangesReferenceEachOther();
+verify.singleReferenceGroup("function f(): void");
 verify.goToDefinition("ref", "def");

tests/cases/fourslash/findAllRefsForDefaultExport01.ts

@@ -1,10 +1,13 @@
 /// <reference path='fourslash.ts'/>
 
-////export default class [|DefaultExportedClass|] {
+////export default class [|{| "isWriteAccess": true, "isDefinition": true |}DefaultExportedClass|] {
 ////}
 ////
 ////var x: [|DefaultExportedClass|];
 ////
 ////var y = new [|DefaultExportedClass|];
 
-verify.rangesReferenceEachOther();
+const ranges = test.ranges();
+const [r0, r1, r2] = ranges;
+verify.referenceGroups([r0, r1], [{ definition: "class DefaultExportedClass", ranges }]);
+verify.referenceGroups(r2, [{ definition: "constructor DefaultExportedClass(): DefaultExportedClass", ranges }]);

tests/cases/fourslash/findAllRefsForDefaultExport02.ts

@@ -1,11 +1,22 @@
 /// <reference path='fourslash.ts'/>
 
-////export default function [|DefaultExportedFunction|]() {
+////export default function [|{| "isWriteAccess": true, "isDefinition": true |}DefaultExportedFunction|]() {
-////    return [|DefaultExportedFunction|]
+////    return [|DefaultExportedFunction|];
 ////}
 ////
 ////var x: typeof [|DefaultExportedFunction|];
 ////
 ////var y = [|DefaultExportedFunction|]();
+////
+////namespace [|{| "isWriteAccess": true, "isDefinition": true |}DefaultExportedFunction|] {
+////}
 
-verify.rangesReferenceEachOther();
+
+const ranges = test.ranges();
+const [r0, r1, r2, r3, r4] = ranges;
+const fnRanges = [r0, r1, r2, r3];
+verify.singleReferenceGroup("function DefaultExportedFunction(): () => typeof DefaultExportedFunction", fnRanges);
+
+// The namespace and function do not merge,
+// so the namespace should be all alone.
+verify.singleReferenceGroup("namespace DefaultExportedFunction", [r4]);

tests/cases/fourslash/findAllRefsForDefaultExport03.ts

@@ -1,6 +1,6 @@
 /// <reference path='fourslash.ts'/>
 
-////function [|f|]() {
+////function [|{| "isWriteAccess": true, "isDefinition": true |}f|]() {
 ////    return 100;
 ////}
 ////
@@ -10,8 +10,11 @@
 ////
 ////var y = [|f|]();
 ////
-////namespace [|f|] {
+////namespace [|{| "isWriteAccess": true, "isDefinition": true |}f|] {
 ////    var local = 100;
 ////}
 
-verify.rangesReferenceEachOther();
+const ranges = test.ranges();
+const [r0, r1, r2, r3, r4] = ranges;
+verify.referenceGroups([r0, r3], [{ definition: "function f(): number\nnamespace f", ranges }]);
+verify.referenceGroups([r1, r2, r4], [{ definition: "namespace f\nfunction f(): number", ranges }]);

tests/cases/fourslash/findAllRefsForDefaultExport04.ts

@@ -1,23 +0,0 @@
-/// <reference path='fourslash.ts'/>
-
-////function f() {
-////    return 100;
-////}
-////
-////export default [|f|];
-////
-////var x: typeof f;
-////
-////var y = f();
-////
-////namespace /**/[|f|] {
-////}
-
-// The function 'f' and the namespace 'f' don't get merged,
-// but the 'export default' site, includes both meanings.
-
-// Here we are testing whether the 'export default'
-// site is included in the references to the namespace.
-
-goTo.marker();
-verify.referencesAre(test.ranges());

tests/cases/fourslash/findAllRefsForDefaultExport05.ts

@@ -1,23 +0,0 @@
-/// <reference path='fourslash.ts'/>
-
-////function /**/[|f|]() {
-////    return 100;
-////}
-////
-////export default [|f|];
-////
-////var x: typeof [|f|];
-////
-////var y = [|f|]();
-////
-////namespace f {
-////}
-
-// The function 'f' and the namespace 'f' don't get merged,
-// but the 'export default' site, includes both meanings.
-
-// Here we are testing whether the 'export default' site
-// and all value-uses of 'f' are included in the references to the function.
-
-goTo.marker();
-verify.referencesAre(test.ranges());

tests/cases/fourslash/findAllRefsForDefaultExport06.ts

@@ -1,23 +0,0 @@
-/// <reference path='fourslash.ts'/>
-
-////function [|f|]() {
-////    return 100;
-////}
-////
-////export default /**/[|f|];
-////
-////var x: typeof [|f|];
-////
-////var y = [|f|]();
-////
-////namespace [|f|] {
-////}
-
-// The function 'f' and the namespace 'f' don't get merged,
-// but the 'export default' site, includes both meanings.
-
-// Here we are testing whether the 'export default' site
-// and all value-uses of 'f' are included in the references to the function.
-
-goTo.marker();
-verify.referencesAre(test.ranges());

tests/cases/fourslash/findAllRefsForDefaultExport07.ts

@@ -1,16 +0,0 @@
-/// <reference path='fourslash.ts'/>
-
-////export default function DefaultExportedFunction() {
-////    return DefaultExportedFunction
-////}
-////
-////var x: typeof DefaultExportedFunction;
-////
-////var y = DefaultExportedFunction();
-////
-////namespace [|DefaultExportedFunction|] {
-////}
-
-// The namespace and function do not merge,
-// so the namespace should be all alone.
-verify.rangesReferenceEachOther();

tests/cases/fourslash/findAllRefsForDefaultExport08.ts

@@ -7,10 +7,9 @@
 ////
 ////var y = new DefaultExportedClass;
 ////
-////namespace [|DefaultExportedClass|] {
+////namespace [|{| "isWriteAccess": true, "isDefinition": true |}DefaultExportedClass|] {
 ////}
 
 // The namespace and class do not merge,
 // so the namespace should be all alone.
-
+verify.singleReferenceGroup("namespace DefaultExportedClass");
-verify.rangesReferenceEachOther();

tests/cases/fourslash/findAllRefsForFunctionExpression01.ts

@@ -1,7 +1,7 @@
 /// <reference path='fourslash.ts'/>
 
 // @Filename: file1.ts
-////var foo = function [|foo|](a = [|foo|](), b = () => [|foo|]) {
+////var foo = function [|{| "isWriteAccess": true, "isDefinition": true |}foo|](a = [|foo|](), b = () => [|foo|]) {
 ////    [|foo|]([|foo|], [|foo|]);
 ////}
 
@@ -9,4 +9,4 @@
 /////// <reference path="file1.ts" />
 ////foo();
 
-verify.rangesReferenceEachOther();
+verify.singleReferenceGroup("(local function) foo(a?: void, b?: () => (a?: void, b?: any) => void): void");

tests/cases/fourslash/findAllRefsForMappedType.ts

@@ -1,9 +1,19 @@
 /// <reference path='fourslash.ts'/>
 
-////interface T { [|a|]: number };
+////interface T { [|{| "isWriteAccess": true, "isDefinition": true |}a|]: number };
 ////type U = { [K in keyof T]: string };
 ////type V = { [K in keyof U]: boolean };
-////const u: U = { [|a|]: "" }
+////const u: U = { [|{| "isWriteAccess": true, "isDefinition": true |}a|]: "" }
-////const v: V = { [|a|]: true }
+////const v: V = { [|{| "isWriteAccess": true, "isDefinition": true |}a|]: true }
 
-verify.rangesReferenceEachOther();
+const ranges = test.ranges();
+const [r0, r1, r2] = ranges;
+verify.referenceGroups(r0, [{ definition: "(property) T.a: number", ranges }]);
+verify.referenceGroups(r1, [
+    { definition: "(property) T.a: number", ranges: [r0, r2] },
+    { definition: "(property) a: string", ranges: [r1] }
+]);
+verify.referenceGroups(r2, [
+    { definition: "(property) T.a: number", ranges: [r0, r1] },
+    { definition: "(property) a: boolean", ranges: [r2] }
+]);

tests/cases/fourslash/findAllRefsForObjectLiteralProperties.ts

@@ -1,11 +1,17 @@
 /// <reference path='fourslash.ts'/>
 
 ////var x = {
-////    [|property|]: {}
+////    [|{| "isWriteAccess": true, "isDefinition": true |}property|]: {}
 ////};
 ////
 ////x.[|property|];
 ////
 ////let {[|property|]: pVar} = x;
 
-verify.rangesReferenceEachOther();
+const ranges = test.ranges();
+const [r0, r1, r2] = ranges;
+verify.referenceGroups(r0, [{ definition: "(property) property: {}", ranges }]);
+verify.referenceGroups([r1, r2], [
+    { definition: "(property) property: {}", ranges: [r0] },
+    { definition: "(property) property: {}", ranges: [r1, r2] }
+]);

tests/cases/fourslash/findAllRefsForObjectSpread.ts

@@ -1,14 +1,21 @@
 /// <reference path='fourslash.ts'/>
 
-////interface A1 { [|a|]: string };
+////interface A1 { [|{| "isWriteAccess": true, "isDefinition": true |}a|]: string };
-////interface A2 { [|a|]?: number };
+////interface A2 { [|{| "isWriteAccess": true, "isDefinition": true |}a|]?: number };
 ////let a1: A1;
 ////let a2: A2;
 ////let a12 = { ...a1, ...a2 };
 ////a12.[|a|];
 const ranges = test.ranges();
+const [r0, r1, r2] = ranges;
+
 // members of spread types only refer to themselves and the resulting property
-verify.referencesOf(ranges[0], [ranges[0], ranges[2]]);
+verify.referenceGroups(r0, [{ definition: "(property) A1.a: string", ranges: [r0, r2] }]);
-verify.referencesOf(ranges[1], [ranges[1], ranges[2]]);
+verify.referenceGroups(r1, [{ definition: "(property) A2.a: number", ranges: [r1, r2] }]);
+
 // but the resulting property refers to everything
-verify.referencesOf(ranges[2], ranges);
+verify.referenceGroups(r2, [
+    { definition: "(property) A1.a: string", ranges: [r0] },
+    { definition: "(property) A2.a: number", ranges: [r1] },
+    { definition: "(property) a: string | number", ranges: [r2] }
+]);

tests/cases/fourslash/findAllRefsForRest.ts

@@ -1,11 +1,11 @@
 /// <reference path='fourslash.ts'/>
 ////interface Gen {
 ////    x: number
-////    [|parent|]: Gen;
+////    [|{| "isWriteAccess": true, "isDefinition": true |}parent|]: Gen;
 ////    millenial: string;
 ////}
 ////let t: Gen;
 ////var { x, ...rest } = t;
 ////rest.[|parent|];
 
-verify.rangesReferenceEachOther();
+verify.singleReferenceGroup("(property) Gen.parent: Gen");

tests/cases/fourslash/findAllRefsForStringLiteralTypes.ts

@@ -3,4 +3,4 @@
 ////type Options = "[|option 1|]" | "option 2";
 ////let myOption: Options = "[|option 1|]";
 
-verify.rangesReferenceEachOther();
+verify.singleReferenceGroup('"option 1"');

tests/cases/fourslash/findAllRefsForUMDModuleAlias1.ts

@@ -4,10 +4,10 @@
 //// export function doThing(): string;
 //// export function doTheOtherThing(): void;
 
-//// export as namespace [|myLib|];
+//// export as namespace [|{| "isWriteAccess": true, "isDefinition": true |}myLib|];
 
 // @Filename: 1.ts
 //// /// <reference path="0.d.ts" />
 //// [|myLib|].doThing();
 
-verify.rangesReferenceEachOther();
+verify.singleReferenceGroup("export namespace myLib");

tests/cases/fourslash/findAllRefsForVariableInExtendsClause01.ts

@@ -1,6 +1,6 @@
 /// <reference path="fourslash.ts"/>
 
-////var [|Base|] = class { };
+////var [|{| "isWriteAccess": true, "isDefinition": true |}Base|] = class { };
 ////class C extends [|Base|] { }
 
-verify.rangesReferenceEachOther();
+verify.singleReferenceGroup("var Base: typeof (Anonymous class)");

tests/cases/fourslash/findAllRefsForVariableInExtendsClause02.ts

@@ -1,9 +1,9 @@
 /// <reference path="fourslash.ts"/>
 
-////interface [|Base|] { }
+////interface [|{| "isWriteAccess": true, "isDefinition": true |}Base|] { }
 ////namespace n {
 ////    var Base = class { };
 ////    interface I extends [|Base|] { }
 ////}
 
-verify.rangesReferenceEachOther();
+verify.singleReferenceGroup("interface Base");

tests/cases/fourslash/findAllRefsForVariableInImplementsClause01.ts

@@ -3,5 +3,4 @@
 ////var Base = class { };
 ////class C extends Base implements /**/Base { }
 
-goTo.marker();
+verify.noReferences("");
-verify.referencesAre([]);

tests/cases/fourslash/findAllRefsInClassExpression.ts

@@ -1,8 +1,14 @@
 /// <reference path='fourslash.ts'/>
 
-////interface I { [|boom|](): void; }
+////interface I { [|{| "isWriteAccess": true, "isDefinition": true |}boom|](): void; }
 ////new class C implements I {
-////   [|boom|](){}
+////   [|{| "isWriteAccess": true, "isDefinition": true |}boom|](){}
 ////}
 
-verify.rangesReferenceEachOther();
+const ranges = test.ranges();
+const [r0, r1] = ranges;
+verify.referenceGroups(r0, [{ definition: "(method) I.boom(): void", ranges }]);
+verify.referenceGroups(r1, [
+    { definition: "(method) I.boom(): void", ranges: [r0] },
+    { definition: "(method) C.boom(): void", ranges: [r1] }
+]);

tests/cases/fourslash/findAllRefsInheritedProperties1.ts

@@ -1,8 +1,8 @@
 /// <reference path='fourslash.ts'/>
 
 //// class class1 extends class1 {
-////    [|doStuff|]() { }
+////    [|{| "isWriteAccess": true, "isDefinition": true |}doStuff|]() { }
-////    [|propName|]: string;
+////    [|{| "isWriteAccess": true, "isDefinition": true |}propName|]: string;
 //// }
 ////
 //// var v: class1;
@@ -10,7 +10,9 @@
 //// v.[|propName|];
 
 const [r0, r1, r2, r3] = test.ranges();
-verify.referencesOf(r0, [r0, r2]);
+verify.referenceGroups(r0, [{ definition: "(method) class1.doStuff(): void", ranges: [r0, r2] }]);
-verify.referencesOf(r1, [r1, r3]);
+verify.referenceGroups(r2, [
-verify.referencesOf(r2, [r0, r2]);
+    { definition: "(method) class1.doStuff(): void", ranges: [r0] },
-verify.referencesOf(r3, [r1, r3]);
+    { definition: "(method) class1.doStuff(): void", ranges: [r2] }
+]);
+verify.singleReferenceGroup("(property) class1.propName: string", [r1, r3]);

tests/cases/fourslash/findAllRefsInheritedProperties2.ts

@@ -1,8 +1,8 @@
 /// <reference path='fourslash.ts'/>
 
 //// interface interface1 extends interface1 {
-////    [|doStuff|](): void;   // r0
+////    [|{| "isWriteAccess": true, "isDefinition": true |}doStuff|](): void;   // r0
-////    [|propName|]: string;  // r1
+////    [|{| "isWriteAccess": true, "isDefinition": true |}propName|]: string;  // r1
 //// }
 ////
 //// var v: interface1;
@@ -10,7 +10,5 @@
 //// v.[|propName|];   // r3
 
 const [r0, r1, r2, r3] = test.ranges();
-verify.referencesOf(r0, [r0, r2]);
+verify.singleReferenceGroup("(method) interface1.doStuff(): void", [r0, r2]);
-verify.referencesOf(r1, [r1, r3]);
+verify.singleReferenceGroup("(property) interface1.propName: string", [r1, r3]);
-verify.referencesOf(r2, [r0, r2]);
-verify.referencesOf(r3, [r1, r3]);

tests/cases/fourslash/findAllRefsInheritedProperties3.ts

@@ -1,28 +1,40 @@
 /// <reference path='fourslash.ts'/>
 
 //// class class1 extends class1 {
-////     [|doStuff|]() { }     // r0
+////     [|{| "isWriteAccess": true, "isDefinition": true |}doStuff|]() { }     // r0
-////     [|propName|]: string; // r1
+////     [|{| "isWriteAccess": true, "isDefinition": true |}propName|]: string; // r1
 //// }
 //// interface interface1 extends interface1 {
-////     [|doStuff|](): void;   // r2
+////     [|{| "isWriteAccess": true, "isDefinition": true |}doStuff|](): void;   // r2
-////     [|propName|]: string;  // r3
+////     [|{| "isWriteAccess": true, "isDefinition": true |}propName|]: string;  // r3
 //// }
 //// class class2 extends class1 implements interface1 {
-////     [|doStuff|]() { }      // r4
+////     [|{| "isWriteAccess": true, "isDefinition": true |}doStuff|]() { }      // r4
-////     [|propName|]: string;  // r5
+////     [|{| "isWriteAccess": true, "isDefinition": true |}propName|]: string;  // r5
 //// }
-//// 
+////
 //// var v: class2;
-//// v.[|propName|];   // r6
+//// v.[|doStuff|]();  // r6
-//// v.[|doStuff|]();  // r7
+//// v.[|propName|];   // r7
 
 const [r0, r1, r2, r3, r4, r5, r6, r7] = test.ranges();
-verify.referencesOf(r0, [r0, r4, r7]);
+verify.referenceGroups(r0, [{ definition: "(method) class1.doStuff(): void", ranges: [r0, r4, r6] }]);
-verify.referencesOf(r1, [r1, r5, r6]);
+verify.referenceGroups(r1, [{ definition: "(property) class1.propName: string", ranges: [r1, r5, r7] }]);
-verify.referencesOf(r2, [r2, r4, r7]);
+verify.referenceGroups(r2, [{ definition: "(method) interface1.doStuff(): void", ranges: [r2, r4, r6] }]);
-verify.referencesOf(r3, [r3, r5, r6]);
+verify.referenceGroups(r3, [{ definition: "(property) interface1.propName: string", ranges: [r3, r5, r7] }]);
-verify.referencesOf(r4, [r0, r2, r4, r7]);
+verify.referenceGroups(r4, [
-verify.referencesOf(r5, [r1, r3, r5, r6]);
+    { definition: "(method) class1.doStuff(): void", ranges: [r0] },
-verify.referencesOf(r6, [r1, r3, r5, r6]);
+    { definition: "(method) interface1.doStuff(): void", ranges: [r2] },
-verify.referencesOf(r7, [r0, r2, r4, r7]);
+    { definition: "(method) class2.doStuff(): void", ranges: [r4, r6] }
+]);
+verify.referenceGroups([r5, r7], [
+    { definition: "(property) class1.propName: string", ranges: [r1] },
+    { definition: "(property) interface1.propName: string", ranges: [r3] },
+    { definition: "(property) class2.propName: string", ranges: [r5, r7] }
+]);
+verify.referenceGroups(r6, [
+    { definition: "(method) class1.doStuff(): void", ranges: [r0] },
+    { definition: "(method) interface1.doStuff(): void", ranges: [r2] },
+    { definition: "(method) class2.doStuff(): void", ranges: [r4] },
+    { definition: "(method) class2.doStuff(): void", ranges: [r6] }
+]);

tests/cases/fourslash/findAllRefsInheritedProperties4.ts

@@ -1,12 +1,12 @@
 /// <reference path='fourslash.ts'/>
 
 //// interface C extends D {
-////     [|prop0|]: string;  // r0
+////     [|{| "isWriteAccess": true, "isDefinition": true |}prop0|]: string;  // r0
-////     [|prop1|]: number;  // r1
+////     [|{| "isWriteAccess": true, "isDefinition": true |}prop1|]: number;  // r1
 //// }
 ////
 //// interface D extends C {
-////     [|prop0|]: string;  // r2
+////     [|{| "isWriteAccess": true, "isDefinition": true |}prop0|]: string;  // r2
 //// }
 ////
 //// var d: D;
@@ -14,8 +14,9 @@
 //// d.[|prop1|];  // r4
 
 const [r0, r1, r2, r3, r4] = test.ranges();
-verify.referencesOf(r0, [r0, r2, r3]);
+verify.referenceGroups([r0, r2, r3], [
-verify.referencesOf(r1, [r1]);
+    { definition: "(property) C.prop0: string", ranges: [r0] },
-verify.referencesOf(r2, [r0, r2, r3]);
+    { definition: "(property) D.prop0: string", ranges: [r2, r3] }
-verify.referencesOf(r3, [r0, r2, r3]);
+]);
-verify.referencesOf(r4, []);
+verify.singleReferenceGroup("(property) C.prop1: number", [r1]);
+verify.noReferences(r4);

tests/cases/fourslash/findAllRefsInheritedProperties5.ts

@@ -1,12 +1,12 @@
 /// <reference path='fourslash.ts'/>
 
 //// class C extends D {
-////     [|prop0|]: string;  // r0
+////     [|{| "isWriteAccess": true, "isDefinition": true |}prop0|]: string;  // r0
-////     [|prop1|]: number;  // r1
+////     [|{| "isWriteAccess": true, "isDefinition": true |}prop1|]: number;  // r1
 //// }
 ////
 //// class D extends C {
-////     [|prop0|]: string;  // r2
+////     [|{| "isWriteAccess": true, "isDefinition": true |}prop0|]: string;  // r2
 //// }
 ////
 //// var d: D;
@@ -14,8 +14,7 @@
 //// d.[|prop1|];  // r4
 
 const [r0, r1, r2, r3, r4] = test.ranges();
-verify.referencesOf(r0, [r0]);
+verify.singleReferenceGroup("(property) C.prop0: string", [r0]);
-verify.referencesOf(r1, [r1]);
+verify.singleReferenceGroup("(property) C.prop1: number", [r1]);
-verify.referencesOf(r2, [r2, r3]);
+verify.singleReferenceGroup("(property) D.prop0: string", [r2, r3]);
-verify.referencesOf(r3, [r2, r3]);
+verify.noReferences(r4);
-verify.referencesOf(r4, []);

tests/cases/fourslash/findAllRefsInsideTemplates1.ts

@@ -1,6 +1,6 @@
 /// <reference path='fourslash.ts'/>
 
-////var [|x|] = 10;
+////var [|{| "isWriteAccess": true, "isDefinition": true |}x|] = 10;
 ////var y = `${ [|x|] } ${ [|x|] }`
 
-verify.rangesReferenceEachOther();
+verify.singleReferenceGroup("var x: number");

tests/cases/fourslash/findAllRefsInsideTemplates2.ts

@@ -1,6 +1,6 @@
 /// <reference path='fourslash.ts'/>
 
-////function [|f|](...rest: any[]) { }
+////function [|{| "isWriteAccess": true, "isDefinition": true |}f|](...rest: any[]) { }
 ////[|f|] `${ [|f|] } ${ [|f|] }`
 
-verify.rangesReferenceEachOther();
+verify.singleReferenceGroup("function f(...rest: any[]): void");

tests/cases/fourslash/findAllRefsInsideWithBlock.ts

@@ -1,12 +1,12 @@
 /// <reference path='fourslash.ts'/>
 
-////var [|x|] = 0;
+////var [|{| "isWriteAccess": true, "isDefinition": true |}x|] = 0;
 ////
 ////with ({}) {
 ////    var y = x;  // Reference of x here should not be picked
 ////    /*2*/y++;        // also reference for y should be ignored
 ////}
 ////
-////[|x|] = [|x|] + 1;
+////[|{| "isWriteAccess": true |}x|] = [|x|] + 1;
 
-verify.rangesReferenceEachOther();
+verify.singleReferenceGroup("var x: number");

tests/cases/fourslash/findAllRefsObjectBindingElementPropertyName01.ts

@@ -1,11 +1,11 @@
 /// <reference path='fourslash.ts'/>
 
 ////interface I {
-////    [|property1|]: number;
+////    [|{| "isWriteAccess": true, "isDefinition": true |}property1|]: number;
 ////    property2: string;
 ////}
 ////
 ////var foo: I;
 ////var { [|property1|]: prop1 } = foo;
 
-verify.rangesReferenceEachOther();
+verify.singleReferenceGroup("(property) I.property1: number");

tests/cases/fourslash/findAllRefsObjectBindingElementPropertyName02.ts

@@ -1,11 +1,11 @@
 /// <reference path='fourslash.ts'/>
 
 ////interface I {
-////    [|property1|]: number;
+////    [|{| "isWriteAccess": true, "isDefinition": true |}property1|]: number;
 ////    property2: string;
 ////}
 ////
 ////var foo: I;
 ////var { [|property1|]: {} } = foo;
 
-verify.rangesReferenceEachOther();
+verify.singleReferenceGroup("(property) I.property1: number");

tests/cases/fourslash/findAllRefsObjectBindingElementPropertyName03.ts

@@ -1,11 +1,17 @@
 /// <reference path='fourslash.ts'/>
 
 ////interface I {
-////    [|property1|]: number;
+////    [|{| "isWriteAccess": true, "isDefinition": true |}property1|]: number;
 ////    property2: string;
 ////}
 ////
 ////var foo: I;
-////var [{ [|property1|]: prop1 }, { [|property1|], property2 } ] = [foo, foo];
+////var [{ [|property1|]: prop1 }, { [|{| "isWriteAccess": true, "isDefinition": true |}property1|], property2 } ] = [foo, foo];
 
-verify.rangesReferenceEachOther();
+const ranges = test.ranges();
+const [r0, r1, r2] = ranges;
+verify.referenceGroups([r0, r1], [{ definition: "(property) I.property1: number", ranges }]);
+verify.referenceGroups(r2, [
+    { definition: "(property) I.property1: number", ranges: [r0, r1] },
+    { definition: "var property1: number", ranges: [r2] }
+]);

tests/cases/fourslash/findAllRefsObjectBindingElementPropertyName04.ts

@@ -1,15 +1,22 @@
 /// <reference path='fourslash.ts'/>
 
 ////interface I {
-////    [|property1|]: number;
+////    [|{| "isWriteAccess": true, "isDefinition": true |}property1|]: number;
 ////    property2: string;
 ////}
 ////
 ////function f({ [|property1|]: p1 }: I,
-////           { [|property1|] }: I,
+////           { [|{| "isWriteAccess": true, "isDefinition": true |}property1|] }: I,
 ////           { property1: p2 }) {
 ////
 ////    return [|property1|] + 1;
 ////}
 
-verify.rangesReferenceEachOther();
+const ranges = test.ranges();
+const [r0, r1, r2, r3] = ranges;
+verify.referenceGroups([r0, r1], [{ definition: "(property) I.property1: number", ranges }]);
+verify.referenceGroups([r2, r3], [
+    { definition: "(property) I.property1: number", ranges: [r0, r1] },
+    { definition: "var property1: number", ranges: [r2, r3] }
+]);
+

tests/cases/fourslash/findAllRefsObjectBindingElementPropertyName05.ts

@@ -10,4 +10,4 @@
 ////}
 
 goTo.marker();
-verify.referencesAre([]);
+verify.noReferences("");

tests/cases/fourslash/findAllRefsObjectBindingElementPropertyName06.ts

@@ -1,22 +1,29 @@
 /// <reference path='fourslash.ts'/>
 
 ////interface I {
-////    [|property1|]: number;
+////    [|{| "isWriteAccess": true, "isDefinition": true |}property1|]: number;
 ////    property2: string;
 ////}
 ////
 ////var elems: I[];
 ////for (let { [|property1|]: p } of elems) {
 ////}
-////for (let { [|property1|] } of elems) {
+////for (let { [|{| "isWriteAccess": true, "isDefinition": true |}property1|] } of elems) {
 ////}
 ////for (var { [|property1|]: p1 } of elems) {
 ////}
 ////var p2;
-////for ({ [|property1|] : p2 } of elems) {
+////for ({ [|{| "isWriteAccess": true, "isDefinition": true |}property1|] : p2 } of elems) {
 ////}
 
-// Note: if this test ever changes, consider updating
+const ranges = test.ranges();
-//       'quickInfoForObjectBindingElementPropertyName05.ts'
+const [r0, r1, r2, r3, r4] = ranges;
-
+verify.referenceGroups([r0, r1, r3], [{ definition: "(property) I.property1: number", ranges }]);
-verify.rangesReferenceEachOther();
+verify.referenceGroups(r2, [
+    { definition: "(property) I.property1: number", ranges: [r0, r1, r3, r4] },
+    { definition: "let property1: number", ranges: [r2] }
+]);
+verify.referenceGroups(r4, [
+    { definition: "(property) I.property1: number", ranges: [r0, r1, r2, r3] },
+    { definition: "(property) property1: I", ranges: [r4] }
+]);

tests/cases/fourslash/findAllRefsObjectBindingElementPropertyName07.ts

@@ -2,6 +2,12 @@
 
 ////let p, b;
 ////
-////p, [{ [|a|]: p, b }] = [{ [|a|]: 10, b: true }];
+////p, [{ [|{| "isWriteAccess": true, "isDefinition": true |}a|]: p, b }] = [{ [|{| "isWriteAccess": true, "isDefinition": true |}a|]: 10, b: true }];
 
-verify.rangesReferenceEachOther();
+const ranges = test.ranges();
+const [r0, r1] = ranges;
+verify.referenceGroups(r0, [{ definition: "(property) a: any", ranges }]);
+verify.referenceGroups(r1, [
+    { definition: "(property) a: any", ranges: [r0] },
+    { definition: "(property) a: number", ranges: [r1] }
+]);

tests/cases/fourslash/findAllRefsObjectBindingElementPropertyName09.ts

@@ -1,15 +0,0 @@
-/// <reference path='fourslash.ts'/>
-
-////interface I {
-////    [|property1|]: number;
-////    property2: string;
-////}
-////
-////function f({ [|property1|]: p1 }: I,
-////           { [|property1|] }: I,
-////           { property1: p2 }) {
-////
-////    return [|property1|] + 1;
-////}
-
-verify.rangesReferenceEachOther();

tests/cases/fourslash/findAllRefsObjectBindingElementPropertyName10.ts

@@ -1,11 +1,11 @@
 /// <reference path='fourslash.ts'/>
 
 ////interface Recursive {
-////    [|next|]?: Recursive;
+////    [|{| "isWriteAccess": true, "isDefinition": true |}next|]?: Recursive;
 ////    value: any;
 ////}
 ////
 ////function f ({ [|next|]: { [|next|]: x} }: Recursive) {
 ////}
 
-verify.rangesReferenceEachOther();
+verify.singleReferenceGroup("(property) Recursive.next: Recursive");

tests/cases/fourslash/findAllRefsOfConstructor_withModifier.ts

@@ -6,5 +6,4 @@
 ////var x = new [|X|]();
 
 const ranges = test.ranges();
-const ctr = ranges[0];
+verify.referenceGroups(ranges[0], [{ definition: "constructor X(): X", ranges }]);
-verify.referencesOf(ctr, ranges);

tests/cases/fourslash/findAllRefsOnDecorators.ts

@@ -1,7 +1,7 @@
 /// <reference path="fourslash.ts" />
 
 // @Filename: a.ts
-////function [|decorator|](target) {
+////function [|{| "isWriteAccess": true, "isDefinition": true |}decorator|](target) {
 ////    return target;
 ////}
 ////[|decorator|]();
@@ -13,4 +13,4 @@
 ////    method() {}
 ////}
 
-verify.rangesReferenceEachOther();
+verify.singleReferenceGroup("function decorator(target: any): any");

tests/cases/fourslash/findAllRefsOnDefinition.ts

@@ -7,7 +7,7 @@
 ////
 ////    }
 ////
-////    public [|start|](){
+////    public [|{| "isWriteAccess": true, "isDefinition": true |}start|](){
 ////        return this;
 ////    }
 ////
@@ -23,4 +23,10 @@
 ////second.[|start|]();
 ////second.stop();
 
-verify.rangesReferenceEachOther();
+const ranges = test.ranges();
+const [r0, r1] = ranges;
+verify.referenceGroups(r0, [{ definition: "(method) Test.start(): this", ranges }]);
+verify.referenceGroups(r1, [
+    { definition: "(method) Second.Test.start(): Second.Test", ranges: [r0] },
+    { definition: "(method) Second.Test.start(): Second.Test", ranges: [r1] },
+]);

tests/cases/fourslash/findAllRefsOnDefinition2.ts

@@ -3,7 +3,7 @@
 //@Filename: findAllRefsOnDefinition2-import.ts
 ////export module Test{
 ////
-////    export interface [|start|] { }
+////    export interface [|{| "isWriteAccess": true, "isDefinition": true |}start|] { }
 ////
 ////    export interface stop { }
 ////}
@@ -14,4 +14,8 @@
 ////var start: Second.Test.[|start|];
 ////var stop: Second.Test.stop;
 
-verify.rangesReferenceEachOther();
+const ranges = test.ranges();
+const [r0, r1] = ranges;
+verify.referenceGroups(r0, [{ definition: "interface Test.start", ranges }]);
+verify.referenceGroups(r1, [{ definition: "interface Second.Test.start", ranges }]);
+

tests/cases/fourslash/findAllRefsOnImportAliases.ts

@@ -1,15 +1,18 @@
 /// <reference path="fourslash.ts" />
 
 //@Filename: a.ts
-////export class [|Class|] {
+////export class [|{| "isWriteAccess": true, "isDefinition": true |}Class|] {
 ////}
 
 //@Filename: b.ts
-////import { [|Class|] } from "./a";
+////import { [|{| "isWriteAccess": true, "isDefinition": true |}Class|] } from "./a";
 ////
 ////var c = new [|Class|]();
 
 //@Filename: c.ts
-////export { [|Class|] } from "./a";
+////export { [|{| "isWriteAccess": true, "isDefinition": true |}Class|] } from "./a";
 
-verify.rangesReferenceEachOther();
+const ranges = test.ranges();
+const [r0, r1, r2, r3] = ranges;
+verify.referenceGroups([r0, r1, r3], [{ definition: "class Class", ranges }]);
+verify.referenceGroups(r2, [{ definition: "constructor Class(): Class", ranges }]);

tests/cases/fourslash/findAllRefsOnImportAliases2.ts

@@ -1,15 +1,23 @@
 /// <reference path="fourslash.ts" />
 
 //@Filename: a.ts
-////export class [|Class|] {
+////export class [|{| "isWriteAccess": true, "isDefinition": true |}Class|] {
 ////}
 
 //@Filename: b.ts
-////import { [|Class|] as [|C2|] } from "./a";
+////import { [|{| "isWriteAccess": true, "isDefinition": true |}Class|] as [|{| "isWriteAccess": true, "isDefinition": true |}C2|] } from "./a";
 ////
 ////var c = new [|C2|]();
 
 //@Filename: c.ts
-////export { [|Class|] as [|C3|] } from "./a";
+////export { [|{| "isWriteAccess": true, "isDefinition": true |}Class|] as [|{| "isWriteAccess": true, "isDefinition": true |}C3|] } from "./a";
 
-verify.rangesWithSameTextReferenceEachOther();
+const ranges = test.rangesByText();
+verify.singleReferenceGroup("class Class", ranges.get("Class"));
+
+const c2s = ranges.get("C2");
+const [c2_0, c2_1] = c2s;
+verify.referenceGroups(c2_0, [{ definition: "import C2", ranges: c2s }]);
+verify.referenceGroups(c2_1, [{ definition: "(alias) new C2(): C2\nimport C2", ranges: c2s }]);
+
+verify.singleReferenceGroup("import C3", ranges.get("C3"));

tests/cases/fourslash/findAllRefsOnPrivateParameterProperty1.ts

@@ -1,7 +1,7 @@
 /// <reference path="fourslash.ts" />
 
 ////class ABCD {
-////    constructor(private x: number, public y: number, private [|z|]: number) {
+////    constructor(private x: number, public y: number, private [|{| "isWriteAccess": true, "isDefinition": true |}z|]: number) {
 ////    }
 ////
 ////    func() {
@@ -9,4 +9,4 @@
 ////    }
 ////}
 
-verify.rangesReferenceEachOther();
+verify.singleReferenceGroup("(property) ABCD.z: number");

tests/cases/fourslash/findAllRefsParameterPropertyDeclaration1.ts

@@ -1,10 +1,15 @@
 /// <reference path='fourslash.ts'/>
 
 //// class Foo {
-////     constructor(private [|privateParam|]: number) {
+////     constructor(private [|{| "isWriteAccess": true, "isDefinition": true |}privateParam|]: number) {
 ////         let localPrivate = [|privateParam|];
 ////         this.[|privateParam|] += 10;
 ////     }
 //// }
 
-verify.rangesReferenceEachOther();
+const ranges = test.ranges();
+const [r0, r1, r2] = ranges;
+verify.referenceGroups(ranges, [
+    { definition: "(property) Foo.privateParam: number", ranges: [r0, r2] },
+    { definition: "(parameter) privateParam: number", ranges: [r1] }
+]);

tests/cases/fourslash/findAllRefsParameterPropertyDeclaration2.ts

@@ -1,10 +1,15 @@
 /// <reference path='fourslash.ts'/>
 
 //// class Foo {
-////     constructor(public [|publicParam|]: number) {
+////     constructor(public [|{| "isWriteAccess": true, "isDefinition": true |}publicParam|]: number) {
 ////         let localPublic = [|publicParam|];
 ////         this.[|publicParam|] += 10;
 ////     }
 //// }
 
-verify.rangesReferenceEachOther();
+const ranges = test.ranges();
+const [r0, r1, r2] = ranges;
+verify.referenceGroups(ranges, [
+    { definition: "(property) Foo.publicParam: number", ranges: [r0, r2] },
+    { definition: "(parameter) publicParam: number", ranges: [r1] }
+]);

tests/cases/fourslash/findAllRefsParameterPropertyDeclaration3.ts

@@ -1,10 +1,15 @@
 /// <reference path='fourslash.ts'/>
 
 //// class Foo {
-////     constructor(protected [|protectedParam|]: number) {
+////     constructor(protected [|{| "isWriteAccess": true, "isDefinition": true |}protectedParam|]: number) {
 ////         let localProtected = [|protectedParam|];
 ////         this.[|protectedParam|] += 10;
 ////     }
 //// }
 
-verify.rangesReferenceEachOther();
+const ranges = test.ranges();
+const [r0, r1, r2] = ranges;
+verify.referenceGroups(ranges, [
+    { definition: "(property) Foo.protectedParam: number", ranges: [r0, r2] },
+    { definition: "(parameter) protectedParam: number", ranges: [r1] }
+]);

tests/cases/fourslash/findAllRefsPrimitive.ts

@@ -24,7 +24,7 @@
 // @Filename: b.ts
 // const z: [|any|] = 0;
 
-verify.rangesWithSameTextReferenceEachOther();
+test.rangesByText().forEach((ranges, text) => verify.singleReferenceGroup(text, ranges));
 verify.rangesWithSameTextAreDocumentHighlights();
 
 goTo.rangeStart(test.ranges()[0]);

tests/cases/fourslash/findAllRefsPropertyContextuallyTypedByTypeParam01.ts

@@ -1,12 +1,12 @@
 /// <reference path="./fourslash.ts" />
 
 ////interface IFoo {
-////    [|a|]: string;
+////    [|{| "isWriteAccess": true, "isDefinition": true |}a|]: string;
 ////}
 ////class C<T extends IFoo> {
 ////    method() {
 ////        var x: T = {
-////            [|a|]: ""
+////            [|{| "isWriteAccess": true, "isDefinition": true |}a|]: ""
 ////        };
 ////        x.[|a|];
 ////    }
@@ -14,7 +14,17 @@
 ////
 ////
 ////var x: IFoo = {
-////    [|a|]: "ss"
+////    [|{| "isWriteAccess": true, "isDefinition": true |}a|]: "ss"
 ////};
 
-verify.rangesReferenceEachOther();
+const ranges = test.ranges();
+const [r0, r1, r2, r3] = ranges;
+verify.referenceGroups([r0, r2], [{ definition: "(property) IFoo.a: string", ranges }]);
+verify.referenceGroups(r1, [
+    { definition: "(property) IFoo.a: string", ranges: [r0, r2, r3] },
+    { definition: "(property) a: string", ranges: [r1] }
+]);
+verify.referenceGroups(r3, [
+    { definition: "(property) IFoo.a: string", ranges: [r0, r1, r2] },
+    { definition: "(property) a: string", ranges: [r3] }
+]);

tests/cases/fourslash/findAllRefsThisKeyword.ts

@@ -2,9 +2,9 @@
 // @noLib: true
 
 ////[|this|];
-////function f([|this|]) {
+////function f([|{| "isWriteAccess": true, "isDefinition": true |}this|]) {
 ////    return [|this|];
-////    function g([|this|]) { return [|this|]; }
+////    function g([|{| "isWriteAccess": true, "isDefinition": true |}this|]) { return [|this|]; }
 ////}
 ////class C {
 ////    static x() {
@@ -21,13 +21,19 @@
 ////    }
 ////}
 ////// These are *not* real uses of the 'this' keyword, they are identifiers.
-////const x = { [|this|]: 0 }
+////const x = { [|{| "isWriteAccess": true, "isDefinition": true |}this|]: 0 }
 ////x.[|this|];
 
 const [global, f0, f1, g0, g1, x, y, constructor, method, propDef, propUse] = test.ranges();
 verify.referencesOf(global, [global]);
-verify.rangesReferenceEachOther([f0, f1]);
+verify.referenceGroups(f0, [{ definition: "(parameter) this: any", ranges: [f0, f1] }]);
-verify.rangesReferenceEachOther([g0, g1]);
+verify.referenceGroups(f1, [{ definition: "this: any", ranges: [f0, f1] }]);
-verify.rangesReferenceEachOther([x, y]);
+verify.referenceGroups(g0, [{ definition: "(parameter) this: any", ranges: [g0, g1] }]);
-verify.rangesReferenceEachOther([constructor, method]);
+verify.referenceGroups(g1, [{ definition: "this: any", ranges: [g0, g1] }]);
-verify.rangesReferenceEachOther([propDef, propUse]);
+verify.singleReferenceGroup("this: typeof C", [x, y]);
+verify.singleReferenceGroup("this: this", [constructor, method]);
+verify.referenceGroups(propDef, [{ definition: "(property) this: number", ranges: [propDef, propUse] }]);
+verify.referenceGroups(propUse, [
+    { definition: "(property) this: number", ranges: [propDef] },
+    { definition: "(property) this: number", ranges: [propUse] },
+]);

tests/cases/fourslash/findAllRefsWithLeadingUnderscoreNames1.ts

@@ -1,10 +1,16 @@
 /// <reference path='fourslash.ts'/>
 
 ////class Foo {
-////    public [|_bar|]() { return 0; }
+////    public [|{| "isWriteAccess": true, "isDefinition": true |}_bar|]() { return 0; }
 ////}
 ////
 ////var x: Foo;
 ////x.[|_bar|];
 
-verify.rangesReferenceEachOther();
+const ranges = test.ranges();
+const [r0, r1] = ranges;
+verify.referenceGroups(r0, [{ definition: "(method) Foo._bar(): number", ranges }]);
+verify.referenceGroups(r1, [
+    { definition: "(method) Foo._bar(): number", ranges: [r0] },
+    { definition: "(method) Foo._bar(): number", ranges: [r1] }
+]);

tests/cases/fourslash/findAllRefsWithLeadingUnderscoreNames2.ts

@@ -1,10 +1,16 @@
 /// <reference path='fourslash.ts'/>
 
 ////class Foo {
-////    public [|__bar|]() { return 0; }
+////    public [|{| "isWriteAccess": true, "isDefinition": true |}__bar|]() { return 0; }
 ////}
 ////
 ////var x: Foo;
 ////x.[|__bar|];
 
-verify.rangesReferenceEachOther();
+const ranges = test.ranges();
+const [r0, r1] = ranges;
+verify.referenceGroups(r0, [{ definition: "(method) Foo.__bar(): number", ranges }]);
+verify.referenceGroups(r1, [
+    { definition: "(method) Foo.__bar(): number", ranges: [r0] },
+    { definition: "(method) Foo.__bar(): number", ranges: [r1] }
+]);

tests/cases/fourslash/findAllRefsWithLeadingUnderscoreNames3.ts

@@ -1,10 +1,16 @@
 /// <reference path='fourslash.ts'/>
 
 ////class Foo {
-////    public [|___bar|]() { return 0; }
+////    public [|{| "isWriteAccess": true, "isDefinition": true |}___bar|]() { return 0; }
 ////}
 ////
 ////var x: Foo;
 ////x.[|___bar|];
 
-verify.rangesReferenceEachOther();
+const ranges = test.ranges();
+const [r0, r1] = ranges;
+verify.referenceGroups(r0, [{ definition: "(method) Foo.___bar(): number", ranges }]);
+verify.referenceGroups(r1, [
+    { definition: "(method) Foo.___bar(): number", ranges: [r0] },
+    { definition: "(method) Foo.___bar(): number", ranges: [r1] }
+]);

tests/cases/fourslash/findAllRefsWithLeadingUnderscoreNames4.ts

@@ -1,10 +1,16 @@
 /// <reference path='fourslash.ts'/>
 
 ////class Foo {
-////    public [|____bar|]() { return 0; }
+////    public [|{| "isWriteAccess": true, "isDefinition": true |}____bar|]() { return 0; }
 ////}
 ////
 ////var x: Foo;
 ////x.[|____bar|];
 
-verify.rangesReferenceEachOther();
+const ranges = test.ranges();
+const [r0, r1] = ranges;
+verify.referenceGroups(r0, [{ definition: "(method) Foo.____bar(): number", ranges }]);
+verify.referenceGroups(r1, [
+    { definition: "(method) Foo.____bar(): number", ranges: [r0] },
+    { definition: "(method) Foo.____bar(): number", ranges: [r1] }
+]);

tests/cases/fourslash/findAllRefsWithLeadingUnderscoreNames5.ts

@@ -3,7 +3,7 @@
 ////class Foo {
 ////    public _bar;
 ////    public __bar;
-////    public [|___bar|];
+////    public [|{| "isWriteAccess": true, "isDefinition": true |}___bar|];
 ////    public ____bar;
 ////}
 ////
@@ -13,4 +13,4 @@
 ////x.[|___bar|];
 ////x.____bar;
 
-verify.rangesReferenceEachOther();
+verify.singleReferenceGroup("(property) Foo.___bar: any");

tests/cases/fourslash/findAllRefsWithLeadingUnderscoreNames6.ts

@@ -2,7 +2,7 @@
 
 ////class Foo {
 ////    public _bar;
-////    public [|__bar|];
+////    public [|{| "isWriteAccess": true, "isDefinition": true |}__bar|];
 ////    public ___bar;
 ////    public ____bar;
 ////}
@@ -13,4 +13,4 @@
 ////x.___bar;
 ////x.____bar;
 
-verify.rangesReferenceEachOther();
+verify.singleReferenceGroup("(property) Foo.__bar: any");

tests/cases/fourslash/findAllRefsWithLeadingUnderscoreNames7.ts

@@ -1,7 +1,7 @@
 /// <reference path='fourslash.ts' />
 
-////function [|__foo|]() {
+////function [|{| "isWriteAccess": true, "isDefinition": true |}__foo|]() {
 ////    [|__foo|]();
 ////}
 
-verify.rangesReferenceEachOther();
+verify.singleReferenceGroup("function __foo(): void");

tests/cases/fourslash/findAllRefsWithLeadingUnderscoreNames8.ts

@@ -1,7 +1,7 @@
 /// <reference path='fourslash.ts' />
 
-////(function [|__foo|]() {
+////(function [|{| "isWriteAccess": true, "isDefinition": true |}__foo|]() {
 ////    [|__foo|]();
 ////})
 
-verify.rangesReferenceEachOther();
+verify.singleReferenceGroup("(local function) __foo(): void");

tests/cases/fourslash/findAllRefsWithLeadingUnderscoreNames9.ts

@@ -1,7 +1,7 @@
 /// <reference path='fourslash.ts' />
 
-////(function [|___foo|]() {
+////(function [|{| "isWriteAccess": true, "isDefinition": true |}___foo|]() {
 ////    [|___foo|]();
 ////})
 
-verify.rangesReferenceEachOther();
+verify.singleReferenceGroup("(local function) ___foo(): void");

tests/cases/fourslash/findAllRefsWithShorthandPropertyAssignment.ts

@@ -1,14 +1,19 @@
 /// <reference path='fourslash.ts'/>
 
-//// var [|name|] = "Foo";
+//// var [|{| "isWriteAccess": true, "isDefinition": true |}name|] = "Foo";
 ////
-//// var obj = { [|name|] };
+//// var obj = { [|{| "isWriteAccess": true, "isDefinition": true |}name|] };
-//// var obj1 = { [|name|]:[|name|] };
+//// var obj1 = { [|{| "isWriteAccess": true, "isDefinition": true |}name|]:[|name|] };
 //// obj.[|name|];
 
 const [r0, r1, r2, r3, r4] = test.ranges();
-verify.referencesOf(r0, [r0, r1, r3]);
+verify.referenceGroups([r0, r3], [{ definition: "var name: string", ranges: [r0, r1, r3] }]);
-verify.referencesOf(r1, [r0, r1, r3, r4]);
+verify.referenceGroups(r1, [
-verify.referencesOf(r2, [r2]);
+    { definition: "var name: string", ranges: [r0, r3] },
-verify.referencesOf(r3, [r0, r1, r3]);
+    { definition: "(property) name: string", ranges: [r1, r4] }
-verify.referencesOf(r4, [r1, r4]);
+]);
+verify.singleReferenceGroup("(property) name: string", [r2]);
+verify.referenceGroups(r4, [
+    { definition: "(property) name: string", ranges: [r1] },
+    { definition: "(property) name: string", ranges: [r4] },
+]);

tests/cases/fourslash/findAllRefsWithShorthandPropertyAssignment2.ts

@@ -1,16 +1,22 @@
 /// <reference path='fourslash.ts'/>
 
-//// var [|dx|] = "Foo";
+//// var [|{| "isWriteAccess": true, "isDefinition": true |}dx|] = "Foo";
 ////
-//// module M { export var [|dx|]; }
+//// module M { export var [|{| "isWriteAccess": true, "isDefinition": true |}dx|]; }
 //// module M {
 ////    var z = 100;
-////    export var y = { [|dx|], z };
+////    export var y = { [|{| "isWriteAccess": true, "isDefinition": true |}dx|], z };
 //// }
 //// M.y.[|dx|];
 
 const [r0, r1, r2, r3] = test.ranges();
-verify.referencesOf(r0, [r0]);
+verify.singleReferenceGroup("var dx: string", [r0]);
-verify.referencesOf(r1, [r1, r2]);
+verify.referenceGroups(r1, [{ definition: "var M.dx: any", ranges: [r1, r2] }]);
-verify.referencesOf(r2, [r1, r2, r3]);
+verify.referenceGroups(r2, [
-verify.referencesOf(r3, [r2, r3]);
+    { definition: "var M.dx: any", ranges: [r1] },
+    { definition: "(property) dx: any", ranges: [r2, r3] }
+]);
+verify.referenceGroups(r3, [
+    { definition: "(property) dx: any", ranges: [r2] },
+    { definition: "(property) dx: any", ranges: [r3] }
+]);

tests/cases/fourslash/findReferencesAcrossMultipleProjects.ts

@@ -1,14 +1,14 @@
 /// <reference path="fourslash.ts" />
 
 //@Filename: a.ts
-////var [|x|]: number;
+////var [|{| "isWriteAccess": true, "isDefinition": true |}x|]: number;
 
 //@Filename: b.ts
 /////// <reference path="a.ts" />
-////[|x|]++;
+////[|{| "isWriteAccess": true |}x|]++;
 
 //@Filename: c.ts
 /////// <reference path="a.ts" />
-////[|x|]++;
+////[|{| "isWriteAccess": true |}x|]++;
 
-verify.rangesReferenceEachOther();
+verify.singleReferenceGroup("var x: number");

tests/cases/fourslash/findReferencesAfterEdit.ts

@@ -2,7 +2,7 @@
 
 // @Filename: a.ts
 ////interface A {
-////    [|foo|]: string;
+////    [|{| "isWriteAccess": true, "isDefinition": true |}foo|]: string;
 ////}
 
 // @Filename: b.ts
@@ -12,9 +12,9 @@
 ////    x.[|foo|]
 ////}
 
-verify.rangesReferenceEachOther();
+verify.singleReferenceGroup("(property) A.foo: string");
 
 goTo.marker("");
 edit.insert("\r\n");
 
-verify.rangesReferenceEachOther();
+verify.singleReferenceGroup("(property) A.foo: string");

tests/cases/fourslash/findReferencesJSXTagName.ts

@@ -1,14 +1,16 @@
 /// <reference path='fourslash.ts'/>
 
 // @Filename: index.tsx
-////import { [|SubmissionComp|] } from "./RedditSubmission"
+////import { [|{| "isWriteAccess": true, "isDefinition": true |}SubmissionComp|] } from "./RedditSubmission"
 ////function displaySubreddit(subreddit: string) {
 ////    let components = submissions
 ////        .map((value, index) => <[|SubmissionComp|] key={ index } elementPosition= { index } {...value.data} />);
 ////}
 
 // @Filename: RedditSubmission.ts
-////export const [|SubmissionComp|] = (submission: SubmissionProps) =>
+////export const [|{| "isWriteAccess": true, "isDefinition": true |}SubmissionComp|] = (submission: SubmissionProps) =>
 ////    <div style={{ fontFamily: "sans-serif" }}></div>;
 
-verify.rangesReferenceEachOther();
+const ranges = test.ranges();
+const [r0, r1, r2] = ranges;
+verify.referenceGroups(ranges, [{ definition: "const SubmissionComp: (submission: any) => any", ranges: [r2, r0, r1] }]);

tests/cases/fourslash/findReferencesJSXTagName2.ts

@@ -1,7 +1,9 @@
 /// <reference path='fourslash.ts'/>
 
 // @Filename: index.tsx
-////const [|obj|] = {Component: () => <div/>};
+////const [|{| "isWriteAccess": true, "isDefinition": true |}obj|] = {Component: () => <div/>};
 ////const element = <[|obj|].Component/>;
 
-verify.rangesReferenceEachOther();
+verify.singleReferenceGroup(`const obj: {
+    Component: () => any;
+}`);

tests/cases/fourslash/fourslash.ts

@@ -182,18 +182,19 @@ declare namespace FourSlashInterface {
         goToType(startMarkerNames: string | string[], endMarkerNames: string | string[]): void;
         verifyGetEmitOutputForCurrentFile(expected: string): void;
         verifyGetEmitOutputContentsForCurrentFile(expected: ts.OutputFile[]): void;
+        noReferences(markerNameOrRange?: string | Range): void;
         /**
-         * Asserts that the given ranges are the references from the current position.
+         * @deprecated, prefer 'referenceGroups'
-         * If ranges have markers, those markers may have "isDefinition" and "isWriteAccess" data
-         * (otherwise these properties pf the reference are not tested).
-         * Order of ranges does not matter.
-         */
-        referencesAre(ranges: Range[]): void;
-        /**
          * Like `referencesAre`, but goes to `start` first.
          * `start` should be included in `references`.
          */
         referencesOf(start: Range, references: Range[]): void;
+        /**
+         * For each of startRanges, asserts the ranges that are referenced from there.
+         * This uses the 'findReferences' command instead of 'getReferencesAtPosition', so references are grouped by their definition.
+         */
+        referenceGroups(startRanges: Range | Range[], parts: Array<{ definition: string, ranges: Range[] }>): void;
+        singleReferenceGroup(definition: string, ranges?: Range[]): void;
         rangesAreOccurrences(isWriteAccess?: boolean): void;
         rangesAreRenameLocations(findInStrings?: boolean, findInComments?: boolean): void;
         /**
@@ -202,7 +203,6 @@ declare namespace FourSlashInterface {
          */
         rangesReferenceEachOther(ranges?: Range[]): void;
         findReferencesDefinitionDisplayPartsAtCaretAre(expected: ts.SymbolDisplayPart[]): void;
-        rangesWithSameTextReferenceEachOther(): void;
         currentParameterHelpArgumentNameIs(name: string): void;
         currentParameterSpanIs(parameter: string): void;
         currentParameterHelpArgumentDocCommentIs(docComment: string): void;

tests/cases/fourslash/getOccurrencesIsDefinitionOfArrowFunction.ts

@@ -1,5 +1,5 @@
 /// <reference path='fourslash.ts' />
-////var [|{| "isDefinition": true |}f|] = x => x + 1;
+////var [|{| "isWriteAccess": true, "isDefinition": true |}f|] = x => x + 1;
-////[|{| "isDefinition": false |}f|](12);
+////[|f|](12);
 
-verify.rangesReferenceEachOther();
+verify.singleReferenceGroup("var f: (x: any) => any");

tests/cases/fourslash/getOccurrencesIsDefinitionOfBindingPattern.ts

@@ -1,5 +1,5 @@
 /// <reference path='fourslash.ts' />
-////const { [|{| "isDefinition": true |}x|], y } = { x: 1, y: 2 };
+////const { [|{| "isWriteAccess": true, "isDefinition": true |}x|], y } = { x: 1, y: 2 };
 ////const z = [|{| "isDefinition": false |}x|];
 
-verify.rangesReferenceEachOther();
+verify.singleReferenceGroup("const x: number");

tests/cases/fourslash/getOccurrencesIsDefinitionOfClass.ts

@@ -1,10 +1,13 @@
 /// <reference path='fourslash.ts' />
-////class [|{| "isDefinition": true |}C|] {
+////class [|{| "isWriteAccess": true, "isDefinition": true |}C|] {
 ////    n: number;
 ////    constructor() {
 ////        this.n = 12;
 ////    }
 ////}
-////let c = new [|{| "isDefinition": false |}C|]();
+////let c = new [|C|]();
 
-verify.rangesReferenceEachOther();
+const ranges = test.ranges();
+const [r0, r1] = ranges;
+verify.referenceGroups(r0, [{ definition: "class C", ranges }]);
+verify.referenceGroups(r1, [{ definition: "constructor C(): C", ranges }]);

tests/cases/fourslash/getOccurrencesIsDefinitionOfComputedProperty.ts

@@ -1,7 +1,9 @@
 /// <reference path='fourslash.ts' />
-////let o = { ["/**/[|{| "isDefinition": true |}foo|]"]: 12 };
+////let o = { ["[|{| "isDefinition": true |}foo|]"]: 12 };
-////let y = o.[|{| "isDefinition": false |}foo|];
+////let y = o.[|foo|];
-////let z = o['[|{| "isDefinition": false |}foo|]'];
+////let z = o['[|foo|]'];
 
-goTo.marker();
+const ranges = test.ranges();
-verify.referencesAre(test.ranges());
+const [r0, r1, r2] = ranges;
+verify.referenceGroups(r0, [{ definition: '(property) ["foo"]: number', ranges }]);
+verify.referenceGroups([r1, r2], []); // TODO: fix

tests/cases/fourslash/getOccurrencesIsDefinitionOfEnum.ts

@@ -1,8 +1,8 @@
 /// <reference path='fourslash.ts' />
-////enum [|{| "isDefinition": true |}E|] {
+////enum [|{| "isWriteAccess": true, "isDefinition": true |}E|] {
 ////    First,
 ////    Second
 ////}
-////let first = [|{| "isDefinition": false |}E|].First;
+////let first = [|E|].First;
 
-verify.rangesReferenceEachOther();
+verify.singleReferenceGroup("enum E");

tests/cases/fourslash/getOccurrencesIsDefinitionOfExport.ts

@@ -1,8 +1,8 @@
 /// <reference path='fourslash.ts' />
 // @Filename: m.ts
-////export var [|{| "isDefinition": true |}x|] = 12;
+////export var [|{| "isWriteAccess": true, "isDefinition": true |}x|] = 12;
 // @Filename: main.ts
-////import { [|{| "isDefinition": true |}x|] } from "./m";
+////import { [|{| "isWriteAccess": true, "isDefinition": true |}x|] } from "./m";
-////const y = [|{| "isDefinition": false |}x|];
+////const y = [|x|];
 
-verify.rangesReferenceEachOther();
+verify.singleReferenceGroup("var x: number");

tests/cases/fourslash/getOccurrencesIsDefinitionOfFunction.ts

@@ -1,6 +1,6 @@
 /// <reference path='fourslash.ts' />
-////function [|{| "isDefinition": true |}func|](x: number) {
+////function [|{| "isWriteAccess": true, "isDefinition": true |}func|](x: number) {
 ////}
-////[|{| "isDefinition": false |}func|](x)
+////[|func|](x)
 
-verify.rangesReferenceEachOther();
+verify.singleReferenceGroup("function func(x: number): void");

tests/cases/fourslash/getOccurrencesIsDefinitionOfInterface.ts

@@ -1,7 +1,7 @@
 /// <reference path='fourslash.ts' />
-////interface [|{| "isDefinition": true |}I|] {
+////interface [|{| "isWriteAccess": true, "isDefinition": true |}I|] {
 ////    p: number;
 ////}
-////let i: [|{| "isDefinition": false |}I|] = { p: 12 };
+////let i: [|I|] = { p: 12 };
 
-verify.rangesReferenceEachOther();
+verify.singleReferenceGroup("interface I");

tests/cases/fourslash/getOccurrencesIsDefinitionOfInterfaceClassMerge.ts

@@ -1,16 +1,19 @@
 /// <reference path='fourslash.ts' />
-////interface [|{| "isDefinition": true |}Numbers|] {
+////interface [|{| "isWriteAccess": true, "isDefinition": true |}Numbers|] {
 ////    p: number;
 ////}
-////interface [|{| "isDefinition": true |}Numbers|] {
+////interface [|{| "isWriteAccess": true, "isDefinition": true |}Numbers|] {
 ////    m: number;
 ////}
-////class [|{| "isDefinition": true |}Numbers|] {
+////class [|{| "isWriteAccess": true, "isDefinition": true |}Numbers|] {
 ////    f(n: number) {
 ////        return this.p + this.m + n;
 ////    }
 ////}
-////let i: [|{| "isDefinition": false |}Numbers|] = new [|{| "isDefinition": false |}Numbers|]();
+////let i: [|Numbers|] = new [|Numbers|]();
 ////let x = i.f(i.p + i.m);
 
-verify.rangesReferenceEachOther();
+const ranges = test.ranges();
+const [r0, r1, r2, r3, r4] = ranges;
+verify.referenceGroups([r0, r1, r2, r3], [{ definition: "class Numbers\ninterface Numbers", ranges }]);
+verify.referenceGroups(r4, [{ definition: "constructor Numbers(): Numbers", ranges }]);

tests/cases/fourslash/getOccurrencesIsDefinitionOfNamespace.ts

@@ -1,7 +1,7 @@
 /// <reference path='fourslash.ts' />
-////namespace [|{| "isDefinition": true |}Numbers|] {
+////namespace [|{| "isWriteAccess": true, "isDefinition": true |}Numbers|] {
 ////    export var n = 12;
 ////}
-////let x = [|{| "isDefinition": false |}Numbers|].n + 1;
+////let x = [|Numbers|].n + 1;
 
-verify.rangesReferenceEachOther();
+verify.singleReferenceGroup("namespace Numbers");

tests/cases/fourslash/getOccurrencesIsDefinitionOfNumberNamedProperty.ts

@@ -1,5 +1,11 @@
 /// <reference path='fourslash.ts' />
 ////let o = { [|{| "isDefinition": true |}1|]: 12 };
-////let y = o[[|{| "isDefinition": false |}1|]];
+////let y = o[[|1|]];
 
-verify.rangesReferenceEachOther();
+const ranges = test.ranges();
+const [r0, r1] = ranges;
+verify.referenceGroups(r0, [{ definition: "(property) 1: number", ranges }]);
+verify.referenceGroups(r1, [
+    { definition: "(property) 1: number", ranges: [r0] },
+    { definition: "(property) 1: number", ranges: [r1] }
+]);

tests/cases/fourslash/getOccurrencesIsDefinitionOfParameter.ts

@@ -1,6 +1,6 @@
 /// <reference path='fourslash.ts' />
-////function f([|{| "isDefinition": true |}x|]: number) {
+////function f([|{| "isWriteAccess": true, "isDefinition": true |}x|]: number) {
-////  return [|{| "isDefinition": false |}x|] + 1
+////  return [|x|] + 1
 ////}
 
-verify.rangesReferenceEachOther();
+verify.singleReferenceGroup("(parameter) x: number");

tests/cases/fourslash/getOccurrencesIsDefinitionOfStringNamedProperty.ts

@@ -1,5 +1,11 @@
 /// <reference path='fourslash.ts' />
 ////let o = { "[|{| "isDefinition": true |}x|]": 12 };
-////let y = o.[|{| "isDefinition": false |}x|];
+////let y = o.[|x|];
 
-verify.rangesReferenceEachOther();
+const ranges = test.ranges();
+const [r0, r1] = ranges;
+verify.referenceGroups(r0, [{ definition: '(property) "x": number', ranges }]);
+verify.referenceGroups(r1, [
+    { definition: '(property) "x": number', ranges: [r0] },
+    { definition: '(property) "x": number', ranges: [r1] },
+]);

tests/cases/fourslash/getOccurrencesIsDefinitionOfTypeAlias.ts

@@ -1,5 +1,5 @@
 /// <reference path='fourslash.ts' />
-////type [|{| "isDefinition": true |}Alias|]= number;
+////type [|{| "isWriteAccess": true, "isDefinition": true |}Alias|]= number;
-////let n: [|{| "isDefinition": false |}Alias|] = 12;
+////let n: [|Alias|] = 12;
 
-verify.rangesReferenceEachOther();
+verify.singleReferenceGroup("type Alias = number");

tests/cases/fourslash/getOccurrencesIsDefinitionOfVariable.ts

@@ -1,20 +1,20 @@
 /// <reference path='fourslash.ts' />
-////var [|{| "isDefinition": true |}x|] = 0;
+////var [|{| "isWriteAccess": true, "isDefinition": true |}x|] = 0;
-////var assignmentRightHandSide = [|{| "isDefinition": false |}x|];
+////var assignmentRightHandSide = [|x|];
-////var assignmentRightHandSide2 = 1 + [|{| "isDefinition": false |}x|];
+////var assignmentRightHandSide2 = 1 + [|x|];
 ////
-////[|{| "isDefinition": false |}x|] = 1;
+////[|{| "isWriteAccess": true |}x|] = 1;
-////[|{| "isDefinition": false |}x|] = [|{| "isDefinition": false |}x|] + [|{| "isDefinition": false |}x|];
+////[|{| "isWriteAccess": true |}x|] = [|x|] + [|x|];
 ////
-////[|{| "isDefinition": false |}x|] == 1;
+////[|x|] == 1;
-////[|{| "isDefinition": false |}x|] <= 1;
+////[|x|] <= 1;
 ////
-////var preIncrement = ++[|{| "isDefinition": false |}x|];
+////var preIncrement = ++[|{| "isWriteAccess": true |}x|];
-////var postIncrement = [|{| "isDefinition": false |}x|]++;
+////var postIncrement = [|{| "isWriteAccess": true |}x|]++;
-////var preDecrement = --[|{| "isDefinition": false |}x|];
+////var preDecrement = --[|{| "isWriteAccess": true |}x|];
-////var postDecrement = [|{| "isDefinition": false |}x|]--;
+////var postDecrement = [|{| "isWriteAccess": true |}x|]--;
 ////
-////[|{| "isDefinition": false |}x|] += 1;
+////[|{| "isWriteAccess": true |}x|] += 1;
-////[|{| "isDefinition": false |}x|] <<= 1;
+////[|{| "isWriteAccess": true |}x|] <<= 1;
 
-verify.rangesReferenceEachOther();
+verify.singleReferenceGroup("var x: number");

tests/cases/fourslash/hoverOverComment.ts

@@ -7,4 +7,4 @@
 goTo.marker();
 verify.quickInfoIs("");
 verify.goToDefinitionIs([]);
-verify.referencesAre([]);
+verify.noReferences();

tests/cases/fourslash/localGetReferences.ts

@@ -3,17 +3,17 @@
 // @Filename: localGetReferences_1.ts
 ////// Comment Refence Test: g/*1*/lobalVar
 ////// References to a variable declared in global.
-////var [|globalVar|]: number = 2;
+////var [|{| "isWriteAccess": true, "isDefinition": true |}globalVar|]: number = 2;
 ////
 ////class fooCls {
 ////    // References to static variable declared in a class.
-////    static [|clsSVar|] = 1;
+////    static [|{| "isWriteAccess": true, "isDefinition": true |}clsSVar|] = 1;
 ////    // References to a variable declared in a class.
-////    [|clsVar|] = 1;
+////    [|{| "isWriteAccess": true, "isDefinition": true |}clsVar|] = 1;
 ////
-////    constructor (public [|clsParam|]: number) {
+////    constructor (public [|{| "isWriteAccess": true, "isDefinition": true |}clsParam|]: number) {
 ////        //Increments
-////        [|globalVar|]++;
+////        [|{| "isWriteAccess": true |}globalVar|]++;
 ////        this.[|clsVar|]++;
 ////        fooCls.[|clsSVar|]++;
 ////        // References to a class parameter.
@@ -23,18 +23,18 @@
 ////}
 ////
 ////// References to a function parameter.
-////function [|foo|]([|x|]: number) {
+////function [|{| "isWriteAccess": true, "isDefinition": true |}foo|]([|{| "isWriteAccess": true, "isDefinition": true |}x|]: number) {
 ////    // References to a variable declared in a function.
-////    var [|fnVar|] = 1;
+////    var [|{| "isWriteAccess": true, "isDefinition": true |}fnVar|] = 1;
 ////
 ////    //Increments
 ////    fooCls.[|clsSVar|]++;
-////    [|globalVar|]++;
+////    [|{| "isWriteAccess": true |}globalVar|]++;
 ////    modTest.modVar++;
-////    [|fnVar|]++;
+////    [|{| "isWriteAccess": true |}fnVar|]++;
 ////
 ////    //Return
-////    return [|x|]++;
+////    return [|{| "isWriteAccess": true |}x|]++;
 ////}
 ////
 ////module modTest {
@@ -42,7 +42,7 @@
 ////    export var modVar:number;
 ////
 ////    //Increments
-////    [|globalVar|]++;
+////    [|{| "isWriteAccess": true |}globalVar|]++;
 ////    fooCls.[|clsSVar|]++;
 ////    modVar++;
 ////
@@ -54,7 +54,7 @@
 ////        static boo = [|foo|];
 ////
 ////        //Increments
-////        [|globalVar|]++;
+////        [|{| "isWriteAccess": true |}globalVar|]++;
 ////        fooCls.[|clsSVar|]++;
 ////        modVar++;
 ////    }
@@ -76,18 +76,18 @@
 //////Increments
 ////fooCls.[|clsSVar|]++;
 ////modTest.modVar++;
-////[|globalVar|] = [|globalVar|] + [|globalVar|];
+////[|{| "isWriteAccess": true |}globalVar|] = [|globalVar|] + [|globalVar|];
 ////
 //////ETC - Other cases
-////[|globalVar|] = 3;
+////[|{| "isWriteAccess": true |}globalVar|] = 3;
 ////// References to illegal assignment.
-////[|foo|] = [|foo|] + 1;
+////[|{| "isWriteAccess": true |}foo|] = [|foo|] + 1;
 /////*3*/err = err++;
 /////*4*/
 //////Shadowed fn Parameter
-////function shdw([|{| "shadow": true |}globalVar|]: number) {
+////function shdw([|{| "isWriteAccess": true, "isDefinition": true, "shadow": true |}globalVar|]: number) {
 ////    //Increments
-////    [|{| "shadow": true |}globalVar|]++;
+////    [|{| "isWriteAccess": true, "shadow": true |}globalVar|]++;
 ////    return [|{| "shadow": true |}globalVar|];
 ////}
 ////
@@ -117,7 +117,7 @@
 ////array.forEach(
 ////
 ////
-////function([|str|]) {
+////function([|{| "isWriteAccess": true, "isDefinition": true |}str|]) {
 ////
 ////
 ////
@@ -187,24 +187,36 @@
 
 // References to comment.
 goTo.marker("1");
-verify.referencesAre([]);
+verify.noReferences();
 
 // References to unresolved symbol.
 goTo.marker("3");
-verify.referencesAre([]);
+verify.noReferences();
 
 // References to no context.
 goTo.marker("4");
-verify.referencesAre([]);
+verify.noReferences();
 
-const rangesByText = test.rangesByText();
+test.rangesByText().forEach((ranges, text) => {
-rangesByText.forEach((ranges, text) => {
     if (text === "globalVar") {
-        verify.rangesReferenceEachOther(ranges.filter(isShadow));
+        verify.singleReferenceGroup("(parameter) globalVar: number", ranges.filter(isShadow));
-        verify.rangesReferenceEachOther(ranges.filter(r => !isShadow(r)));
+        verify.singleReferenceGroup("var globalVar: number", ranges.filter(r => !isShadow(r)));
-    } else {
+        return;
-        verify.rangesReferenceEachOther(ranges);
     }
+
+    const definition = (() => {
+        switch (text) {
+            case "fnVar": return "(local var) fnVar: number";
+            case "clsSVar": return "(property) fooCls.clsSVar: number";
+            case "clsVar": return "(property) fooCls.clsVar: number";
+            case "clsParam": return "(property) fooCls.clsParam: number";
+            case "foo": return "function foo(x: number): number";
+            case "x": return "(parameter) x: number";
+            case "str": return "(parameter) str: string";
+            default: throw new Error(text);
+        }
+    })();
+    verify.singleReferenceGroup(definition, ranges);
 });
 
 function isShadow(r) {

tests/cases/fourslash/quickInfoForRequire.ts

@@ -6,5 +6,6 @@
 //@Filename: quickInfoForRequire_input.ts
 ////import a = require("./AA/B/*1*/B");
 
-verify.quickInfoAt("1", "module a");
+goTo.marker("1");
-verify.referencesAre([]);
+verify.quickInfoIs("module a");
+verify.noReferences();

tests/cases/fourslash/referenceInParameterPropertyDeclaration.ts

@@ -2,19 +2,26 @@
 
 // @Filename: file1.ts
 //// class Foo {
-////     constructor(private [|privateParam|]: number,
+////     constructor(private [|{| "isWriteAccess": true, "isDefinition": true, "type": "number" |}privateParam|]: number,
-////         public [|publicParam|]: string,
+////         public [|{| "isWriteAccess": true, "isDefinition": true, "type": "string" |}publicParam|]: string,
-////         protected [|protectedParam|]: boolean) {
+////         protected [|{| "isWriteAccess": true, "isDefinition": true, "type": "boolean" |}protectedParam|]: boolean) {
-//// 
+////
 ////         let localPrivate = [|privateParam|];
 ////         this.[|privateParam|] += 10;
-//// 
+////
 ////         let localPublic = [|publicParam|];
 ////         this.[|publicParam|] += " Hello!";
-//// 
+////
 ////         let localProtected = [|protectedParam|];
 ////         this.[|protectedParam|] = false;
 ////     }
 //// }
 
-verify.rangesWithSameTextReferenceEachOther();
+test.rangesByText().forEach((ranges, text) => {
+    const [r0, r1, r2] = ranges;
+    const type = r0.marker.data.type;
+    verify.referenceGroups(ranges, [
+        { definition: `(property) Foo.${text}: ${type}`, ranges: [r0, r2] },
+        { definition: `(parameter) ${text}: ${type}`, ranges: [r1] }
+    ]);
+});

tests/cases/fourslash/referenceToClass.ts

@@ -3,7 +3,7 @@
 // Class references should work across file and not find local variables.
 
 // @Filename: referenceToClass_1.ts
-////class [|foo|] {
+////class [|{| "isWriteAccess": true, "isDefinition": true |}foo|] {
 ////    public n: [|foo|];
 ////    public foo: number;
 ////}
@@ -20,4 +20,7 @@
 // @Filename: referenceToClass_2.ts
 ////var k: [|foo|];
 
-verify.rangesReferenceEachOther();
+const ranges = test.ranges();
+const [r0, r1, r2, r3, r4, r5] = ranges;
+verify.referenceGroups([r0, r1, r2, r4, r5], [{ definition: "class foo", ranges }]);
+verify.referenceGroups(r3, [{ definition: "constructor foo(): foo", ranges }]);

tests/cases/fourslash/referencesBloomFilters.ts

@@ -3,7 +3,7 @@
 // Ensure BloomFilter building logic is correct, by having one reference per file
 
 // @Filename: declaration.ts
-////var container = { [|searchProp|] : 1 };
+////var container = { [|{| "isWriteAccess": true, "isDefinition": true |}searchProp|] : 1 };
 
 // @Filename: expression.ts
 ////function blah() { return (1 + 2 + container.[|searchProp|]()) === 2;  };
@@ -12,6 +12,16 @@
 ////function blah2() { container["[|searchProp|]"] };
 
 // @Filename: redeclaration.ts
-////container = { "[|searchProp|]" : 18 };
+////container = { "[|{| "isDefinition": true |}searchProp|]" : 18 };
 
-verify.rangesReferenceEachOther();
+const ranges = test.ranges();
+const [r0, r1, r2, r3] = ranges;
+verify.referenceGroups(r0, [{ definition: "(property) searchProp: number", ranges }]);
+verify.referenceGroups([r1, r2], [
+    { definition: "(property) searchProp: number", ranges: [r0, r3] },
+    { definition: "(property) searchProp: number", ranges: [r1, r2] }
+]);
+verify.referenceGroups(r3, [
+    { definition: "(property) searchProp: number", ranges: [r0, r1, r2] },
+    { definition: '(property) "searchProp": number', ranges: [r3] }
+]);

tests/cases/fourslash/referencesBloomFilters2.ts

@@ -3,7 +3,7 @@
 // Ensure BloomFilter building logic is correct, by having one reference per file
 
 // @Filename: declaration.ts
-////var container = { [|42|]: 1 };
+////var container = { [|{| "isDefinition": true |}42|]: 1 };
 
 // @Filename: expression.ts
 ////function blah() { return (container[[|42|]]) === 2;  };
@@ -12,6 +12,16 @@
 ////function blah2() { container["[|42|]"] };
 
 // @Filename: redeclaration.ts
-////container = { "[|42|]" : 18 };
+////container = { "[|{| "isDefinition": true |}42|]" : 18 };
 
-verify.rangesReferenceEachOther();
+const ranges = test.ranges();
+const [r0, r1, r2, r3] = ranges;
+verify.referenceGroups(r0, [{ definition: "(property) 42: number", ranges }]);
+verify.referenceGroups([r1, r2], [
+    { definition: "(property) 42: number", ranges: [r0, r3] },
+    { definition: "(property) 42: number", ranges: [r1, r2] }
+]);
+verify.referenceGroups(r3, [
+    { definition: "(property) 42: number", ranges: [r0, r1, r2] },
+    { definition: '(property) "42": number', ranges: [r3] }
+]);

tests/cases/fourslash/referencesBloomFilters3.ts

@@ -4,9 +4,9 @@
 
 
 // @Filename: declaration.ts
-////enum Test { "[|42|]" = 1 };
+////enum Test { "[|{| "isDefinition": true |}42|]" = 1 };
 
 // @Filename: expression.ts
 ////(Test[[|42|]]);
 
-verify.rangesReferenceEachOther();
+verify.singleReferenceGroup('(enum member) Test["42"] = 1');

tests/cases/fourslash/referencesForAmbients.ts

@@ -1,11 +1,11 @@
 /// <reference path='fourslash.ts'/>
 
-////declare module "[|foo|]" {
+////declare module "[|{| "isDefinition": true |}foo|]" {
-////    var [|f|]: number;
+////    var [|{| "isWriteAccess": true, "isDefinition": true |}f|]: number;
 ////}
 ////
-////declare module "[|bar|]" {
+////declare module "[|{| "isDefinition": true |}bar|]" {
-////    export import [|foo|] = require("[|foo|]");
+////    export import [|{| "isWriteAccess": true, "isDefinition": true |}foo|] = require("[|foo|]");
 ////    var f2: typeof [|foo|].[|f|];
 ////}
 ////
@@ -15,7 +15,7 @@
 ////}
 
 const [moduleFoo0, f0, moduleBar0, foo0, moduleFoo1, foo1, f1, moduleBar1, foo2] = test.ranges();
-verify.rangesReferenceEachOther([moduleFoo0, moduleFoo1]);
+verify.singleReferenceGroup('module "foo"', [moduleFoo0, moduleFoo1]);
-verify.rangesReferenceEachOther([moduleBar0, moduleBar1]);
+verify.singleReferenceGroup('module "bar"', [moduleBar0, moduleBar1]);
-verify.rangesReferenceEachOther([foo0, foo1, foo2]);
+verify.singleReferenceGroup('import foo = require("foo")', [foo0, foo1, foo2]);
-verify.rangesReferenceEachOther([f0, f1]);
+verify.singleReferenceGroup("var f: number", [f0, f1]);

tests/cases/fourslash/referencesForClassLocal.ts

@@ -5,7 +5,7 @@
 ////var n = 14;
 ////
 ////class foo {
-////    private [|n|] = 0;
+////    private [|{| "isWriteAccess": true, "isDefinition": true |}n|] = 0;
 ////
 ////    public bar() {
 ////        this.[|n|] = 9;
@@ -20,4 +20,4 @@
 ////    }
 ////}
 
-verify.rangesReferenceEachOther();
+verify.singleReferenceGroup("(property) foo.n: number");