More Tests

tests/cases/fourslash/referenceToClass.ts

@@ -3,10 +3,10 @@
 // Class references should work across file and not find local variables.
 
 // @Filename: referenceToClass_1.ts
-////class [|{| "isWriteAccess": true, "isDefinition": true |}foo|] {
+////[|class [|{| "isWriteAccess": true, "isDefinition": true, "declarationRangeIndex": 0 |}foo|] {
 ////    public n: [|foo|];
 ////    public foo: number;
-////}
+////}|]
 ////
 ////class bar {
 ////    public n: [|foo|];
@@ -20,4 +20,5 @@
 // @Filename: referenceToClass_2.ts
 ////var k: [|foo|];
 
-verify.singleReferenceGroup("class foo");
+const [rDef, ...ranges] = test.ranges();
+verify.singleReferenceGroup("class 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 = { [|{| "isWriteAccess": true, "isDefinition": true |}searchProp|] : 1 };
+////var container = { [|[|{| "isWriteAccess": true, "isDefinition": true, "declarationRangeIndex": 0 |}searchProp|] : 1|] };
 
 // @Filename: expression.ts
 ////function blah() { return (1 + 2 + container.[|searchProp|]()) === 2;  };
@@ -12,6 +12,6 @@
 ////function blah2() { container["[|searchProp|]"] };
 
 // @Filename: redeclaration.ts
-////container = { "[|{| "isWriteAccess": true, "isDefinition": true |}searchProp|]" : 18 };
+////container = { [|"[|{| "isWriteAccess": true, "isDefinition": true, "declarationRangeIndex": 4 |}searchProp|]" : 18|] };
 
-verify.singleReferenceGroup("(property) searchProp: number");
+verify.singleReferenceGroup("(property) searchProp: number", test.rangesByText().get("searchProp"));

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 = { [|{| "isWriteAccess": true, "isDefinition": true |}42|]: 1 };
+////var container = { [|[|{| "isWriteAccess": true, "isDefinition": true, "declarationRangeIndex": 0 |}42|]: 1|] };
 
 // @Filename: expression.ts
 ////function blah() { return (container[[|42|]]) === 2;  };
@@ -12,6 +12,6 @@
 ////function blah2() { container["[|42|]"] };
 
 // @Filename: redeclaration.ts
-////container = { "[|{| "isWriteAccess": true, "isDefinition": true |}42|]" : 18 };
+////container = { [|"[|{| "isWriteAccess": true, "isDefinition": true, "declarationRangeIndex": 4 |}42|]" : 18|] };
 
-verify.singleReferenceGroup("(property) 42: number");
+verify.singleReferenceGroup("(property) 42: number", test.rangesByText().get("42"));

tests/cases/fourslash/referencesBloomFilters3.ts

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

tests/cases/fourslash/referencesForAmbients.ts

@@ -1,20 +1,20 @@
 /// <reference path='fourslash.ts'/>
 
-////declare module "[|{| "isWriteAccess": true, "isDefinition": true |}foo|]" {
-////    var [|{| "isWriteAccess": true, "isDefinition": true |}f|]: number;
-////}
+////[|declare module "[|{| "isWriteAccess": true, "isDefinition": true, "declarationRangeIndex": 0 |}foo|]" {
+////    [|var [|{| "isWriteAccess": true, "isDefinition": true, "declarationRangeIndex": 2 |}f|]: number;|]
+////}|]
 ////
-////declare module "[|{| "isWriteAccess": true, "isDefinition": true |}bar|]" {
-////    export import [|{| "isWriteAccess": true, "isDefinition": true |}foo|] = require("[|foo|]");
+////[|declare module "[|{| "isWriteAccess": true, "isDefinition": true, "declarationRangeIndex": 4 |}bar|]" {
+////    [|export import [|{| "isWriteAccess": true, "isDefinition": true, "declarationRangeIndex": 6 |}foo|] = require("[|foo|]");|]
 ////    var f2: typeof [|foo|].[|f|];
-////}
+////}|]
 ////
 ////declare module "baz" {
 ////    import bar = require("[|bar|]");
 ////    var f2: typeof bar.[|foo|];
 ////}
 
-const [moduleFoo0, f0, moduleBar0, foo0, moduleFoo1, foo1, f1, moduleBar1, foo2] = test.ranges();
+const [moduleFoo0Def, moduleFoo0, f0Def, f0, moduleBar0Def, moduleBar0, foo0Def, foo0, moduleFoo1, foo1, f1, moduleBar1, foo2] = test.ranges();
 verify.singleReferenceGroup('module "foo"', [moduleFoo0, moduleFoo1]);
 verify.singleReferenceGroup('module "bar"', [moduleBar0, moduleBar1]);
 verify.singleReferenceGroup('(alias) module "foo"\nimport foo = require("foo")', [foo0, foo1, foo2]);

tests/cases/fourslash/referencesForAmbients2.ts

@@ -2,7 +2,7 @@
 
 // @Filename: /defA.ts
 ////declare module "a" {
-////    export type [|{| "isWriteAccess": true, "isDefinition": true |}T|] = number;
+////    [|export type [|{| "isWriteAccess": true, "isDefinition": true, "declarationRangeIndex": 0 |}T|] = number;|]
 ////}
 
 // @Filename: /defB.ts
@@ -18,4 +18,4 @@
 ////}
 
 verify.noErrors();
-verify.singleReferenceGroup("type T = number");
+verify.singleReferenceGroup("type T = number", test.rangesByText().get("T"));

tests/cases/fourslash/referencesForClassLocal.ts

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

tests/cases/fourslash/referencesForClassMembers.ts

@@ -1,12 +1,12 @@
 /// <reference path='fourslash.ts'/>
 
 ////class Base {
-////    [|{| "isDefinition": true |}a|]: number;
-////    [|{| "isWriteAccess": true, "isDefinition": true |}method|](): void { }
+////    [|[|{| "isDefinition": true, "declarationRangeIndex": 0 |}a|]: number;|]
+////    [|[|{| "isWriteAccess": true, "isDefinition": true, "declarationRangeIndex": 2 |}method|](): void { }|]
 ////}
 ////class MyClass extends Base {
-////    [|{| "isDefinition": true |}a|];
-////    [|{| "isWriteAccess": true, "isDefinition": true |}method|]() { }
+////    [|[|{| "isDefinition": true, "declarationRangeIndex": 4 |}a|];|]
+////    [|[|{| "isWriteAccess": true, "isDefinition": true, "declarationRangeIndex": 6 |}method|]() { }|]
 ////}
 ////
 ////var c: MyClass;

tests/cases/fourslash/referencesForClassMembersExtendingAbstractClass.ts

@@ -1,12 +1,12 @@
 /// <reference path='fourslash.ts'/>
 
 ////abstract class Base {
-////    abstract [|{| "isDefinition": true |}a|]: number;
-////    abstract [|{| "isDefinition": true |}method|](): void;
+////    [|abstract [|{| "isDefinition": true, "declarationRangeIndex": 0 |}a|]: number;|]
+////    [|abstract [|{| "isDefinition": true, "declarationRangeIndex": 2 |}method|](): void;|]
 ////}
 ////class MyClass extends Base {
-////    [|{| "isDefinition": true |}a|];
-////    [|{| "isWriteAccess": true, "isDefinition": true |}method|]() { }
+////    [|[|{| "isDefinition": true, "declarationRangeIndex": 4 |}a|];|]
+////    [|[|{| "isWriteAccess": true, "isDefinition": true, "declarationRangeIndex": 6 |}method|]() { }|]
 ////}
 ////
 ////var c: MyClass;

tests/cases/fourslash/referencesForClassMembersExtendingGenericClass.ts

@@ -1,12 +1,12 @@
 /// <reference path='fourslash.ts'/>
 
 ////class Base<T> {
-////    [|{| "isDefinition": true |}a|]: this;
-////    [|{| "isWriteAccess": true, "isDefinition": true |}method|]<U>(a?:T, b?:U): this { }
+////    [|[|{| "isDefinition": true, "declarationRangeIndex": 0 |}a|]: this;|]
+////    [|[|{| "isWriteAccess": true, "isDefinition": true, "declarationRangeIndex": 2 |}method|]<U>(a?:T, b?:U): this { }|]
 ////}
 ////class MyClass extends Base<number> {
-////    [|{| "isDefinition": true |}a|];
-////    [|{| "isWriteAccess": true, "isDefinition": true |}method|]() { }
+////    [|[|{| "isDefinition": true, "declarationRangeIndex": 4 |}a|];|]
+////    [|[|{| "isWriteAccess": true, "isDefinition": true, "declarationRangeIndex": 6 |}method|]() { }|]
 ////}
 ////
 ////var c: MyClass;

tests/cases/fourslash/referencesForClassParameter.ts

@@ -7,7 +7,7 @@
 ////class p { }
 ////
 ////class foo {
-////    constructor (public [|{| "isWriteAccess": true, "isDefinition": true |}p|]: any) {
+////    constructor ([|public [|{| "isWriteAccess": true, "isDefinition": true, "declarationRangeIndex": 0 |}p|]: any|]) {
 ////    }
 ////
 ////    public f(p) {
@@ -19,4 +19,4 @@
 ////var n = new foo(undefined);
 ////n.[|{| "isWriteAccess": true |}p|] = null;
 
-verify.singleReferenceGroup("(property) foo.p: any");
+verify.singleReferenceGroup("(property) foo.p: any", test.rangesByText().get("p"));

tests/cases/fourslash/referencesForContextuallyTypedObjectLiteralProperties.ts

@@ -1,28 +1,28 @@
 /// <reference path='fourslash.ts'/>
 
-////interface IFoo { [|{| "isDefinition": true |}xy|]: number; }
+////interface IFoo { [|[|{| "isDefinition": true, "declarationRangeIndex": 0 |}xy|]: number;|] }
 ////
 ////// Assignment
-////var a1: IFoo = { [|{| "isWriteAccess": true, "isDefinition": true |}xy|]: 0 };
-////var a2: IFoo = { [|{| "isWriteAccess": true, "isDefinition": true |}xy|]: 0 };
+////var a1: IFoo = { [|[|{| "isWriteAccess": true, "isDefinition": true, "declarationRangeIndex": 2 |}xy|]: 0|] };
+////var a2: IFoo = { [|[|{| "isWriteAccess": true, "isDefinition": true, "declarationRangeIndex": 4 |}xy|]: 0|] };
 ////
 ////// Function call
 ////function consumer(f: IFoo) { }
-////consumer({ [|{| "isWriteAccess": true, "isDefinition": true |}xy|]: 1 });
+////consumer({ [|[|{| "isWriteAccess": true, "isDefinition": true, "declarationRangeIndex": 6 |}xy|]: 1|] });
 ////
 ////// Type cast
-////var c = <IFoo>{ [|{| "isWriteAccess": true, "isDefinition": true |}xy|]: 0 };
+////var c = <IFoo>{ [|[|{| "isWriteAccess": true, "isDefinition": true, "declarationRangeIndex": 8 |}xy|]: 0|] };
 ////
 ////// Array literal
-////var ar: IFoo[] = [{ [|{| "isWriteAccess": true, "isDefinition": true |}xy|]: 1 }, { [|{| "isWriteAccess": true, "isDefinition": true |}xy|]: 2 }];
+////var ar: IFoo[] = [{ [|[|{| "isWriteAccess": true, "isDefinition": true, "declarationRangeIndex": 10 |}xy|]: 1|] }, { [|[|{| "isWriteAccess": true, "isDefinition": true, "declarationRangeIndex": 12 |}xy|]: 2|] }];
 ////
 ////// Nested object literal
-////var ob: { ifoo: IFoo } = { ifoo: { [|{| "isWriteAccess": true, "isDefinition": true |}xy|]: 0 } };
+////var ob: { ifoo: IFoo } = { ifoo: { [|[|{| "isWriteAccess": true, "isDefinition": true, "declarationRangeIndex": 14 |}xy|]: 0|] } };
 ////
 ////// Widened type
-////var w: IFoo = { [|{| "isWriteAccess": true, "isDefinition": true, "type": "undefined" |}xy|]: undefined };
+////var w: IFoo = { [|[|{| "isWriteAccess": true, "isDefinition": true, "type": "undefined", "declarationRangeIndex": 16 |}xy|]: undefined|] };
 ////
 ////// Untped -- should not be included
 ////var u = { xy: 0 };
 
-verify.singleReferenceGroup("(property) IFoo.xy: number");
+verify.singleReferenceGroup("(property) IFoo.xy: number", test.rangesByText().get("xy"));

tests/cases/fourslash/referencesForContextuallyTypedUnionProperties.ts

@@ -2,39 +2,39 @@
 
 ////interface A {
 ////    a: number;
-////    [|{| "isDefinition": true |}common|]: string;
+////    [|[|{| "isDefinition": true, "declarationRangeIndex": 0 |}common|]: string;|]
 ////}
 ////
 ////interface B {
 ////    b: number;
-////    [|{| "isDefinition": true |}common|]: number;
+////    [|[|{| "isDefinition": true, "declarationRangeIndex": 2 |}common|]: number;|]
 ////}
 ////
 ////// Assignment
-////var v1: A | B = { a: 0, [|{| "isWriteAccess": true, "isDefinition": true, "type": "string" |}common|]: "" };
-////var v2: A | B = { b: 0, [|{| "isWriteAccess": true, "isDefinition": true, "type": "number" |}common|]: 3 };
+////var v1: A | B = { a: 0, [|[|{| "isWriteAccess": true, "isDefinition": true, "type": "string", "declarationRangeIndex": 4 |}common|]: ""|] };
+////var v2: A | B = { b: 0, [|[|{| "isWriteAccess": true, "isDefinition": true, "type": "number", "declarationRangeIndex": 6 |}common|]: 3|] };
 ////
 ////// Function call
 ////function consumer(f:  A | B) { }
-////consumer({ a: 0, b: 0, [|{| "isWriteAccess": true, "isDefinition": true, "type": "number" |}common|]: 1 });
+////consumer({ a: 0, b: 0, [|[|{| "isWriteAccess": true, "isDefinition": true, "type": "number", "declarationRangeIndex": 8 |}common|]: 1|] });
 ////
 ////// Type cast
-////var c = <A | B> { [|{| "isWriteAccess": true, "isDefinition": true, "type": "number" |}common|]: 0, b: 0 };
+////var c = <A | B> { [|[|{| "isWriteAccess": true, "isDefinition": true, "type": "number", "declarationRangeIndex": 10 |}common|]: 0|], b: 0 };
 ////
 ////// Array literal
-////var ar: Array<A|B> = [{ a: 0, [|{| "isWriteAccess": true, "isDefinition": true, "type": "string" |}common|]: "" }, { b: 0, [|{| "isWriteAccess": true, "isDefinition": true, "type": "number" |}common|]: 0 }];
+////var ar: Array<A|B> = [{ a: 0, [|[|{| "isWriteAccess": true, "isDefinition": true, "type": "string", "declarationRangeIndex": 12 |}common|]: ""|] }, { b: 0, [|[|{| "isWriteAccess": true, "isDefinition": true, "type": "number", "declarationRangeIndex": 14 |}common|]: 0|] }];
 ////
 ////// Nested object literal
-////var ob: { aorb: A|B } = { aorb: { b: 0, [|{| "isWriteAccess": true, "isDefinition": true, "type": "number" |}common|]: 0 } };
+////var ob: { aorb: A|B } = { aorb: { b: 0, [|[|{| "isWriteAccess": true, "isDefinition": true, "type": "number", "declarationRangeIndex": 16 |}common|]: 0|] } };
 ////
 ////// Widened type
-////var w: A|B = { a:0, [|{| "isWriteAccess": true, "isDefinition": true, "type": "undefined" |}common|]: undefined };
+////var w: A|B = { a:0, [|[|{| "isWriteAccess": true, "isDefinition": true, "type": "undefined", "declarationRangeIndex": 18 |}common|]: undefined|] };
 ////
 ////// Untped -- should not be included
 ////var u1 = { a: 0, b: 0, common: "" };
 ////var u2 = { b: 0, common: 0 };
 
-const [aCommon, bCommon, ...unionRefs] = test.ranges();
+const [aCommon, bCommon, ...unionRefs] = test.rangesByText().get("common");
 verify.referenceGroups(aCommon, [
     { definition: "(property) A.common: string", ranges: [aCommon] },
     { definition: "(property) common: string | number", ranges: unionRefs },

tests/cases/fourslash/referencesForContextuallyTypedUnionProperties2.ts

@@ -6,32 +6,32 @@
 ////}
 ////
 ////interface B {
-////    [|{| "isDefinition": true |}b|]: number;
+////    [|[|{| "isDefinition": true, "declarationRangeIndex": 0 |}b|]: number;|]
 ////    common: number;
 ////}
 ////
 ////// Assignment
 ////var v1: A | B = { a: 0, common: "" };
-////var v2: A | B = { [|{| "isWriteAccess": true, "isDefinition": true, "type": "number" |}b|]: 0, common: 3 };
+////var v2: A | B = { [|[|{| "isWriteAccess": true, "isDefinition": true, "type": "number", "declarationRangeIndex": 2 |}b|]: 0|], common: 3 };
 ////
 ////// Function call
 ////function consumer(f:  A | B) { }
-////consumer({ a: 0, [|{| "isWriteAccess": true, "isDefinition": true, "type": "number" |}b|]: 0, common: 1 });
+////consumer({ a: 0, [|[|{| "isWriteAccess": true, "isDefinition": true, "type": "number", "declarationRangeIndex": 4 |}b|]: 0|], common: 1 });
 ////
 ////// Type cast
-////var c = <A | B> { common: 0, [|{| "isWriteAccess": true, "isDefinition": true, "type": "number" |}b|]: 0 };
+////var c = <A | B> { common: 0, [|[|{| "isWriteAccess": true, "isDefinition": true, "type": "number", "declarationRangeIndex": 6 |}b|]: 0|] };
 ////
 ////// Array literal
-////var ar: Array<A|B> = [{ a: 0, common: "" }, { [|{| "isWriteAccess": true, "isDefinition": true, "type": "number" |}b|]: 0, common: 0 }];
+////var ar: Array<A|B> = [{ a: 0, common: "" }, { [|[|{| "isWriteAccess": true, "isDefinition": true, "type": "number", "declarationRangeIndex": 8 |}b|]: 0|], common: 0 }];
 ////
 ////// Nested object literal
-////var ob: { aorb: A|B } = { aorb: { [|{| "isWriteAccess": true, "isDefinition": true, "type": "number" |}b|]: 0, common: 0 } };
+////var ob: { aorb: A|B } = { aorb: { [|[|{| "isWriteAccess": true, "isDefinition": true, "type": "number", "declarationRangeIndex": 10 |}b|]: 0|], common: 0 } };
 ////
 ////// Widened type
-////var w: A|B = { [|{| "isWriteAccess": true, "isDefinition": true, "type": "undefined" |}b|]:undefined, common: undefined };
+////var w: A|B = { [|[|{| "isWriteAccess": true, "isDefinition": true, "type": "undefined", "declarationRangeIndex": 12 |}b|]:undefined|], common: undefined };
 ////
 ////// Untped -- should not be included
 ////var u1 = { a: 0, b: 0, common: "" };
 ////var u2 = { b: 0, common: 0 };
 
-verify.singleReferenceGroup("(property) B.b: number");
+verify.singleReferenceGroup("(property) B.b: number", test.rangesByText().get("b"));

tests/cases/fourslash/referencesForEnums.ts

@@ -1,9 +1,9 @@
 /// <reference path='fourslash.ts'/>
 
 ////enum E {
-////    [|{| "isWriteAccess": true, "isDefinition": true |}value1|] = 1,
-////    "[|{| "isWriteAccess": true, "isDefinition": true |}value2|]" = [|value1|],
-////    [|{| "isWriteAccess": true, "isDefinition": true |}111|] = 11
+////    [|[|{| "isWriteAccess": true, "isDefinition": true, "declarationRangeIndex": 0 |}value1|] = 1|],
+////    [|"[|{| "isWriteAccess": true, "isDefinition": true, "declarationRangeIndex": 2 |}value2|]" = [|value1|]|],
+////    [|[|{| "isWriteAccess": true, "isDefinition": true, "declarationRangeIndex": 5 |}111|] = 11|]
 ////}
 ////
 ////E.[|value1|];

tests/cases/fourslash/referencesForExportedValues.ts

@@ -1,7 +1,7 @@
 /// <reference path='fourslash.ts'/>
 
 ////module M {
-////    export var [|{| "isWriteAccess": true, "isDefinition": true |}variable|] = 0;
+////    [|export var [|{| "isWriteAccess": true, "isDefinition": true, "declarationRangeIndex": 0 |}variable|] = 0;|]
 ////
 ////    // local use
 ////    var x = [|variable|];
@@ -10,4 +10,4 @@
 ////// external use
 ////M.[|variable|]
 
-verify.singleReferenceGroup("var M.variable: number");
+verify.singleReferenceGroup("var M.variable: number", test.rangesByText().get("variable"));

tests/cases/fourslash/referencesForExternalModuleNames.ts

@@ -1,11 +1,11 @@
 /// <reference path='fourslash.ts'/>
 
 // @Filename: referencesForGlobals_1.ts
-////declare module "[|{| "isWriteAccess": true, "isDefinition": true |}foo|]" {
+////[|declare module "[|{| "isWriteAccess": true, "isDefinition": true, "declarationRangeIndex": 0 |}foo|]" {
 ////    var f: number;
-////}
+////}|]
 
 // @Filename: referencesForGlobals_2.ts
 ////import f = require("[|foo|]");
 
-verify.singleReferenceGroup('module "foo"');
+verify.singleReferenceGroup('module "foo"', test.rangesByText().get("foo"));

tests/cases/fourslash/referencesForFunctionOverloads.ts

@@ -2,9 +2,9 @@
 
 // Function overloads should be highlighted together.
 
-////function [|{| "isDefinition": true |}foo|](x: string);
-////function [|{| "isWriteAccess": true, "isDefinition": true |}foo|](x: string, y: number) {
+////[|function [|{| "isDefinition": true, "declarationRangeIndex": 0 |}foo|](x: string);|]
+////[|function [|{| "isWriteAccess": true, "isDefinition": true, "declarationRangeIndex": 2 |}foo|](x: string, y: number) {
 ////    [|foo|]('', 43);
-////}
+////}|]
 
-verify.singleReferenceGroup("function foo(x: string): any");
+verify.singleReferenceGroup("function foo(x: string): any", test.rangesByText().get("foo"));

tests/cases/fourslash/referencesForFunctionParameter.ts

@@ -3,9 +3,9 @@
 ////var x;
 ////var n;
 ////
-////function n(x: number, [|{| "isWriteAccess": true, "isDefinition": true |}n|]: number) {
+////function n(x: number, [|[|{| "isWriteAccess": true, "isDefinition": true, "declarationRangeIndex": 0 |}n|]: number|]) {
 ////    [|{| "isWriteAccess": true |}n|] = 32;
 ////    x = [|n|];
 ////}
 
-verify.singleReferenceGroup("(parameter) n: number");
+verify.singleReferenceGroup("(parameter) n: number", test.rangesByText().get("n"));