maxmustermann/TypeScript
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Change find-all-references tests to test for groups

Browse source 
* Also always test for isWriteAccess and isDefinition
This commit is contained in:
Andy Hanson 2017-01-27 08:59:33 -08:00
parent 445421b68b
commit 8515f7e2b5
166 changed files with 1349 additions and 776 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

121
src/harness/fourslash.ts
View file

@ -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 startMarkerNames) {
this.verifyGoToXSingle(start, endMarkerNames, getDefs);
}
}
else {
this.verifyGoToXSingle(startMarkerNames, endMarkerNames, getDefs);
for (const start of toArray(startMarkerNames)) {
this.verifyGoToXSingle(start, 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() {
this.rangesByText().forEach(ranges => this.verifyRangesReferenceEachOther(ranges));
public verifyReferenceGroups(startRanges: Range | Range[], parts: Array<{ definition: string, ranges: Range[] }>): void {
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();
}

19
src/services/findAllReferences.ts
View file

@ -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;

7
src/services/services.ts
View file

@ -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();
}
initializeServices();
objectAllocator = getServicesObjectAllocator();
}

15
tests/cases/fourslash/ambientShorthandFindAllRefs.ts
View file

@ -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] }
]);

18
tests/cases/fourslash/cancellationWhenfindingAllRefsOnDefinition.ts
View file

@ -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] }
]);
}

6
tests/cases/fourslash/findAllReferencesOfConstructor.ts
View file

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

2
tests/cases/fourslash/findAllReferencesOfConstructor_badOverload.ts
View file

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

20
tests/cases/fourslash/findAllRefsForComputedProperties.ts
View file

@ -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] }
]);

18
tests/cases/fourslash/findAllRefsForComputedProperties2.ts
View file

@ -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] }
]);

6
tests/cases/fourslash/findAllRefsForDefaultExport.ts
View file

@ -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");

7
tests/cases/fourslash/findAllRefsForDefaultExport01.ts
View file

@ -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 }]);

17
tests/cases/fourslash/findAllRefsForDefaultExport02.ts
View file

@ -1,11 +1,22 @@
/// <reference path='fourslash.ts'/>
////export default function [|DefaultExportedFunction|]() {
//// return [|DefaultExportedFunction|]
////export default function [|{| "isWriteAccess": true, "isDefinition": true |}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]);

9
tests/cases/fourslash/findAllRefsForDefaultExport03.ts
View file

@ -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 }]);

23
tests/cases/fourslash/findAllRefsForDefaultExport04.ts
View file

@ -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());

23
tests/cases/fourslash/findAllRefsForDefaultExport05.ts
View file

@ -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());

23
tests/cases/fourslash/findAllRefsForDefaultExport06.ts
View file

@ -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());

16
tests/cases/fourslash/findAllRefsForDefaultExport07.ts
View file

@ -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();

5
tests/cases/fourslash/findAllRefsForDefaultExport08.ts
View file

@ -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.rangesReferenceEachOther();
verify.singleReferenceGroup("namespace DefaultExportedClass");

4
tests/cases/fourslash/findAllRefsForFunctionExpression01.ts
View file

@ -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");

18
tests/cases/fourslash/findAllRefsForMappedType.ts
View file

@ -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 v: V = { [|a|]: true }
////const u: U = { [|{| "isWriteAccess": true, "isDefinition": true |}a|]: "" }
////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] }
]);

10
tests/cases/fourslash/findAllRefsForObjectLiteralProperties.ts
View file

@ -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] }
]);

17
tests/cases/fourslash/findAllRefsForObjectSpread.ts
View file

@ -1,14 +1,21 @@
/// <reference path='fourslash.ts'/>
////interface A1 { [|a|]: string };
////interface A2 { [|a|]?: number };
////interface A1 { [|{| "isWriteAccess": true, "isDefinition": true |}a|]: string };
////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.referencesOf(ranges[1], [ranges[1], ranges[2]]);
verify.referenceGroups(r0, [{ definition: "(property) A1.a: string", ranges: [r0, r2] }]);
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] }
]);

4
tests/cases/fourslash/findAllRefsForRest.ts
View file

@ -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");

2
tests/cases/fourslash/findAllRefsForStringLiteralTypes.ts
View file

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

4
tests/cases/fourslash/findAllRefsForUMDModuleAlias1.ts
View file

@ -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");

4
tests/cases/fourslash/findAllRefsForVariableInExtendsClause01.ts
View file

@ -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)");

4
tests/cases/fourslash/findAllRefsForVariableInExtendsClause02.ts
View file

@ -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");

3
tests/cases/fourslash/findAllRefsForVariableInImplementsClause01.ts
View file

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

12
tests/cases/fourslash/findAllRefsInClassExpression.ts
View file

@ -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] }
]);

14
tests/cases/fourslash/findAllRefsInheritedProperties1.ts
View file

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

10
tests/cases/fourslash/findAllRefsInheritedProperties2.ts
View file

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

46
tests/cases/fourslash/findAllRefsInheritedProperties3.ts
View file

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

