Change find-all-references tests to test for groups
* Also always test for isWriteAccess and isDefinition
This commit is contained in:
parent
445421b68b
commit
8515f7e2b5
166 changed files with 1349 additions and 776 deletions
|
@ -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,15 +600,10 @@ namespace FourSlash {
|
|||
}
|
||||
|
||||
private verifyGoToXPlain(startMarkerNames: string | string[], endMarkerNames: string | string[], getDefs: () => ts.DefinitionInfo[] | undefined) {
|
||||
if (startMarkerNames instanceof Array) {
|
||||
for (const start of startMarkerNames) {
|
||||
for (const start of toArray(startMarkerNames)) {
|
||||
this.verifyGoToXSingle(start, endMarkerNames, getDefs);
|
||||
}
|
||||
}
|
||||
else {
|
||||
this.verifyGoToXSingle(startMarkerNames, endMarkerNames, getDefs);
|
||||
}
|
||||
}
|
||||
|
||||
public verifyGoToDefinitionForMarkers(markerNames: string[]) {
|
||||
for (const markerName of markerNames) {
|
||||
|
@ -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();
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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();
|
||||
}
|
||||
|
|
|
@ -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] }
|
||||
]);
|
||||
|
|
|
@ -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] }
|
||||
]);
|
||||
}
|
||||
|
|
|
@ -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 }]);
|
||||
|
|
|
@ -5,4 +5,4 @@
|
|||
//// [|constructor|](){}
|
||||
////}
|
||||
|
||||
verify.rangesReferenceEachOther();
|
||||
verify.singleReferenceGroup("constructor C(n: number): C");
|
||||
|
|
|
@ -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] }
|
||||
]);
|
||||
|
||||
|
|
|
@ -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] }
|
||||
]);
|
||||
|
|
|
@ -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");
|
||||
|
|
|
@ -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 }]);
|
||||
|
|
|
@ -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]);
|
||||
|
|
|
@ -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 }]);
|
||||
|
|
|
@ -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());
|
|
@ -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());
|
|
@ -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());
|
|
@ -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();
|
|
@ -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");
|
||||
|
|
|
@ -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");
|
||||
|
|
|
@ -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] }
|
||||
]);
|
||||
|
|
|
@ -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] }
|
||||
]);
|
||||
|
|
|
@ -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] }
|
||||
]);
|
||||
|
|
|
@ -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");
|
||||
|
|
|
@ -3,4 +3,4 @@
|
|||
////type Options = "[|option 1|]" | "option 2";
|
||||
////let myOption: Options = "[|option 1|]";
|
||||
|
||||
verify.rangesReferenceEachOther();
|
||||
verify.singleReferenceGroup('"option 1"');
|
||||
|
|
|
@ -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");
|
||||
|
|
|
@ -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)");
|
||||
|
|
|
@ -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,5 +3,4 @@
|
|||
////var Base = class { };
|
||||
////class C extends Base implements /**/Base { }
|
||||
|
||||
goTo.marker();
|
||||
verify.referencesAre([]);
|
||||
verify.noReferences("");
|
||||
|
|
|
@ -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] }
|
||||
]);
|
||||
|
|
|
@ -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]);
|
||||
|
|
|
@ -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]);
|
||||
|
|
|
@ -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] }
|
||||
]);
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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");
|
||||
|
|
|
@ -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");
|
||||
|
|
|
@ -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");
|
||||
|
|
|
@ -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");
|
||||
|
|
|
@ -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");
|
||||
|
|
|
@ -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] }
|
||||
]);
|
||||
|
|
|
@ -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] }
|
||||
]);
|
||||
|
||||
|
|
|
@ -10,4 +10,4 @@
|
|||
////}
|
||||
|
||||
goTo.marker();
|
||||
verify.referencesAre([]);
|
||||
verify.noReferences("");
|
|
@ -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] }
|
||||
]);
|
||||
|
|
|
@ -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] }
|
||||
]);
|
||||
|
|
|
@ -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();
|
|
@ -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");
|
||||
|
|
|
@ -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 }]);
|
||||
|
|
|
@ -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");
|
||||
|
|
|
@ -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] },
|
||||
]);
|
||||
|
|
|
@ -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 }]);
|
||||
|
||||
|
|
|
@ -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 }]);
|
||||
|
|
|
@ -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"));
|
||||
|
|
|
@ -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");
|
||||
|
|
|
@ -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] }
|
||||
]);
|
||||
|
|
|
@ -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] }
|
||||
]);
|
||||
|
|
|
@ -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] }
|
||||
]);
|
||||
|
|
|
@ -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]);
|
||||
|
|
|
@ -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] }
|
||||
]);
|
||||
|
|
|
@ -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] },
|
||||
]);
|
||||
|
|
|
@ -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] }
|
||||
]);
|
||||
|
|
|
@ -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] }
|
||||
]);
|
||||
|
|
|
@ -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] }
|
||||
]);
|
||||
|
|
|
@ -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] }
|
||||
]);
|
||||
|
|
|
@ -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");
|
||||
|
|
|
@ -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");
|
||||
|
|
|
@ -1,7 +1,7 @@
|
|||
/// <reference path='fourslash.ts' />
|
||||
|
||||
////function [|__foo|]() {
|
||||
////function [|{| "isWriteAccess": true, "isDefinition": true |}__foo|]() {
|
||||
//// [|__foo|]();
|
||||
////}
|
||||
|
||||
verify.rangesReferenceEachOther();
|
||||
verify.singleReferenceGroup("function __foo(): void");
|
||||
|
|
|
@ -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");
|
||||
|
|
|
@ -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");
|
||||
|
|
|
@ -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] },
|
||||
]);
|
||||
|
|
|
@ -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] }
|
||||
]);
|
||||
|
|
|
@ -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");
|
||||
|
|
|
@ -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");
|
||||
|
|
|
@ -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] }]);
|
||||
|
|
|
@ -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;
|
||||
}`);
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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");
|
||||
|
|
|
@ -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");
|
||||
|
|
|
@ -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 }]);
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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");
|
||||
|
|
|
@ -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");
|
||||
|
|
|
@ -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");
|
||||
|
|
|
@ -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");
|
||||
|
|
|
@ -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 }]);
|
||||
|
|
|
@ -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");
|
||||
|
|
|
@ -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] }
|
||||
]);
|
||||
|
|
|
@ -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");
|
||||
|
|
|
@ -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] },
|
||||
]);
|
||||
|
|
|
@ -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");
|
||||
|
|
|
@ -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");
|
||||
|
|
|
@ -7,4 +7,4 @@
|
|||
goTo.marker();
|
||||
verify.quickInfoIs("");
|
||||
verify.goToDefinitionIs([]);
|
||||
verify.referencesAre([]);
|
||||
verify.noReferences();
|
||||
|
|
|
@ -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) {
|
||||
|
|
|
@ -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();
|
||||
|
|
|
@ -2,9 +2,9 @@
|
|||
|
||||
// @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;
|
||||
|
@ -17,4 +17,11 @@
|
|||
//// }
|
||||
//// }
|
||||
|
||||
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] }
|
||||
]);
|
||||
});
|
||||
|
|
|
@ -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 }]);
|
||||
|
|
|
@ -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] }
|
||||
]);
|
||||
|
|
|
@ -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,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');
|
||||
|
|
|
@ -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]);
|
||||
|
|
|
@ -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
Loading…
Reference in a new issue