Microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2025-11-18 17:21:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

Always use verify.completions when testing completions (#28137)

Browse Source
This commit is contained in:
Andy
2018-10-29 10:03:25 -07:00
committed by GitHub
parent a6952887e9
commit c97fc64972
589 changed files with 4239 additions and 5730 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/harness/fourslash.ts
+499 -383
View File
@@ -729,97 +729,6 @@ namespace FourSlash {
});
}
public verifyCompletionListCount(expectedCount: number, negative: boolean) {
if (expectedCount === 0 && negative) {
this.verifyCompletionListIsEmpty(/*negative*/ false);
return;
}
const members = this.getCompletionListAtCaret();
if (members) {
const match = members.entries.length === expectedCount;
if ((!match && !negative) || (match && negative)) {
this.raiseError("Member list count was " + members.entries.length + ". Expected " + expectedCount);
}
}
else if (expectedCount) {
this.raiseError("Member list count was 0. Expected " + expectedCount);
}
}
public verifyCompletionListItemsCountIsGreaterThan(count: number, negative: boolean) {
const completions = this.getCompletionListAtCaret();
const itemsCount = completions ? completions.entries.length : 0;
if (negative) {
if (itemsCount > count) {
this.raiseError(`Expected completion list items count to not be greater than ${count}, but is actually ${itemsCount}`);
}
}
else {
if (itemsCount <= count) {
this.raiseError(`Expected completion list items count to be greater than ${count}, but is actually ${itemsCount}`);
}
}
}
public verifyCompletionListStartsWithItemsInOrder(items: string[]): void {
if (items.length === 0) {
return;
}
const entries = this.getCompletionListAtCaret()!.entries;
assert.isTrue(items.length <= entries.length, `Amount of expected items in completion list [ ${items.length} ] is greater than actual number of items in list [ ${entries.length} ]`);
ts.zipWith(entries, items, (entry, item) => {
assert.equal(entry.name, item, `Unexpected item in completion list`);
});
}
public noItemsWithSameNameButDifferentKind(): void {
const completions = this.getCompletionListAtCaret()!;
const uniqueItems = ts.createMap<string>();
for (const item of completions.entries) {
const uniqueItem = uniqueItems.get(item.name);
if (!uniqueItem) {
uniqueItems.set(item.name, item.kind);
}
else {
assert.equal(item.kind, uniqueItem, `Items should have the same kind, got ${item.kind} and ${uniqueItem}`);
}
}
}
public verifyCompletionListIsEmpty(negative: boolean) {
const completions = this.getCompletionListAtCaret();
if ((!completions || completions.entries.length === 0) && negative) {
this.raiseError("Completion list is empty at caret at position " + this.activeFile.fileName + " " + this.currentCaretPosition);
}
else if (completions && completions.entries.length !== 0 && !negative) {
this.raiseError(`Completion list is not empty at caret at position ${this.activeFile.fileName} ${this.currentCaretPosition}\n` +
`Completion List contains: ${stringify(completions.entries.map(e => e.name))}`);
}
}
public verifyCompletionListAllowsNewIdentifier(negative: boolean) {
const completions = this.getCompletionListAtCaret();
if ((completions && !completions.isNewIdentifierLocation) && !negative) {
this.raiseError("Expected builder completion entry");
}
else if ((completions && completions.isNewIdentifierLocation) && negative) {
this.raiseError("Un-expected builder completion entry");
}
}
public verifyCompletionListIsGlobal(expected: boolean) {
const completions = this.getCompletionListAtCaret();
if (completions && completions.isGlobalCompletion !== expected) {
this.raiseError(`verifyCompletionListIsGlobal failed - expected result to be ${completions.isGlobalCompletion}`);
}
}
public verifyCompletions(options: FourSlashInterface.VerifyCompletionsOptions) {
if (options.marker === undefined) {
this.verifyCompletionsWorker(options);
@@ -843,13 +752,21 @@ namespace FourSlash {
this.raiseError(`Expected 'isNewIdentifierLocation' to be ${options.isNewIdentifierLocation || false}, got ${actualCompletions.isNewIdentifierLocation}`);
}
const actualByName = ts.createMap<ts.CompletionEntry>();
if ("isGlobalCompletion" in options && actualCompletions.isGlobalCompletion !== options.isGlobalCompletion) {
this.raiseError(`Expected 'isGlobalCompletion to be ${options.isGlobalCompletion}, got ${actualCompletions.isGlobalCompletion}`);
}
const nameToEntries = ts.createMap<ts.CompletionEntry[]>();
for (const entry of actualCompletions.entries) {
if (actualByName.has(entry.name)) {
this.raiseError(`Duplicate (${actualCompletions.entries.filter(a => a.name === entry.name).length}) completions for ${entry.name}`);
const entries = nameToEntries.get(entry.name);
if (!entries) {
nameToEntries.set(entry.name, [entry]);
}
else {
actualByName.set(entry.name, entry);
if (entries.some(e => e.source === entry.source)) {
this.raiseError(`Duplicate completions for ${entry.name}`);
}
entries.push(entry);
}
}
@@ -862,23 +779,16 @@ namespace FourSlash {
if (options.includes) {
for (const include of toArray(options.includes)) {
const name = typeof include === "string" ? include : include.name;
const found = actualByName.get(name);
const found = nameToEntries.get(name);
if (!found) throw this.raiseError(`No completion ${name} found`);
this.verifyCompletionEntry(found, include);
assert(found.length === 1); // Must use 'exact' for multiple completions with same name
this.verifyCompletionEntry(ts.first(found), include);
}
}
if (options.excludes) {
for (const exclude of toArray(options.excludes)) {
if (typeof exclude === "string") {
if (actualByName.has(exclude)) {
this.raiseError(`Did not expect to get a completion named ${exclude}`);
}
}
else {
const found = actualByName.get(exclude.name);
if (found && found.source === exclude.source) {
this.raiseError(`Did not expect to get a completion named ${exclude.name} with source ${exclude.source}`);
}
if (nameToEntries.has(exclude)) {
this.raiseError(`Did not expect to get a completion named ${exclude}`);
}
}
}
@@ -902,6 +812,7 @@ namespace FourSlash {
}
if (kind !== undefined) assert.equal(actual.kind, kind);
if (typeof expected !== "string" && "kindModifiers" in expected) assert.equal(actual.kindModifiers, expected.kindModifiers);
assert.equal(actual.hasAction, hasAction);
assert.equal(actual.isRecommended, isRecommended);
@@ -923,9 +834,8 @@ namespace FourSlash {
}
private verifyCompletionsAreExactly(actual: ReadonlyArray<ts.CompletionEntry>, expected: ReadonlyArray<FourSlashInterface.ExpectedCompletionEntry>) {
if (actual.length !== expected.length) {
this.raiseError(`Expected ${expected.length} completions, got ${actual.length} (${actual.map(a => a.name)}).`);
}
// First pass: test that names are right. Then we'll test details.
assert.deepEqual(actual.map(a => a.name), expected.map(e => typeof e === "string" ? e : e.name));
ts.zipWith(actual, expected, (completion, expectedCompletion, index) => {
const name = typeof expectedCompletion === "string" ? expectedCompletion : expectedCompletion.name;
@@ -936,117 +846,6 @@ namespace FourSlash {
});
}
public verifyCompletionsAt(markerName: string | ReadonlyArray<string>, expected: ReadonlyArray<FourSlashInterface.ExpectedCompletionEntry>, options?: FourSlashInterface.CompletionsAtOptions) {
this.verifyCompletions({
marker: markerName,
exact: expected,
isNewIdentifierLocation: options && options.isNewIdentifierLocation,
preferences: options,
triggerCharacter: options && options.triggerCharacter,
});
}
public verifyCompletionListContains(entryId: ts.Completions.CompletionEntryIdentifier, text?: string, documentation?: string, kind?: string | { kind?: string, kindModifiers?: string }, spanIndex?: number, hasAction?: boolean, options?: FourSlashInterface.VerifyCompletionListContainsOptions) {
const completions = this.getCompletionListAtCaret(options);
if (completions) {
this.assertItemInCompletionList(completions.entries, entryId, text, documentation, kind, spanIndex, hasAction, options);
}
else {
this.raiseError(`No completions at position '${this.currentCaretPosition}' when looking for '${JSON.stringify(entryId)}'.`);
}
}
/**
* Verify that the completion list does NOT contain the given symbol.
* The symbol is considered matched with the symbol in the list if and only if all given parameters must matched.
* When any parameter is omitted, the parameter is ignored during comparison and assumed that the parameter with
* that property of the symbol in the list.
* @param symbol the name of symbol
* @param expectedText the text associated with the symbol
* @param expectedDocumentation the documentation text associated with the symbol
* @param expectedKind the kind of symbol (see ScriptElementKind)
* @param spanIndex the index of the range that the completion item's replacement text span should match
*/
public verifyCompletionListDoesNotContain(entryId: ts.Completions.CompletionEntryIdentifier, expectedText?: string, expectedDocumentation?: string, expectedKind?: string | { kind?: string, kindModifiers?: string }, spanIndex?: number, options?: FourSlashInterface.CompletionsAtOptions) {
let replacementSpan: ts.TextSpan | undefined;
if (spanIndex !== undefined) {
replacementSpan = this.getTextSpanForRangeAtIndex(spanIndex);
}
const completions = this.getCompletionListAtCaret(options);
if (completions) {
let filterCompletions = completions.entries.filter(e => e.name === entryId.name && e.source === entryId.source);
filterCompletions = expectedKind ? filterCompletions.filter(e => e.kind === expectedKind || (typeof expectedKind === "object" && e.kind === expectedKind.kind)) : filterCompletions;
filterCompletions = filterCompletions.filter(entry => {
const details = this.getCompletionEntryDetails(entry.name);
const documentation = details && ts.displayPartsToString(details.documentation);
const text = details && ts.displayPartsToString(details.displayParts);
// If any of the expected values are undefined, assume that users don't
// care about them.
if (replacementSpan && !ts.textSpansEqual(replacementSpan, entry.replacementSpan)) {
return false;
}
else if (expectedText && text !== expectedText) {
return false;
}
else if (expectedDocumentation && documentation !== expectedDocumentation) {
return false;
}
return true;
});
if (filterCompletions.length !== 0) {
// After filtered using all present criterion, if there are still symbol left in the list
// then these symbols must meet the criterion for Not supposed to be in the list. So we
// raise an error
let error = `Completion list did contain '${JSON.stringify(entryId)}\'.`;
const details = this.getCompletionEntryDetails(filterCompletions[0].name)!;
if (expectedText) {
error += "Expected text: " + expectedText + " to equal: " + ts.displayPartsToString(details.displayParts) + ".";
}
if (expectedDocumentation) {
error += "Expected documentation: " + expectedDocumentation + " to equal: " + ts.displayPartsToString(details.documentation) + ".";
}
if (expectedKind) {
error += "Expected kind: " + expectedKind + " to equal: " + filterCompletions[0].kind + ".";
}
else {
error += "kind: " + filterCompletions[0].kind + ".";
}
if (replacementSpan) {
const spanText = filterCompletions[0].replacementSpan ? stringify(filterCompletions[0].replacementSpan) : undefined;
error += "Expected replacement span: " + stringify(replacementSpan) + " to equal: " + spanText + ".";
}
this.raiseError(error);
}
}
}
public verifyCompletionEntryDetails(entryName: string, expectedText: string, expectedDocumentation?: string, kind?: string, tags?: ts.JSDocTagInfo[]) {
const details = this.getCompletionEntryDetails(entryName)!;
assert(details, "no completion entry available");
assert.equal(ts.displayPartsToString(details.displayParts), expectedText, this.assertionMessageAtLastKnownMarker("completion entry details text"));
if (expectedDocumentation !== undefined) {
assert.equal(ts.displayPartsToString(details.documentation), expectedDocumentation, this.assertionMessageAtLastKnownMarker("completion entry documentation"));
}
if (kind !== undefined) {
assert.equal(details.kind, kind, this.assertionMessageAtLastKnownMarker("completion entry kind"));
}
if (tags !== undefined) {
assert.equal(details.tags!.length, tags.length, this.messageAtLastKnownMarker("QuickInfo tags"));
ts.zipWith(tags, details.tags!, (expectedTag, actualTag) => {
assert.equal(actualTag.name, expectedTag.name);
assert.equal(actualTag.text, expectedTag.text, this.messageAtLastKnownMarker("QuickInfo tag " + actualTag.name));
});
}
}
/** Use `getProgram` instead of accessing this directly. */
private _program: ts.Program;
/** Use `getChecker` instead of accessing this directly. */
@@ -3172,74 +2971,6 @@ Actual: ${stringify(fullActual)}`);
return text.substring(startPos, endPos);
}
private assertItemInCompletionList(
items: ts.CompletionEntry[],
entryId: ts.Completions.CompletionEntryIdentifier,
text: string | undefined,
documentation: string | undefined,
kind: string | undefined | { kind?: string, kindModifiers?: string },
spanIndex: number | undefined,
hasAction: boolean | undefined,
options: FourSlashInterface.VerifyCompletionListContainsOptions | undefined,
) {
const eq = <T>(a: T, b: T, msg: string) => {
assert.deepEqual(a, b, this.assertionMessageAtLastKnownMarker(msg + " for " + stringify(entryId)));
};
const matchingItems = items.filter(item => item.name === entryId.name && item.source === entryId.source);
if (matchingItems.length === 0) {
const itemsString = items.map(item => stringify({ name: item.name, source: item.source, kind: item.kind })).join(",\n");
this.raiseError(`Expected "${stringify({ entryId, text, documentation, kind })}" to be in list [${itemsString}]`);
}
else if (matchingItems.length > 1) {
this.raiseError(`Found duplicate completion items for ${stringify(entryId)}`);
}
const item = matchingItems[0];
if (documentation !== undefined || text !== undefined || entryId.source !== undefined) {
const details = this.getCompletionEntryDetails(item.name, item.source)!;
if (documentation !== undefined) {
eq(ts.displayPartsToString(details.documentation), documentation, "completion item documentation");
}
if (text !== undefined) {
eq(ts.displayPartsToString(details.displayParts), text, "completion item detail text");
}
if (entryId.source === undefined) {
eq(options && options.sourceDisplay, /*b*/ undefined, "source display");
}
else {
eq(details.source, [ts.textPart(options!.sourceDisplay)], "source display");
}
}
if (kind !== undefined) {
if (typeof kind === "string") {
eq(item.kind, kind, "completion item kind");
}
else {
if (kind.kind) {
eq(item.kind, kind.kind, "completion item kind");
}
if (kind.kindModifiers !== undefined) {
eq(item.kindModifiers, kind.kindModifiers, "completion item kindModifiers");
}
}
}
if (spanIndex !== undefined) {
const span = this.getTextSpanForRangeAtIndex(spanIndex);
assert.isTrue(ts.textSpansEqual(span, item.replacementSpan), this.assertionMessageAtLastKnownMarker(stringify(span) + " does not equal " + stringify(item.replacementSpan) + " replacement span for " + stringify(entryId)));
}
eq(item.hasAction, hasAction, "hasAction");
eq(item.isRecommended, options && options.isRecommended, "isRecommended");
eq(item.insertText, options && options.insertText, "insertText");
eq(item.replacementSpan, options && options.replacementSpan && ts.createTextSpanFromRange(options.replacementSpan), "replacementSpan");
}
private findFile(indexOrName: string | number): FourSlashFile {
if (typeof indexOrName === "number") {
const index = indexOrName;
@@ -3289,16 +3020,6 @@ Actual: ${stringify(fullActual)}`);
return `line ${(pos.line + 1)}, col ${pos.character}`;
}
private getTextSpanForRangeAtIndex(index: number): ts.TextSpan {
const ranges = this.getRanges();
if (ranges.length > index) {
return ts.createTextSpanFromRange(ranges[index]);
}
else {
throw this.raiseError("Supplied span index: " + index + " does not exist in range list of size: " + ranges.length);
}
}
public getMarkerByName(markerName: string) {
const markerPos = this.testData.markerPositions.get(markerName);
if (markerPos === undefined) {
@@ -3418,7 +3139,7 @@ Actual: ${stringify(fullActual)}`);
function runCode(code: string, state: TestState): void {
// Compile and execute the test
const wrappedCode =
`(function(test, goTo, verify, edit, debug, format, cancellation, classification, verifyOperationIsCancelled) {
`(function(test, goTo, verify, edit, debug, format, cancellation, classification, completion, verifyOperationIsCancelled) {
${code}
})`;
try {
@@ -3430,7 +3151,7 @@ ${code}
const format = new FourSlashInterface.Format(state);
const cancellation = new FourSlashInterface.Cancellation(state);
const f = eval(wrappedCode);
f(test, goTo, verify, edit, debug, format, cancellation, FourSlashInterface.Classification, verifyOperationIsCancelled);
f(test, goTo, verify, edit, debug, format, cancellation, FourSlashInterface.Classification, FourSlashInterface.Completion, verifyOperationIsCancelled);
}
catch (err) {
throw err;
@@ -3997,24 +3718,6 @@ namespace FourSlashInterface {
export class VerifyNegatable {
public not: VerifyNegatable;
public allowedClassElementKeywords = [
"public",
"private",
"protected",
"static",
"abstract",
"readonly",
"get",
"set",
"constructor",
"async"
];
public allowedConstructorParameterKeywords = [
"public",
"private",
"protected",
"readonly",
];
constructor(protected state: FourSlash.TestState, private negative = false) {
if (!negative) {
@@ -4022,58 +3725,10 @@ namespace FourSlashInterface {
}
}
public completionListCount(expectedCount: number) {
this.state.verifyCompletionListCount(expectedCount, this.negative);
}
// Verifies the completion list contains the specified symbol. The
// completion list is brought up if necessary
public completionListContains(entryId: string | ts.Completions.CompletionEntryIdentifier, text?: string, documentation?: string, kind?: string | { kind?: string, kindModifiers?: string }, spanIndex?: number, hasAction?: boolean, options?: VerifyCompletionListContainsOptions) {
if (typeof entryId === "string") {
entryId = { name: entryId, source: undefined };
}
if (this.negative) {
this.state.verifyCompletionListDoesNotContain(entryId, text, documentation, kind, spanIndex, options);
}
else {
this.state.verifyCompletionListContains(entryId, text, documentation, kind, spanIndex, hasAction, options);
}
}
// Verifies the completion list items count to be greater than the specified amount. The
// completion list is brought up if necessary
public completionListItemsCountIsGreaterThan(count: number) {
this.state.verifyCompletionListItemsCountIsGreaterThan(count, this.negative);
}
public assertHasRanges(ranges: FourSlash.Range[]) {
assert(ranges.length !== 0, "Array of ranges is expected to be non-empty");
}
public completionListIsEmpty() {
this.state.verifyCompletionListIsEmpty(this.negative);
}
public completionListContainsClassElementKeywords() {
for (const keyword of this.allowedClassElementKeywords) {
this.completionListContains(keyword, keyword, /*documentation*/ undefined, "keyword");
}
}
public completionListContainsConstructorParameterKeywords() {
for (const keyword of this.allowedConstructorParameterKeywords) {
this.completionListContains(keyword, keyword, /*documentation*/ undefined, "keyword");
}
}
public completionListIsGlobal(expected: boolean) {
this.state.verifyCompletionListIsGlobal(expected);
}
public completionListAllowsNewIdentifier() {
this.state.verifyCompletionListAllowsNewIdentifier(this.negative);
}
public noSignatureHelp(...markers: string[]): void {
this.state.verifySignatureHelpPresence(/*expectPresent*/ false, /*triggerReason*/ undefined, markers);
}
@@ -4160,10 +3815,6 @@ namespace FourSlashInterface {
super(state);
}
public completionsAt(markerName: ArrayOrSingle<string>, completions: ReadonlyArray<ExpectedCompletionEntry>, options?: CompletionsAtOptions) {
this.state.verifyCompletionsAt(markerName, completions, options);
}
public completions(...optionsArray: VerifyCompletionsOptions[]) {
for (const options of optionsArray) {
this.state.verifyCompletions(options);
@@ -4413,10 +4064,6 @@ namespace FourSlashInterface {
this.state.verifyNoDocumentHighlights(startRange);
}
public completionEntryDetailIs(entryName: string, text: string, documentation?: string, kind?: string, tags?: ts.JSDocTagInfo[]) {
this.state.verifyCompletionEntryDetails(entryName, text, documentation, kind, tags);
}
/**
* This method *requires* a contiguous, complete, and ordered stream of classifications for a file.
*/
@@ -4761,6 +4408,477 @@ namespace FourSlashInterface {
return { classificationType, text, textSpan };
}
}
export namespace Completion {
const res: string[] = [];
for (let i = ts.SyntaxKind.FirstKeyword; i <= ts.SyntaxKind.LastKeyword; i++) {
res.push(ts.Debug.assertDefined(ts.tokenToString(i)));
}
export const keywordsWithUndefined: ReadonlyArray<string> = res;
export const keywords: ReadonlyArray<string> = keywordsWithUndefined.filter(k => k !== "undefined");
export const typeKeywords: ReadonlyArray<string> =
["false", "null", "true", "void", "any", "boolean", "keyof", "never", "number", "object", "string", "symbol", "undefined", "unique", "unknown"];
const globalTypeDecls = [
"Symbol",
"PropertyKey",
"PropertyDescriptor",
"PropertyDescriptorMap",
"Object",
"ObjectConstructor",
"Function",
"FunctionConstructor",
"CallableFunction",
"NewableFunction",
"IArguments",
"String",
"StringConstructor",
"Boolean",
"BooleanConstructor",
"Number",
"NumberConstructor",
"TemplateStringsArray",
"ImportMeta",
"Math",
"Date",
"DateConstructor",
"RegExpMatchArray",
"RegExpExecArray",
"RegExp",
"RegExpConstructor",
"Error",
"ErrorConstructor",
"EvalError",
"EvalErrorConstructor",
"RangeError",
"RangeErrorConstructor",
"ReferenceError",
"ReferenceErrorConstructor",
"SyntaxError",
"SyntaxErrorConstructor",
"TypeError",
"TypeErrorConstructor",
"URIError",
"URIErrorConstructor",
"JSON",
"ReadonlyArray",
"ConcatArray",
"Array",
"ArrayConstructor",
"TypedPropertyDescriptor",
"ClassDecorator",
"PropertyDecorator",
"MethodDecorator",
"ParameterDecorator",
"PromiseConstructorLike",
"PromiseLike",
"Promise",
"ArrayLike",
"Partial",
"Required",
"Readonly",
"Pick",
"Record",
"Exclude",
"Extract",
"NonNullable",
"Parameters",
"ConstructorParameters",
"ReturnType",
"InstanceType",
"ThisType",
"ArrayBuffer",
"ArrayBufferTypes",
"ArrayBufferLike",
"ArrayBufferConstructor",
"ArrayBufferView",
"DataView",
"DataViewConstructor",
"Int8Array",
"Int8ArrayConstructor",
"Uint8Array",
"Uint8ArrayConstructor",
"Uint8ClampedArray",
"Uint8ClampedArrayConstructor",
"Int16Array",
"Int16ArrayConstructor",
"Uint16Array",
"Uint16ArrayConstructor",
"Int32Array",
"Int32ArrayConstructor",
"Uint32Array",
"Uint32ArrayConstructor",
"Float32Array",
"Float32ArrayConstructor",
"Float64Array",
"Float64ArrayConstructor",
"Intl",
];
export const globalTypes = globalTypesPlus([]);
export function globalTypesPlus(plus: ReadonlyArray<ExpectedCompletionEntry>): ReadonlyArray<ExpectedCompletionEntry> {
return [
...globalTypeDecls,
...plus,
...typeKeywords,
];
}
export const classElementKeywords: ReadonlyArray<string> =
["private", "protected", "public", "static", "abstract", "async", "constructor", "get", "readonly", "set"];
export const constructorParameterKeywords: ReadonlyArray<ExpectedCompletionEntry> =
["private", "protected", "public", "readonly"].map((name): ExpectedCompletionEntry => ({ name, kind: "keyword" }));
export const functionMembers: ReadonlyArray<ExpectedCompletionEntry> = [
"apply",
"call",
"bind",
"toString",
"length",
{ name: "arguments", text: "(property) Function.arguments: any" },
"caller"
];
export const stringMembers: ReadonlyArray<ExpectedCompletionEntry> = [
"toString",
"charAt",
"charCodeAt",
"concat",
"indexOf",
"lastIndexOf",
"localeCompare",
"match",
"replace",
"search",
"slice",
"split",
"substring",
"toLowerCase",
"toLocaleLowerCase",
"toUpperCase",
"toLocaleUpperCase",
"trim",
"length",
"substr",
"valueOf",
];
export const functionMembersWithPrototype: ReadonlyArray<ExpectedCompletionEntry> = [
...functionMembers.slice(0, 4),
"prototype",
...functionMembers.slice(4),
];
// TODO: Shouldn't propose type keywords in statement position
export const statementKeywordsWithTypes: ReadonlyArray<string> = [
"break",
"case",
"catch",
"class",
"const",
"continue",
"debugger",
"default",
"delete",
"do",
"else",
"enum",
"export",
"extends",
"false",
"finally",
"for",
"function",
"if",
"import",
"in",
"instanceof",
"new",
"null",
"return",
"super",
"switch",
"this",
"throw",
"true",
"try",
"typeof",
"var",
"void",
"while",
"with",
"implements",
"interface",
"let",
"package",
"private",
"protected",
"public",
"static",
"yield",
"abstract",
"as",
"any",
"async",
"await",
"boolean",
"constructor",
"declare",
"get",
"infer",
"is",
"keyof",
"module",
"namespace",
"never",
"readonly",
"require",
"number",
"object",
"set",
"string",
"symbol",
"type",
"unique",
"unknown",
"from",
"global",
"of",
];
export const statementKeywords: ReadonlyArray<string> = statementKeywordsWithTypes.filter(k =>
k === "false" || k === "true" || k === "null" || k === "void" || !ts.contains(typeKeywords, k) && k !== "declare" && k !== "module");
export const globalsVars: ReadonlyArray<string> = [
"eval",
"parseInt",
"parseFloat",
"isNaN",
"isFinite",
"decodeURI",
"decodeURIComponent",
"encodeURI",
"encodeURIComponent",
"escape",
"unescape",
"NaN",
"Infinity",
"Object",
"Function",
"String",
"Boolean",
"Number",
"Math",
"Date",
"RegExp",
"Error",
"EvalError",
"RangeError",
"ReferenceError",
"SyntaxError",
"TypeError",
"URIError",
"JSON",
"Array",
"ArrayBuffer",
"DataView",
"Int8Array",
"Uint8Array",
"Uint8ClampedArray",
"Int16Array",
"Uint16Array",
"Int32Array",
"Uint32Array",
"Float32Array",
"Float64Array",
"Intl",
];
// TODO: many of these are inappropriate to always provide
export const globalsInsideFunction = (plus: ReadonlyArray<ExpectedCompletionEntry>): ReadonlyArray<ExpectedCompletionEntry> => [
"arguments",
...plus,
...globalsVars,
"undefined",
"break",
"case",
"catch",
"class",
"const",
"continue",
"debugger",
"default",
"delete",
"do",
"else",
"enum",
"export",
"extends",
"false",
"finally",
"for",
"function",
"if",
"import",
"in",
"instanceof",
"new",
"null",
"return",
"super",
"switch",
"this",
"throw",
"true",
"try",
"typeof",
"var",
"void",
"while",
"with",
"implements",
"interface",
"let",
"package",
"yield",
"async",
];
// TODO: many of these are inappropriate to always provide
export const globalKeywords: ReadonlyArray<string> = [
"break",
"case",
"catch",
"class",
"const",
"continue",
"debugger",
"default",
"delete",
"do",
"else",
"enum",
"export",
"extends",
"false",
"finally",
"for",
"function",
"if",
"import",
"in",
"instanceof",
"new",
"null",
"return",
"super",
"switch",
"this",
"throw",
"true",
"try",
"typeof",
"var",
"void",
"while",
"with",
"implements",
"interface",
"let",
"package",
"private",
"protected",
"public",
"static",
"yield",
"abstract",
"as",
"any",
"async",
"await",
"boolean",
"constructor",
"declare",
"get",
"infer",
"is",
"keyof",
"module",
"namespace",
"never",
"readonly",
"require",
"number",
"object",
"set",
"string",
"symbol",
"type",
"unique",
"unknown",
"from",
"global",
"of",
];
export const insideMethodKeywords: ReadonlyArray<string> = [
"break",
"case",
"catch",
"class",
"const",
"continue",
"debugger",
"default",
"delete",
"do",
"else",
"enum",
"export",
"extends",
"false",
"finally",
"for",
"function",
"if",
"import",
"in",
"instanceof",
"new",
"null",
"return",
"super",
"switch",
"this",
"throw",
"true",
"try",
"typeof",
"var",
"void",
"while",
"with",
"implements",
"interface",
"let",
"package",
"yield",
"async",
];
export const globalKeywordsPlusUndefined: ReadonlyArray<string> = (() => {
const i = globalKeywords.indexOf("unique");
return [...globalKeywords.slice(0, i), "undefined", ...globalKeywords.slice(i)];
})();
export const globals: ReadonlyArray<string> = [...globalsVars, "undefined", ...globalKeywords];
export function globalsPlus(plus: ReadonlyArray<ExpectedCompletionEntry>): ReadonlyArray<ExpectedCompletionEntry> {
return [...globalsVars, ...plus, "undefined", ...globalKeywords];
}
}
export interface ReferenceGroup {
definition: ReferenceGroupDefinition;
@@ -4784,22 +4902,20 @@ namespace FourSlashInterface {
readonly hasAction?: boolean, // If not specified, will assert that this is false.
readonly isRecommended?: boolean; // If not specified, will assert that this is false.
readonly kind?: string, // If not specified, won't assert about this
readonly text: string;
readonly documentation: string;
readonly kindModifiers?: string;
readonly text?: string;
readonly documentation?: string;
readonly sourceDisplay?: string;
readonly tags?: ReadonlyArray<ts.JSDocTagInfo>;
};
export interface CompletionsAtOptions extends Partial<ts.UserPreferences> {
triggerCharacter?: ts.CompletionsTriggerCharacter;
isNewIdentifierLocation?: boolean;
}
export interface VerifyCompletionsOptions {
readonly marker?: ArrayOrSingle<string | FourSlash.Marker>;
readonly isNewIdentifierLocation?: boolean;
readonly isNewIdentifierLocation?: boolean; // Always tested
readonly isGlobalCompletion?: boolean; // Only tested if set
readonly exact?: ArrayOrSingle<ExpectedCompletionEntry>;
readonly includes?: ArrayOrSingle<ExpectedCompletionEntry>;
readonly excludes?: ArrayOrSingle<string | { readonly name: string, readonly source: string }>;
readonly excludes?: ArrayOrSingle<string>;
readonly preferences?: ts.UserPreferences;
readonly triggerCharacter?: ts.CompletionsTriggerCharacter;
}
tests/cases/fourslash/argumentsAreAvailableAfterEditsAtEndOfFunction.ts
+1 -1
View File
@@ -12,4 +12,4 @@
goTo.marker();
var text = "this.children = ch";
edit.insert(text);
verify.completionListContains("children", "(parameter) children: string[]");
verify.completions({ includes: { name: "children", text: "(parameter) children: string[]" }, isNewIdentifierLocation: true });
tests/cases/fourslash/asOperatorCompletion.ts
+2 -2
View File
@@ -4,5 +4,5 @@
//// var x;
//// var y = x as /**/
goTo.marker();
verify.completionListContains('T');
verify.completions({ marker: "", includes: "T" });
tests/cases/fourslash/augmentedTypesClass2.ts
+2 -4
View File
@@ -6,8 +6,6 @@
////var r = new c5b();
////r./*2*/
goTo.marker('1');
verify.not.completionListContains('y', 'var y: number');
verify.completions({ marker: "1", excludes: ["y"] });
edit.backspace(4);
goTo.marker('2');
verify.completionListContains('foo', '(method) c5b.foo(): void');
verify.completions({ marker: "2", exact: { name: "foo", text: "(method) c5b.foo(): void" } });
tests/cases/fourslash/augmentedTypesClass3.ts
+1 -3
View File
@@ -8,6 +8,4 @@ verify.quickInfos({
1: "class c5b\nnamespace c5b",
2: "class c5b\nnamespace c5b"
});
goTo.marker('3');
verify.completionListContains("c5b", "class c5b\nnamespace c5b");
verify.completions({ marker: "3", includes: { name: "c5b", text: "class c5b\nnamespace c5b" }})
tests/cases/fourslash/augmentedTypesModule1.ts
+1 -4
View File
@@ -7,8 +7,5 @@
////var x: m1c./*1*/;
////var /*2*/r = m1c;
goTo.marker('1');
verify.completionListContains('I');
verify.not.completionListContains('foo');
verify.completions({ marker: "1", exact: "I" });
verify.quickInfoAt("2", "var r: number");
tests/cases/fourslash/augmentedTypesModule2.ts
+2 -3
View File
@@ -7,11 +7,10 @@
verify.quickInfoAt("11", "function m2f(x: number): void\nnamespace m2f");
goTo.marker('1');
verify.completionListContains('I');
verify.completions({ marker: "1", exact: "I" });
edit.insert('I.');
verify.not.completionListContains('foo');
verify.completions({ exact: undefined });
edit.backspace(1);
verify.quickInfoAt("2", "var r: (x: number) => void");
tests/cases/fourslash/augmentedTypesModule3.ts
+2 -3
View File
@@ -5,11 +5,10 @@
////var x: m2g./*1*/;
////var /*2*/r = m2g/*3*/;
goTo.marker('1');
verify.completionListContains('C');
verify.completions({ marker: "1", exact: "C" });
edit.insert('C.');
verify.not.completionListContains('foo');
verify.completions({ exact: undefined });
edit.backspace(1);
verify.quickInfoAt("2", "var r: typeof m2g");
tests/cases/fourslash/augmentedTypesModule4.ts
+3 -5
View File
@@ -1,6 +1,6 @@
/// <reference path='fourslash.ts'/>
////module m3d { export var y = 2; }
////module m3d { export var y = 2; }
////declare class m3d { foo(): void }
////var /*1*/r = new m3d();
////r./*2*/
@@ -8,12 +8,10 @@
verify.quickInfoAt("1", "var r: m3d");
goTo.marker('2');
verify.completionListContains('foo');
verify.completions({ marker: "2", exact: "foo" });
edit.insert('foo();');
goTo.marker('3');
verify.completionListContains('y');
verify.completions({ marker: "3", includes: "y" });
edit.insert('y;');
verify.quickInfoAt("4", "var r2: number");
tests/cases/fourslash/augmentedTypesModule5.ts
+3 -5
View File
@@ -1,6 +1,6 @@
/// <reference path='fourslash.ts'/>
////declare class m3e { foo(): void }
////declare class m3e { foo(): void }
////module m3e { export var y = 2; }
////var /*1*/r = new m3e();
////r./*2*/
@@ -8,13 +8,11 @@
verify.quickInfoAt("1", "var r: m3e");
goTo.marker('2');
verify.completionListContains('foo');
verify.completions({ marker: "2", exact: "foo" });
edit.insert('foo();');
goTo.marker('3');
verify.completionListContains('y');
verify.completions({ marker: "3", includes: "y" });
edit.insert('y;');
verify.quickInfoAt("4", "var r2: number");
tests/cases/fourslash/basicClassMembers.ts
+1 -3
View File
@@ -7,6 +7,4 @@
goTo.eof();
edit.insert('t.');
verify.completionListContains('x');
verify.completionListContains('y');
verify.not.completionListContains('z');
verify.completions({ includes: ["x", "y"], excludes: "z" });
tests/cases/fourslash/cloduleAsBaseClass.ts
+3 -18
View File
@@ -23,23 +23,8 @@
////d./*1*/
////D./*2*/
goTo.marker('1');
verify.completionListContains('foo');
verify.completionListContains('foo2');
verify.not.completionListContains('bar');
verify.not.completionListContains('bar2');
verify.not.completionListContains('baz');
verify.not.completionListContains('x');
verify.completions({ marker: "1", exact: ["foo2", "foo"] });
edit.insert('foo()');
goTo.marker('2');
verify.not.completionListContains('foo');
verify.not.completionListContains('foo2');
verify.completionListContains('bar');
verify.completionListContains('bar2');
verify.completionListContains('baz');
verify.completionListContains('x');
verify.completions({ marker: "2", exact: ["prototype", "bar2", "bar", "baz", "x", ...completion.functionMembers] });
edit.insert('bar()');
verify.noErrors();
verify.noErrors();
tests/cases/fourslash/closedCommentsInConstructor.ts
+1 -2
View File
@@ -4,5 +4,4 @@
//// constructor(/* /**/ */) { }
////}
goTo.marker();
verify.completionListIsEmpty();
verify.completions({ marker: "", exact: undefined });
tests/cases/fourslash/codeCompletionEscaping.ts
+7 -3
View File
@@ -4,6 +4,10 @@
// @allowJs: true
////___foo; __foo;/**/
goTo.marker();
verify.completionListContains("__foo", undefined, undefined, "warning");
verify.completionListContains("___foo", undefined, undefined, "warning");
verify.completions({
marker: "",
includes: [
{ name: "__foo", kind: "warning" },
{ name: "___foo", kind: "warning" },
],
});
tests/cases/fourslash/commentsClass.ts
+20 -16
View File
@@ -106,22 +106,26 @@ verify.quickInfos({
25: ["class c6", "class with statics and constructor"]
});
goTo.marker('26');
verify.completionListContains("c2", "class c2", "This is class c2 without constructor");
verify.completionListContains("i2", "var i2: c2", "");
verify.completionListContains("i2_c", "var i2_c: typeof c2", "");
verify.completionListContains("c3", "class c3", "");
verify.completionListContains("i3", "var i3: c3", "");
verify.completionListContains("i3_c", "var i3_c: typeof c3", "");
verify.completionListContains("c4", "class c4", "Class comment");
verify.completionListContains("i4", "var i4: c4", "");
verify.completionListContains("i4_c", "var i4_c: typeof c4", "");
verify.completionListContains("c5", "class c5", "Class with statics");
verify.completionListContains("i5", "var i5: c5", "");
verify.completionListContains("i5_c", "var i5_c: typeof c5");
verify.completionListContains("c6", "class c6", "class with statics and constructor");
verify.completionListContains("i6", "var i6: c6", "");
verify.completionListContains("i6_c", "var i6_c: typeof c6", "");
verify.completions({
marker: "26",
includes: [
{ name: "c2", text: "class c2", documentation: "This is class c2 without constructor" },
{ name: "i2", text: "var i2: c2" },
{ name: "i2_c", text: "var i2_c: typeof c2" },
{ name: "c3", text: "class c3" },
{ name: "i3", text: "var i3: c3" },
{ name: "i3_c", text: "var i3_c: typeof c3" },
{ name: "c4", text: "class c4", documentation: "Class comment" },
{ name: "i4", text: "var i4: c4" },
{ name: "i4_c", text: "var i4_c: typeof c4" },
{ name: "c5", text: "class c5", documentation: "Class with statics" },
{ name: "i5", text: "var i5: c5" },
{ name: "i5_c", text: "var i5_c: typeof c5" },
{ name: "c6", text: "class c6", documentation: "class with statics and constructor" },
{ name: "i6", text: "var i6: c6" },
{ name: "i6_c", text: "var i6_c: typeof c6" },
],
});
verify.signatureHelp({
marker: "27",
tests/cases/fourslash/commentsClassMembers.ts
+147 -395
View File
@@ -132,342 +132,163 @@
//// }
////}
const publicProperties: ReadonlyArray<FourSlashInterface.ExpectedCompletionEntry> = [
{ name: "p1", text: "(property) c1.p1: number", documentation: "p1 is property of c1" },
{ name: "p2", text: "(method) c1.p2(b: number): number", documentation: "sum with property" },
{ name: "p3", text: "(property) c1.p3: number", documentation: "getter property 1\nsetter property 1" },
];
const publicNcProperties: ReadonlyArray<FourSlashInterface.ExpectedCompletionEntry> = [
{ name: "nc_p1", text: "(property) c1.nc_p1: number" },
{ name: "nc_p2", text: "(method) c1.nc_p2(b: number): number" },
{ name: "nc_p3", text: "(property) c1.nc_p3: number" },
];
const locals: ReadonlyArray<FourSlashInterface.ExpectedCompletionEntry> = [
{ name: "c1", text: "class c1", documentation: "This is comment for c1" },
{ name: "i1", text: "var i1: c1" },
{ name: "i1_p", text: "var i1_p: number" },
{ name: "i1_f", text: "var i1_f: (b: number) => number" },
{ name: "i1_r", text: "var i1_r: number" },
{ name: "i1_prop", text: "var i1_prop: number" },
{ name: "i1_nc_p", text: "var i1_nc_p: number" },
{ name: "i1_ncf", text: "var i1_ncf: (b: number) => number" },
{ name: "i1_ncr", text: "var i1_ncr: number" },
{ name: "i1_ncprop", text: "var i1_ncprop: number" },
{ name: "i1_s_p", text: "var i1_s_p: number" },
{ name: "i1_s_f", text: "var i1_s_f: (b: number) => number" },
{ name: "i1_s_r", text: "var i1_s_r: number" },
{ name: "i1_s_prop", text: "var i1_s_prop: number" },
{ name: "i1_s_nc_p", text: "var i1_s_nc_p: number" },
{ name: "i1_s_ncf", text: "var i1_s_ncf: (b: number) => number" },
{ name: "i1_s_ncr", text: "var i1_s_ncr: number" },
{ name: "i1_s_ncprop", text: "var i1_s_ncprop: number" },
{ name: "i1_c", text: "var i1_c: typeof c1" },
];
verify.completions(
{
marker: ["4", "7", "9", "11", "12", "16", "19", "21", "23", "24"],
exact: [
...publicProperties,
{ name: "pp1", text: "(property) c1.pp1: number", documentation: "pp1 is property of c1" },
{ name: "pp2", text: "(method) c1.pp2(b: number): number", documentation: "sum with property" },
{ name: "pp3", text: "(property) c1.pp3: number", documentation: "getter property 2\nsetter property 2" },
...publicNcProperties,
{ name: "nc_pp1", text: "(property) c1.nc_pp1: number" },
{ name: "nc_pp2", text: "(method) c1.nc_pp2(b: number): number" },
{ name: "nc_pp3", text: "(property) c1.nc_pp3: number" },
],
},
{
marker: ["5", "17"],
includes: { name: "b", text: "(parameter) b: number", documentation: "number to add" },
},
{
marker: ["13", "25"],
includes: [{ name: "value", text: "(parameter) value: number", documentation: "this is value" }],
isNewIdentifierLocation: true,
},
{
marker: ["30", "34", "36", "39", "41", "88"],
exact: [
"prototype",
{ name: "s1", text: "(property) c1.s1: number", documentation: "s1 is static property of c1" },
{ name: "s2", text: "(method) c1.s2(b: number): number", documentation: "static sum with property" },
{ name: "s3", text: "(property) c1.s3: number", documentation: "static getter property\nsetter property 3" },
{ name: "nc_s1", text: "(property) c1.nc_s1: number" },
{ name: "nc_s2", text: "(method) c1.nc_s2(b: number): number" },
{ name: "nc_s3", text: "(property) c1.nc_s3: number" },
...completion.functionMembers,
],
},
{ marker: ["29", "33", "38", "109"], includes: locals },
{ marker: ["35", "40", "87"], includes: locals, isNewIdentifierLocation: true },
{ marker: "31", includes: { name: "b", text: "(parameter) b: number", documentation: "number to add" } },
{ marker: "42", includes: { name: "value", text: "(parameter) value: number", documentation: "this is value" }, isNewIdentifierLocation: true },
{ marker: ["45", "52", "59"], includes: { name: "b", text: "(parameter) b: number" } },
{ marker: ["49", "56", "63"], includes: { name: "value", text: "(parameter) value: number" }, isNewIdentifierLocation: true },
{ marker: "67", exact: [...publicProperties, ...publicNcProperties] },
{
marker: "110",
includes: [
{ name: "p1", text: "(property) cProperties.p1: number", documentation: "getter only property" },
{ name: "p2", text: "(property) cProperties.p2: number", documentation: "setter only property" },
{ name: "nc_p1", text: "(property) cProperties.nc_p1: number" },
{ name: "nc_p2", text: "(property) cProperties.nc_p2: number" },
],
},
{
marker: "114",
includes: {
name: "a",
text: "(property) cWithConstructorProperty.a: number",
documentation: "more info about a\nthis is first parameter a",
tags: [{ name: "param", text: "a this is first parameter a" }],
},
},
{
marker: "115",
includes: {
name: "a",
text: "(parameter) a: number",
documentation: "more info about a\nthis is first parameter a",
tags: [{ name: "param", text: "a this is first parameter a" }],
},
isNewIdentifierLocation: true,
},
);
verify.signatureHelp(
{ marker: ["8", "13", "20", "25", "71"], docComment: "sum with property", parameterDocComment: "number to add" },
{ marker: ["35", "42", "92"], docComment: "static sum with property", parameterDocComment: "number to add" },
{ marker: ["47", "49", "54", "56", "61", "63", "81", "102"], docComment: "" },
{ marker: "65", docComment: "Constructor method" },
);
verify.quickInfos({
1: ["class c1", "This is comment for c1"],
2: ["(property) c1.p1: number", "p1 is property of c1"],
3: ["(method) c1.p2(b: number): number", "sum with property"]
});
goTo.marker('4');
verify.completionListContains("p1", "(property) c1.p1: number", "p1 is property of c1");
verify.completionListContains("p2", "(method) c1.p2(b: number): number", "sum with property");
verify.completionListContains("p3", "(property) c1.p3: number", "getter property 1\nsetter property 1");
verify.completionListContains("pp1", "(property) c1.pp1: number", "pp1 is property of c1");
verify.completionListContains("pp2", "(method) c1.pp2(b: number): number", "sum with property");
verify.completionListContains("pp3", "(property) c1.pp3: number", "getter property 2\nsetter property 2");
verify.completionListContains("nc_p1", "(property) c1.nc_p1: number", "");
verify.completionListContains("nc_p2", "(method) c1.nc_p2(b: number): number", "");
verify.completionListContains("nc_p3", "(property) c1.nc_p3: number", "");
verify.completionListContains("nc_pp1", "(property) c1.nc_pp1: number", "");
verify.completionListContains("nc_pp2", "(method) c1.nc_pp2(b: number): number", "");
verify.completionListContains("nc_pp3", "(property) c1.nc_pp3: number", "");
goTo.marker('5');
verify.completionListContains("b", "(parameter) b: number", "number to add");
verify.quickInfoAt("6", "(property) c1.p3: number", "getter property 1\nsetter property 1");
goTo.marker('7');
verify.completionListContains("p1", "(property) c1.p1: number", "p1 is property of c1");
verify.completionListContains("p2", "(method) c1.p2(b: number): number", "sum with property");
verify.completionListContains("p3", "(property) c1.p3: number", "getter property 1\nsetter property 1");
verify.completionListContains("pp1", "(property) c1.pp1: number", "pp1 is property of c1");
verify.completionListContains("pp2", "(method) c1.pp2(b: number): number", "sum with property");
verify.completionListContains("pp3", "(property) c1.pp3: number", "getter property 2\nsetter property 2");
verify.completionListContains("nc_p1", "(property) c1.nc_p1: number", "");
verify.completionListContains("nc_p2", "(method) c1.nc_p2(b: number): number", "");
verify.completionListContains("nc_p3", "(property) c1.nc_p3: number", "");
verify.completionListContains("nc_pp1", "(property) c1.nc_pp1: number", "");
verify.completionListContains("nc_pp2", "(method) c1.nc_pp2(b: number): number", "");
verify.completionListContains("nc_pp3", "(property) c1.nc_pp3: number", "");
verify.signatureHelp({ marker: "8", docComment: "sum with property", parameterDocComment: "number to add" });
verify.quickInfoAt("8q", "(method) c1.p2(b: number): number", "sum with property");
goTo.marker('9');
verify.completionListContains("p1", "(property) c1.p1: number", "p1 is property of c1");
verify.completionListContains("p2", "(method) c1.p2(b: number): number", "sum with property");
verify.completionListContains("p3", "(property) c1.p3: number", "getter property 1\nsetter property 1");
verify.completionListContains("pp1", "(property) c1.pp1: number", "pp1 is property of c1");
verify.completionListContains("pp2", "(method) c1.pp2(b: number): number", "sum with property");
verify.completionListContains("pp3", "(property) c1.pp3: number", "getter property 2\nsetter property 2");
verify.completionListContains("nc_p1", "(property) c1.nc_p1: number", "");
verify.completionListContains("nc_p2", "(method) c1.nc_p2(b: number): number", "");
verify.completionListContains("nc_p3", "(property) c1.nc_p3: number", "");
verify.completionListContains("nc_pp1", "(property) c1.nc_pp1: number", "");
verify.completionListContains("nc_pp2", "(method) c1.nc_pp2(b: number): number", "");
verify.completionListContains("nc_pp3", "(property) c1.nc_pp3: number", "");
verify.quickInfoAt("10", "(property) c1.p3: number", "getter property 1\nsetter property 1");
goTo.marker('11');
verify.completionListContains("p1", "(property) c1.p1: number", "p1 is property of c1");
verify.completionListContains("p2", "(method) c1.p2(b: number): number", "sum with property");
verify.completionListContains("p3", "(property) c1.p3: number", "getter property 1\nsetter property 1");
verify.completionListContains("pp1", "(property) c1.pp1: number", "pp1 is property of c1");
verify.completionListContains("pp2", "(method) c1.pp2(b: number): number", "sum with property");
verify.completionListContains("pp3", "(property) c1.pp3: number", "getter property 2\nsetter property 2");
verify.completionListContains("nc_p1", "(property) c1.nc_p1: number", "");
verify.completionListContains("nc_p2", "(method) c1.nc_p2(b: number): number", "");
verify.completionListContains("nc_p3", "(property) c1.nc_p3: number", "");
verify.completionListContains("nc_pp1", "(property) c1.nc_pp1: number", "");
verify.completionListContains("nc_pp2", "(method) c1.nc_pp2(b: number): number", "");
verify.completionListContains("nc_pp3", "(property) c1.nc_pp3: number", "");
goTo.marker('12');
verify.completionListContains("p1", "(property) c1.p1: number", "p1 is property of c1");
verify.completionListContains("p2", "(method) c1.p2(b: number): number", "sum with property");
verify.completionListContains("p3", "(property) c1.p3: number", "getter property 1\nsetter property 1");
verify.completionListContains("pp1", "(property) c1.pp1: number", "pp1 is property of c1");
verify.completionListContains("pp2", "(method) c1.pp2(b: number): number", "sum with property");
verify.completionListContains("pp3", "(property) c1.pp3: number", "getter property 2\nsetter property 2");
verify.completionListContains("nc_p1", "(property) c1.nc_p1: number", "");
verify.completionListContains("nc_p2", "(method) c1.nc_p2(b: number): number", "");
verify.completionListContains("nc_p3", "(property) c1.nc_p3: number", "");
verify.completionListContains("nc_pp1", "(property) c1.nc_pp1: number", "");
verify.completionListContains("nc_pp2", "(method) c1.nc_pp2(b: number): number", "");
verify.completionListContains("nc_pp3", "(property) c1.nc_pp3: number", "");
verify.signatureHelp({ marker: "13", docComment: "sum with property", parameterDocComment: "number to add" });
verify.completionListContains("value", "(parameter) value: number", "this is value");
verify.quickInfos({
3: ["(method) c1.p2(b: number): number", "sum with property"],
6: ["(property) c1.p3: number", "getter property 1\nsetter property 1"],
"8q": ["(method) c1.p2(b: number): number", "sum with property"],
10: ["(property) c1.p3: number", "getter property 1\nsetter property 1"],
"13q": ["(method) c1.p2(b: number): number", "sum with property"],
14: ["(property) c1.pp1: number", "pp1 is property of c1"],
15: ["(method) c1.pp2(b: number): number", "sum with property"]
});
goTo.marker('16');
verify.completionListContains("p1", "(property) c1.p1: number", "p1 is property of c1");
verify.completionListContains("p2", "(method) c1.p2(b: number): number", "sum with property");
verify.completionListContains("p3", "(property) c1.p3: number", "getter property 1\nsetter property 1");
verify.completionListContains("pp1", "(property) c1.pp1: number", "pp1 is property of c1");
verify.completionListContains("pp2", "(method) c1.pp2(b: number): number", "sum with property");
verify.completionListContains("pp3", "(property) c1.pp3: number", "getter property 2\nsetter property 2");
verify.completionListContains("nc_p1", "(property) c1.nc_p1: number", "");
verify.completionListContains("nc_p2", "(method) c1.nc_p2(b: number): number", "");
verify.completionListContains("nc_p3", "(property) c1.nc_p3: number", "");
verify.completionListContains("nc_pp1", "(property) c1.nc_pp1: number", "");
verify.completionListContains("nc_pp2", "(method) c1.nc_pp2(b: number): number", "");
verify.completionListContains("nc_pp3", "(property) c1.nc_pp3: number", "");
goTo.marker('17');
verify.completionListContains("b", "(parameter) b: number", "number to add");
verify.quickInfoAt("18", "(property) c1.pp3: number", "getter property 2\nsetter property 2");
goTo.marker('19');
verify.completionListContains("p1", "(property) c1.p1: number", "p1 is property of c1");
verify.completionListContains("p2", "(method) c1.p2(b: number): number", "sum with property");
verify.completionListContains("p3", "(property) c1.p3: number", "getter property 1\nsetter property 1");
verify.completionListContains("pp1", "(property) c1.pp1: number", "pp1 is property of c1");
verify.completionListContains("pp2", "(method) c1.pp2(b: number): number", "sum with property");
verify.completionListContains("pp3", "(property) c1.pp3: number", "getter property 2\nsetter property 2");
verify.completionListContains("nc_p1", "(property) c1.nc_p1: number", "");
verify.completionListContains("nc_p2", "(method) c1.nc_p2(b: number): number", "");
verify.completionListContains("nc_p3", "(property) c1.nc_p3: number", "");
verify.completionListContains("nc_pp1", "(property) c1.nc_pp1: number", "");
verify.completionListContains("nc_pp2", "(method) c1.nc_pp2(b: number): number", "");
verify.completionListContains("nc_pp3", "(property) c1.nc_pp3: number", "");
verify.signatureHelp({ marker: "20", docComment: "sum with property", parameterDocComment: "number to add" });
verify.quickInfoAt("20q", "(method) c1.pp2(b: number): number", "sum with property");
goTo.marker('21');
verify.completionListContains("p1", "(property) c1.p1: number", "p1 is property of c1");
verify.completionListContains("p2", "(method) c1.p2(b: number): number", "sum with property");
verify.completionListContains("p3", "(property) c1.p3: number", "getter property 1\nsetter property 1");
verify.completionListContains("pp1", "(property) c1.pp1: number", "pp1 is property of c1");
verify.completionListContains("pp2", "(method) c1.pp2(b: number): number", "sum with property");
verify.completionListContains("pp3", "(property) c1.pp3: number", "getter property 2\nsetter property 2");
verify.completionListContains("nc_p1", "(property) c1.nc_p1: number", "");
verify.completionListContains("nc_p2", "(method) c1.nc_p2(b: number): number", "");
verify.completionListContains("nc_p3", "(property) c1.nc_p3: number", "");
verify.completionListContains("nc_pp1", "(property) c1.nc_pp1: number", "");
verify.completionListContains("nc_pp2", "(method) c1.nc_pp2(b: number): number", "");
verify.completionListContains("nc_pp3", "(property) c1.nc_pp3: number", "");
verify.quickInfoAt("22", "(property) c1.pp3: number", "getter property 2\nsetter property 2");
goTo.marker('23');
verify.completionListContains("p1", "(property) c1.p1: number", "p1 is property of c1");
verify.completionListContains("p2", "(method) c1.p2(b: number): number", "sum with property");
verify.completionListContains("p3", "(property) c1.p3: number", "getter property 1\nsetter property 1");
verify.completionListContains("pp1", "(property) c1.pp1: number", "pp1 is property of c1");
verify.completionListContains("pp2", "(method) c1.pp2(b: number): number", "sum with property");
verify.completionListContains("pp3", "(property) c1.pp3: number", "getter property 2\nsetter property 2");
verify.completionListContains("nc_p1", "(property) c1.nc_p1: number", "");
verify.completionListContains("nc_p2", "(method) c1.nc_p2(b: number): number", "");
verify.completionListContains("nc_p3", "(property) c1.nc_p3: number", "");
verify.completionListContains("nc_pp1", "(property) c1.nc_pp1: number", "");
verify.completionListContains("nc_pp2", "(method) c1.nc_pp2(b: number): number", "");
verify.completionListContains("nc_pp3", "(property) c1.nc_pp3: number", "");
goTo.marker('24');
verify.completionListContains("p1", "(property) c1.p1: number", "p1 is property of c1");
verify.completionListContains("p2", "(method) c1.p2(b: number): number", "sum with property");
verify.completionListContains("p3", "(property) c1.p3: number", "getter property 1\nsetter property 1");
verify.completionListContains("pp1", "(property) c1.pp1: number", "pp1 is property of c1");
verify.completionListContains("pp2", "(method) c1.pp2(b: number): number", "sum with property");
verify.completionListContains("pp3", "(property) c1.pp3: number", "getter property 2\nsetter property 2");
verify.completionListContains("nc_p1", "(property) c1.nc_p1: number", "");
verify.completionListContains("nc_p2", "(method) c1.nc_p2(b: number): number", "");
verify.completionListContains("nc_p3", "(property) c1.nc_p3: number", "");
verify.completionListContains("nc_pp1", "(property) c1.nc_pp1: number", "");
verify.completionListContains("nc_pp2", "(method) c1.nc_pp2(b: number): number", "");
verify.completionListContains("nc_pp3", "(property) c1.nc_pp3: number", "");
verify.signatureHelp({ marker: "25", docComment: "sum with property", parameterDocComment: "number to add" });
verify.completionListContains("value", "(parameter) value: number", "this is value");
verify.quickInfos({
15: ["(method) c1.pp2(b: number): number", "sum with property"],
18: ["(property) c1.pp3: number", "getter property 2\nsetter property 2"],
"20q": ["(method) c1.pp2(b: number): number", "sum with property"],
22: ["(property) c1.pp3: number", "getter property 2\nsetter property 2"],
"25q": ["(method) c1.pp2(b: number): number", "sum with property"],
26: ["constructor c1(): c1", "Constructor method"],
27: ["(property) c1.s1: number", "s1 is static property of c1"],
28: ["(method) c1.s2(b: number): number", "static sum with property"]
});
goTo.marker('29');
verify.completionListContains("c1", "class c1", "This is comment for c1");
goTo.marker('30');
verify.completionListContains("s1", "(property) c1.s1: number", "s1 is static property of c1");
verify.completionListContains("s2", "(method) c1.s2(b: number): number", "static sum with property");
verify.completionListContains("s3", "(property) c1.s3: number", "static getter property\nsetter property 3");
verify.completionListContains("nc_s1", "(property) c1.nc_s1: number", "");
verify.completionListContains("nc_s2", "(method) c1.nc_s2(b: number): number", "");
verify.completionListContains("nc_s3", "(property) c1.nc_s3: number", "");
goTo.marker('31');
verify.completionListContains("b", "(parameter) b: number", "number to add");
verify.quickInfoAt("32", "(property) c1.s3: number", "static getter property\nsetter property 3");
goTo.marker('33');
verify.completionListContains("c1", "class c1", "This is comment for c1");
goTo.marker('34');
verify.completionListContains("s1", "(property) c1.s1: number", "s1 is static property of c1");
verify.completionListContains("s2", "(method) c1.s2(b: number): number", "static sum with property");
verify.completionListContains("s3", "(property) c1.s3: number", "static getter property\nsetter property 3");
verify.completionListContains("nc_s1", "(property) c1.nc_s1: number", "");
verify.completionListContains("nc_s2", "(method) c1.nc_s2(b: number): number", "");
verify.completionListContains("nc_s3", "(property) c1.nc_s3: number", "");
verify.signatureHelp({ marker: "35", docComment: "static sum with property", parameterDocComment: "number to add" });
verify.completionListContains("c1", "class c1", "This is comment for c1");
verify.quickInfoAt("35q", "(method) c1.s2(b: number): number", "static sum with property");
goTo.marker('36');
verify.completionListContains("s1", "(property) c1.s1: number", "s1 is static property of c1");
verify.completionListContains("s2", "(method) c1.s2(b: number): number", "static sum with property");
verify.completionListContains("s3", "(property) c1.s3: number", "static getter property\nsetter property 3");
verify.completionListContains("nc_s1", "(property) c1.nc_s1: number", "");
verify.completionListContains("nc_s2", "(method) c1.nc_s2(b: number): number", "");
verify.completionListContains("nc_s3", "(property) c1.nc_s3: number", "");
verify.quickInfoAt("37", "(property) c1.s3: number", "static getter property\nsetter property 3");
goTo.marker('38');
verify.completionListContains("c1", "class c1", "This is comment for c1");
goTo.marker('39');
verify.completionListContains("s1", "(property) c1.s1: number", "s1 is static property of c1");
verify.completionListContains("s2", "(method) c1.s2(b: number): number", "static sum with property");
verify.completionListContains("s3", "(property) c1.s3: number", "static getter property\nsetter property 3");
verify.completionListContains("nc_s1", "(property) c1.nc_s1: number", "");
verify.completionListContains("nc_s2", "(method) c1.nc_s2(b: number): number", "");
verify.completionListContains("nc_s3", "(property) c1.nc_s3: number", "");
goTo.marker('40');
verify.completionListContains("c1", "class c1", "This is comment for c1");
goTo.marker('41');
verify.completionListContains("s1", "(property) c1.s1: number", "s1 is static property of c1");
verify.completionListContains("s2", "(method) c1.s2(b: number): number", "static sum with property");
verify.completionListContains("s3", "(property) c1.s3: number", "static getter property\nsetter property 3");
verify.completionListContains("nc_s1", "(property) c1.nc_s1: number", "");
verify.completionListContains("nc_s2", "(method) c1.nc_s2(b: number): number", "");
verify.completionListContains("nc_s3", "(property) c1.nc_s3: number", "");
verify.signatureHelp({ marker: "42", docComment: "static sum with property", parameterDocComment: "number to add" });
verify.completionListContains("value", "(parameter) value: number", "this is value");
verify.quickInfos({
28: ["(method) c1.s2(b: number): number", "static sum with property"],
32: ["(property) c1.s3: number", "static getter property\nsetter property 3"],
"35q": ["(method) c1.s2(b: number): number", "static sum with property"],
37: ["(property) c1.s3: number", "static getter property\nsetter property 3"],
"42q": ["(method) c1.s2(b: number): number", "static sum with property"],
43: "(property) c1.nc_p1: number",
44: "(method) c1.nc_p2(b: number): number"
});
goTo.marker('45');
verify.completionListContains("b", "(parameter) b: number", "");
verify.quickInfoAt("46", "(property) c1.nc_p3: number");
verify.signatureHelp({ marker: "47", docComment: "" });
verify.quickInfos({
44: "(method) c1.nc_p2(b: number): number",
46: "(property) c1.nc_p3: number",
"47q": "(method) c1.nc_p2(b: number): number",
48: "(property) c1.nc_p3: number"
});
verify.signatureHelp({ marker: "49", docComment: "" });
verify.completionListContains("value", "(parameter) value: number", "");
verify.quickInfos({
48: "(property) c1.nc_p3: number",
"49q": "(method) c1.nc_p2(b: number): number",
50: "(property) c1.nc_pp1: number",
51: "(method) c1.nc_pp2(b: number): number"
});
goTo.marker('52');
verify.completionListContains("b", "(parameter) b: number", "");
verify.quickInfoAt("53", "(property) c1.nc_pp3: number");
verify.signatureHelp({ marker: "54", docComment: "" });
verify.quickInfos({
51: "(method) c1.nc_pp2(b: number): number",
53: "(property) c1.nc_pp3: number",
"54q": "(method) c1.nc_pp2(b: number): number",
55: "(property) c1.nc_pp3: number"
});
verify.signatureHelp({ marker: "56", docComment: "" });
verify.completionListContains("value", "(parameter) value: number", "");
verify.quickInfos({
55: "(property) c1.nc_pp3: number",
"56q": "(method) c1.nc_pp2(b: number): number",
57: "(property) c1.nc_s1: number",
58: "(method) c1.nc_s2(b: number): number"
});
goTo.marker('59');
verify.completionListContains("b", "(parameter) b: number", "");
verify.quickInfoAt("60", "(property) c1.nc_s3: number");
verify.signatureHelp({ marker: "61", docComment: "" });
verify.quickInfos({
58: "(method) c1.nc_s2(b: number): number",
60: "(property) c1.nc_s3: number",
"61q": "(method) c1.nc_s2(b: number): number",
62: "(property) c1.nc_s3: number"
});
verify.signatureHelp({ marker: "63", docComment: "" });
verify.completionListContains("value", "(parameter) value: number", "");
verify.quickInfos({
62: "(property) c1.nc_s3: number",
"63q": "(method) c1.nc_s2(b: number): number",
64: "var i1: c1"
});
verify.signatureHelp({ marker: "65", docComment: "Constructor method" });
verify.quickInfos({
64: "var i1: c1",
"65q": ["constructor c1(): c1", "Constructor method"],
66: "var i1_p: number"
});
goTo.marker("67");
verify.quickInfoIs("(property) c1.p1: number", "p1 is property of c1");
verify.completionListContains("p1", "(property) c1.p1: number", "p1 is property of c1");
verify.completionListContains("p2", "(method) c1.p2(b: number): number", "sum with property");
verify.completionListContains("p3", "(property) c1.p3: number", "getter property 1\nsetter property 1");
verify.completionListContains("nc_p1", "(property) c1.nc_p1: number", "");
verify.completionListContains("nc_p2", "(method) c1.nc_p2(b: number): number", "");
verify.completionListContains("nc_p3", "(property) c1.nc_p3: number", "");
verify.quickInfos({
66: "var i1_p: number",
68: "var i1_f: (b: number) => number",
69: ["(method) c1.p2(b: number): number", "sum with property"],
70: "var i1_r: number"
});
verify.signatureHelp({ marker: "71", docComment: "sum with property", parameterDocComment: "number to add" });
verify.quickInfos({
70: "var i1_r: number",
"71q": ["(method) c1.p2(b: number): number", "sum with property"],
72: "var i1_prop: number",
73: ["(property) c1.p3: number", "getter property 1\nsetter property 1"],
@@ -477,42 +298,17 @@ verify.quickInfos({
77: "(property) c1.nc_p1: number",
78: "var i1_ncf: (b: number) => number",
79: "(method) c1.nc_p2(b: number): number",
80: "var i1_ncr: number"
});
verify.signatureHelp({ marker: "81", docComment: "" });
verify.quickInfos({
80: "var i1_ncr: number",
"81q": "(method) c1.nc_p2(b: number): number",
82: "var i1_ncprop: number",
83: "(property) c1.nc_p3: number",
84: "(property) c1.nc_p3: number",
85: "var i1_ncprop: number",
86: "var i1_s_p: number"
});
goTo.marker('87');
verify.quickInfoIs("class c1", "This is comment for c1");
verify.completionListContains("c1", "class c1", "This is comment for c1");
goTo.marker('88');
verify.quickInfoIs("(property) c1.s1: number", "s1 is static property of c1");
verify.completionListContains("s1", "(property) c1.s1: number", "s1 is static property of c1");
verify.completionListContains("s2", "(method) c1.s2(b: number): number", "static sum with property");
verify.completionListContains("s3", "(property) c1.s3: number", "static getter property\nsetter property 3");
verify.completionListContains("nc_s1", "(property) c1.nc_s1: number", "");
verify.completionListContains("nc_s2", "(method) c1.nc_s2(b: number): number", "");
verify.completionListContains("nc_s3", "(property) c1.nc_s3: number", "");
verify.quickInfos({
86: "var i1_s_p: number",
87: ["class c1", "This is comment for c1"],
89: "var i1_s_f: (b: number) => number",
90: ["(method) c1.s2(b: number): number", "static sum with property"],
91: "var i1_s_r: number"
});
verify.signatureHelp({ marker: "92", docComment: "static sum with property", parameterDocComment: "number to add" });
verify.quickInfos({
91: "var i1_s_r: number",
"92q": ["(method) c1.s2(b: number): number", "static sum with property"],
93: "var i1_s_prop: number",
94: ["(property) c1.s3: number", "static getter property\nsetter property 3"],
@@ -522,69 +318,25 @@ verify.quickInfos({
98: "(property) c1.nc_s1: number",
99: "var i1_s_ncf: (b: number) => number",
100: "(method) c1.nc_s2(b: number): number",
101: "var i1_s_ncr: number"
});
verify.signatureHelp({ marker: "102", docComment: "" });
verify.quickInfos({
101: "var i1_s_ncr: number",
"102q": "(method) c1.nc_s2(b: number): number",
103: "var i1_s_ncprop: number",
104: "(property) c1.nc_s3: number",
105: "(property) c1.nc_s3: number",
106: "var i1_s_ncprop: number",
107: "var i1_c: typeof c1",
108: ["class c1", "This is comment for c1"]
});
goTo.marker('109');
verify.completionListContains("c1", "class c1", "This is comment for c1");
verify.completionListContains("i1", "var i1: c1", "");
verify.completionListContains("i1_p", "var i1_p: number", "");
verify.completionListContains("i1_f", "var i1_f: (b: number) => number", "");
verify.completionListContains("i1_r", "var i1_r: number", "");
verify.completionListContains("i1_prop", "var i1_prop: number", "");
verify.completionListContains("i1_nc_p", "var i1_nc_p: number", "");
verify.completionListContains("i1_ncf", "var i1_ncf: (b: number) => number", "");
verify.completionListContains("i1_ncr", "var i1_ncr: number", "");
verify.completionListContains("i1_ncprop", "var i1_ncprop: number", "");
verify.completionListContains("i1_s_p", "var i1_s_p: number", "");
verify.completionListContains("i1_s_f", "var i1_s_f: (b: number) => number", "");
verify.completionListContains("i1_s_r", "var i1_s_r: number", "");
verify.completionListContains("i1_s_prop", "var i1_s_prop: number", "");
verify.completionListContains("i1_s_nc_p", "var i1_s_nc_p: number", "");
verify.completionListContains("i1_s_ncf", "var i1_s_ncf: (b: number) => number", "");
verify.completionListContains("i1_s_ncr", "var i1_s_ncr: number", "");
verify.completionListContains("i1_s_ncprop", "var i1_s_ncprop: number", "");
verify.completionListContains("i1_c", "var i1_c: typeof c1", "");
goTo.marker('110');
verify.quickInfoIs("(property) cProperties.p2: number", "setter only property");
verify.completionListContains("p1", "(property) cProperties.p1: number", "getter only property");
verify.completionListContains("p2", "(property) cProperties.p2: number", "setter only property");
verify.completionListContains("nc_p1", "(property) cProperties.nc_p1: number", "");
verify.completionListContains("nc_p2", "(property) cProperties.nc_p2: number", "");
verify.quickInfos({
108: ["class c1", "This is comment for c1"],
110: ["(property) cProperties.p2: number", "setter only property"],
111: ["(property) cProperties.p1: number", "getter only property"],
112: "(property) cProperties.nc_p2: number",
113: "(property) cProperties.nc_p1: number"
});
goTo.marker('114');
verify.completionListContains("a", "(property) cWithConstructorProperty.a: number", "more info about a\nthis is first parameter a");
verify.quickInfoIs("(property) cWithConstructorProperty.a: number", "more info about a\nthis is first parameter a");
goTo.marker('115');
verify.completionListContains("a", "(parameter) a: number", "more info about a\nthis is first parameter a");
verify.quickInfoIs("(parameter) a: number", "more info about a\nthis is first parameter a");
verify.quickInfos({
113: "(property) cProperties.nc_p1: number",
114: ["(property) cWithConstructorProperty.a: number", "more info about a\nthis is first parameter a"],
115: ["(parameter) a: number", "more info about a\nthis is first parameter a"],
116: "this: this",
117: "(local var) bbbb: number",
118: "(local var) bbbb: number",
119: [
"constructor cWithConstructorProperty(a: number): cWithConstructorProperty",
"this is class cWithConstructorProperty's constructor"
]
],
});
tests/cases/fourslash/commentsCommentParsing.ts
+80 -19
View File
@@ -280,10 +280,13 @@ verify.signatureHelp({
});
verify.quickInfoAt("17aq", "(parameter) b: number", "second number");
goTo.marker('18');
verify.quickInfoIs("(parameter) a: number", "first number");
verify.completionListContains("a", "(parameter) a: number", "first number");
verify.completionListContains("b", "(parameter) b: number", "second number");
verify.completions({
marker: "18",
includes: [
{ name: "a", text: "(parameter) a: number", documentation: "first number", tags: [{ name: "param", text: "a first number" }] },
{ name: "b", text: "(parameter) b: number", documentation: "second number", tags: [{ name: "param", text: "b second number" }] },
],
});
const multiplyTags: ReadonlyArray<FourSlashInterface.JSDocTagInfo> = [
{ name: "param", text: "" },
@@ -316,9 +319,18 @@ verify.quickInfoAt("22aq", "(parameter) d: any");
verify.signatureHelp({ marker: "23", docComment: "This is multiplication function", parameterDocComment: "LastParam", tags: multiplyTags });
verify.quickInfoAt("23aq", "(parameter) e: any", "LastParam");
goTo.marker('24');
verify.completionListContains("aOrb", "(parameter) aOrb: any", "");
verify.completionListContains("opt", "(parameter) opt: any", "optional parameter");
verify.completions({
marker: "24",
includes: [
{ name: "aOrb", text: "(parameter) aOrb: any" },
{
name: "opt",
text: "(parameter) opt: any",
documentation: "optional parameter",
tags: [{ name: "param", text: "opt optional parameter" }],
},
]
});
verify.signatureHelp({
marker: "25",
@@ -337,9 +349,32 @@ verify.quickInfos({
"26aq": "(parameter) b: string"
});
goTo.marker('27');
verify.completionListContains("multiply", "function multiply(a: number, b: number, c?: number, d?: any, e?: any): void", "This is multiplication function");
verify.completionListContains("f1", "function f1(a: number): any (+1 overload)", "fn f1 with number");
verify.completions({
marker: "27",
includes: [
{
name: "multiply",
text: "function multiply(a: number, b: number, c?: number, d?: any, e?: any): void",
documentation: "This is multiplication function",
tags: [
{ name: "param", text: "" },
{ name: "param", text: "a first number" },
{ name: "param", text: "b" },
{ name: "param", text: "c" },
{ name: "param", text: "d" },
{ name: "anotherTag", text: undefined },
{ name: "param", text: "e LastParam" },
{ name: "anotherTag", text: undefined },
],
},
{
name: "f1",
text: "function f1(a: number): any (+1 overload)",
documentation: "fn f1 with number",
tags: [{ name: "param", text: "b about b" }],
},
],
});
const subtractDoc = "This is subtract function";
const subtractTags: ReadonlyArray<FourSlashInterface.JSDocTagInfo> = [
@@ -429,11 +464,25 @@ verify.quickInfos({
verify.signatureHelp({ marker: "38", docComment: concatDoc, parameterDocComment: "is second string", tags: concatTags });
verify.quickInfoAt("38aq", "(parameter) bar: string", "is second string");
goTo.marker('39');
verify.completionListContains("a", "(parameter) a: number", "this is inline comment for a\nit is first parameter");
verify.completionListContains("b", "(parameter) b: number", "this is inline comment for b");
verify.completionListContains("c", "(parameter) c: number", "it is third parameter");
verify.completionListContains("d", "(parameter) d: number", "");
verify.completions({
marker: "39",
includes: [
{
name: "a",
text: "(parameter) a: number",
documentation: "this is inline comment for a\nit is first parameter",
tags: [{ name: "param", text: "a it is first parameter" }],
},
{ name: "b", text: "(parameter) b: number", documentation: "this is inline comment for b" },
{
name: "c",
text: "(parameter) c: number",
documentation: "it is third parameter",
tags: [{ name: "param", text: "c it is third parameter" }],
},
{ name: "d", text: "(parameter) d: number" },
],
});
const jsdocTestDocComment = "this is jsdoc style function with param tag as well as inline parameter help";
const jsdocTestTags: ReadonlyArray<FourSlashInterface.JSDocTagInfo> = [
@@ -461,10 +510,22 @@ verify.quickInfoAt("42aq", "(parameter) c: number", "it is third parameter");
verify.signatureHelp({ marker: "43", docComment: jsdocTestDocComment, tags: jsdocTestTags });
verify.quickInfoAt("43aq", "(parameter) d: number");
goTo.marker('44');
verify.completionListContains("jsDocParamTest", "function jsDocParamTest(a: number, b: number, c: number, d: number): number", jsdocTestDocComment);
verify.completionListContains("x", "var x: any", "This is a comment");
verify.completionListContains("y", "var y: any", "This is a comment");
verify.completions({
marker: "44",
includes: [
{
name: "jsDocParamTest",
text: "function jsDocParamTest(a: number, b: number, c: number, d: number): number",
documentation: jsdocTestDocComment,
tags: [
{ name: "param", text: "a it is first parameter" },
{ name: "param", text: "c it is third parameter" },
],
},
{ name: "x", text: "var x: any", documentation: "This is a comment" },
{ name: "y", text: "var y: any", documentation: "This is a comment" },
],
});
verify.signatureHelp({ marker: "45", docComment: "This is function comment\nAnd properly aligned comment" });
verify.quickInfoAt("45q", "function jsDocCommentAlignmentTest1(): void", "This is function comment\nAnd properly aligned comment");
tests/cases/fourslash/commentsEnums.ts
+18 -17
View File
@@ -14,22 +14,23 @@ verify.quickInfos({
1: ["enum Colors", "Enum of colors"],
2: ["(enum member) Colors.Cornflower = 0", "Fancy name for 'blue'"],
3: ["(enum member) Colors.FancyPink = 1", "Fancy name for 'pink'"],
4: "var x: Colors"
4: "var x: Colors",
5: ["enum Colors", "Enum of colors"],
6: ["(enum member) Colors.Cornflower = 0", "Fancy name for 'blue'"],
7: ["(enum member) Colors.FancyPink = 1", "Fancy name for 'pink'"],
});
verify.completions({
marker: "5",
includes: { name: "Colors", text: "enum Colors", documentation: "Enum of colors" },
isNewIdentifierLocation: true,
});
verify.quickInfoIs("enum Colors", "Enum of colors");
const completions = [
{ name: "Cornflower", text: "(enum member) Colors.Cornflower = 0", documentation: "Fancy name for 'blue'" },
{ name: "FancyPink", text: "(enum member) Colors.FancyPink = 1", documentation: "Fancy name for 'pink'" },
];
verify.completions({ marker: "6", includes: completions });
verify.quickInfoIs("(enum member) Colors.Cornflower = 0", "Fancy name for 'blue'");
verify.completions({ marker: "7", includes: completions });
verify.quickInfoIs("(enum member) Colors.FancyPink = 1", "Fancy name for 'pink'");
verify.completions(
{
marker: "5",
includes: { name: "Colors", text: "enum Colors", documentation: "Enum of colors" },
isNewIdentifierLocation: true,
},
{
marker: ["6", "7"],
exact: [
{ name: "Cornflower", text: "(enum member) Colors.Cornflower = 0", documentation: "Fancy name for 'blue'" },
{ name: "FancyPink", text: "(enum member) Colors.FancyPink = 1", documentation: "Fancy name for 'pink'" },
]
},
);
tests/cases/fourslash/commentsExternalModules.ts
+51 -25
View File
@@ -34,49 +34,75 @@
goTo.file("commentsExternalModules_file0.ts");
verify.quickInfoAt("1", "namespace m1", "Namespace comment");
goTo.marker('2');
verify.completionListContains("b", "var b: number", "b's comment");
verify.completionListContains("foo", "function foo(): number", "foo's comment");
verify.completions({
marker: "2",
includes: [
{ name: "b", text: "var b: number", documentation: "b's comment" },
{ name: "foo", text: "function foo(): number", documentation: "foo's comment" },
]
});
verify.signatureHelp({ marker: "3", docComment: "foo's comment" });
verify.quickInfoAt("3q", "function foo(): number", "foo's comment");
goTo.marker('4');
verify.completionListContains("m1", "namespace m1", "Namespace comment");
verify.completions({
marker: "4",
includes: { name: "m1", text: "namespace m1", documentation: "Namespace comment" },
});
goTo.marker('5');
verify.completionListContains("b", "var m1.b: number", "b's comment");
verify.completionListContains("fooExport", "function m1.fooExport(): number", "exported function");
verify.completionListContains("m2", "namespace m1.m2");
verify.completions({
marker: "5",
includes: [
{ name: "b", text: "var m1.b: number", documentation: "b's comment" },
{ name: "fooExport", text: "function m1.fooExport(): number", documentation: "exported function" },
{ name: "m2", text: "namespace m1.m2", documentation: "m2 comments" },
],
});
verify.signatureHelp({ marker: "6", docComment: "exported function" });
verify.quickInfoAt("6q", "function m1.fooExport(): number", "exported function");
verify.quickInfoAt("7", "var myvar: m1.m2.c");
goTo.marker('8');
verify.completionListContains("c", "constructor m1.m2.c(): m1.m2.c", "class comment;");
verify.completionListContains("i", "var m1.m2.i: m1.m2.c", "i");
verify.completions({
marker: "8",
includes: [
{ name: "c", text: "constructor m1.m2.c(): m1.m2.c", documentation: "class comment;" },
{ name: "i", text: "var m1.m2.i: m1.m2.c", documentation: "i" },
],
});
goTo.file("commentsExternalModules_file1.ts");
verify.quickInfoAt("9", 'import extMod = require("./commentsExternalModules_file0")', "This is on import declaration");
goTo.marker('10');
verify.completionListContains("extMod", 'import extMod = require("./commentsExternalModules_file0")', "This is on import declaration");
goTo.marker('11');
verify.completionListContains("m1", "namespace extMod.m1");
goTo.marker('12');
verify.completionListContains("b", "var extMod.m1.b: number", "b's comment");
verify.completionListContains("fooExport", "function extMod.m1.fooExport(): number", "exported function");
verify.completionListContains("m2", "namespace extMod.m1.m2");
verify.completions(
{
marker: "10",
includes: { name: "extMod", text: 'import extMod = require("./commentsExternalModules_file0")', documentation: "This is on import declaration" },
},
{
marker: "11",
includes: { name: "m1", text: "namespace extMod.m1", documentation: "Namespace comment" },
},
{
marker: "12",
includes: [
{ name: "b", text: "var extMod.m1.b: number", documentation: "b's comment" },
{ name: "fooExport", text: "function extMod.m1.fooExport(): number", documentation: "exported function" },
{ name: "m2", text: "namespace extMod.m1.m2", documentation: "m2 comments" },
],
},
);
verify.signatureHelp({ marker: "13", docComment: "exported function" });
verify.quickInfoAt("13q", "function extMod.m1.fooExport(): number", "exported function");
verify.quickInfoAt("14", "var newVar: extMod.m1.m2.c");
goTo.marker('15');
verify.completionListContains("c", "constructor extMod.m1.m2.c(): extMod.m1.m2.c", "class comment;");
verify.completionListContains("i", "var extMod.m1.m2.i: extMod.m1.m2.c", "i");
verify.completions({
marker: "15",
exact: [
{ name: "c", text: "constructor extMod.m1.m2.c(): extMod.m1.m2.c", documentation: "class comment;" },
{ name: "i", text: "var extMod.m1.m2.i: extMod.m1.m2.c", documentation: "i" },
],
});
tests/cases/fourslash/commentsFunctionDeclaration.ts
+13 -6
View File
@@ -24,8 +24,7 @@ verify.quickInfoAt("1", "function foo(): void", "This comment should appear for
verify.quickInfoAt("2", "function foo(): void", "This comment should appear for foo");
goTo.marker('3');
verify.completionListContains('foo', 'function foo(): void', 'This comment should appear for foo');
verify.completions({ marker: "3", includes: { name: "foo", text: "function foo(): void", documentation: "This comment should appear for foo" }})
verify.signatureHelp({ marker: "4", docComment: "This comment should appear for foo" });
@@ -33,14 +32,22 @@ verify.quickInfoAt("5", "function fooWithParameters(a: string, b: number): void"
verify.quickInfoAt("6", "(local var) d: string");
goTo.marker('7');
verify.completionListContains('a', '(parameter) a: string', 'this is comment about a');
verify.completionListContains('b', '(parameter) b: number', 'this is comment for b');
verify.completions({
marker: "7",
includes: [
{ name: "a", text: "(parameter) a: string", documentation: "this is comment about a" },
{ name: "b", text: "(parameter) b: number", documentation: "this is comment for b" },
],
isNewIdentifierLocation: true,
});
verify.quickInfoAt("8", "function fooWithParameters(a: string, b: number): void", "This is comment for function signature");
goTo.marker('9');
verify.completionListContains('fooWithParameters', 'function fooWithParameters(a: string, b: number): void', 'This is comment for function signature');
verify.completions({
marker: "9",
includes: { name: "fooWithParameters", text: "function fooWithParameters(a: string, b: number): void", documentation: "This is comment for function signature" }
})
verify.signatureHelp(
{ marker: "10", docComment: "This is comment for function signature", parameterDocComment: "this is comment about a" },
tests/cases/fourslash/commentsFunctionExpression.ts
+40 -10
View File
@@ -34,16 +34,24 @@
verify.quickInfoAt("1", "var lambdaFoo: (a: number, b: number) => number", "this is lambda comment\nlambdaFoo var comment");
goTo.marker('2');
verify.completionListContains('a', '(parameter) a: number', 'param a');
verify.completionListContains('b', '(parameter) b: number', 'param b');
verify.completions({
marker: "2",
includes: [
{ name: "a", text: "(parameter) a: number", documentation: "param a" },
{ name: "b", text: "(parameter) b: number", documentation: "param b" },
],
});
// pick up doccomments from the lambda itself
verify.quickInfoAt("3", "var lambddaNoVarComment: (a: number, b: number) => number", "this is lambda multiplication");
goTo.marker('4');
verify.completionListContains('lambdaFoo', 'var lambdaFoo: (a: number, b: number) => number', "this is lambda comment\nlambdaFoo var comment");
verify.completionListContains('lambddaNoVarComment', 'var lambddaNoVarComment: (a: number, b: number) => number', 'this is lambda multiplication');
verify.completions({
marker: "4",
includes: [
{ name: "lambdaFoo", text: "var lambdaFoo: (a: number, b: number) => number", documentation: "this is lambda comment\nlambdaFoo var comment" },
{ name: "lambddaNoVarComment", text: "var lambddaNoVarComment: (a: number, b: number) => number", documentation: "this is lambda multiplication" },
]
});
verify.signatureHelp(
{
@@ -73,11 +81,33 @@ verify.quickInfos({
]
});
goTo.marker('15');
verify.completionListContains('s', '(parameter) s: string', "On parameter\nparam on expression\nthe first parameter!");
verify.completions({
marker: "15",
includes: {
name: "s",
text: "(parameter) s: string",
documentation: "On parameter\nparam on expression\nthe first parameter!",
tags: [
{ name: "param", text: "s param on expression" },
{ name: "param", text: "s the first parameter!" },
],
},
});
verify.quickInfoAt("16", "var assigned: (s: string) => number", "Summary on expression\nOn variable");
goTo.marker('17');
verify.completionListContains("assigned", "var assigned: (s: string) => number", "Summary on expression\nOn variable");
verify.completions({
marker: "17",
includes: [{
name: "assigned",
text: "var assigned: (s: string) => number",
documentation: "Summary on expression\nOn variable",
tags: [
{ name: "param", text: "s param on expression" },
{ name: "returns", text: "return on expression" },
{ name: "param", text: "s the first parameter!" },
{ name: "returns", text: "the parameter's length" },
],
},
]});
verify.signatureHelp({
marker: "18",
docComment: "Summary on expression\nOn variable",
tests/cases/fourslash/commentsInheritance.ts
+181 -142
View File
@@ -220,19 +220,23 @@
//// }
////}
goTo.marker('1');
verify.completionListContains("i1_p1", "(property) i1.i1_p1: number", "i1_p1");
verify.completionListContains("i1_f1", "(method) i1.i1_f1(): void", "i1_f1");
verify.completionListContains("i1_l1", "(property) i1.i1_l1: () => void", "i1_l1");
verify.completionListContains("i1_nc_p1", "(property) i1.i1_nc_p1: number", "");
verify.completionListContains("i1_nc_f1", "(method) i1.i1_nc_f1(): void", "");
verify.completionListContains("i1_nc_l1", "(property) i1.i1_nc_l1: () => void", "");
verify.completionListContains("p1", "(property) i1.p1: number", "");
verify.completionListContains("f1", "(method) i1.f1(): void", "");
verify.completionListContains("l1", "(property) i1.l1: () => void", "");
verify.completionListContains("nc_p1", "(property) i1.nc_p1: number", "");
verify.completionListContains("nc_f1", "(method) i1.nc_f1(): void", "");
verify.completionListContains("nc_l1", "(property) i1.nc_l1: () => void", "");
verify.completions({
marker: ["1", "11"],
includes: [
{ name: "i1_p1", text: "(property) i1.i1_p1: number", documentation: "i1_p1" },
{ name: "i1_f1", text: "(method) i1.i1_f1(): void", documentation: "i1_f1" },
{ name: "i1_l1", text: "(property) i1.i1_l1: () => void", documentation: "i1_l1" },
{ name: "i1_nc_p1", text: "(property) i1.i1_nc_p1: number" },
{ name: "i1_nc_f1", text: "(method) i1.i1_nc_f1(): void" },
{ name: "i1_nc_l1", text: "(property) i1.i1_nc_l1: () => void" },
{ name: "p1", text: "(property) i1.p1: number" },
{ name: "f1", text: "(method) i1.f1(): void" },
{ name: "l1", text: "(property) i1.l1: () => void" },
{ name: "nc_p1", text: "(property) i1.nc_p1: number" },
{ name: "nc_f1", text: "(method) i1.nc_f1(): void" },
{ name: "nc_l1", text: "(property) i1.nc_l1: () => void" },
],
});
verify.signatureHelp(
{ marker: "2", docComment: "i1_f1" },
{ marker: ["3", "4", "5", "l2", "l3", "l4", "l5"], docComment: "" },
@@ -250,19 +254,23 @@ verify.quickInfos({
l5q: "(property) i1.nc_l1: () => void"
});
goTo.marker('6');
verify.completionListContains("i1_p1", "(property) c1.i1_p1: number", "i1_p1");
verify.completionListContains("i1_f1", "(method) c1.i1_f1(): void", "i1_f1");
verify.completionListContains("i1_l1", "(property) c1.i1_l1: () => void", "i1_l1");
verify.completionListContains("i1_nc_p1", "(property) c1.i1_nc_p1: number", "");
verify.completionListContains("i1_nc_f1", "(method) c1.i1_nc_f1(): void", "");
verify.completionListContains("i1_nc_l1", "(property) c1.i1_nc_l1: () => void", "");
verify.completionListContains("p1", "(property) c1.p1: number", "c1_p1");
verify.completionListContains("f1", "(method) c1.f1(): void", "c1_f1");
verify.completionListContains("l1", "(property) c1.l1: () => void", "c1_l1");
verify.completionListContains("nc_p1", "(property) c1.nc_p1: number", "c1_nc_p1");
verify.completionListContains("nc_f1", "(method) c1.nc_f1(): void", "c1_nc_f1");
verify.completionListContains("nc_l1", "(property) c1.nc_l1: () => void", "c1_nc_l1");
verify.completions({
marker: "6",
includes: [
{ name: "i1_p1", text: "(property) c1.i1_p1: number", documentation: "i1_p1" },
{ name: "i1_f1", text: "(method) c1.i1_f1(): void", documentation: "i1_f1" },
{ name: "i1_l1", text: "(property) c1.i1_l1: () => void", documentation: "i1_l1" },
{ name: "i1_nc_p1", text: "(property) c1.i1_nc_p1: number" },
{ name: "i1_nc_f1", text: "(method) c1.i1_nc_f1(): void" },
{ name: "i1_nc_l1", text: "(property) c1.i1_nc_l1: () => void" },
{ name: "p1", text: "(property) c1.p1: number", documentation: "c1_p1" },
{ name: "f1", text: "(method) c1.f1(): void", documentation: "c1_f1" },
{ name: "l1", text: "(property) c1.l1: () => void", documentation: "c1_l1" },
{ name: "nc_p1", text: "(property) c1.nc_p1: number", documentation: "c1_nc_p1" },
{ name: "nc_f1", text: "(method) c1.nc_f1(): void", documentation: "c1_nc_f1" },
{ name: "nc_l1", text: "(property) c1.nc_l1: () => void", documentation: "c1_nc_l1" },
],
});
verify.signatureHelp(
{ marker: "7", docComment: "i1_f1" },
{ marker: "9", docComment: "c1_f1" },
@@ -284,19 +292,23 @@ verify.quickInfos({
l10q: ["(property) c1.nc_l1: () => void", "c1_nc_l1"],
});
goTo.marker('11');
verify.completionListContains("i1_p1", "(property) i1.i1_p1: number", "i1_p1");
verify.completionListContains("i1_f1", "(method) i1.i1_f1(): void", "i1_f1");
verify.completionListContains("i1_l1", "(property) i1.i1_l1: () => void", "i1_l1");
verify.completionListContains("i1_nc_p1", "(property) i1.i1_nc_p1: number", "");
verify.completionListContains("i1_nc_f1", "(method) i1.i1_nc_f1(): void", "");
verify.completionListContains("i1_nc_l1", "(property) i1.i1_nc_l1: () => void", "");
verify.completionListContains("p1", "(property) i1.p1: number", "");
verify.completionListContains("f1", "(method) i1.f1(): void", "");
verify.completionListContains("l1", "(property) i1.l1: () => void", "");
verify.completionListContains("nc_p1", "(property) i1.nc_p1: number", "");
verify.completionListContains("nc_f1", "(method) i1.nc_f1(): void", "");
verify.completionListContains("nc_l1", "(property) i1.nc_l1: () => void", "");
verify.completions({
marker: "11",
includes: [
{ name: "i1_p1", text: "(property) i1.i1_p1: number", documentation: "i1_p1" },
{ name: "i1_f1", text: "(method) i1.i1_f1(): void", documentation: "i1_f1" },
{ name: "i1_l1", text: "(property) i1.i1_l1: () => void", documentation: "i1_l1" },
{ name: "i1_nc_p1", text: "(property) i1.i1_nc_p1: number" },
{ name: "i1_nc_f1", text: "(method) i1.i1_nc_f1(): void" },
{ name: "i1_nc_l1", text: "(property) i1.i1_nc_l1: () => void" },
{ name: "p1", text: "(property) i1.p1: number" },
{ name: "f1", text: "(method) i1.f1(): void" },
{ name: "l1", text: "(property) i1.l1: () => void" },
{ name: "nc_p1", text: "(property) i1.nc_p1: number" },
{ name: "nc_f1", text: "(method) i1.nc_f1(): void" },
{ name: "nc_l1", text: "(property) i1.nc_l1: () => void" },
],
});
verify.signatureHelp(
{ marker: "12", docComment: "i1_f1" },
{ marker: ["13", "14", "15", "l12", "l13", "l14", "l15"], docComment: "" },
@@ -313,14 +325,21 @@ verify.quickInfos({
l15q: "(property) i1.nc_l1: () => void",
});
goTo.marker('16');
verify.not.completionListContains("i1", "interface i1", "i1 is interface with properties");
verify.completionListContains("i1_i", "var i1_i: i1", "");
verify.completionListContains("c1", "class c1", "");
verify.completionListContains("c1_i", "var c1_i: c1", "");
goTo.marker('16i');
verify.completionListContains("i1", "interface i1", "i1 is interface with properties");
verify.completions(
{
marker: "16",
includes: [
{ name: "i1_i", text: "var i1_i: i1" },
{ name: "c1", text: "class c1" },
{ name: "c1_i", text: "var c1_i: c1" },
],
excludes: "i1",
},
{
marker: "16i",
includes: { name: "i1", text: "interface i1", documentation: "i1 is interface with properties" },
},
);
verify.quickInfos({
"17iq": "var c2_i: c2",
@@ -342,19 +361,23 @@ verify.quickInfos({
"18q": "constructor c3(): c3"
});
goTo.marker('19');
verify.completionListContains("c2_p1", "(property) c2.c2_p1: number", "c2 c2_p1");
verify.completionListContains("c2_f1", "(method) c2.c2_f1(): void", "c2 c2_f1");
verify.completionListContains("c2_prop", "(property) c2.c2_prop: number", "c2 c2_prop");
verify.completionListContains("c2_nc_p1", "(property) c2.c2_nc_p1: number", "");
verify.completionListContains("c2_nc_f1", "(method) c2.c2_nc_f1(): void", "");
verify.completionListContains("c2_nc_prop", "(property) c2.c2_nc_prop: number", "");
verify.completionListContains("p1", "(property) c2.p1: number", "c2 p1");
verify.completionListContains("f1", "(method) c2.f1(): void", "c2 f1");
verify.completionListContains("prop", "(property) c2.prop: number", "c2 prop");
verify.completionListContains("nc_p1", "(property) c2.nc_p1: number", "");
verify.completionListContains("nc_f1", "(method) c2.nc_f1(): void", "");
verify.completionListContains("nc_prop", "(property) c2.nc_prop: number", "");
verify.completions({
marker: ["19", "29"],
includes: [
{ name: "c2_p1", text: "(property) c2.c2_p1: number", documentation: "c2 c2_p1" },
{ name: "c2_f1", text: "(method) c2.c2_f1(): void", documentation: "c2 c2_f1" },
{ name: "c2_prop", text: "(property) c2.c2_prop: number", documentation: "c2 c2_prop" },
{ name: "c2_nc_p1", text: "(property) c2.c2_nc_p1: number" },
{ name: "c2_nc_f1", text: "(method) c2.c2_nc_f1(): void" },
{ name: "c2_nc_prop", text: "(property) c2.c2_nc_prop: number" },
{ name: "p1", text: "(property) c2.p1: number", documentation: "c2 p1" },
{ name: "f1", text: "(method) c2.f1(): void", documentation: "c2 f1" },
{ name: "prop", text: "(property) c2.prop: number", documentation: "c2 prop" },
{ name: "nc_p1", text: "(property) c2.nc_p1: number" },
{ name: "nc_f1", text: "(method) c2.nc_f1(): void" },
{ name: "nc_prop", text: "(property) c2.nc_prop: number" },
],
});
verify.signatureHelp(
{ marker: "20", docComment: "c2 c2_f1" },
{ marker: "22", docComment: "c2 f1" },
@@ -368,19 +391,23 @@ verify.quickInfos({
"23q": "(method) c2.nc_f1(): void"
});
goTo.marker('24');
verify.completionListContains("c2_p1", "(property) c2.c2_p1: number", "c2 c2_p1");
verify.completionListContains("c2_f1", "(method) c2.c2_f1(): void", "c2 c2_f1");
verify.completionListContains("c2_prop", "(property) c2.c2_prop: number", "c2 c2_prop");
verify.completionListContains("c2_nc_p1", "(property) c2.c2_nc_p1: number", "");
verify.completionListContains("c2_nc_f1", "(method) c2.c2_nc_f1(): void", "");
verify.completionListContains("c2_nc_prop", "(property) c2.c2_nc_prop: number", "");
verify.completionListContains("p1", "(property) c3.p1: number", "c3 p1");
verify.completionListContains("f1", "(method) c3.f1(): void", "c3 f1");
verify.completionListContains("prop", "(property) c3.prop: number", "c3 prop");
verify.completionListContains("nc_p1", "(property) c3.nc_p1: number", "");
verify.completionListContains("nc_f1", "(method) c3.nc_f1(): void", "");
verify.completionListContains("nc_prop", "(property) c3.nc_prop: number", "");
verify.completions({
marker: "24",
includes: [
{ name: "c2_p1", text: "(property) c2.c2_p1: number", documentation: "c2 c2_p1" },
{ name: "c2_f1", text: "(method) c2.c2_f1(): void", documentation: "c2 c2_f1" },
{ name: "c2_prop", text: "(property) c2.c2_prop: number", documentation: "c2 c2_prop" },
{ name: "c2_nc_p1", text: "(property) c2.c2_nc_p1: number" },
{ name: "c2_nc_f1", text: "(method) c2.c2_nc_f1(): void" },
{ name: "c2_nc_prop", text: "(property) c2.c2_nc_prop: number" },
{ name: "p1", text: "(property) c3.p1: number", documentation: "c3 p1" },
{ name: "f1", text: "(method) c3.f1(): void", documentation: "c3 f1" },
{ name: "prop", text: "(property) c3.prop: number", documentation: "c3 prop" },
{ name: "nc_p1", text: "(property) c3.nc_p1: number" },
{ name: "nc_f1", text: "(method) c3.nc_f1(): void" },
{ name: "nc_prop", text: "(property) c3.nc_prop: number" },
],
});
verify.signatureHelp(
{ marker: "25", docComment: "c2 c2_f1" },
{ marker: "27", docComment: "c3 f1" },
@@ -394,19 +421,6 @@ verify.quickInfos({
"28q": "(method) c3.nc_f1(): void"
});
goTo.marker('29');
verify.completionListContains("c2_p1", "(property) c2.c2_p1: number", "c2 c2_p1");
verify.completionListContains("c2_f1", "(method) c2.c2_f1(): void", "c2 c2_f1");
verify.completionListContains("c2_prop", "(property) c2.c2_prop: number", "c2 c2_prop");
verify.completionListContains("c2_nc_p1", "(property) c2.c2_nc_p1: number", "");
verify.completionListContains("c2_nc_f1", "(method) c2.c2_nc_f1(): void", "");
verify.completionListContains("c2_nc_prop", "(property) c2.c2_nc_prop: number");
verify.completionListContains("p1", "(property) c2.p1: number", "c2 p1");
verify.completionListContains("f1", "(method) c2.f1(): void", "c2 f1");
verify.completionListContains("prop", "(property) c2.prop: number", "c2 prop");
verify.completionListContains("nc_p1", "(property) c2.nc_p1: number", "");
verify.completionListContains("nc_f1", "(method) c2.nc_f1(): void", "");
verify.completionListContains("nc_prop", "(property) c2.nc_prop: number", "");
verify.signatureHelp(
{ marker: "30", docComment: "c2 c2_f1" },
{ marker: "32", docComment: "c2 f1" },
@@ -426,27 +440,36 @@ verify.quickInfos({
"34q": ["constructor c4(a: number): c4", "c2 constructor"]
});
goTo.marker('35');
verify.completionListContains("c2", "class c2", "");
verify.completionListContains("c2_i", "var c2_i: c2", "");
verify.completionListContains("c3", "class c3", "");
verify.completionListContains("c3_i", "var c3_i: c3", "");
verify.completionListContains("c4", "class c4", "");
verify.completionListContains("c4_i", "var c4_i: c4", "");
goTo.marker('36');
verify.completionListContains("i2_p1", "(property) i2.i2_p1: number", "i2_p1");
verify.completionListContains("i2_f1", "(method) i2.i2_f1(): void", "i2_f1");
verify.completionListContains("i2_l1", "(property) i2.i2_l1: () => void", "i2_l1");
verify.completionListContains("i2_nc_p1", "(property) i2.i2_nc_p1: number", "");
verify.completionListContains("i2_nc_f1", "(method) i2.i2_nc_f1(): void", "");
verify.completionListContains("i2_nc_l1", "(property) i2.i2_nc_l1: () => void", "");
verify.completionListContains("p1", "(property) i2.p1: number", "i2 p1");
verify.completionListContains("f1", "(method) i2.f1(): void", "i2 f1");
verify.completionListContains("l1", "(property) i2.l1: () => void", "i2 l1");
verify.completionListContains("nc_p1", "(property) i2.nc_p1: number", "");
verify.completionListContains("nc_f1", "(method) i2.nc_f1(): void", "");
verify.completionListContains("nc_l1", "(property) i2.nc_l1: () => void", "");
verify.completions(
{
marker: "35",
includes: [
{ name: "c2", text: "class c2" },
{ name: "c2_i", text: "var c2_i: c2" },
{ name: "c3", text: "class c3" },
{ name: "c3_i", text: "var c3_i: c3" },
{ name: "c4", text: "class c4" },
{ name: "c4_i", text: "var c4_i: c4" },
],
},
{
marker: ["36", "46"],
includes: [
{ name: "i2_p1", text: "(property) i2.i2_p1: number", documentation: "i2_p1" },
{ name: "i2_f1", text: "(method) i2.i2_f1(): void", documentation: "i2_f1" },
{ name: "i2_l1", text: "(property) i2.i2_l1: () => void", documentation: "i2_l1" },
{ name: "i2_nc_p1", text: "(property) i2.i2_nc_p1: number" },
{ name: "i2_nc_f1", text: "(method) i2.i2_nc_f1(): void" },
{ name: "i2_nc_l1", text: "(property) i2.i2_nc_l1: () => void" },
{ name: "p1", text: "(property) i2.p1: number", documentation: "i2 p1" },
{ name: "f1", text: "(method) i2.f1(): void", documentation: "i2 f1" },
{ name: "l1", text: "(property) i2.l1: () => void", documentation: "i2 l1" },
{ name: "nc_p1", text: "(property) i2.nc_p1: number" },
{ name: "nc_f1", text: "(method) i2.nc_f1(): void" },
{ name: "nc_l1", text: "(property) i2.nc_l1: () => void" },
],
},
);
verify.signatureHelp(
{ marker: "37", docComment: "i2_f1" },
{ marker: "39", docComment: "i2 f1" },
@@ -466,19 +489,23 @@ verify.quickInfos({
"l40q": "(property) i2.nc_l1: () => void",
});
goTo.marker('41');
verify.completionListContains("i2_p1", "(property) i2.i2_p1: number", "i2_p1");
verify.completionListContains("i2_f1", "(method) i2.i2_f1(): void", "i2_f1");
verify.completionListContains("i2_l1", "(property) i2.i2_l1: () => void", "i2_l1");
verify.completionListContains("i2_nc_p1", "(property) i2.i2_nc_p1: number", "");
verify.completionListContains("i2_nc_f1", "(method) i2.i2_nc_f1(): void", "");
verify.completionListContains("i2_nc_l1", "(property) i2.i2_nc_l1: () => void", "");
verify.completionListContains("p1", "(property) i3.p1: number", "i3 p1");
verify.completionListContains("f1", "(method) i3.f1(): void", "i3 f1");
verify.completionListContains("l1", "(property) i3.l1: () => void", "i3 l1");
verify.completionListContains("nc_p1", "(property) i3.nc_p1: number", "");
verify.completionListContains("nc_f1", "(method) i3.nc_f1(): void", "");
verify.completionListContains("nc_l1", "(property) i3.nc_l1: () => void", "");
verify.completions({
marker: "41",
includes: [
{ name: "i2_p1", text: "(property) i2.i2_p1: number", documentation: "i2_p1" },
{ name: "i2_f1", text: "(method) i2.i2_f1(): void", documentation: "i2_f1" },
{ name: "i2_l1", text: "(property) i2.i2_l1: () => void", documentation: "i2_l1" },
{ name: "i2_nc_p1", text: "(property) i2.i2_nc_p1: number" },
{ name: "i2_nc_f1", text: "(method) i2.i2_nc_f1(): void" },
{ name: "i2_nc_l1", text: "(property) i2.i2_nc_l1: () => void" },
{ name: "p1", text: "(property) i3.p1: number", documentation: "i3 p1" },
{ name: "f1", text: "(method) i3.f1(): void", documentation: "i3 f1" },
{ name: "l1", text: "(property) i3.l1: () => void", documentation: "i3 l1" },
{ name: "nc_p1", text: "(property) i3.nc_p1: number" },
{ name: "nc_f1", text: "(method) i3.nc_f1(): void" },
{ name: "nc_l1", text: "(property) i3.nc_l1: () => void" },
],
});
verify.signatureHelp(
{ marker: "42", docComment: "i2_f1" },
{ marker: "44", docComment: "i3 f1" },
@@ -496,19 +523,23 @@ verify.quickInfos({
l45q: "(property) i3.nc_l1: () => void"
});
goTo.marker('46');
verify.completionListContains("i2_p1", "(property) i2.i2_p1: number", "i2_p1");
verify.completionListContains("i2_f1", "(method) i2.i2_f1(): void", "i2_f1");
verify.completionListContains("i2_l1", "(property) i2.i2_l1: () => void", "i2_l1");
verify.completionListContains("i2_nc_p1", "(property) i2.i2_nc_p1: number", "");
verify.completionListContains("i2_nc_f1", "(method) i2.i2_nc_f1(): void", "");
verify.completionListContains("i2_nc_l1", "(property) i2.i2_nc_l1: () => void", "");
verify.completionListContains("p1", "(property) i2.p1: number", "i2 p1");
verify.completionListContains("f1", "(method) i2.f1(): void", "i2 f1");
verify.completionListContains("l1", "(property) i2.l1: () => void", "i2 l1");
verify.completionListContains("nc_p1", "(property) i2.nc_p1: number", "");
verify.completionListContains("nc_f1", "(method) i2.nc_f1(): void", "");
verify.completionListContains("nc_l1", "(property) i2.nc_l1: () => void", "");
verify.completions({
marker: "46",
includes: [
{ name: "i2_p1", text: "(property) i2.i2_p1: number", documentation: "i2_p1" },
{ name: "i2_f1", text: "(method) i2.i2_f1(): void", documentation: "i2_f1" },
{ name: "i2_l1", text: "(property) i2.i2_l1: () => void", documentation: "i2_l1" },
{ name: "i2_nc_p1", text: "(property) i2.i2_nc_p1: number" },
{ name: "i2_nc_f1", text: "(method) i2.i2_nc_f1(): void" },
{ name: "i2_nc_l1", text: "(property) i2.i2_nc_l1: () => void" },
{ name: "p1", text: "(property) i2.p1: number", documentation: "i2 p1" },
{ name: "f1", text: "(method) i2.f1(): void", documentation: "i2 f1" },
{ name: "l1", text: "(property) i2.l1: () => void", documentation: "i2 l1" },
{ name: "nc_p1", text: "(property) i2.nc_p1: number" },
{ name: "nc_f1", text: "(method) i2.nc_f1(): void" },
{ name: "nc_l1", text: "(property) i2.nc_l1: () => void" },
],
});
verify.signatureHelp(
{ marker: "47", docComment: "i2_f1" },
{ marker: "49", docComment: "i2 f1" },
@@ -526,15 +557,23 @@ verify.quickInfos({
l40q: "(property) i2.nc_l1: () => void"
});
goTo.marker('51');
verify.not.completionListContains("i2", "interface i2", "");
verify.completionListContains("i2_i", "var i2_i: i2", "");
verify.not.completionListContains("i3", "interface i3", "");
verify.completionListContains("i3_i", "var i3_i: i3", "");
goTo.marker('51i');
verify.completionListContains("i2", "interface i2", "");
verify.completionListContains("i3", "interface i3", "");
verify.completions(
{
marker: "51",
includes: [
{ name: "i2_i", text: "var i2_i: i2" },
{ name: "i3_i", text: "var i3_i: i3" },
],
excludes: ["i2", "i3"],
},
{
marker: "51i",
includes: [
{ name: "i2", text: "interface i2" },
{ name: "i3", text: "interface i3" },
],
},
);
verify.quickInfos({
52: ["constructor c5(): c5", "c5 class"],
tests/cases/fourslash/commentsInterface.ts
+64 -48
View File
@@ -7,7 +7,7 @@
////interface nc_/*3*/i1 {
////}
////var nc_/*4*/i1_i: nc_i1;
/////** this is interface 2 with memebers*/
/////** this is interface 2 with members*/
////interface i/*5*/2 {
//// /** this is x*/
//// x: number;
@@ -73,19 +73,25 @@ verify.quickInfos({
2: "var i1_i: i1",
3: "interface nc_i1",
4: "var nc_i1_i: nc_i1",
5: ["interface i2", "this is interface 2 with memebers"],
5: ["interface i2", "this is interface 2 with members"],
6: "var i2_i: i2",
7: "var i2_i_x: number"
});
goTo.marker('8');
verify.quickInfoIs("(property) i2.x: number", "this is x");
verify.completionListContains("x", "(property) i2.x: number", "this is x");
verify.completionListContains("foo", "(property) i2.foo: (b: number) => string", "this is foo");
verify.completionListContains("nc_x", "(property) i2.nc_x: number", "");
verify.completionListContains("nc_foo", "(property) i2.nc_foo: (b: number) => string", "");
verify.completionListContains("fnfoo", "(method) i2.fnfoo(b: number): string", "this is fnfoo");
verify.completionListContains("nc_fnfoo", "(method) i2.nc_fnfoo(b: number): string", "");
verify.quickInfoAt("8", "(property) i2.x: number", "this is x");
verify.completions({
marker: "8",
exact: [
{ name: "x", text: "(property) i2.x: number", documentation: "this is x" },
{ name: "foo", text: "(property) i2.foo: (b: number) => string", documentation: "this is foo" },
{ name: "nc_x", text: "(property) i2.nc_x: number" },
{ name: "nc_foo", text: "(property) i2.nc_foo: (b: number) => string" },
{ name: "fnfoo", text: "(method) i2.fnfoo(b: number): string", documentation: "this is fnfoo" },
{ name: "nc_fnfoo", text: "(method) i2.nc_fnfoo(b: number): string" },
...completion.functionMembersWithPrototype,
],
isNewIdentifierLocation: true,
});
verify.quickInfos({
9: "var i2_i_foo: (b: number) => string",
@@ -148,49 +154,59 @@ verify.quickInfos({
verify.signatureHelp({ marker: "33", docComment: "" });
verify.quickInfoAt("33q", "(method) i2.nc_fnfoo(b: number): string");
goTo.marker('34');
verify.not.completionListContains("i1", "interface i1", "this is interface 1");
verify.completionListContains("i1_i", "var i1_i: i1", "");
verify.not.completionListContains("nc_i1", "interface nc_i1", "");
verify.completionListContains("nc_i1_i", "var nc_i1_i: nc_i1", "");
verify.not.completionListContains("i2", "interface i2", "this is interface 2 with memebers");
verify.completionListContains("i2_i", "var i2_i: i2", "");
verify.completionListContains("i2_i_x", "var i2_i_x: number", "");
verify.completionListContains("i2_i_foo", "var i2_i_foo: (b: number) => string", "");
verify.completionListContains("i2_i_foo_r", "var i2_i_foo_r: string", "");
verify.completionListContains("i2_i_i2_si", "var i2_i_i2_si: number", "");
verify.completionListContains("i2_i_i2_ii", "var i2_i_i2_ii: number", "");
verify.completionListContains("i2_i_n", "var i2_i_n: any", "");
verify.completionListContains("i2_i_nc_x", "var i2_i_nc_x: number", "");
verify.completionListContains("i2_i_nc_foo", "var i2_i_nc_foo: (b: number) => string", "");
verify.completionListContains("i2_i_nc_foo_r", "var i2_i_nc_foo_r: string", "");
verify.completionListContains("i2_i_r", "var i2_i_r: number", "");
verify.completionListContains("i2_i_fnfoo", "var i2_i_fnfoo: (b: number) => string", "");
verify.completionListContains("i2_i_fnfoo_r", "var i2_i_fnfoo_r: string", "");
verify.completionListContains("i2_i_nc_fnfoo", "var i2_i_nc_fnfoo: (b: number) => string", "");
verify.completionListContains("i2_i_nc_fnfoo_r", "var i2_i_nc_fnfoo_r: string", "");
goTo.marker('34i');
verify.completionListContains("i1", "interface i1", "this is interface 1");
verify.completionListContains("nc_i1", "interface nc_i1", "");
verify.completionListContains("i2", "interface i2", "this is interface 2 with memebers");
goTo.marker('36');
verify.completionListContains("a", "(parameter) a: number", "i3_i a");
verify.completions(
{
marker: "34",
includes: [
{ name: "i1_i", text: "var i1_i: i1" },
{ name: "nc_i1_i", text: "var nc_i1_i: nc_i1", documentation: "" },
{ name: "i2_i", text: "var i2_i: i2" },
{ name: "i2_i_x", text: "var i2_i_x: number" },
{ name: "i2_i_foo", text: "var i2_i_foo: (b: number) => string" },
{ name: "i2_i_foo_r", text: "var i2_i_foo_r: string" },
{ name: "i2_i_i2_si", text: "var i2_i_i2_si: number" },
{ name: "i2_i_i2_ii", text: "var i2_i_i2_ii: number" },
{ name: "i2_i_n", text: "var i2_i_n: any" },
{ name: "i2_i_nc_x", text: "var i2_i_nc_x: number" },
{ name: "i2_i_nc_foo", text: "var i2_i_nc_foo: (b: number) => string" },
{ name: "i2_i_nc_foo_r", text: "var i2_i_nc_foo_r: string" },
{ name: "i2_i_r", text: "var i2_i_r: number" },
{ name: "i2_i_fnfoo", text: "var i2_i_fnfoo: (b: number) => string" },
{ name: "i2_i_fnfoo_r", text: "var i2_i_fnfoo_r: string" },
{ name: "i2_i_nc_fnfoo", text: "var i2_i_nc_fnfoo: (b: number) => string" },
{ name: "i2_i_nc_fnfoo_r", text: "var i2_i_nc_fnfoo_r: string" },
],
excludes: ["i1", "nc_i1", "i2"],
},
{
marker: "34i",
includes: [
{ name: "i1", text: "interface i1", documentation: "this is interface 1" },
{ name: "nc_i1", text: "interface nc_i1" },
{ name: "i2", text: "interface i2", documentation: "this is interface 2 with members" },
],
},
{
marker: "36", includes: { name: "a", text: "(parameter) a: number", documentation: "i3_i a" },
}
);
verify.quickInfoAt("40q", "var i3_i: i3");
goTo.marker('40');
verify.not.completionListContains("i3", "interface i3", "");
verify.completionListContains("i3_i", "var i3_i: i3", "");
verify.completions({ marker: "40", includes: { name: "i3_i", text: "var i3_i: i3" }, excludes: "i3" });
goTo.marker('41');
verify.quickInfoIs("(method) i3.f(a: number): string", "Function i3 f");
verify.completionListContains("f", "(method) i3.f(a: number): string", "Function i3 f");
verify.completionListContains("l", "(property) i3.l: (b: number) => string", "i3 l");
verify.completionListContains("x", "(property) i3.x: number", "Comment i3 x");
verify.completionListContains("nc_f", "(method) i3.nc_f(a: number): string", "");
verify.completionListContains("nc_l", "(property) i3.nc_l: (b: number) => string", "");
verify.completionListContains("nc_x", "(property) i3.nc_x: number", "");
verify.completions({
marker: "41",
exact: [
{ name: "x", text: "(property) i3.x: number", documentation: "Comment i3 x" },
{ name: "f", text: "(method) i3.f(a: number): string", documentation: "Function i3 f" },
{ name: "l", text: "(property) i3.l: (b: number) => string", documentation: "i3 l" },
{ name: "nc_x", text: "(property) i3.nc_x: number" },
{ name: "nc_f", text: "(method) i3.nc_f(a: number): string" },
{ name: "nc_l", text: "(property) i3.nc_l: (b: number) => string" },
],
});
verify.signatureHelp({ marker: "42", docComment: "Function i3 f", parameterDocComment: "number parameter" });
tests/cases/fourslash/commentsModules.ts
+63 -113
View File
@@ -98,134 +98,84 @@
verify.quickInfoAt("1", "namespace m1", "Namespace comment");
goTo.marker('2');
verify.completionListContains("b", "var b: number", "b's comment");
verify.completionListContains("foo", "function foo(): number", "foo's comment");
verify.completions({
marker: "2",
includes: [
{ name: "b", text: "var b: number", documentation: "b's comment" },
{ name: "foo", text: "function foo(): number", documentation: "foo's comment" },
],
});
verify.signatureHelp({ marker: "3", docComment: "foo's comment" });
verify.quickInfoAt("3q", "function foo(): number", "foo's comment");
goTo.marker('4');
verify.completionListContains("m1", "namespace m1", "Namespace comment");
verify.completions(
{ marker: "4", includes: { name: "m1", text: "namespace m1", documentation: "Namespace comment" } },
{
marker: "5",
includes: [
{ name: "b", text: "var m1.b: number", documentation: "b's comment" },
{ name: "fooExport", text: "function m1.fooExport(): number", documentation: "exported function" },
{ name: "m2", text: "namespace m1.m2", documentation: "m2 comments" },
],
},
);
goTo.marker('5');
verify.completionListContains("b", "var m1.b: number", "b's comment");
verify.completionListContains("fooExport", "function m1.fooExport(): number", "exported function");
verify.completionListContains("m2", "namespace m1.m2");
verify.quickInfoIs("function m1.fooExport(): number", "exported function");
verify.quickInfoAt("5", "function m1.fooExport(): number", "exported function");
verify.signatureHelp({ marker: "6", docComment: "exported function" });
verify.quickInfoAt("7", "var myvar: m1.m2.c");
goTo.marker('8');
verify.quickInfoIs("constructor m1.m2.c(): m1.m2.c", "class comment;");
verify.completionListContains("c", "constructor m1.m2.c(): m1.m2.c", "class comment;");
verify.completionListContains("i", "var m1.m2.i: m1.m2.c", "i");
verify.quickInfoAt("8", "constructor m1.m2.c(): m1.m2.c", "class comment;");
verify.completions(
{
marker: "8",
includes: [
{ name: "c", text: "constructor m1.m2.c(): m1.m2.c", documentation: "class comment;" },
{ name: "i", text: "var m1.m2.i: m1.m2.c", documentation: "i" },
],
}
);
goTo.marker('9');
verify.completionListContains("m2", "namespace m2", "namespace comment of m2.m3");
verify.quickInfoIs("namespace m2", "namespace comment of m2.m3");
function both(marker: string, name: string, text: string, documentation?: string) {
verify.completions({ marker, includes: { name, text, documentation } });
verify.quickInfoAt(marker, text, documentation);
}
goTo.marker('10');
verify.completionListContains("m3", "namespace m2.m3");
verify.quickInfoIs("namespace m2.m3", "namespace comment of m2.m3");
both("9", "m2", "namespace m2", "namespace comment of m2.m3");
both("10", "m3", "namespace m2.m3", "namespace comment of m2.m3");
both("11", "c", "constructor m2.m3.c(): m2.m3.c", "Exported class comment");
both("12", "m3", "namespace m3", "namespace comment of m3.m4.m5");
both("13", "m4", "namespace m3.m4", "namespace comment of m3.m4.m5");
both("14", "m5", "namespace m3.m4.m5", "namespace comment of m3.m4.m5");
both("15", "c", "constructor m3.m4.m5.c(): m3.m4.m5.c", "Exported class comment");
goTo.marker('11');
verify.quickInfoIs("constructor m2.m3.c(): m2.m3.c", "Exported class comment");
verify.completionListContains("c", "constructor m2.m3.c(): m2.m3.c", "Exported class comment");
both("16", "m4", "namespace m4", "namespace comment of m4.m5.m6");
both("17", "m5", "namespace m4.m5", "namespace comment of m4.m5.m6");
both("18", "m6", "namespace m4.m5.m6", "namespace comment of m4.m5.m6");
both("19", "m7", "namespace m4.m5.m6.m7");
goTo.marker('12');
verify.completionListContains("m3", "namespace m3", "namespace comment of m3.m4.m5");
verify.quickInfoIs("namespace m3", "namespace comment of m3.m4.m5");
verify.completions({
marker: "20",
includes: { name: "c", text: "constructor m4.m5.m6.m7.c(): m4.m5.m6.m7.c", documentation: "Exported class comment" },
});
verify.quickInfoAt("20", "constructor m4.m5.m6.m7.c(): m4.m5.m6.m7.c", "Exported class comment");
goTo.marker('13');
verify.completionListContains("m4", "namespace m3.m4", "namespace comment of m3.m4.m5");
verify.quickInfoIs("namespace m3.m4", "namespace comment of m3.m4.m5");
goTo.marker('14');
verify.completionListContains("m5", "namespace m3.m4.m5");
verify.quickInfoIs("namespace m3.m4.m5", "namespace comment of m3.m4.m5");
goTo.marker('15');
verify.quickInfoIs("constructor m3.m4.m5.c(): m3.m4.m5.c", "Exported class comment");
verify.completionListContains("c", "constructor m3.m4.m5.c(): m3.m4.m5.c", "Exported class comment");
goTo.marker('16');
verify.completionListContains("m4", "namespace m4", "namespace comment of m4.m5.m6");
verify.quickInfoIs("namespace m4", "namespace comment of m4.m5.m6");
goTo.marker('17');
verify.completionListContains("m5", "namespace m4.m5", "namespace comment of m4.m5.m6");
verify.quickInfoIs("namespace m4.m5", "namespace comment of m4.m5.m6");
goTo.marker('18');
verify.completionListContains("m6", "namespace m4.m5.m6");
verify.quickInfoIs("namespace m4.m5.m6", "namespace comment of m4.m5.m6");
goTo.marker('19');
verify.completionListContains("m7", "namespace m4.m5.m6.m7");
verify.quickInfoIs("namespace m4.m5.m6.m7");
goTo.marker('20');
verify.completionListContains("c", "constructor m4.m5.m6.m7.c(): m4.m5.m6.m7.c", "Exported class comment");
verify.quickInfoIs("constructor m4.m5.m6.m7.c(): m4.m5.m6.m7.c", "Exported class comment");
goTo.marker('21');
verify.completionListContains("m5", "namespace m5");
verify.quickInfoIs("namespace m5", "namespace comment of m5.m6.m7");
goTo.marker('22');
verify.completionListContains("m6", "namespace m5.m6");
verify.quickInfoIs("namespace m5.m6", "namespace comment of m5.m6.m7");
goTo.marker('23');
verify.completionListContains("m7", "namespace m5.m6.m7");
verify.quickInfoIs("namespace m5.m6.m7", "namespace comment of m5.m6.m7");
goTo.marker('24');
verify.completionListContains("m8", "namespace m5.m6.m7.m8");
verify.quickInfoIs("namespace m5.m6.m7.m8", "namespace m8 comment");
goTo.marker('25');
verify.completionListContains("c", "constructor m5.m6.m7.m8.c(): m5.m6.m7.m8.c", "Exported class comment");
verify.quickInfoIs("constructor m5.m6.m7.m8.c(): m5.m6.m7.m8.c", "Exported class comment");
goTo.marker('26');
verify.completionListContains("m6", "namespace m6");
verify.quickInfoIs("namespace m6");
goTo.marker('27');
verify.completionListContains("m7", "namespace m6.m7");
verify.quickInfoIs("namespace m6.m7");
goTo.marker('28');
verify.completionListContains("m8", "namespace m6.m7.m8");
verify.quickInfoIs("namespace m6.m7.m8");
goTo.marker('29');
verify.completionListContains("c", "constructor m6.m7.m8.c(): m6.m7.m8.c", "Exported class comment");
verify.quickInfoIs("constructor m6.m7.m8.c(): m6.m7.m8.c", "Exported class comment");
goTo.marker('30');
verify.completionListContains("m7", "namespace m7");
verify.quickInfoIs("namespace m7");
goTo.marker('31');
verify.completionListContains("m8", "namespace m7.m8");
verify.quickInfoIs("namespace m7.m8");
goTo.marker('32');
verify.completionListContains("m9", "namespace m7.m8.m9");
verify.quickInfoIs("namespace m7.m8.m9", "namespace m9 comment");
goTo.marker('33');
verify.completionListContains("c", "constructor m7.m8.m9.c(): m7.m8.m9.c", "Exported class comment");
verify.quickInfoIs("constructor m7.m8.m9.c(): m7.m8.m9.c", "Exported class comment");
goTo.marker('34');
verify.completionListContains("c", 'class c', "");
verify.quickInfoIs('class c');
both("21", "m5", "namespace m5", "namespace comment of m5.m6.m7");
both("22", "m6", "namespace m5.m6", "namespace comment of m5.m6.m7");
both("23", "m7", "namespace m5.m6.m7", "namespace comment of m5.m6.m7");
both("24", "m8", "namespace m5.m6.m7.m8", "namespace m8 comment");
both("25", "c", "constructor m5.m6.m7.m8.c(): m5.m6.m7.m8.c", "Exported class comment");
both("26", "m6", "namespace m6");
both("27", "m7", "namespace m6.m7");
both("28", "m8", "namespace m6.m7.m8");
both("29", "c", "constructor m6.m7.m8.c(): m6.m7.m8.c", "Exported class comment");
both("30", "m7", "namespace m7");
both("31", "m8", "namespace m7.m8");
both("32", "m9", "namespace m7.m8.m9", "namespace m9 comment");
both("33", "c", "constructor m7.m8.m9.c(): m7.m8.m9.c", "Exported class comment");
both("34", "c", "class c");
verify.quickInfos({
35: "var myComplexVal: number",
tests/cases/fourslash/commentsMultiModuleMultiFile.ts
+4 -5
View File
@@ -28,12 +28,11 @@
const comment = "this is multi declare namespace\nthi is multi namespace 2\nthis is multi namespace 3 comment";
goTo.marker('1');
verify.completionListContains("multiM", "namespace multiM", comment);
verify.completions({
marker: ["1", "7"],
includes: { name: "multiM", text: "namespace multiM", documentation: comment },
});
for (const marker of ["2", "3", "4", "5", "6", "8"]) {
verify.quickInfoAt(marker, "namespace multiM", comment);
}
goTo.marker('7');
verify.completionListContains("multiM", "namespace multiM", comment);
tests/cases/fourslash/commentsMultiModuleSingleFile.ts
+1 -2
View File
@@ -18,8 +18,7 @@
const comment = "this is multi declare namespace\nthi is multi namespace 2";
goTo.marker('1');
verify.completionListContains("multiM", "namespace multiM", comment);
verify.completions({ marker: "1", includes: { name: "multiM", text: "namespace multiM", documentation: comment } });
for (const marker of ["2", "3", "4", "5"]) {
verify.quickInfoAt(marker, "namespace multiM", comment);
tests/cases/fourslash/commentsOverloads.ts
+64 -46
View File
@@ -272,21 +272,27 @@ verify.signatureHelp(
{ marker: "o16", overloadsCount: 2, docComment: "this is signature 4 - with number parameter", parameterDocComment: "param a" },
);
goTo.marker('17');
verify.completionListContains('f1', 'function f1(a: number): number (+1 overload)', 'this is signature 1');
verify.completionListContains('f2', 'function f2(a: number): number (+1 overload)', 'this is signature 2\nthis is f2 var comment');
verify.completionListContains('f3', 'function f3(a: number): number (+1 overload)', '');
verify.completionListContains('f4', 'function f4(a: number): number (+1 overload)', 'this is signature 4 - with number parameter');
goTo.marker('18');
verify.not.completionListContains('i1', 'interface i1', '');
verify.completionListContains('i1_i', 'var i1_i: i1\nnew (b: number) => any (+1 overload)', '');
verify.not.completionListContains('i2', 'interface i2', '');
verify.completionListContains('i2_i', 'var i2_i: i2\nnew (a: string) => any (+1 overload)', '');
verify.not.completionListContains('i3', 'interface i3', '');
verify.completionListContains('i3_i', 'var i3_i: i3\nnew (a: string) => any (+1 overload)', 'new 1');
verify.not.completionListContains('i4', 'interface i4', '');
verify.completionListContains('i4_i', 'var i4_i: i4\nnew (a: string) => any (+1 overload)', '');
verify.completions(
{
marker: "17",
includes: [
{ name: "f1", text: "function f1(a: number): number (+1 overload)", documentation: "this is signature 1" },
{ name: "f2", text: "function f2(a: number): number (+1 overload)", documentation: "this is signature 2\nthis is f2 var comment" },
{ name: "f3", text: "function f3(a: number): number (+1 overload)" },
{ name: "f4", text: "function f4(a: number): number (+1 overload)", documentation: "this is signature 4 - with number parameter" },
],
},
{
marker: "18",
includes: [
{ name: "i1_i", text: "var i1_i: i1\nnew (b: number) => any (+1 overload)" },
{ name: "i2_i", text: "var i2_i: i2\nnew (a: string) => any (+1 overload)" },
{ name: "i3_i", text: "var i3_i: i3\nnew (a: string) => any (+1 overload)", documentation: "new 1" },
{ name: "i4_i", text: "var i4_i: i4\nnew (a: string) => any (+1 overload)" },
],
excludes: ["i1", "i2", "i3", "i4"],
},
);
verify.signatureHelp({ marker: "19", overloadsCount: 2 });
verify.quickInfoAt("19q", "var i1_i: i1\nnew (b: number) => any (+1 overload)");
@@ -301,11 +307,15 @@ verify.signatureHelp({ marker: "22", overloadsCount: 2, docComment: "this is sig
goTo.marker('22q');
verify.quickInfoAt("22q", "var i1_i: i1\n(b: string) => number (+1 overload)", "this is signature 2");
goTo.marker('23');
verify.completionListContains('foo', '(method) i1.foo(a: number): number (+1 overload)', 'foo 1');
verify.completionListContains('foo2', '(method) i1.foo2(a: number): number (+1 overload)', 'foo2 2');
verify.completionListContains('foo3', '(method) i1.foo3(a: number): number (+1 overload)', '');
verify.completionListContains('foo4', '(method) i1.foo4(a: number): number (+1 overload)', 'foo4 1');
verify.completions({
marker: "23",
includes: [
{ name: "foo" , text: "(method) i1.foo(a: number): number (+1 overload)", documentation: "foo 1" },
{ name: "foo2", text: "(method) i1.foo2(a: number): number (+1 overload)", documentation: "foo2 2" },
{ name: "foo3", text: "(method) i1.foo3(a: number): number (+1 overload)" },
{ name: "foo4", text: "(method) i1.foo4(a: number): number (+1 overload)", documentation: "foo4 1" },
],
});
verify.signatureHelp({ marker: "24", overloadsCount: 2, docComment: "foo 1" });
verify.quickInfoAt("24q", "(method) i1.foo(a: number): number (+1 overload)", "foo 1");
@@ -367,12 +377,16 @@ verify.quickInfoAt("42q", "var i4_i: i4\n(a: number) => number (+1 overload)");
verify.signatureHelp({ marker: "43", overloadsCount: 2 });
verify.quickInfoAt("43q", "var i4_i: i4\n(b: string) => number (+1 overload)");
goTo.marker('44');
verify.completionListContains('prop1', '(method) c.prop1(a: number): number (+1 overload)', '');
verify.completionListContains('prop2', '(method) c.prop2(a: number): number (+1 overload)', 'prop2 1');
verify.completionListContains('prop3', '(method) c.prop3(a: number): number (+1 overload)', 'prop3 2');
verify.completionListContains('prop4', '(method) c.prop4(a: number): number (+1 overload)', 'prop4 1');
verify.completionListContains('prop5', '(method) c.prop5(a: number): number (+1 overload)', 'prop5 1');
verify.completions({
marker: "44",
exact: [
{ name: "prop1", text: "(method) c.prop1(a: number): number (+1 overload)" },
{ name: "prop2", text: "(method) c.prop2(a: number): number (+1 overload)", documentation: "prop2 1" },
{ name: "prop3", text: "(method) c.prop3(a: number): number (+1 overload)", documentation: "prop3 2" },
{ name: "prop4", text: "(method) c.prop4(a: number): number (+1 overload)", documentation: "prop4 1" },
{ name: "prop5", text: "(method) c.prop5(a: number): number (+1 overload)", documentation: "prop5 1" },
],
});
verify.signatureHelp({ marker: "45", overloadsCount: 2 });
verify.quickInfoAt("45q", "(method) c.prop1(a: number): number (+1 overload)");
@@ -434,26 +448,30 @@ verify.quickInfoAt("63q", "constructor c5(a: number): c5 (+1 overload)", "c5 1")
verify.signatureHelp({ marker: "64", overloadsCount: 2, docComment: "c5 2" });
verify.quickInfoAt("64q", "constructor c5(b: string): c5 (+1 overload)", "c5 2");
goTo.marker('65');
verify.completionListContains("c", "class c", "");
verify.completionListContains("c1", "class c1", "");
verify.completionListContains("c2", "class c2", "");
verify.completionListContains("c3", "class c3", "");
verify.completionListContains("c4", "class c4", "");
verify.completionListContains("c5", "class c5", "");
verify.completionListContains("c_i", "var c_i: c", "");
verify.completionListContains("c1_i_1", "var c1_i_1: c1", "");
verify.completionListContains("c2_i_1", "var c2_i_1: c2", "");
verify.completionListContains("c3_i_1", "var c3_i_1: c3", "");
verify.completionListContains("c4_i_1", "var c4_i_1: c4", "");
verify.completionListContains("c5_i_1", "var c5_i_1: c5", "");
verify.completionListContains("c1_i_2", "var c1_i_2: c1", "");
verify.completionListContains("c2_i_2", "var c2_i_2: c2", "");
verify.completionListContains("c3_i_2", "var c3_i_2: c3", "");
verify.completionListContains("c4_i_2", "var c4_i_2: c4", "");
verify.completionListContains("c5_i_2", "var c5_i_2: c5", "");
verify.completionListContains('multiOverload', 'function multiOverload(a: number): string (+2 overloads)', 'This is multiOverload F1 1');
verify.completionListContains('ambientF1', 'function ambientF1(a: number): string (+2 overloads)', 'This is ambient F1 1');
verify.completions({
marker: "65",
includes: [
{ name: "c", text: "class c" },
{ name: "c1", text: "class c1" },
{ name: "c2", text: "class c2" },
{ name: "c3", text: "class c3" },
{ name: "c4", text: "class c4" },
{ name: "c5", text: "class c5" },
{ name: "c_i", text: "var c_i: c" },
{ name: "c1_i_1", text: "var c1_i_1: c1" },
{ name: "c2_i_1", text: "var c2_i_1: c2" },
{ name: "c3_i_1", text: "var c3_i_1: c3" },
{ name: "c4_i_1", text: "var c4_i_1: c4" },
{ name: "c5_i_1", text: "var c5_i_1: c5" },
{ name: "c1_i_2", text: "var c1_i_2: c1" },
{ name: "c2_i_2", text: "var c2_i_2: c2" },
{ name: "c3_i_2", text: "var c3_i_2: c3" },
{ name: "c4_i_2", text: "var c4_i_2: c4" },
{ name: "c5_i_2", text: "var c5_i_2: c5" },
{ name: "multiOverload", text: "function multiOverload(a: number): string (+2 overloads)", documentation: "This is multiOverload F1 1" },
{ name: "ambientF1", text: "function ambientF1(a: number): string (+2 overloads)", documentation: "This is ambient F1 1" },
],
});
verify.quickInfos({
66: "var c1_i_1: c1",
tests/cases/fourslash/completionAfterAtChar.ts
+1 -2
View File
@@ -2,5 +2,4 @@
////@a/**/
goTo.marker();
verify.not.completionListIsEmpty();
verify.completions({ marker: "", exact: completion.globals });
tests/cases/fourslash/completionAfterBackslashFollowingString.ts
+1 -2
View File
@@ -2,5 +2,4 @@
////Harness.newLine = ""\n/**/
goTo.marker();
verify.not.completionListIsEmpty();
verify.completions({ marker: "", exact: completion.globals });
tests/cases/fourslash/completionAfterBrace.ts
+3 -5
View File
@@ -1,9 +1,7 @@
/// <reference path='fourslash.ts'/>
////
////
//// }/**/
////
////
goTo.marker();
verify.not.completionListIsEmpty();
verify.completions({ marker: "", exact: completion.globals });
tests/cases/fourslash/completionAfterDotDotDot.ts
+1 -2
View File
@@ -2,5 +2,4 @@
////.../**/
goTo.marker();
verify.not.completionListIsEmpty();
verify.completions({ marker: "", exact: completion.globals });
tests/cases/fourslash/completionAwaitKeyword.ts
-4
View File
@@ -1,4 +0,0 @@
//// /**/
goTo.marker("")
verify.completionListContains("await");
tests/cases/fourslash/completionBeforeSemanticDiagnosticsInArrowFunction1.ts
+1 -2
View File
@@ -11,8 +11,7 @@ edit.insert("A");
// Bring up completion to force a pull resolve. This will end up resolving several symbols and
// producing unreported diagnostics (i.e. that 'V' wasn't found).
verify.completionListContains("T");
verify.completionEntryDetailIs("T", "(type parameter) T in <T>(x: any): void");
verify.completions({ includes: { name: "T", text: "(type parameter) T in <T>(x: any): void" } });
// There should now be a single error.
verify.numberOfErrorsInCurrentFile(1);
tests/cases/fourslash/completionEntryForClassMembers.ts
+106 -142
View File
@@ -1,5 +1,7 @@
///<reference path="fourslash.ts" />
// @noLib: true
////abstract class B {
//// private privateMethod() { }
//// protected protectedMethod() { };
@@ -114,149 +116,111 @@
////}
////class O extends B {
//// constructor(public a) {
//// },
//// },
//// /*classElementAfterConstructorSeparatedByComma*/
////}
const allowedKeywordCount = verify.allowedClassElementKeywords.length;
type CompletionInfo = [string, string];
type CompletionInfoVerifier = { validMembers: CompletionInfo[], invalidMembers: CompletionInfo[] };
const getValue: FourSlashInterface.ExpectedCompletionEntry = { name: "getValue", text: "(method) B.getValue(): number" };
const protectedMethod: FourSlashInterface.ExpectedCompletionEntry = { name: "protectedMethod", text: "(method) B.protectedMethod(): void" };
const staticMethod: FourSlashInterface.ExpectedCompletionEntry = { name: "staticMethod", text: "(method) B.staticMethod(): void" };
function verifyClassElementLocations({ validMembers, invalidMembers }: CompletionInfoVerifier, classElementCompletionLocations: string[]) {
for (const marker of classElementCompletionLocations) {
goTo.marker(marker);
verifyCompletionInfo(validMembers, verify);
verifyCompletionInfo(invalidMembers, verify.not);
verify.completionListContainsClassElementKeywords();
verify.completionListCount(allowedKeywordCount + validMembers.length);
}
}
function verifyCompletionInfo(memberInfo: CompletionInfo[], verify: FourSlashInterface.verifyNegatable) {
for (const [symbol, text] of memberInfo) {
verify.completionListContains(symbol, text, /*documentation*/ undefined, "method");
}
}
const allMembersOfBase: CompletionInfo[] = [
["getValue", "(method) B.getValue(): number"],
["protectedMethod", "(method) B.protectedMethod(): void"],
["privateMethod", "(method) B.privateMethod(): void"],
["staticMethod", "(method) B.staticMethod(): void"]
];
const publicCompletionInfoOfD1: CompletionInfo[] = [
["getValue1", "(method) D1.getValue1(): number"]
];
const publicCompletionInfoOfD2: CompletionInfo[] = [
["protectedMethod", "(method) D2.protectedMethod(): void"]
];
function filterCompletionInfo(fn: (a: CompletionInfo) => boolean): CompletionInfoVerifier {
const validMembers: CompletionInfo[] = [];
const invalidMembers: CompletionInfo[] = [];
for (const member of allMembersOfBase) {
if (fn(member)) {
validMembers.push(member);
}
else {
invalidMembers.push(member);
}
}
return { validMembers, invalidMembers };
}
const instanceMemberInfo = filterCompletionInfo(([a]: CompletionInfo) => a === "getValue" || a === "protectedMethod");
const staticMemberInfo = filterCompletionInfo(([a]: CompletionInfo) => a === "staticMethod");
const instanceWithoutProtectedMemberInfo = filterCompletionInfo(([a]: CompletionInfo) => a === "getValue");
const instanceWithoutPublicMemberInfo = filterCompletionInfo(([a]: CompletionInfo) => a === "protectedMethod");
const instanceMemberInfoD1: CompletionInfoVerifier = {
validMembers: instanceMemberInfo.validMembers.concat(publicCompletionInfoOfD1),
invalidMembers: instanceMemberInfo.invalidMembers
};
const instanceMemberInfoD2: CompletionInfoVerifier = {
validMembers: instanceWithoutProtectedMemberInfo.validMembers.concat(publicCompletionInfoOfD2),
invalidMembers: instanceWithoutProtectedMemberInfo.invalidMembers
};
const staticMemberInfoDn: CompletionInfoVerifier = {
validMembers: staticMemberInfo.validMembers,
invalidMembers: staticMemberInfo.invalidMembers.concat(publicCompletionInfoOfD1, publicCompletionInfoOfD2)
};
// Not a class element declaration location
const nonClassElementMarkers = [
"InsideMethod"
];
for (const marker of nonClassElementMarkers) {
goTo.marker(marker);
verifyCompletionInfo(allMembersOfBase, verify.not);
verify.not.completionListIsEmpty();
}
// Only keywords allowed at this position since they dont extend the class or are private
const onlyClassElementKeywordLocations = [
"abstractClass",
"classThatDoesNotExtendAnotherClass",
"classThatHasWrittenPrivateKeyword",
"classElementContainingPrivateStatic",
"classThatStartedWritingIdentifierAfterPrivateModifier",
"classThatStartedWritingIdentifierAfterPrivateStaticModifier"
];
verifyClassElementLocations({ validMembers: [], invalidMembers: allMembersOfBase }, onlyClassElementKeywordLocations);
// Instance base members and class member keywords allowed
const classInstanceElementLocations = [
"classThatIsEmptyAndExtendingAnotherClass",
"classThatHasDifferentMethodThanBase",
"classThatHasDifferentMethodThanBaseAfterMethod",
"classThatHasWrittenPublicKeyword",
"classThatStartedWritingIdentifier",
"propDeclarationWithoutSemicolon",
"propDeclarationWithSemicolon",
"propAssignmentWithSemicolon",
"propAssignmentWithoutSemicolon",
"methodSignatureWithoutSemicolon",
"methodSignatureWithSemicolon",
"methodImplementation",
"accessorSignatureWithoutSemicolon",
"accessorSignatureImplementation",
"classThatHasWrittenGetKeyword",
"classThatHasWrittenSetKeyword",
"classThatStartedWritingIdentifierOfGetAccessor",
"classThatStartedWritingIdentifierOfSetAccessor",
"classThatStartedWritingIdentifierAfterModifier",
"classThatHasWrittenAsyncKeyword",
"classElementAfterConstructorSeparatedByComma"
];
verifyClassElementLocations(instanceMemberInfo, classInstanceElementLocations);
// Static Base members and class member keywords allowed
const staticClassLocations = [
"classElementContainingStatic",
"classThatStartedWritingIdentifierAfterStaticModifier"
];
verifyClassElementLocations(staticMemberInfo, staticClassLocations);
const classInstanceElementWithoutPublicMethodLocations = [
"classThatHasAlreadyImplementedAnotherClassMethod",
"classThatHasAlreadyImplementedAnotherClassMethodAfterMethod",
];
verifyClassElementLocations(instanceWithoutPublicMemberInfo, classInstanceElementWithoutPublicMethodLocations);
const classInstanceElementWithoutProtectedMethodLocations = [
"classThatHasAlreadyImplementedAnotherClassProtectedMethod",
"classThatHasDifferentMethodThanBaseAfterProtectedMethod",
];
verifyClassElementLocations(instanceWithoutProtectedMemberInfo, classInstanceElementWithoutProtectedMethodLocations);
// instance memebers in D1 and base class are shown
verifyClassElementLocations(instanceMemberInfoD1, ["classThatExtendsClassExtendingAnotherClass"]);
// instance memebers in D2 and base class are shown
verifyClassElementLocations(instanceMemberInfoD2, ["classThatExtendsClassExtendingAnotherClassWithOverridingMember"]);
// static base members and class member keywords allowed
verifyClassElementLocations(staticMemberInfoDn, [
"classThatExtendsClassExtendingAnotherClassAndTypesStatic",
"classThatExtendsClassExtendingAnotherClassWithOverridingMemberAndTypesStatic"
]);
verify.completions(
{
// Not a class element declaration location
marker: "InsideMethod",
exact: [
"arguments",
"B", "C", "D", "D1", "D2", "D3", "D4", "D5", "D6", "E", "F", "F2", "G", "G2", "H", "I", "J", "K", "L", "L2", "M", "N", "O",
"undefined",
...completion.insideMethodKeywords,
],
},
{
// Only keywords allowed at this position since they dont extend the class or are private
marker: [
"abstractClass",
"classThatDoesNotExtendAnotherClass",
"classThatHasWrittenPrivateKeyword",
"classElementContainingPrivateStatic",
"classThatStartedWritingIdentifierAfterPrivateModifier",
"classThatStartedWritingIdentifierAfterPrivateStaticModifier",
],
exact: ["private", "protected", "public", "static", "abstract", "async", "constructor", "get", "readonly", "set"],
isNewIdentifierLocation: true,
},
{
// Instance base members and class member keywords allowed
marker:[
"classThatIsEmptyAndExtendingAnotherClass",
"classThatHasDifferentMethodThanBase",
"classThatHasDifferentMethodThanBaseAfterMethod",
"classThatHasWrittenPublicKeyword",
"classThatStartedWritingIdentifier",
"propDeclarationWithoutSemicolon",
"propDeclarationWithSemicolon",
"propAssignmentWithSemicolon",
"propAssignmentWithoutSemicolon",
"methodSignatureWithoutSemicolon",
"methodSignatureWithSemicolon",
"methodImplementation",
"accessorSignatureWithoutSemicolon",
"accessorSignatureImplementation",
"classThatHasWrittenGetKeyword",
"classThatHasWrittenSetKeyword",
"classThatStartedWritingIdentifierOfGetAccessor",
"classThatStartedWritingIdentifierOfSetAccessor",
"classThatStartedWritingIdentifierAfterModifier",
"classThatHasWrittenAsyncKeyword",
"classElementAfterConstructorSeparatedByComma",
],
exact: [protectedMethod, getValue, ...completion.classElementKeywords],
isNewIdentifierLocation: true,
},
{
// Static Base members and class member keywords allowed
marker: ["classElementContainingStatic", "classThatStartedWritingIdentifierAfterStaticModifier"],
exact: [staticMethod, ...completion.classElementKeywords],
isNewIdentifierLocation: true,
},
{
marker: [
"classThatHasAlreadyImplementedAnotherClassMethod",
"classThatHasAlreadyImplementedAnotherClassMethodAfterMethod",
],
exact: [protectedMethod, ...completion.classElementKeywords],
isNewIdentifierLocation: true,
},
{
marker: [
"classThatHasAlreadyImplementedAnotherClassProtectedMethod",
"classThatHasDifferentMethodThanBaseAfterProtectedMethod",
],
exact: [getValue, ...completion.classElementKeywords],
isNewIdentifierLocation: true,
},
{
// instance memebers in D1 and base class are shown
marker: "classThatExtendsClassExtendingAnotherClass",
exact: ["getValue1", "protectedMethod", "getValue", ...completion.classElementKeywords],
isNewIdentifierLocation: true,
},
{
// instance memebers in D2 and base class are shown
marker: "classThatExtendsClassExtendingAnotherClassWithOverridingMember",
exact: [
{ name: "protectedMethod", text: "(method) D2.protectedMethod(): void" },
getValue,
...completion.classElementKeywords,
],
isNewIdentifierLocation: true,
},
{
// static base members and class member keywords allowed
marker: [
"classThatExtendsClassExtendingAnotherClassAndTypesStatic",
"classThatExtendsClassExtendingAnotherClassWithOverridingMemberAndTypesStatic"
],
exact: [staticMethod, ...completion.classElementKeywords],
isNewIdentifierLocation: true,
},
);
tests/cases/fourslash/completionEntryForClassMembers2.ts
+191 -243
View File
@@ -188,268 +188,216 @@
//// static /*extendsB0AndImplementsI6ThatExtendsB0AndHasStaticMethodOfB0TypesStatic*/
////}
const allowedKeywordCount = verify.allowedClassElementKeywords.length;
type CompletionInfo = [string, string];
type CompletionInfoVerifier = { validMembers: CompletionInfo[], invalidMembers: CompletionInfo[] };
function verifyClassElementLocations({ validMembers, invalidMembers }: CompletionInfoVerifier, classElementCompletionLocations: string[]) {
for (const marker of classElementCompletionLocations) {
goTo.marker(marker);
verifyCompletionInfo(validMembers, verify);
verifyCompletionInfo(invalidMembers, verify.not);
verify.completionListContainsClassElementKeywords();
verify.completionListCount(allowedKeywordCount + validMembers.length);
}
}
function verifyCompletionInfo(memberInfo: CompletionInfo[], verify: FourSlashInterface.verifyNegatable) {
for (const [symbol, text] of memberInfo) {
verify.completionListContains(symbol, text, /*documentation*/ undefined, "method");
}
}
const validInstanceMembersOfBaseClassB: CompletionInfo[] = [
["getValue", "(method) B.getValue(): string | boolean"],
["protectedMethod", "(method) B.protectedMethod(): void"],
const validInstanceMembersOfBaseClassB: ReadonlyArray<FourSlashInterface.ExpectedCompletionEntryObject> = [
{ name: "protectedMethod", text: "(method) B.protectedMethod(): void" },
{ name: "getValue", text: "(method) B.getValue(): string | boolean" },
];
const validStaticMembersOfBaseClassB: CompletionInfo[] = [
["staticMethod", "(method) B.staticMethod(): void"]
const validStaticMembersOfBaseClassB: ReadonlyArray<FourSlashInterface.ExpectedCompletionEntryObject> = [
{ name: "staticMethod", text: "(method) B.staticMethod(): void" },
];
const privateMembersOfBaseClassB: CompletionInfo[] = [
["privateMethod", "(method) B.privateMethod(): void"],
const privateMembersOfBaseClassB: ReadonlyArray<FourSlashInterface.ExpectedCompletionEntryObject> = [
{ name: "privateMethod", text: "(method) B.privateMethod(): void" },
];
const protectedPropertiesOfBaseClassB0: CompletionInfo[] = [
["protectedMethod", "(method) B0.protectedMethod(): void"],
["protectedMethod1", "(method) B0.protectedMethod1(): void"],
const protectedPropertiesOfBaseClassB0: ReadonlyArray<FourSlashInterface.ExpectedCompletionEntryObject> = [
{ name: "protectedMethod", text: "(method) B0.protectedMethod(): void" },
{ name: "protectedMethod1", text: "(method) B0.protectedMethod1(): void" },
];
const publicPropertiesOfBaseClassB0: CompletionInfo[] = [
["getValue", "(method) B0.getValue(): string | boolean"],
["getValue1", "(method) B0.getValue1(): string | boolean"],
const publicPropertiesOfBaseClassB0: ReadonlyArray<FourSlashInterface.ExpectedCompletionEntryObject> = [
{ name: "getValue", text: "(method) B0.getValue(): string | boolean" },
{ name: "getValue1", text: "(method) B0.getValue1(): string | boolean" },
];
const validInstanceMembersOfBaseClassB0: CompletionInfo[] = protectedPropertiesOfBaseClassB0.concat(publicPropertiesOfBaseClassB0);
const validStaticMembersOfBaseClassB0: CompletionInfo[] = [
["staticMethod", "(method) B0.staticMethod(): void"],
["staticMethod1", "(method) B0.staticMethod1(): void"]
const validInstanceMembersOfBaseClassB0: ReadonlyArray<FourSlashInterface.ExpectedCompletionEntryObject> = protectedPropertiesOfBaseClassB0.concat(publicPropertiesOfBaseClassB0);
const validInstanceMembersOfBaseClassB0_2 : ReadonlyArray<FourSlashInterface.ExpectedCompletionEntryObject> = [
protectedPropertiesOfBaseClassB0[0],
publicPropertiesOfBaseClassB0[0],
protectedPropertiesOfBaseClassB0[1],
publicPropertiesOfBaseClassB0[1],
];
const privateMembersOfBaseClassB0: CompletionInfo[] = [
["privateMethod", "(method) B0.privateMethod(): void"],
["privateMethod1", "(method) B0.privateMethod1(): void"],
const validStaticMembersOfBaseClassB0: ReadonlyArray<FourSlashInterface.ExpectedCompletionEntryObject> = [
{ name: "staticMethod", text: "(method) B0.staticMethod(): void" },
{ name: "staticMethod1", text: "(method) B0.staticMethod1(): void" },
];
const membersOfI: CompletionInfo[] = [
["methodOfInterface", "(method) I.methodOfInterface(): number"],
const privateMembersOfBaseClassB0: ReadonlyArray<FourSlashInterface.ExpectedCompletionEntryObject> = [
{ name: "privateMethod", text: "(method) B0.privateMethod(): void" },
{ name: "privateMethod1", text: "(method) B0.privateMethod1(): void" },
];
const membersOfI2: CompletionInfo[] = [
["methodOfInterface2", "(method) I2.methodOfInterface2(): number"],
const membersOfI: ReadonlyArray<FourSlashInterface.ExpectedCompletionEntryObject> = [
{ name: "methodOfInterface", text: "(method) I.methodOfInterface(): number" },
];
const membersOfI3: CompletionInfo[] = [
["getValue", "(method) I3.getValue(): string"],
["method", "(method) I3.method(): string"],
const membersOfI2: ReadonlyArray<FourSlashInterface.ExpectedCompletionEntryObject> = [
{ name: "methodOfInterface2", text: "(method) I2.methodOfInterface2(): number" },
];
const membersOfI4: CompletionInfo[] = [
["staticMethod", "(method) I4.staticMethod(): void"],
["method", "(method) I4.method(): string"],
const membersOfI3: ReadonlyArray<FourSlashInterface.ExpectedCompletionEntryObject> = [
{ name: "getValue", text: "(method) I3.getValue(): string" },
{ name: "method", text: "(method) I3.method(): string" },
];
const membersOfI5: CompletionInfo[] = publicPropertiesOfBaseClassB0.concat([
["methodOfInterface5", "(method) I5.methodOfInterface5(): number"]
const membersOfI4: ReadonlyArray<FourSlashInterface.ExpectedCompletionEntryObject> = [
{ name: "staticMethod", text: "(method) I4.staticMethod(): void" },
{ name: "method", text: "(method) I4.method(): string" },
];
const membersOfI5: ReadonlyArray<FourSlashInterface.ExpectedCompletionEntryObject> = publicPropertiesOfBaseClassB0.concat([
{ name: "methodOfInterface5", text: "(method) I5.methodOfInterface5(): number" },
]);
const membersOfI6: CompletionInfo[] = publicPropertiesOfBaseClassB0.concat([
["staticMethod", "(method) I6.staticMethod(): void"],
["methodOfInterface6", "(method) I6.methodOfInterface6(): number"]
]);
const membersOfI7: CompletionInfo[] = membersOfI.concat([
["methodOfInterface7", "(method) I7.methodOfInterface7(): number"]
const membersOfJustI5: ReadonlyArray<FourSlashInterface.ExpectedCompletionEntryObject> = [
{ name: "methodOfInterface5", text: "(method) I5.methodOfInterface5(): number" },
];
const membersOfI6: ReadonlyArray<FourSlashInterface.ExpectedCompletionEntryObject> = publicPropertiesOfBaseClassB0.concat([
{ name: "staticMethod", text: "(method) I6.staticMethod(): void" },
{ name: "methodOfInterface6", text: "(method) I6.methodOfInterface6(): number" },
]);
const membersOfI7: ReadonlyArray<FourSlashInterface.ExpectedCompletionEntryObject> = [
{ name: "methodOfInterface7", text: "(method) I7.methodOfInterface7(): number" },
...membersOfI,
];
const membersOfI7_2: ReadonlyArray<FourSlashInterface.ExpectedCompletionEntryObject> = [
...membersOfI,
{ name: "methodOfInterface7", text: "(method) I7.methodOfInterface7(): number" },
];
function getCompletionInfoVerifier(
validMembers: CompletionInfo[],
invalidMembers: CompletionInfo[],
arrayToDistribute: CompletionInfo[],
isValidDistributionCriteria: (v: CompletionInfo) => boolean): CompletionInfoVerifier {
if (arrayToDistribute) {
validMembers = validMembers.concat(arrayToDistribute.filter(isValidDistributionCriteria));
invalidMembers = invalidMembers.concat(arrayToDistribute.filter(v => !isValidDistributionCriteria(v)));
}
return {
validMembers,
invalidMembers
}
}
const noMembers: CompletionInfo[] = [];
const membersOfIAndI2 = membersOfI.concat(membersOfI2);
const noMembers: ReadonlyArray<FourSlashInterface.ExpectedCompletionEntryObject> = [];
const membersOfIAndI2 = [...membersOfI, ...membersOfI2];
const invalidMembersOfBAtInstanceLocation = privateMembersOfBaseClassB.concat(validStaticMembersOfBaseClassB);
// members of I and I2
verifyClassElementLocations({ validMembers: membersOfIAndI2, invalidMembers: noMembers }, [
"implementsIAndI2",
"implementsIAndI2AndWritingMethodNameOfI"
]);
// Static location so no members of I and I2
verifyClassElementLocations({ validMembers: noMembers, invalidMembers: membersOfIAndI2 },
["implementsIAndI2AndWritingStatic"]);
const allInstanceBAndIAndI2 = [...validInstanceMembersOfBaseClassB, ...membersOfIAndI2];
const allInstanceBAndIAndI2 = membersOfIAndI2.concat(validInstanceMembersOfBaseClassB);
// members of instance B, I and I2
verifyClassElementLocations({
validMembers: allInstanceBAndIAndI2,
invalidMembers: invalidMembersOfBAtInstanceLocation
}, ["extendsBAndImplementsIAndI2"]);
// static location so only static members of B and no members of instance B, I and I2
verifyClassElementLocations({
validMembers: validStaticMembersOfBaseClassB,
invalidMembers: privateMembersOfBaseClassB.concat(allInstanceBAndIAndI2)
}, [
"extendsBAndImplementsIAndI2AndWritingStatic",
"extendsBAndImplementsIAndI2WithMethodFromBAndIAndTypesStatic"
]);
// instance members of B without protectedMethod, I and I2
verifyClassElementLocations(
getCompletionInfoVerifier(
/*validMembers*/ membersOfIAndI2,
/*invalidMembers*/ invalidMembersOfBAtInstanceLocation,
/*arrayToDistribute*/ validInstanceMembersOfBaseClassB,
value => value[0] !== "protectedMethod"),
["extendsBAndImplementsIAndI2WithMethodFromB"]);
// instance members of B, members of T without methodOfInterface and I2
verifyClassElementLocations(
getCompletionInfoVerifier(
/*validMembers*/ membersOfI2.concat(validInstanceMembersOfBaseClassB),
/*invalidMembers*/ invalidMembersOfBAtInstanceLocation,
/*arrayToDistribute*/ membersOfI,
value => value[0] !== "methodOfInterface"),
["extendsBAndImplementsIAndI2WithMethodFromI"]);
// instance members of B without protectedMethod, members of T without methodOfInterface and I2
verifyClassElementLocations(
getCompletionInfoVerifier(
/*validMembers*/ membersOfI2,
/*invalidMembers*/ invalidMembersOfBAtInstanceLocation,
/*arrayToDistribute*/ membersOfI.concat(validInstanceMembersOfBaseClassB),
value => value[0] !== "methodOfInterface" && value[0] !== "protectedMethod"),
["extendsBAndImplementsIAndI2WithMethodFromBAndI"]);
// members of B and members of I3 that are not same as name of method in B
verifyClassElementLocations(
getCompletionInfoVerifier(
/*validMembers*/ validInstanceMembersOfBaseClassB,
/*invalidMembers*/ invalidMembersOfBAtInstanceLocation,
/*arrayToDistribute*/ membersOfI3,
value => value[0] !== "getValue"),
["extendsBAndImplementsI3WithSameNameMembers"]);
// members of B (without getValue since its implemented) and members of I3 that are not same as name of method in B
verifyClassElementLocations(
getCompletionInfoVerifier(
/*validMembers*/ noMembers,
/*invalidMembers*/ invalidMembersOfBAtInstanceLocation,
/*arrayToDistribute*/ membersOfI3.concat(validInstanceMembersOfBaseClassB),
value => value[0] !== "getValue"),
["extendsBAndImplementsI3WithSameNameMembersAndHasImplementedTheMember"]);
const invalidMembersOfB0AtInstanceSide = privateMembersOfBaseClassB0.concat(validStaticMembersOfBaseClassB0);
const invalidMembersOfB0AtStaticSide = privateMembersOfBaseClassB0.concat(validInstanceMembersOfBaseClassB0);
// members of B0 and members of I4
verifyClassElementLocations({
validMembers: validInstanceMembersOfBaseClassB0.concat(membersOfI4),
invalidMembers: invalidMembersOfB0AtInstanceSide
}, [
"extendsB0ThatExtendsAndImplementsI4WithStaticMethod",
"extendsB0ThatExtendsAndImplementsI4WithStaticMethodAndImplementedAnotherMethod",
"extendsB0ThatExtendsAndImplementsI4WithStaticMethodAndImplementedThatMethodAsStatic"
]);
// members of B0 and members of I4 that are not staticMethod
verifyClassElementLocations(
getCompletionInfoVerifier(
/*validMembers*/ validInstanceMembersOfBaseClassB0,
/*invalidMembers*/ invalidMembersOfB0AtInstanceSide,
/*arrayToDistribute*/ membersOfI4,
value => value[0] !== "staticMethod"
), [
"extendsB0ThatExtendsAndImplementsI4WithStaticMethodAndImplementedThatMethod",
"extendsB0ThatExtendsAndImplementsI4WithStaticMethodAndImplementedThatMethodAsBoth"
]);
// static members of B0
verifyClassElementLocations({
validMembers: validStaticMembersOfBaseClassB0,
invalidMembers: invalidMembersOfB0AtStaticSide.concat(membersOfI4)
}, [
"extendsB0ThatExtendsAndImplementsI4WithStaticMethodWritingStatic",
"extendsB0ThatExtendsAndImplementsI4WithStaticMethodAndImplementedAnotherMethodWritingStatic",
"extendsB0ThatExtendsAndImplementsI4WithStaticMethodAndImplementedThatMethodWritingStatic"
]);
// static members of B0 without staticMethod
verifyClassElementLocations(
getCompletionInfoVerifier(
/*validMembers*/ noMembers,
/*invalidMembers*/ invalidMembersOfB0AtStaticSide.concat(membersOfI4),
/*arrayToDistribute*/ validStaticMembersOfBaseClassB0,
value => value[0] !== "staticMethod"
), [
"extendsB0ThatExtendsAndImplementsI4WithStaticMethodAndImplementedThatMethodAsStaticWritingStatic",
"extendsB0ThatExtendsAndImplementsI4WithStaticMethodAndImplementedThatMethodAsBothWritingStatic"
]);
// members of I7 extends I
verifyClassElementLocations({ validMembers: membersOfI7, invalidMembers: noMembers }, [
"implementsI7whichExtendsI",
"implementsI7whichExtendsIAndAlsoImplementsI",
"implementsIAndAlsoImplementsI7whichExtendsI"
]);
const invalidMembersOfB0AtInstanceSide = [...privateMembersOfBaseClassB0, ...validStaticMembersOfBaseClassB0];
const invalidMembersOfB0AtStaticSide = [...privateMembersOfBaseClassB0, validInstanceMembersOfBaseClassB0];
const invalidMembersOfB0AtInstanceSideFromInterfaceExtendingB0 = invalidMembersOfB0AtInstanceSide;
// members of I5 extends B0
verifyClassElementLocations({
validMembers: membersOfI5.concat(protectedPropertiesOfBaseClassB0),
invalidMembers: invalidMembersOfB0AtInstanceSideFromInterfaceExtendingB0
}, [
"implementsI5ThatExtendsB0",
]);
// members of I6 extends B0
verifyClassElementLocations({
validMembers: membersOfI6.concat(protectedPropertiesOfBaseClassB0),
invalidMembers: invalidMembersOfB0AtInstanceSideFromInterfaceExtendingB0
}, [
"implementsI6ThatExtendsB0AndHasStaticMethodOfB0",
]);
const tests: ReadonlyArray<{ readonly marker: string | ReadonlyArray<string>, readonly members: ReadonlyArray<FourSlashInterface.ExpectedCompletionEntryObject> }> = [
// members of I and I2
{ marker: ["implementsIAndI2", "implementsIAndI2AndWritingMethodNameOfI"], members: membersOfIAndI2 },
// Static location so no members of I and I2
{ marker: "implementsIAndI2AndWritingStatic", members: [] },
// members of instance B, I and I2
{ marker: "extendsBAndImplementsIAndI2", members: allInstanceBAndIAndI2 },
// static location so only static members of B and no members of instance B, I and I2
{
marker: [
"extendsBAndImplementsIAndI2AndWritingStatic",
"extendsBAndImplementsIAndI2WithMethodFromBAndIAndTypesStatic"
],
members: validStaticMembersOfBaseClassB,
},
// instance members of B without protectedMethod, I and I2
{ marker: "extendsBAndImplementsIAndI2WithMethodFromB",members: [validInstanceMembersOfBaseClassB[1], ...membersOfIAndI2] }, //TODO:NEATER
// instance members of B, members of T without methodOfInterface and I2
{ marker: "extendsBAndImplementsIAndI2WithMethodFromI", members: [...validInstanceMembersOfBaseClassB, ...membersOfI2] },
// instance members of B without protectedMethod, members of T without methodOfInterface and I2
{ marker: "extendsBAndImplementsIAndI2WithMethodFromBAndI", members: [validInstanceMembersOfBaseClassB[1], ...membersOfI2] },
// members of B and members of I3 that are not same as name of method in B
{ marker: "extendsBAndImplementsI3WithSameNameMembers", members: [...validInstanceMembersOfBaseClassB, membersOfI3[1]] }, //TODO:NEATER
// members of B (without getValue since its implemented) and members of I3 that are not same as name of method in B
{ marker: "extendsBAndImplementsI3WithSameNameMembersAndHasImplementedTheMember", members: [validInstanceMembersOfBaseClassB[0], membersOfI3[1]] }, //TODO:NEATER
// members of B0 and members of I4
{
marker: [
"extendsB0ThatExtendsAndImplementsI4WithStaticMethod",
"extendsB0ThatExtendsAndImplementsI4WithStaticMethodAndImplementedAnotherMethod",
"extendsB0ThatExtendsAndImplementsI4WithStaticMethodAndImplementedThatMethodAsStatic",
],
members: [...validInstanceMembersOfBaseClassB0_2, ...membersOfI4],
},
// members of B0 and members of I4 that are not staticMethod
{
marker: [
"extendsB0ThatExtendsAndImplementsI4WithStaticMethodAndImplementedThatMethod",
"extendsB0ThatExtendsAndImplementsI4WithStaticMethodAndImplementedThatMethodAsBoth",
],
members: [...validInstanceMembersOfBaseClassB0_2, membersOfI4[1]], //TODO:NEATER
},
// static members of B0
{
marker: [
"extendsB0ThatExtendsAndImplementsI4WithStaticMethodWritingStatic",
"extendsB0ThatExtendsAndImplementsI4WithStaticMethodAndImplementedAnotherMethodWritingStatic",
"extendsB0ThatExtendsAndImplementsI4WithStaticMethodAndImplementedThatMethodWritingStatic",
],
members: validStaticMembersOfBaseClassB0,
},
// static members of B0 without staticMethod
{
marker: [
"extendsB0ThatExtendsAndImplementsI4WithStaticMethodAndImplementedThatMethodAsStaticWritingStatic",
"extendsB0ThatExtendsAndImplementsI4WithStaticMethodAndImplementedThatMethodAsBothWritingStatic",
],
members: [validStaticMembersOfBaseClassB0[1]] // TODO:NEATER
},
// members of I7 extends I
{
marker: [
"implementsI7whichExtendsI",
"implementsI7whichExtendsIAndAlsoImplementsI",
],
members: membersOfI7,
},
{
marker: "implementsIAndAlsoImplementsI7whichExtendsI",
members: membersOfI7_2,
},
// members of I5 extends B0
{
marker: "implementsI5ThatExtendsB0",
members: [...membersOfJustI5, protectedPropertiesOfBaseClassB0[0], publicPropertiesOfBaseClassB0[0], protectedPropertiesOfBaseClassB0[1], publicPropertiesOfBaseClassB0[1]], //TODO:NEATER
},
// members of I6 extends B0
{
marker: "implementsI6ThatExtendsB0AndHasStaticMethodOfB0",
//TODO:NEATER
members:[
membersOfI6[3],
membersOfI6[2],
protectedPropertiesOfBaseClassB0[0],
membersOfI6[0],
protectedPropertiesOfBaseClassB0[1],
membersOfI6[1],
],
},
// members of B0 and I5 that extends B0
{
marker: "extendsB0AndImplementsI5ThatExtendsB0",
members: [
protectedPropertiesOfBaseClassB0[0],
membersOfI5[0],
protectedPropertiesOfBaseClassB0[1],
membersOfI5[1],
membersOfI5[2],
],
},
// members of B0 and I6 that extends B0
{
marker: "extendsB0AndImplementsI6ThatExtendsB0AndHasStaticMethodOfB0",
members: [
protectedPropertiesOfBaseClassB0[0],
membersOfI6[0],
protectedPropertiesOfBaseClassB0[1],
membersOfI6[1],
membersOfI6[3],
membersOfI6[2],
],
},
// nothing on static side as these do not extend any other class
{
marker: [
"implementsI5ThatExtendsB0TypesStatic",
"implementsI6ThatExtendsB0AndHasStaticMethodOfB0TypesStatic",
],
members: [],
},
{
marker: [
"extendsB0AndImplementsI5ThatExtendsB0TypesStatic",
"extendsB0AndImplementsI6ThatExtendsB0AndHasStaticMethodOfB0TypesStatic",
],
// statics of base B but nothing from instance side
members: validStaticMembersOfBaseClassB0,
},
];
// members of B0 and I5 that extends B0
verifyClassElementLocations({
validMembers: membersOfI5.concat(protectedPropertiesOfBaseClassB0),
invalidMembers: invalidMembersOfB0AtInstanceSide
}, [
"extendsB0AndImplementsI5ThatExtendsB0"
]);
// members of B0 and I6 that extends B0
verifyClassElementLocations({
validMembers: membersOfI6.concat(protectedPropertiesOfBaseClassB0),
invalidMembers: invalidMembersOfB0AtInstanceSide
}, [
"extendsB0AndImplementsI6ThatExtendsB0AndHasStaticMethodOfB0"
]);
// nothing on static side as these do not extend any other class
verifyClassElementLocations({
validMembers: [],
invalidMembers: membersOfI5.concat(membersOfI6, invalidMembersOfB0AtStaticSide)
}, [
"implementsI5ThatExtendsB0TypesStatic",
"implementsI6ThatExtendsB0AndHasStaticMethodOfB0TypesStatic"
]);
// statics of base B but nothing from instance side
verifyClassElementLocations({
validMembers: validStaticMembersOfBaseClassB0,
invalidMembers: membersOfI5.concat(membersOfI6, invalidMembersOfB0AtStaticSide)
}, [
"extendsB0AndImplementsI5ThatExtendsB0TypesStatic",
"extendsB0AndImplementsI6ThatExtendsB0AndHasStaticMethodOfB0TypesStatic"
]);
verify.completions(...tests.map(({ marker, members }): FourSlashInterface.CompletionsOptions => ({
marker,
exact: [...members.map(m => ({ ...m, kind: "method" })), ...completion.classElementKeywords],
isNewIdentifierLocation: true,
})));
tests/cases/fourslash/completionEntryForClassMembers3.ts
+8 -4
View File
@@ -15,11 +15,15 @@
//// zap() { }
//// b/*3*/: any;
////}
const allowedKeywordCount = verify.allowedClassElementKeywords.length;
function verifyHasBar() {
verify.completionListContains("bar", "(method) IFoo.bar(): void", /*documentation*/ undefined, "method");
verify.completionListContainsClassElementKeywords();
verify.completionListCount(allowedKeywordCount + 1);
verify.completions({
exact: [
{ name: "bar", text: "(method) IFoo.bar(): void", kind: "method" },
...completion.classElementKeywords,
],
isNewIdentifierLocation: true,
});
}
goTo.marker("1");
tests/cases/fourslash/completionEntryForConst.ts
+1 -2
View File
@@ -3,5 +3,4 @@
////const c = "s";
/////**/
goTo.marker();
verify.completionListContains("c", "const c: \"s\"", /*documentation*/ undefined, "const");
verify.completions({ marker: "", includes: { name: "c", text: 'const c: "s"', kind: "const" } });
tests/cases/fourslash/completionEntryForDeferredMappedTypeMembers.ts
+1 -6
View File
@@ -9,9 +9,4 @@
//// out.a./*2*/a
//// out.a.a./*3*/a
goTo.marker('1');
verify.completionListCount(1);
goTo.marker('2');
verify.completionListCount(1);
goTo.marker('3');
verify.completionListCount(1);
verify.completions({ marker: test.markers(), exact: "a" });
tests/cases/fourslash/completionEntryForImportName.ts
+3 -5
View File
@@ -2,10 +2,9 @@
////import /*1*/ /*2*/
goTo.marker('1');
verify.completionListIsEmpty();
verify.completions({ marker: "1", exact: undefined });
edit.insert('q');
verify.completionListIsEmpty();
verify.completions({ exact: undefined });
verifyIncompleteImportName();
goTo.marker('2');
@@ -18,7 +17,6 @@ edit.insert("a.");
verifyIncompleteImportName();
function verifyIncompleteImportName() {
goTo.marker('1');
verify.completionListIsEmpty();
verify.completions({ marker: "1", exact: undefined });
verify.quickInfoIs("import q");
}
tests/cases/fourslash/completionEntryForPropertyFromUnionOfModuleType.ts
+1 -2
View File
@@ -11,5 +11,4 @@
////var q: typeof E | typeof F;
////var j = q./*1*/
goTo.marker('1');
verify.completionListContains('n', "(property) n: number");
verify.completions({ marker: "1", exact: [{ name: "n", text: "(property) n: number" }] });
tests/cases/fourslash/completionEntryForShorthandPropertyAssignment.ts
+1 -2
View File
@@ -2,5 +2,4 @@
//// var person: {name:string; id:number} = {n/**/
goTo.marker();
verify.completionListContains("name", /*text*/ undefined, /*documentation*/ undefined, "property");
verify.completions({ marker: "", includes: { name: "name", kind: "property" } });
tests/cases/fourslash/completionEntryForUnionMethod.ts
+15 -5
View File
@@ -3,9 +3,19 @@
////var y: Array<string>|Array<number>;
////y.map/**/(
goTo.marker();
verify.quickInfoIs(
"(property) map: (<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]) | (<U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[])",
"Calls a defined callback function on each element of an array, and returns an array that contains the results.");
const text = "(property) map: (<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]) | (<U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[])";
const documentation = "Calls a defined callback function on each element of an array, and returns an array that contains the results.";
verify.completionListContains('map', "(property) map: (<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]) | (<U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[])");
verify.quickInfoAt("", text, documentation);
verify.completions({
marker: "",
includes: {
name: "map",
text,
documentation,
tags: [
{ name: "param", text: "callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array." },
{ name: "param", text: "thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value." }
],
},
});
tests/cases/fourslash/completionEntryForUnionProperty.ts
+7 -4
View File
@@ -14,7 +14,10 @@
////
////x./**/
goTo.marker();
verify.completionListContains("commonProperty", "(property) commonProperty: string | number");
verify.completionListContains("commonFunction", "(method) commonFunction(): number");
verify.completionListCount(2);
verify.completions({
marker: "",
exact: [
{ name: "commonProperty", text: "(property) commonProperty: string | number" },
{ name: "commonFunction", text: "(method) commonFunction(): number" },
],
});
tests/cases/fourslash/completionEntryForUnionProperty2.ts
+7 -4
View File
@@ -14,7 +14,10 @@
////
////x.commonProperty./**/
goTo.marker();
verify.completionListContains("toString", "(method) toString(): string");
verify.completionListContains("valueOf", "(method) valueOf(): string | number");
verify.completionListCount(2);
verify.completions({
marker: "",
exact: [
{ name: "toString", text: "(method) toString(): string", documentation: "Returns a string representation of a string.", },
{ name: "valueOf", text: "(method) valueOf(): string | number", documentation: "Returns the primitive value of the specified object." },
],
});
tests/cases/fourslash/completionEntryOnNarrowedType.ts
+5 -8
View File
@@ -10,11 +10,8 @@
//// }
////}
goTo.marker('1');
verify.completionListContains("strOrNum", "(parameter) strOrNum: string | number");
goTo.marker('2');
verify.completionListContains("strOrNum", "(parameter) strOrNum: number");
goTo.marker('3');
verify.completionListContains("strOrNum", "(parameter) strOrNum: string");
verify.completions(
{ marker: "1", includes: { name: "strOrNum", text: "(parameter) strOrNum: string | number" } },
{ marker: "2", includes: { name: "strOrNum", text: "(parameter) strOrNum: number" } },
{ marker: "3", includes: { name: "strOrNum", text: "(parameter) strOrNum: string" } },
);
tests/cases/fourslash/completionForQuotedPropertyInPropertyAssignment1.ts
+4 -4
View File
@@ -3,8 +3,6 @@
//// export interface Configfiles {
//// jspm: string;
//// 'jspm:browser': string;
//// 'jspm:dev': string;
//// 'jspm:node': string;
//// }
//// let files: Configfiles;
@@ -13,5 +11,7 @@
//// '/*1*/': ''
//// }
verify.completionsAt("0", ["jspm", '"jspm:browser"', '"jspm:dev"', '"jspm:node"']);
verify.completionsAt("1", ["jspm", "jspm:browser", "jspm:dev", "jspm:node"]);
verify.completions(
{ marker: "0", exact: ["jspm", '"jspm:browser"'] },
{ marker: "1", exact: ["jspm", "jspm:browser"] },
);
tests/cases/fourslash/completionForQuotedPropertyInPropertyAssignment2.ts
+4 -4
View File
@@ -7,8 +7,6 @@
//// export interface ConfigFiles {
//// jspm: string;
//// 'jspm:browser': string;
//// 'jspm:dev': string;
//// 'jspm:node': string;
//// }
//// let config: Config;
@@ -19,5 +17,7 @@
//// }
//// }
verify.completionsAt("0", ["jspm", '"jspm:browser"', '"jspm:dev"', '"jspm:node"']);
verify.completionsAt("1", ["jspm", "jspm:browser", "jspm:dev", "jspm:node"]);
verify.completions(
{ marker: "0", exact: ["jspm", '"jspm:browser"'] },
{ marker: "1", exact: ["jspm", "jspm:browser"] },
);
tests/cases/fourslash/completionForQuotedPropertyInPropertyAssignment3.ts
+4 -2
View File
@@ -15,5 +15,7 @@
//// '/*1*/': ""
//// }
verify.completionsAt("0", ["jspm", '"jspm:browser"']);
verify.completionsAt("1", ["jspm", "jspm:browser"]);
verify.completions(
{ marker: "0", exact: ["jspm", '"jspm:browser"'] },
{ marker: "1", exact: ["jspm", "jspm:browser"] },
);
tests/cases/fourslash/completionForQuotedPropertyInPropertyAssignment4.ts
+4 -10
View File
@@ -3,8 +3,6 @@
//// export interface ConfigFiles {
//// jspm: string;
//// 'jspm:browser': string;
//// 'jspm:dev': string;
//// 'jspm:node': string;
//// }
//// function foo(c: ConfigFiles) {}
@@ -13,12 +11,8 @@
//// "/*1*/": "",
//// })
goTo.marker('0');
verify.completionListContains("jspm");
//verify.completionListAllowsNewIdentifier();
//verify.completionListCount(1);
/*goTo.marker('1');
verify.completionListContains("jspm:dev");
verify.completionListAllowsNewIdentifier();
verify.completionListCount(4);*/
verify.completions(
{ marker: "0", exact: ["jspm", '"jspm:browser"'] },
{ marker: "1", exact: ["jspm", "jspm:browser"] },
);
tests/cases/fourslash/completionForStringLiteral.ts
+1 -7
View File
@@ -6,10 +6,4 @@
////function f(a: Options) { };
////f("/*2*/
goTo.marker('1');
verify.completionListContains("Option 1");
verify.completionListCount(3);
goTo.marker('2');
verify.completionListContains("Option 2");
verify.completionListCount(3);
verify.completions({ marker: ["1", "2"], exact: ["Option 1", "Option 2", "Option 3"] });
tests/cases/fourslash/completionForStringLiteral10.ts
+1 -6
View File
@@ -4,9 +4,4 @@
////let a: As;
////if ('/**/' != a
goTo.marker();
verify.completionListContains("arf");
verify.completionListContains("abacus");
verify.completionListContains("abaddon");
verify.completionListCount(3);
verify.completions({ marker: "", exact: ["arf", "abacus", "abaddon"] });
tests/cases/fourslash/completionForStringLiteral11.ts
+1 -6
View File
@@ -6,9 +6,4 @@
//// case '/**/
////}
goTo.marker();
verify.completionListContains("arf");
verify.completionListContains("abacus");
verify.completionListContains("abaddon");
verify.completionListCount(3);
verify.completions({ marker: "", exact: ["arf", "abacus", "abaddon" ] });
tests/cases/fourslash/completionForStringLiteral12.ts
+1 -3
View File
@@ -5,6 +5,4 @@
////function foo(x: string) {}
////foo("/**/")
goTo.marker();
verify.completionListContains("bla");
verify.completionListCount(1);
verify.completions({ marker: "", exact: "bla" });
tests/cases/fourslash/completionForStringLiteral13.ts
+1 -2
View File
@@ -10,5 +10,4 @@
////var Promise: PromiseConstructor;
////Promise["/*1*/"];
goTo.marker('1');
verify.not.completionListContains("__@species");
verify.completions({ marker: "1", exact: [] });
tests/cases/fourslash/completionForStringLiteral2.ts
+4 -2
View File
@@ -11,5 +11,7 @@
////o["/*2*/ ;
////p["/*3*/"];
verify.completionsAt(["1", "2"], ["foo", "bar", "some other name"]);
verify.completionsAt("3", ["a"], { isNewIdentifierLocation: true });
verify.completions(
{ marker: ["1", "2"], exact: ["foo", "bar", "some other name"] },
{ marker: "3", exact: "a", isNewIdentifierLocation: true },
);
tests/cases/fourslash/completionForStringLiteral3.ts
+1 -1
View File
@@ -9,4 +9,4 @@
////
////f("/*2*/
verify.completionsAt(["1", "2"], ["A", "B", "C"], { isNewIdentifierLocation: true });
verify.completions({ marker: ["1", "2"], exact: ["A", "B", "C"], isNewIdentifierLocation: true });
tests/cases/fourslash/completionForStringLiteral4.ts
+1 -4
View File
@@ -17,7 +17,4 @@ goTo.marker('1');
verify.quickInfoExists();
verify.quickInfoIs('function f(p1: "literal", p2: "literal", p3: "other1" | "other2", p4: number | "literal", p5: true | 12): string', 'I am documentation');
goTo.marker('2');
verify.completionListContains("other1");
verify.completionListContains("other2");
verify.completionListCount(2);
verify.completions({ marker: "2", exact: ["other1", "other2"] });
tests/cases/fourslash/completionForStringLiteral5.ts
+1 -5
View File
@@ -8,8 +8,4 @@
////function f<K extends keyof Foo>(a: K) { };
////f("/*1*/
goTo.marker('1');
verify.completionListContains("foo");
verify.completionListContains("bar");
verify.completionListCount(2);
verify.completions({ marker: "1", exact: ["foo", "bar"] });
tests/cases/fourslash/completionForStringLiteral6.ts
+1 -4
View File
@@ -6,7 +6,4 @@
////function bar(f: Foo) { };
////bar({x: "/**/"});
goTo.marker();
verify.completionListContains("abc");
verify.completionListContains("def");
verify.completionListCount(2);
verify.completions({ marker: "", exact: ["abc", "def"] });
tests/cases/fourslash/completionForStringLiteral7.ts
+4 -2
View File
@@ -5,5 +5,7 @@
////function f(x: T, ...args: U[]) { };
////f("/*1*/", "/*2*/", "/*3*/");
verify.completionsAt("1", ["foo", "bar"]);
verify.completionsAt(["2", "3"], ["oof", "rab"]);
verify.completions(
{ marker: "1", exact: ["foo", "bar"] },
{ marker: ["2", "3"], exact: ["oof", "rab"] },
);
tests/cases/fourslash/completionForStringLiteral8.ts
+1 -6
View File
@@ -4,9 +4,4 @@
////let a: As;
////if (a === '/**/
goTo.marker();
verify.completionListContains("arf");
verify.completionListContains("abacus");
verify.completionListContains("abaddon");
verify.completionListCount(3);
verify.completions({ marker: "", exact: ["arf", "abacus", "abaddon"] });
tests/cases/fourslash/completionForStringLiteralExport.ts
+6 -4
View File
@@ -21,7 +21,9 @@
// @Filename: my_typings/some-module/index.d.ts
//// export var x = 9;
verify.completionsAt(["0", "4"], ["someFile1", "my_typings", "sub"], { isNewIdentifierLocation: true });
verify.completionsAt("1", ["someFile2"], { isNewIdentifierLocation: true });
verify.completionsAt("2", [{ name: "some-module", replacementSpan: test.ranges()[0] }], { isNewIdentifierLocation: true });
verify.completionsAt("3", ["fourslash"], { isNewIdentifierLocation: true });
verify.completions(
{ marker: ["0", "4"], exact: ["someFile1", "my_typings", "sub"], isNewIdentifierLocation: true },
{ marker: "1", exact: "someFile2", isNewIdentifierLocation: true },
{ marker: "2", exact: { name: "some-module", replacementSpan: test.ranges()[0] }, isNewIdentifierLocation: true },
{ marker: "3", exact: "fourslash", isNewIdentifierLocation: true },
);
tests/cases/fourslash/completionForStringLiteralFromSignature.ts
+1 -1
View File
@@ -4,4 +4,4 @@
////declare function f(a: string): void;
////f("/**/");
verify.completionsAt("", ["x"], { isNewIdentifierLocation: true });
verify.completions({ marker: "", exact: "x", isNewIdentifierLocation: true });
tests/cases/fourslash/completionForStringLiteralFromSignature2.ts
+1 -1
View File
@@ -4,4 +4,4 @@
////declare function f(a: string, b: number): void;
////f("/**/", 0);
verify.completionsAt("", [], { isNewIdentifierLocation: true });
verify.completions({ marker: "", exact: [], isNewIdentifierLocation: true });
tests/cases/fourslash/completionForStringLiteralImport1.ts
+6 -4
View File
@@ -20,7 +20,9 @@
// @Filename: my_typings/some-module/index.d.ts
//// export var x = 9;
verify.completionsAt("0", ["someFile1", "my_typings", "sub"], { isNewIdentifierLocation: true });
verify.completionsAt("1", ["someFile2"], { isNewIdentifierLocation: true });
verify.completionsAt("2", [{ name: "some-module", replacementSpan: test.ranges()[0] }], { isNewIdentifierLocation: true });
verify.completionsAt("3", ["fourslash"], { isNewIdentifierLocation: true });
verify.completions(
{ marker: "0", exact: ["someFile1", "my_typings", "sub"], isNewIdentifierLocation: true },
{ marker: "1", exact: "someFile2", isNewIdentifierLocation: true },
{ marker: "2", exact: { name: "some-module", replacementSpan: test.ranges()[0] }, isNewIdentifierLocation: true },
{ marker: "3", exact: "fourslash", isNewIdentifierLocation: true },
);
tests/cases/fourslash/completionForStringLiteralImport2.ts
+6 -4
View File
@@ -20,7 +20,9 @@
// @Filename: my_typings/some-module/index.d.ts
//// export var x = 9;
verify.completionsAt("0", ["someFile.ts", "my_typings", "sub"], { isNewIdentifierLocation: true });
verify.completionsAt("1", ["some-module"], { isNewIdentifierLocation: true });
verify.completionsAt("2", ["someOtherFile.ts"], { isNewIdentifierLocation: true });
verify.completionsAt("3", ["some-module"], { isNewIdentifierLocation: true });
verify.completions(
{ marker: "0", exact: ["someFile.ts", "my_typings", "sub"], isNewIdentifierLocation: true },
{ marker: "1", exact: "some-module", isNewIdentifierLocation: true },
{ marker: "2", exact: "someOtherFile.ts", isNewIdentifierLocation: true },
{ marker: "3", exact: "some-module", isNewIdentifierLocation: true },
);
tests/cases/fourslash/completionForStringLiteralInIndexedAccess01.ts
+1 -4
View File
@@ -7,7 +7,4 @@
////
////let x: Foo["/*1*/"]
goTo.marker("1");
verify.completionListContains("foo");
verify.completionListContains("bar");
verify.completionListCount(2);
verify.completions({ marker: "1", exact: ["foo", "bar"] });
tests/cases/fourslash/completionForStringLiteralNonrelativeImport1.ts
+5 -3
View File
@@ -42,7 +42,9 @@
//// /*unlisted-module*/
["import_as", "import_equals", "require"].forEach((kind, i) => {
verify.completionsAt(`${kind}0`, ["fake-module", "fake-module-dev"], { isNewIdentifierLocation: true });
verify.completionsAt(`${kind}1`, ["dts", "index", "ts", "tsx"], { isNewIdentifierLocation: true });
verify.completionsAt(`${kind}2`, ["fake-module", "fake-module-dev"].map(name => ({ name, replacementSpan: test.ranges()[i] })), { isNewIdentifierLocation: true });
verify.completions(
{ marker: `${kind}0`, exact: ["fake-module", "fake-module-dev"], isNewIdentifierLocation: true },
{ marker: `${kind}1`, exact: ["dts", "index", "ts", "tsx"], isNewIdentifierLocation: true },
{ marker: `${kind}2`, exact: ["fake-module", "fake-module-dev"].map(name => ({ name, replacementSpan: test.ranges()[i] })), isNewIdentifierLocation: true },
);
});
tests/cases/fourslash/completionForStringLiteralNonrelativeImport10.ts
+1 -1
View File
@@ -24,4 +24,4 @@
// @Filename: dir1/dir2/dir3/node_modules/fake-module3/ts.ts
////
verify.completions({ marker: test.markerNames(), exact: [], isNewIdentifierLocation: true });
verify.completions({ marker: test.markers(), exact: [], isNewIdentifierLocation: true });
tests/cases/fourslash/completionForStringLiteralNonrelativeImport12.ts
+1 -1
View File
@@ -16,7 +16,7 @@
//// }
verify.completions({
marker: test.markerNames(),
marker: test.markers(),
exact: ["module", "dev-module", "peer-module", "optional-module"],
isNewIdentifierLocation: true,
});
tests/cases/fourslash/completionForStringLiteralNonrelativeImport2.ts
+1 -1
View File
@@ -27,4 +27,4 @@
// @Filename: ambient.ts
//// declare module "fake-module/other"
verify.completionsAt(["import_as0", "import_equals0", "require0"], ["other", "repeated"], { isNewIdentifierLocation: true })
verify.completions({ marker: ["import_as0", "import_equals0", "require0"], exact: ["other", "repeated"], isNewIdentifierLocation: true });
tests/cases/fourslash/completionForStringLiteralNonrelativeImport3.ts
+5 -1
View File
@@ -27,4 +27,8 @@
// @Filename: node_modules/fake-module/repeated.jsx
//// /*repeatedjsx*/
verify.completionsAt(["import_as0", "import_equals0", "require0"], ["dts", "js", "jsx", "repeated", "ts", "tsx"], { isNewIdentifierLocation: true });
verify.completions({
marker: ["import_as0", "import_equals0", "require0"],
exact: ["dts", "js", "jsx", "repeated", "ts", "tsx"],
isNewIdentifierLocation: true,
});
tests/cases/fourslash/completionForStringLiteralNonrelativeImport4.ts
+1 -1
View File
@@ -23,7 +23,7 @@
////
verify.completions({
marker: test.markerNames(),
marker: test.markers(),
exact: ["fake-module3", "fake-module2", "fake-module"],
isNewIdentifierLocation: true,
});
tests/cases/fourslash/completionForStringLiteralNonrelativeImport7.ts
+1 -1
View File
@@ -18,7 +18,7 @@
////
verify.completions({
marker: test.markerNames(),
marker: test.markers(),
exact: ["module", "module-from-node"],
isNewIdentifierLocation: true,
});
tests/cases/fourslash/completionForStringLiteralNonrelativeImport8.ts
+1 -1
View File
@@ -41,7 +41,7 @@
//// export var z = 5;
verify.completions({
marker: test.markerNames(),
marker: test.markers(),
exact: ["2test", "prefix", "prefix-only", "0test", "1test"],
isNewIdentifierLocation: true,
});
tests/cases/fourslash/completionForStringLiteralNonrelativeImport9.ts
+1 -1
View File
@@ -25,4 +25,4 @@
// @Filename: some/other/path.ts
//// export var y = 10;
verify.completions({ marker: test.markerNames(), exact: ["module1", "module2"], isNewIdentifierLocation: true });
verify.completions({ marker: test.markers(), exact: ["module1", "module2"], isNewIdentifierLocation: true });
tests/cases/fourslash/completionForStringLiteralNonrelativeImportTypings1.ts
+1 -10
View File
@@ -23,13 +23,4 @@
// @Filename: my_other_typings/module-z/index.d.ts
//// export var z = 9;
const kinds = ["types_ref", "import_as", "import_equals", "require"];
for (const kind of kinds) {
goTo.marker(kind + "0");
verify.completionListContains("module-x");
verify.completionListContains("module-y");
verify.completionListContains("module-z");
verify.not.completionListItemsCountIsGreaterThan(3);
}
verify.completions({ marker: test.markers(), exact: ["module-x", "module-y", "module-z"], isNewIdentifierLocation: true })
tests/cases/fourslash/completionForStringLiteralNonrelativeImportTypings2.ts
+1 -9
View File
@@ -21,12 +21,4 @@
// @Filename: my_other_typings/module-z/index.d.ts
//// export var z = 9;
const kinds = ["types_ref", "import_as", "import_equals", "require"];
for (const kind of kinds) {
goTo.marker(kind + "0");
verify.completionListContains("module-x");
verify.completionListContains("module-z");
verify.not.completionListItemsCountIsGreaterThan(2);
}
verify.completions({ marker: test.markers(), exact: ["module-x", "module-z"], isNewIdentifierLocation: true });
tests/cases/fourslash/completionForStringLiteralNonrelativeImportTypings3.ts
+5 -1
View File
@@ -18,4 +18,8 @@
// @Filename: package.json
//// { "dependencies": { "@types/module-y": "latest" } }
verify.completionsAt(["types_ref0", "import_as0", "import_equals0", "require0"], ["module-x", "module-y"], { isNewIdentifierLocation: true });
verify.completions({
marker: ["types_ref0", "import_as0", "import_equals0", "require0"],
exact: ["module-x", "module-y"],
isNewIdentifierLocation: true,
});
tests/cases/fourslash/completionForStringLiteralRelativeImport4.ts
+1 -1
View File
@@ -38,7 +38,7 @@
////
verify.completions({
marker: test.markerNames(),
marker: test.markers(),
exact: ["module1", "module2", "more", "module0"],
isNewIdentifierLocation: true,
});
tests/cases/fourslash/completionForStringLiteralRelativeImportAllowJSFalse.ts
+17 -36
View File
@@ -22,51 +22,32 @@
// @Filename: f1.ts
//// /*f1*/
////
// @Filename: f2.js
//// /*f2*/
////
// @Filename: f3.d.ts
//// /*f3*/
////
// @Filename: f4.tsx
//// /f4*/
////
// @Filename: f5.js
//// /*f5*/
////
// @Filename: f6.jsx
//// /*f6*/
////
// @Filename: f7.ts
//// /*f7*/
////
// @Filename: d1/f8.ts
//// /*d1f1*/
////
// @Filename: d1/f9.ts
//// /*d1f9*/
////
// @Filename: d2/f10.ts
//// /*d2f1*/
////
// @Filename: d2/f11.ts
//// /*d2f11*/
////
const kinds = ["import_as", "import_equals", "require"];
for (const kind of kinds) {
goTo.marker(kind + "0");
verify.completionListIsEmpty();
goTo.marker(kind + "1");
verify.completionListContains("f1");
verify.completionListContains("f3");
verify.completionListContains("f4");
verify.completionListContains("f7");
verify.completionListContains("d1");
verify.completionListContains("d2");
verify.not.completionListItemsCountIsGreaterThan(6);
goTo.marker(kind + "2");
verify.completionListContains("f8");
verify.completionListContains("f9");
verify.not.completionListItemsCountIsGreaterThan(2);
goTo.marker(kind + "3");
verify.completionListContains("f10");
verify.completionListContains("f11");
verify.completionListContains("d3");
verify.not.completionListItemsCountIsGreaterThan(3);
}
verify.completions(
{ marker: kinds.map(k => k + "0"), exact: [], isNewIdentifierLocation: true },
{ marker: kinds.map(k => k + "1"), exact: ["f1", "f3", "f4", "f7", "d1", "d2"], isNewIdentifierLocation: true },
{ marker: kinds.map(k => k + "2"), exact: ["f8", "f9"], isNewIdentifierLocation: true },
{ marker: kinds.map(k => k + "3"), exact: ["f10", "f11", "d3"], isNewIdentifierLocation: true },
);
tests/cases/fourslash/completionForStringLiteralRelativeImportAllowJSTrue.ts
+13 -23
View File
@@ -15,34 +15,24 @@
//// var foo6 = require("./f/*require1*/
// @Filename: f1.ts
//// /f1*/
////
// @Filename: f2.js
//// /*f2*/
////
// @Filename: f3.d.ts
//// /*f3*/
////
// @Filename: f4.tsx
//// /*f4*/
////
// @Filename: f5.js
//// /*f5*/
////
// @Filename: f6.jsx
//// /*f6*/
////
// @Filename: g1.ts
//// /*g1*/
////
// @Filename: g2.js
//// /*g2*/
const kinds = ["import_as", "import_equals", "require"];
////
for (const kind of kinds) {
for(let i = 0; i < 2; ++i) {
goTo.marker(kind + i);
verify.completionListContains("f1");
verify.completionListContains("f2");
verify.completionListContains("f3");
verify.completionListContains("f4");
verify.completionListContains("f5");
verify.completionListContains("f6");
verify.completionListContains("g1");
verify.completionListContains("g2");
verify.not.completionListItemsCountIsGreaterThan(8);
}
}
verify.completions({
marker: test.markers(),
exact: ["f1", "f2", "f3", "f4", "f5", "f6", "g1", "g2"],
isNewIdentifierLocation: true,
});
tests/cases/fourslash/completionForStringLiteralWithDynamicImport.ts
+6 -4
View File
@@ -20,7 +20,9 @@
// @Filename: my_typings/some-module/index.d.ts
//// export var x = 9;
verify.completionsAt("0", ["someFile1", "my_typings", "sub"], { isNewIdentifierLocation: true });
verify.completionsAt("1", ["someFile2"], { isNewIdentifierLocation: true });
verify.completionsAt("2", [{ name: "some-module", replacementSpan: test.ranges()[0] }], { isNewIdentifierLocation: true });
verify.completionsAt("3", ["fourslash"], { isNewIdentifierLocation: true });
verify.completions(
{ marker: "0", exact: ["someFile1", "my_typings", "sub"], isNewIdentifierLocation: true },
{ marker: "1", exact: "someFile2", isNewIdentifierLocation: true },
{ marker: "2", exact: { name: "some-module", replacementSpan: test.ranges()[0] }, isNewIdentifierLocation: true },
{ marker: "3", exact: "fourslash", isNewIdentifierLocation: true },
);
tests/cases/fourslash/completionForStringLiteral_details.ts
+11 -9
View File
@@ -17,12 +17,14 @@
////declare const o: I;
////o["/*prop*/"];
goTo.marker("path");
verify.completionListContains("other", "other", "", "script");
goTo.marker("type");
verify.completionListContains("a", "a", "", "string");
goTo.marker("prop");
verify.completionListContains("x", "(property) I.x: number", "Prop doc", "property");
verify.completionListContains("m", "(method) I.m(): void", "Method doc", "method");
verify.completions(
{ marker: "path", includes: { name: "other", text: "other", kind: "script" }, isNewIdentifierLocation: true },
{ marker: "type", exact: { name: "a", text: "a", kind: "string" } },
{
marker: "prop",
exact: [
{ name: "x", text: "(property) I.x: number", documentation: "Prop doc", kind: "property" },
{ name: "m", text: "(method) I.m(): void", documentation: "Method doc", kind: "method" },
],
},
);
tests/cases/fourslash/completionImportMeta.ts
+1 -2
View File
@@ -2,5 +2,4 @@
////import./**/
goTo.marker("");
verify.completionListContains("meta");
verify.completions({ marker: "", exact: "meta" });
tests/cases/fourslash/completionInAugmentedClassModule.ts
+1 -2
View File
@@ -4,5 +4,4 @@
////module m3f { export interface I { foo(): void } }
////var x: m3f./**/
goTo.marker();
verify.not.completionListContains("foo");
verify.completions({ marker: "", exact: "I" });
tests/cases/fourslash/completionInFunctionLikeBody.ts
+8 -31
View File
@@ -12,35 +12,12 @@
//// }
//// /*4*/
//// }
goTo.marker("1");
verify.completionListContains("async", "async", /*documentation*/ undefined, "keyword");
verify.not.completionListContains("public", "public", /*documentation*/ undefined, "keyword");
verify.not.completionListContains("private", "private", /*documentation*/ undefined, "keyword");
verify.not.completionListContains("protected", "protected", /*documentation*/ undefined, "keyword");
verify.not.completionListContains("constructor", "constructor", /*documentation*/ undefined, "keyword");
verify.not.completionListContains("readonly", "readonly", /*documentation*/ undefined, "keyword");
verify.not.completionListContains("static", "static", /*documentation*/ undefined, "keyword");
verify.not.completionListContains("abstract", "abstract", /*documentation*/ undefined, "keyword");
verify.not.completionListContains("get", "get", /*documentation*/ undefined, "keyword");
verify.not.completionListContains("set", "set", /*documentation*/ undefined, "keyword");
goTo.marker("2");
verify.completionListContains("async", "async", /*documentation*/ undefined, "keyword");
verify.not.completionListContains("public", "public", /*documentation*/ undefined, "keyword");
verify.not.completionListContains("private", "private", /*documentation*/ undefined, "keyword");
verify.not.completionListContains("protected", "protected", /*documentation*/ undefined, "keyword");
verify.not.completionListContains("constructor", "constructor", /*documentation*/ undefined, "keyword");
verify.not.completionListContains("readonly", "readonly", /*documentation*/ undefined, "keyword");
verify.not.completionListContains("static", "static", /*documentation*/ undefined, "keyword");
verify.not.completionListContains("abstract", "abstract", /*documentation*/ undefined, "keyword");
verify.not.completionListContains("get", "get", /*documentation*/ undefined, "keyword");
verify.not.completionListContains("set", "set", /*documentation*/ undefined, "keyword");
goTo.marker("3");
verify.completionListContainsClassElementKeywords();
goTo.marker("4");
verify.completionListContainsClassElementKeywords();
verify.completions(
{
marker: ["1", "2"],
includes: "async",
excludes: ["public", "private", "protected", "constructor", "readonly", "static", "abstract", "get", "set"],
},
{ marker: ["3", "4"], exact: completion.classElementKeywords, isNewIdentifierLocation: true },
);
tests/cases/fourslash/completionInIncompleteCallExpression.ts
+1 -3
View File
@@ -3,7 +3,5 @@
////var array = [1, 2, 4]
////function a4(x, y, z) { }
////a4(...<crash>/**/
goTo.marker();
verify.not.completionListIsEmpty();
verify.completions({ marker: "", exact: completion.globalsPlus(["a4", "array"]) });
tests/cases/fourslash/completionInJSDocFunctionNew.ts
+1 -2
View File
@@ -5,5 +5,4 @@
/////** @type {function (new: string, string): string} */
////var f = function () { return new/**/; }
goTo.marker();
verify.completionListContains('new');
verify.completions({ marker: "", includes: "new" });
tests/cases/fourslash/completionInJSDocFunctionThis.ts
+1 -2
View File
@@ -4,5 +4,4 @@
/////** @type {function (this: string, string): string} */
////var f = function (s) { return this/**/; }
goTo.marker();
verify.completionListContains('this')
verify.completions({ marker: "", includes: "this" });
tests/cases/fourslash/completionInJsDoc.ts
+7 -53
View File
@@ -54,56 +54,10 @@
////
//// /** @param /*16*/ */
goTo.marker('1');
verify.completionListContains("constructor");
verify.completionListContains("param");
verify.completionListContains("type");
verify.completionListContains("method");
verify.completionListContains("template");
goTo.marker('2');
verify.completionListContains("constructor");
verify.completionListContains("param");
verify.completionListContains("type");
goTo.marker('3');
verify.completionListIsEmpty();
goTo.marker('4');
verify.completionListContains('number');
goTo.marker('5');
verify.completionListContains('number');
goTo.marker('6');
verify.completionListIsEmpty();
goTo.marker('7');
verify.completionListIsEmpty();
goTo.marker('8');
verify.completionListContains('number');
goTo.marker('9');
verify.completionListContains("@argument");
goTo.marker('10');
verify.completionListContains("@returns");
goTo.marker('11');
verify.completionListContains("@argument");
goTo.marker('12');
verify.completionListContains("@constructor");
goTo.marker('13');
verify.completionListContains("@param");
goTo.marker('14');
verify.completionListIsEmpty();
goTo.marker('15');
verify.completionListIsEmpty();
goTo.marker('16');
verify.completionListIsEmpty();
verify.completions(
{ marker: ["1", "2"], includes: ["constructor", "param", "type", "method", "template"] },
{ marker: ["3", "15", "16"], exact: [] },
{ marker: ["4", "5", "8"], includes: "number" },
{ marker: ["6", "7", "14"], exact: undefined },
{ marker: ["9", "10", "11", "12", "13"], includes: ["@argument", "@returns"] },
);
tests/cases/fourslash/completionInJsDocQualifiedNames.ts
+1 -2
View File
@@ -11,5 +11,4 @@
/////** @type {Foo./**/} */
////const x = 0;
goTo.marker();
verify.completionListContains("T", "type T = number", "tee", "type");
verify.completions({ marker: "", includes: { name: "T", text: "type T = number", documentation: "tee", kind: "type" } });
tests/cases/fourslash/completionInNamedImportLocation.ts
+4 -9
View File
@@ -12,12 +12,7 @@
////import { x, /*2*/ } from "./file";
goTo.file("a.ts");
goTo.marker('1');
verify.completionListContains("x", "var x: number");
verify.completionListContains("y", "var y: number");
verify.not.completionListContains("C");
goTo.marker('2');
verify.not.completionListContains("x", "var x: number");
verify.completionListContains("y", "var y: number");
verify.not.completionListContains("C");
verify.completions(
{ marker: "1", exact: [{ name: "x", text: "var x: number" }, { name: "y", text: "var y: number" }] },
{ marker: "2", exact: [{ name: "y", text: "var y: number" }] },
);
tests/cases/fourslash/completionInTypeOf1.ts
+1 -4
View File
@@ -5,8 +5,5 @@
////}
////var x: typeof m1c./*1*/;
goTo.marker('1');
// No completion because m1c is not an instantiated module.
verify.not.completionListContains('I');
verify.not.completionListContains('foo');
verify.completions({ marker: "1", exact: undefined });
tests/cases/fourslash/completionInTypeOf2.ts
+1 -3
View File
@@ -5,6 +5,4 @@
////}
////var x: typeof m1c./*1*/;
goTo.marker('1');
verify.completionListContains('C');
verify.not.completionListContains('foo');
verify.completions({ marker: "1", exact: "C" });
tests/cases/fourslash/completionInfoWithExplicitTypeArguments.ts
+1 -9
View File
@@ -11,12 +11,4 @@
////declare function g<T>(x: keyof T, y: number): void;
////g<I>("/*g*/");
goTo.marker("f");
verify.completionListCount(2);
verify.completionListContains("x");
verify.completionListContains("y");
goTo.marker("g");
verify.completionListContains("x");
verify.completionListContains("y");
verify.completionListCount(2);
verify.completions({ marker: test.markers(), exact: ["x", "y"] });
tests/cases/fourslash/completionInsideFunctionContainsArguments.ts
+4 -10
View File
@@ -10,13 +10,7 @@
////}
////let g = () => /*5*/
goTo.marker('1');
verify.completionListContains("arguments");
goTo.marker('2');
verify.not.completionListContains("arguments");
goTo.marker('3');
verify.completionListContains("arguments");
goTo.marker('4');
verify.completionListContains("arguments");
goTo.marker('5');
verify.not.completionListContains("arguments");
verify.completions(
{ marker: ["1", "3", "4"], includes: "arguments" },
{ marker: ["2", "5"], excludes: "arguments" },
);
tests/cases/fourslash/completionListAfterAnyType.ts
+2 -4
View File
@@ -3,11 +3,9 @@
//// declare class myString {
//// charAt(pos: number): string;
//// }
////
////
//// function bar(a: myString) {
//// var x: any = a./**/
//// }
goTo.marker();
verify.completionListContains("charAt");
verify.completionListCount(1);
verify.completions({ marker: "", exact: "charAt" });
tests/cases/fourslash/completionListAfterClassExtends.ts
+1 -4
View File
@@ -10,7 +10,4 @@
////function Blah(x: Bar.Bleah) {
////}
goTo.marker();
verify.completionListContains("Bar");
verify.completionListContains("Bleah");
verify.completionListContains("Foo");
verify.completions({ marker: "", includes: ["Bar", "Bleah", "Foo"] });
tests/cases/fourslash/completionListAfterFunction.ts
+6 -11
View File
@@ -12,14 +12,9 @@
////// inside the function
////function f4(d: number) { /*4*/}
goTo.marker("1");
verify.not.completionListContains("a");
goTo.marker("2");
verify.completionListContains("b");
goTo.marker("3");
verify.not.completionListContains("c");
goTo.marker("4");
verify.completionListContains("d");
verify.completions(
{ marker: "1", excludes: "a" },
{ marker: "2", includes: "b" },
{ marker: "3", excludes: "c" },
{ marker: "4", includes: "d" },
);

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