17
tests/cases/fourslash/findAllRefsInheritedProperties4.ts
View file

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

15
tests/cases/fourslash/findAllRefsInheritedProperties5.ts
View file

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

4
tests/cases/fourslash/findAllRefsInsideTemplates1.ts
View file

@ -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");

4
tests/cases/fourslash/findAllRefsInsideTemplates2.ts
View file

@ -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");

6
tests/cases/fourslash/findAllRefsInsideWithBlock.ts
View file

@ -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");

4
tests/cases/fourslash/findAllRefsObjectBindingElementPropertyName01.ts
View file

@ -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");

4
tests/cases/fourslash/findAllRefsObjectBindingElementPropertyName02.ts
View file

@ -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");

12
tests/cases/fourslash/findAllRefsObjectBindingElementPropertyName03.ts
View file

@ -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] }
]);

13
tests/cases/fourslash/findAllRefsObjectBindingElementPropertyName04.ts
View file

@ -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] }
]);

2
tests/cases/fourslash/findAllRefsObjectBindingElementPropertyName05.ts
View file

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

21
tests/cases/fourslash/findAllRefsObjectBindingElementPropertyName06.ts
View file

@ -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
// 'quickInfoForObjectBindingElementPropertyName05.ts'
verify.rangesReferenceEachOther();
const ranges = test.ranges();
const [r0, r1, r2, r3, r4] = ranges;
verify.referenceGroups([r0, r1, r3], [{ definition: "(property) I.property1: number", ranges }]);
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] }
]);

10
tests/cases/fourslash/findAllRefsObjectBindingElementPropertyName07.ts
View file

@ -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] }
]);

15
tests/cases/fourslash/findAllRefsObjectBindingElementPropertyName09.ts
View file

@ -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();

4
tests/cases/fourslash/findAllRefsObjectBindingElementPropertyName10.ts
View file

@ -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");

3
tests/cases/fourslash/findAllRefsOfConstructor_withModifier.ts
View file

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

4
tests/cases/fourslash/findAllRefsOnDecorators.ts
View file

@ -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");

10
tests/cases/fourslash/findAllRefsOnDefinition.ts
View file

@ -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] },
]);

8
tests/cases/fourslash/findAllRefsOnDefinition2.ts
View file

@ -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 }]);

11
tests/cases/fourslash/findAllRefsOnImportAliases.ts
View file

@ -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 }]);

16
tests/cases/fourslash/findAllRefsOnImportAliases2.ts
View file

@ -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"));

4
tests/cases/fourslash/findAllRefsOnPrivateParameterProperty1.ts
View file

@ -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");

9
tests/cases/fourslash/findAllRefsParameterPropertyDeclaration1.ts
View file

@ -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] }
]);

9
tests/cases/fourslash/findAllRefsParameterPropertyDeclaration2.ts
View file

@ -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] }
]);

9
tests/cases/fourslash/findAllRefsParameterPropertyDeclaration3.ts
View file

@ -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] }
]);

2
tests/cases/fourslash/findAllRefsPrimitive.ts
View file

@ -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]);

18
tests/cases/fourslash/findAllRefsPropertyContextuallyTypedByTypeParam01.ts
View file

@ -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] }
]);

22
tests/cases/fourslash/findAllRefsThisKeyword.ts
View file

@ -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.rangesReferenceEachOther([g0, g1]);
verify.rangesReferenceEachOther([x, y]);
verify.rangesReferenceEachOther([constructor, method]);
verify.rangesReferenceEachOther([propDef, propUse]);
verify.referenceGroups(f0, [{ definition: "(parameter) this: any", ranges: [f0, f1] }]);
verify.referenceGroups(f1, [{ definition: "this: any", ranges: [f0, f1] }]);
verify.referenceGroups(g0, [{ definition: "(parameter) this: any", ranges: [g0, g1] }]);
verify.referenceGroups(g1, [{ definition: "this: any", ranges: [g0, g1] }]);
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] },
]);

10
tests/cases/fourslash/findAllRefsWithLeadingUnderscoreNames1.ts
View file

@ -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] }
]);

10
tests/cases/fourslash/findAllRefsWithLeadingUnderscoreNames2.ts
View file

@ -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] }
]);

10
tests/cases/fourslash/findAllRefsWithLeadingUnderscoreNames3.ts
View file

@ -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] }
]);

10
tests/cases/fourslash/findAllRefsWithLeadingUnderscoreNames4.ts
View file

@ -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] }
]);

4
tests/cases/fourslash/findAllRefsWithLeadingUnderscoreNames5.ts
View file

@ -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");

4
tests/cases/fourslash/findAllRefsWithLeadingUnderscoreNames6.ts
View file

@ -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");

4
tests/cases/fourslash/findAllRefsWithLeadingUnderscoreNames7.ts
View file

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

4
tests/cases/fourslash/findAllRefsWithLeadingUnderscoreNames8.ts
View file

@ -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");

4
tests/cases/fourslash/findAllRefsWithLeadingUnderscoreNames9.ts
View file

@ -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");

21
tests/cases/fourslash/findAllRefsWithShorthandPropertyAssignment.ts
View file

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

20
tests/cases/fourslash/findAllRefsWithShorthandPropertyAssignment2.ts
View file

@ -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.referencesOf(r1, [r1, r2]);
verify.referencesOf(r2, [r1, r2, r3]);
verify.referencesOf(r3, [r2, r3]);
verify.singleReferenceGroup("var dx: string", [r0]);
verify.referenceGroups(r1, [{ definition: "var M.dx: any", ranges: [r1, r2] }]);
verify.referenceGroups(r2, [
{ 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] }
]);

8
tests/cases/fourslash/findReferencesAcrossMultipleProjects.ts
View file

@ -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");

6
tests/cases/fourslash/findReferencesAfterEdit.ts
View file

@ -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");

8
tests/cases/fourslash/findReferencesJSXTagName.ts
View file

@ -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] }]);

6
tests/cases/fourslash/findReferencesJSXTagName2.ts
View file

@ -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;
}`);

16
tests/cases/fourslash/fourslash.ts
View file

@ -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.
* 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;
/**
* @deprecated, prefer 'referenceGroups'
* 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;

6
tests/cases/fourslash/getOccurrencesIsDefinitionOfArrowFunction.ts
View file

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

4
tests/cases/fourslash/getOccurrencesIsDefinitionOfBindingPattern.ts
View file

@ -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");

9
tests/cases/fourslash/getOccurrencesIsDefinitionOfClass.ts
View file

@ -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 }]);

12
tests/cases/fourslash/getOccurrencesIsDefinitionOfComputedProperty.ts
View file

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

6
tests/cases/fourslash/getOccurrencesIsDefinitionOfEnum.ts
View file

@ -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");

8
tests/cases/fourslash/getOccurrencesIsDefinitionOfExport.ts
View file

@ -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";
////const y = [|{| "isDefinition": false |}x|];
////import { [|{| "isWriteAccess": true, "isDefinition": true |}x|] } from "./m";
////const y = [|x|];
verify.rangesReferenceEachOther();
verify.singleReferenceGroup("var x: number");

6
tests/cases/fourslash/getOccurrencesIsDefinitionOfFunction.ts
View file

@ -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");

6
tests/cases/fourslash/getOccurrencesIsDefinitionOfInterface.ts
View file

@ -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");

13
tests/cases/fourslash/getOccurrencesIsDefinitionOfInterfaceClassMerge.ts
View file

@ -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 }]);

6
tests/cases/fourslash/getOccurrencesIsDefinitionOfNamespace.ts
View file

@ -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");

10
tests/cases/fourslash/getOccurrencesIsDefinitionOfNumberNamedProperty.ts
View file

@ -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] }
]);

6
tests/cases/fourslash/getOccurrencesIsDefinitionOfParameter.ts
View file

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

10
tests/cases/fourslash/getOccurrencesIsDefinitionOfStringNamedProperty.ts
View file

@ -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] },
]);

6
tests/cases/fourslash/getOccurrencesIsDefinitionOfTypeAlias.ts
View file

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

28
tests/cases/fourslash/getOccurrencesIsDefinitionOfVariable.ts
View file

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

2
tests/cases/fourslash/hoverOverComment.ts
View file

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

66
tests/cases/fourslash/localGetReferences.ts
View file

@ -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();
rangesByText.forEach((ranges, text) => {
test.rangesByText().forEach((ranges, text) => {
if (text === "globalVar") {
verify.rangesReferenceEachOther(ranges.filter(isShadow));
verify.rangesReferenceEachOther(ranges.filter(r => !isShadow(r)));
} else {
verify.rangesReferenceEachOther(ranges);
verify.singleReferenceGroup("(parameter) globalVar: number", ranges.filter(isShadow));
verify.singleReferenceGroup("var globalVar: number", ranges.filter(r => !isShadow(r)));
return;
}
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) {

5
tests/cases/fourslash/quickInfoForRequire.ts
View file

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

21
tests/cases/fourslash/referenceInParameterPropertyDeclaration.ts
View file

@ -2,19 +2,26 @@
// @Filename: file1.ts
//// class Foo {
//// constructor(private [|privateParam|]: number,
//// public [|publicParam|]: string,
//// protected [|protectedParam|]: boolean) {
////
//// constructor(private [|{| "isWriteAccess": true, "isDefinition": true, "type": "number" |}privateParam|]: number,
//// public [|{| "isWriteAccess": true, "isDefinition": true, "type": "string" |}publicParam|]: string,
//// 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] }
]);
});

7
tests/cases/fourslash/referenceToClass.ts
View file

@ -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 }]);

16
tests/cases/fourslash/referencesBloomFilters.ts
View file

@ -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] }
]);

16
tests/cases/fourslash/referencesBloomFilters2.ts
View file

@ -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] }
]);

4
tests/cases/fourslash/referencesBloomFilters3.ts
View file

@ -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');

16
tests/cases/fourslash/referencesForAmbients.ts
View file

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

4
tests/cases/fourslash/referencesForClassLocal.ts
View file

@ -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");

Some files were not shown because too many files have changed in this diff Show more