namespace FourSlash {

ts.disableIncrementalParsing = false;

import ArrayOrSingle = FourSlashInterface.ArrayOrSingle;

export const enum FourSlashTestType {

Native,

Shims,

ShimsWithPreprocess,

Server

}

// Represents a parsed source file with metadata

interface FourSlashFile {

// The contents of the file (with markers, etc stripped out)

content: string;

fileName: string;

symlinks?: string[];

version: number;

// File-specific options (name/value pairs)

fileOptions: Harness.TestCaseParser.CompilerSettings;

}

// Represents a set of parsed source files and options

interface FourSlashData {

// Global options (name/value pairs)

globalOptions: Harness.TestCaseParser.CompilerSettings;

files: FourSlashFile[];

// A mapping from marker names to name/position pairs

markerPositions: ts.Map<Marker>;

markers: Marker[];

/**

* Inserted in source files by surrounding desired text

* in a range with `[|` and `|]`. For example,

*

* [|text in range|]

*

* is a range with `text in range` "selected".

*/

ranges: Range[];

}

export interface Marker {

fileName: string;

position: number;

data?: {};

}

export interface Range {

fileName: string;

pos: number;

end: number;

marker?: Marker;

}

interface LocationInformation {

position: number;

sourcePosition: number;

sourceLine: number;

sourceColumn: number;

}

interface RangeLocationInformation extends LocationInformation {

marker?: Marker;

}

interface ImplementationLocationInformation extends ts.ImplementationLocation {

matched?: boolean;

}

export interface TextSpan {

start: number;

end: number;

}

// Name of testcase metadata including ts.CompilerOptions properties that will be used by globalOptions

// To add additional option, add property into the testOptMetadataNames, refer the property in either globalMetadataNames or fileMetadataNames

// Add cases into convertGlobalOptionsToCompilationsSettings function for the compiler to acknowledge such option from meta data

const enum MetadataOptionNames {

baselineFile = "BaselineFile",

emitThisFile = "emitThisFile", // This flag is used for testing getEmitOutput feature. It allows test-cases to indicate what file to be output in multiple files project

fileName = "Filename",

resolveReference = "ResolveReference", // This flag is used to specify entry file for resolve file references. The flag is only allow once per test file

symlink = "Symlink",

}

// List of allowed metadata names

const fileMetadataNames = [MetadataOptionNames.fileName, MetadataOptionNames.emitThisFile, MetadataOptionNames.resolveReference, MetadataOptionNames.symlink];

function convertGlobalOptionsToCompilerOptions(globalOptions: Harness.TestCaseParser.CompilerSettings): ts.CompilerOptions {

const settings: ts.CompilerOptions = { target: ts.ScriptTarget.ES5 };

Harness.Compiler.setCompilerOptionsFromHarnessSetting(globalOptions, settings);

return settings;

}

export class TestCancellationToken implements ts.HostCancellationToken {

// 0 - cancelled

// >0 - not cancelled

// <0 - not cancelled and value denotes number of isCancellationRequested after which token become cancelled

private static readonly notCanceled = -1;

private numberOfCallsBeforeCancellation = TestCancellationToken.notCanceled;

public isCancellationRequested(): boolean {

if (this.numberOfCallsBeforeCancellation < 0) {

return false;

}

if (this.numberOfCallsBeforeCancellation > 0) {

this.numberOfCallsBeforeCancellation--;

return false;

}

return true;

}

public setCancelled(numberOfCalls = 0): void {

ts.Debug.assert(numberOfCalls >= 0);

this.numberOfCallsBeforeCancellation = numberOfCalls;

}

public resetCancelled(): void {

this.numberOfCallsBeforeCancellation = TestCancellationToken.notCanceled;

}

}

export function verifyOperationIsCancelled(f: () => void) {

try {

f();

}

catch (e) {

if (e instanceof ts.OperationCanceledException) {

return;

}

}

throw new Error("Operation should be cancelled");

}

// This function creates IScriptSnapshot object for testing getPreProcessedFileInfo

// Return object may lack some functionalities for other purposes.

function createScriptSnapShot(sourceText: string): ts.IScriptSnapshot {

return ts.ScriptSnapshot.fromString(sourceText);

}

export class TestState {

// Language service instance

private languageServiceAdapterHost: Harness.LanguageService.LanguageServiceAdapterHost;

private languageService: ts.LanguageService;

private cancellationToken: TestCancellationToken;

// The current caret position in the active file

public currentCaretPosition = 0;

// The position of the end of the current selection, or -1 if nothing is selected

public selectionEnd = -1;

public lastKnownMarker = "";

// The file that's currently 'opened'

public activeFile: FourSlashFile;

// Whether or not we should format on keystrokes

public enableFormatting = true;

public formatCodeSettings: ts.FormatCodeSettings;

private inputFiles = ts.createMap<string>(); // Map between inputFile's fileName and its content for easily looking up when resolving references

private static getDisplayPartsJson(displayParts: ts.SymbolDisplayPart[] | undefined) {

let result = "";

ts.forEach(displayParts, part => {

if (result) {

result += ",\n ";

}

else {

result = "[\n ";

}

result += JSON.stringify(part);

});

if (result) {

result += "\n]";

}

return result;

}

// Add input file which has matched file name with the given reference-file path.

// This is necessary when resolveReference flag is specified

private addMatchedInputFile(referenceFilePath: string, extensions: ReadonlyArray<string> | undefined) {

const inputFiles = this.inputFiles;

const languageServiceAdapterHost = this.languageServiceAdapterHost;

const didAdd = tryAdd(referenceFilePath);

if (extensions && !didAdd) {

ts.forEach(extensions, ext => tryAdd(referenceFilePath + ext));

}

function tryAdd(path: string) {

const inputFile = inputFiles.get(path);

if (inputFile && !Harness.isDefaultLibraryFile(path)) {

languageServiceAdapterHost.addScript(path, inputFile, /*isRootFile*/ true);

return true;

}

}

}

private getLanguageServiceAdapter(testType: FourSlashTestType, cancellationToken: TestCancellationToken, compilationOptions: ts.CompilerOptions): Harness.LanguageService.LanguageServiceAdapter {

switch (testType) {

case FourSlashTestType.Native:

return new Harness.LanguageService.NativeLanguageServiceAdapter(cancellationToken, compilationOptions);

case FourSlashTestType.Shims:

return new Harness.LanguageService.ShimLanguageServiceAdapter(/*preprocessToResolve*/ false, cancellationToken, compilationOptions);

case FourSlashTestType.ShimsWithPreprocess:

return new Harness.LanguageService.ShimLanguageServiceAdapter(/*preprocessToResolve*/ true, cancellationToken, compilationOptions);

case FourSlashTestType.Server:

return new Harness.LanguageService.ServerLanguageServiceAdapter(cancellationToken, compilationOptions);

default:

throw new Error("Unknown FourSlash test type: ");

}

}

constructor(private basePath: string, private testType: FourSlashTestType, public testData: FourSlashData) {

// Create a new Services Adapter

this.cancellationToken = new TestCancellationToken();

let compilationOptions = convertGlobalOptionsToCompilerOptions(this.testData.globalOptions);

compilationOptions.skipDefaultLibCheck = true;

// Initialize the language service with all the scripts

let startResolveFileRef: FourSlashFile | undefined;

let configFileName: string | undefined;

for (const file of testData.files) {

// Create map between fileName and its content for easily looking up when resolveReference flag is specified

this.inputFiles.set(file.fileName, file.content);

if (isConfig(file)) {

const configJson = ts.parseConfigFileTextToJson(file.fileName, file.content);

if (configJson.config === undefined) {

throw new Error(`Failed to parse test ${file.fileName}: ${configJson.error!.messageText}`);

}

// Extend our existing compiler options so that we can also support tsconfig only options

if (configJson.config.compilerOptions) {

const baseDirectory = ts.normalizePath(ts.getDirectoryPath(file.fileName));

const tsConfig = ts.convertCompilerOptionsFromJson(configJson.config.compilerOptions, baseDirectory, file.fileName);

if (!tsConfig.errors || !tsConfig.errors.length) {

compilationOptions = ts.extend(compilationOptions, tsConfig.options);

}

}

configFileName = file.fileName;

}

if (!startResolveFileRef && file.fileOptions[MetadataOptionNames.resolveReference] === "true") {

startResolveFileRef = file;

}

else if (startResolveFileRef) {

// If entry point for resolving file references is already specified, report duplication error

throw new Error("There exists a Fourslash file which has resolveReference flag specified; remove duplicated resolveReference flag");

}

}

if (configFileName) {

const baseDir = ts.normalizePath(ts.getDirectoryPath(configFileName));

const files: vfs.FileSet = { [baseDir]: {} };

this.inputFiles.forEach((data, path) => {

const scriptInfo = new Harness.LanguageService.ScriptInfo(path, undefined!, /*isRootFile*/ false); // TODO: GH#18217

files[path] = new vfs.File(data, { meta: { scriptInfo } });

});

const fs = new vfs.FileSystem(/*ignoreCase*/ true, { cwd: baseDir, files });

const host = new fakes.ParseConfigHost(fs);

const jsonSourceFile = ts.parseJsonText(configFileName, this.inputFiles.get(configFileName)!);

compilationOptions = ts.parseJsonSourceFileConfigFileContent(jsonSourceFile, host, baseDir, compilationOptions, configFileName).options;

}

if (compilationOptions.typeRoots) {

compilationOptions.typeRoots = compilationOptions.typeRoots.map(p => ts.getNormalizedAbsolutePath(p, this.basePath));

}

const languageServiceAdapter = this.getLanguageServiceAdapter(testType, this.cancellationToken, compilationOptions);

this.languageServiceAdapterHost = languageServiceAdapter.getHost();

this.languageService = memoWrap(languageServiceAdapter.getLanguageService(), this); // Wrap the LS to cache some expensive operations certain tests call repeatedly

if (startResolveFileRef) {

// Add the entry-point file itself into the languageServiceShimHost

this.languageServiceAdapterHost.addScript(startResolveFileRef.fileName, startResolveFileRef.content, /*isRootFile*/ true);

const resolvedResult = languageServiceAdapter.getPreProcessedFileInfo(startResolveFileRef.fileName, startResolveFileRef.content);

const referencedFiles: ts.FileReference[] = resolvedResult.referencedFiles;

const importedFiles: ts.FileReference[] = resolvedResult.importedFiles;

// Add triple reference files into language-service host

ts.forEach(referencedFiles, referenceFile => {

// Fourslash insert tests/cases/fourslash into inputFile.unitName so we will properly append the same base directory to refFile path

const referenceFilePath = this.basePath + "/" + referenceFile.fileName;

this.addMatchedInputFile(referenceFilePath, /* extensions */ undefined);

});

// Add import files into language-service host

ts.forEach(importedFiles, importedFile => {

// Fourslash insert tests/cases/fourslash into inputFile.unitName and import statement doesn't require ".ts"

// so convert them before making appropriate comparison

const importedFilePath = this.basePath + "/" + importedFile.fileName;

this.addMatchedInputFile(importedFilePath, ts.getSupportedExtensions(compilationOptions));

});

// Check if no-default-lib flag is false and if so add default library

if (!resolvedResult.isLibFile) {

this.languageServiceAdapterHost.addScript(Harness.Compiler.defaultLibFileName,

Harness.Compiler.getDefaultLibrarySourceFile()!.text, /*isRootFile*/ false);

}

}

else {

// resolveReference file-option is not specified then do not resolve any files and include all inputFiles

this.inputFiles.forEach((file, fileName) => {

if (!Harness.isDefaultLibraryFile(fileName)) {

this.languageServiceAdapterHost.addScript(fileName, file, /*isRootFile*/ true);

}

});

if (!compilationOptions.noLib) {

this.languageServiceAdapterHost.addScript(Harness.Compiler.defaultLibFileName,

Harness.Compiler.getDefaultLibrarySourceFile()!.text, /*isRootFile*/ false);

}

}

for (const file of testData.files) {

ts.forEach(file.symlinks, link => {

this.languageServiceAdapterHost.vfs.mkdirpSync(vpath.dirname(link));

this.languageServiceAdapterHost.vfs.symlinkSync(file.fileName, link);

});

}

this.formatCodeSettings = {

baseIndentSize: 0,

indentSize: 4,

tabSize: 4,

newLineCharacter: "\n",

convertTabsToSpaces: true,

indentStyle: ts.IndentStyle.Smart,

insertSpaceAfterCommaDelimiter: true,

insertSpaceAfterSemicolonInForStatements: true,

insertSpaceBeforeAndAfterBinaryOperators: true,

insertSpaceAfterConstructor: false,

insertSpaceAfterKeywordsInControlFlowStatements: true,

insertSpaceAfterFunctionKeywordForAnonymousFunctions: false,

insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: false,

insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: false,

insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: true,

insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: false,

insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces: false,

insertSpaceAfterTypeAssertion: false,

placeOpenBraceOnNewLineForFunctions: false,

placeOpenBraceOnNewLineForControlBlocks: false,

insertSpaceBeforeTypeAnnotation: false

};

// Open the first file by default

this.openFile(0);

function memoWrap(ls: ts.LanguageService, target: TestState): ts.LanguageService {

const cacheableMembers: (keyof typeof ls)[] = [

"getCompletionEntryDetails",

"getCompletionEntrySymbol",

"getQuickInfoAtPosition",

"getReferencesAtPosition",

"getDocumentHighlights",

];

const proxy = {} as ts.LanguageService;

for (const k in ls) {

const key = k as keyof typeof ls;

if (cacheableMembers.indexOf(key) === -1) {

proxy[key] = (...args: any[]) => (ls[key] as Function)(...args);

continue;

}

const memo = Utils.memoize(

(_version: number, _active: string, _caret: number, _selectEnd: number, _marker: string, ...args: any[]) => (ls[key] as Function)(...args),

(...args) => args.join("|,|")

);

proxy[key] = (...args: any[]) => memo(

target.languageServiceAdapterHost.getScriptInfo(target.activeFile.fileName)!.version,

target.activeFile.fileName,

target.currentCaretPosition,

target.selectionEnd,

target.lastKnownMarker,

...args

);

}

return proxy;

}

}

private getFileContent(fileName: string): string {

return ts.Debug.assertDefined(this.tryGetFileContent(fileName));

}

private tryGetFileContent(fileName: string): string | undefined {

const script = this.languageServiceAdapterHost.getScriptInfo(fileName);

return script && script.content;

}

// Entry points from fourslash.ts

public goToMarker(name: string | Marker = "") {

const marker = ts.isString(name) ? this.getMarkerByName(name) : name;

if (this.activeFile.fileName !== marker.fileName) {

this.openFile(marker.fileName);

}

const content = this.getFileContent(marker.fileName);

if (marker.position === -1 || marker.position > content.length) {

throw new Error(`Marker "${name}" has been invalidated by unrecoverable edits to the file.`);

}

const mName = ts.isString(name) ? name : this.markerName(marker);

this.lastKnownMarker = mName;

this.goToPosition(marker.position);

}

public goToEachMarker(markers: ReadonlyArray<Marker>, action: (marker: Marker, index: number) => void) {

assert(markers.length);

for (let i = 0; i < markers.length; i++) {

this.goToMarker(markers[i]);

action(markers[i], i);

}

}

public goToEachRange(action: () => void) {

const ranges = this.getRanges();

assert(ranges.length);

for (const range of ranges) {

this.selectRange(range);

action();

}

}

public markerName(m: Marker): string {

return ts.forEachEntry(this.testData.markerPositions, (marker, name) => {

if (marker === m) {

return name;

}

})!;

}

public goToPosition(pos: number) {

this.currentCaretPosition = pos;

this.selectionEnd = -1;

}

public select(startMarker: string, endMarker: string) {

const start = this.getMarkerByName(startMarker), end = this.getMarkerByName(endMarker);

ts.Debug.assert(start.fileName === end.fileName);

if (this.activeFile.fileName !== start.fileName) {

this.openFile(start.fileName);

}

this.goToPosition(start.position);

this.selectionEnd = end.position;

}

public selectAllInFile(fileName: string) {

this.openFile(fileName);

this.goToPosition(0);

this.selectionEnd = this.activeFile.content.length;

}

public selectRange(range: Range): void {

this.goToRangeStart(range);

this.selectionEnd = range.end;

}

public moveCaretRight(count = 1) {

this.currentCaretPosition += count;

this.currentCaretPosition = Math.min(this.currentCaretPosition, this.getFileContent(this.activeFile.fileName).length);

this.selectionEnd = -1;

}

// Opens a file given its 0-based index or fileName

public openFile(indexOrName: number | string, content?: string, scriptKindName?: string): void {

const fileToOpen: FourSlashFile = this.findFile(indexOrName);

fileToOpen.fileName = ts.normalizeSlashes(fileToOpen.fileName);

this.activeFile = fileToOpen;

// Let the host know that this file is now open

this.languageServiceAdapterHost.openFile(fileToOpen.fileName, content, scriptKindName);

}

public verifyErrorExistsBetweenMarkers(startMarkerName: string, endMarkerName: string, shouldExist: boolean) {

const startMarker = this.getMarkerByName(startMarkerName);

const endMarker = this.getMarkerByName(endMarkerName);

const predicate = (errorMinChar: number, errorLimChar: number, startPos: number, endPos: number) =>

((errorMinChar === startPos) && (errorLimChar === endPos)) ? true : false;

const exists = this.anyErrorInRange(predicate, startMarker, endMarker);

if (exists !== shouldExist) {

this.printErrorLog(shouldExist, this.getAllDiagnostics());

throw new Error(`${shouldExist ? "Expected" : "Did not expect"} failure between markers: '${startMarkerName}', '${endMarkerName}'`);

}

}

private raiseError(message: string): never {

throw new Error(this.messageAtLastKnownMarker(message));

}

private messageAtLastKnownMarker(message: string) {

const locationDescription = this.lastKnownMarker ? this.lastKnownMarker : this.getLineColStringAtPosition(this.currentCaretPosition);

return `At ${locationDescription}: ${message}`;

}

private assertionMessageAtLastKnownMarker(msg: string) {

return "\nMarker: " + this.lastKnownMarker + "\nChecking: " + msg + "\n\n";

}

private getDiagnostics(fileName: string, includeSuggestions = false): ts.Diagnostic[] {

return [

...this.languageService.getSyntacticDiagnostics(fileName),

...this.languageService.getSemanticDiagnostics(fileName),

...(includeSuggestions ? this.languageService.getSuggestionDiagnostics(fileName) : ts.emptyArray),

];

}

private getAllDiagnostics(): ts.Diagnostic[] {

return ts.flatMap(this.languageServiceAdapterHost.getFilenames(), fileName => {

if (!ts.isAnySupportedFileExtension(fileName)) {

return [];

}

const baseName = ts.getBaseFileName(fileName);

if (baseName === "package.json" || baseName === "tsconfig.json" || baseName === "jsconfig.json") {

return [];

}

return this.getDiagnostics(fileName);

});

}

public verifyErrorExistsAfterMarker(markerName: string, shouldExist: boolean, after: boolean) {

const marker: Marker = this.getMarkerByName(markerName);

let predicate: (errorMinChar: number, errorLimChar: number, startPos: number, endPos: number) => boolean;

if (after) {

predicate = (errorMinChar: number, errorLimChar: number, startPos: number) =>

((errorMinChar >= startPos) && (errorLimChar >= startPos)) ? true : false;

}

else {

predicate = (errorMinChar: number, errorLimChar: number, startPos: number) =>

((errorMinChar <= startPos) && (errorLimChar <= startPos)) ? true : false;

}

const exists = this.anyErrorInRange(predicate, marker);

const diagnostics = this.getAllDiagnostics();

if (exists !== shouldExist) {

this.printErrorLog(shouldExist, diagnostics);

throw new Error(`${shouldExist ? "Expected" : "Did not expect"} failure at marker '${markerName}'`);

}

}

private anyErrorInRange(predicate: (errorMinChar: number, errorLimChar: number, startPos: number, endPos: number | undefined) => boolean, startMarker: Marker, endMarker?: Marker): boolean {

return this.getDiagnostics(startMarker.fileName).some(({ start, length }) =>

predicate(start!, start! + length!, startMarker.position, endMarker === undefined ? undefined : endMarker.position)); // TODO: GH#18217

}

private printErrorLog(expectErrors: boolean, errors: ts.Diagnostic[]) {

if (expectErrors) {

Harness.IO.log("Expected error not found. Error list is:");

}

else {

Harness.IO.log("Unexpected error(s) found. Error list is:");

}

for (const { start, length, messageText, file } of errors) {

Harness.IO.log(" " + this.formatRange(file, start!, length!) + // TODO: GH#18217

", message: " + ts.flattenDiagnosticMessageText(messageText, Harness.IO.newLine()) + "\n");

}

}

private formatRange(file: ts.SourceFile | undefined, start: number, length: number) {

if (file) {

return `from: ${this.formatLineAndCharacterOfPosition(file, start)}, to: ${this.formatLineAndCharacterOfPosition(file, start + length)}`;

}

return "global";

}

private formatLineAndCharacterOfPosition(file: ts.SourceFile, pos: number) {

if (file) {

const { line, character } = ts.getLineAndCharacterOfPosition(file, pos);

return `${line}:${character}`;

}

return "global";

}

private formatPosition(file: ts.SourceFile, pos: number) {

if (file) {

return file.fileName + "@" + pos;

}

return "global";

}

public verifyNoErrors() {

ts.forEachKey(this.inputFiles, fileName => {

if (!ts.isAnySupportedFileExtension(fileName)

|| !this.getProgram().getCompilerOptions().allowJs && !ts.extensionIsTypeScript(ts.extensionFromPath(fileName))) return;

const errors = this.getDiagnostics(fileName).filter(e => e.category !== ts.DiagnosticCategory.Suggestion);

if (errors.length) {

this.printErrorLog(/*expectErrors*/ false, errors);

const error = errors[0];

this.raiseError(`Found an error: ${this.formatPosition(error.file!, error.start!)}: ${error.messageText}`);

}

});

}

public verifyNumberOfErrorsInCurrentFile(expected: number) {

const errors = this.getDiagnostics(this.activeFile.fileName);

const actual = errors.length;

if (actual !== expected) {

this.printErrorLog(/*expectErrors*/ false, errors);

const errorMsg = "Actual number of errors (" + actual + ") does not match expected number (" + expected + ")";

Harness.IO.log(errorMsg);

this.raiseError(errorMsg);

}

}

public verifyEval(expr: string, value: any) {

const emit = this.languageService.getEmitOutput(this.activeFile.fileName);

if (emit.outputFiles.length !== 1) {

throw new Error("Expected exactly one output from emit of " + this.activeFile.fileName);

}

const evaluation = new Function(`${emit.outputFiles[0].text};\r\nreturn (${expr});`)();

if (evaluation !== value) {

this.raiseError(`Expected evaluation of expression "${expr}" to equal "${value}", but got "${evaluation}"`);

}

}

public verifyGoToDefinitionIs(endMarker: ArrayOrSingle<string>) {

this.verifyGoToXWorker(toArray(endMarker), () => this.getGoToDefinition());

}

public verifyGoToDefinition(arg0: any, endMarkerNames?: ArrayOrSingle<string>) {

this.verifyGoToX(arg0, endMarkerNames, () => this.getGoToDefinitionAndBoundSpan());

}

private getGoToDefinition(): ts.DefinitionInfo[] {

return this.languageService.getDefinitionAtPosition(this.activeFile.fileName, this.currentCaretPosition)!;

}

private getGoToDefinitionAndBoundSpan(): ts.DefinitionInfoAndBoundSpan {

return this.languageService.getDefinitionAndBoundSpan(this.activeFile.fileName, this.currentCaretPosition)!;

}

public verifyGoToType(arg0: any, endMarkerNames?: ArrayOrSingle<string>) {

this.verifyGoToX(arg0, endMarkerNames, () =>

this.languageService.getTypeDefinitionAtPosition(this.activeFile.fileName, this.currentCaretPosition));

}

private verifyGoToX(arg0: any, endMarkerNames: ArrayOrSingle<string> | undefined, getDefs: () => ts.DefinitionInfo[] | ts.DefinitionInfoAndBoundSpan | undefined) {

if (endMarkerNames) {

this.verifyGoToXPlain(arg0, endMarkerNames, getDefs);

}

else if (ts.isArray(arg0)) {

const pairs = arg0 as ReadonlyArray<[ArrayOrSingle<string>, ArrayOrSingle<string>]>;

for (const [start, end] of pairs) {

this.verifyGoToXPlain(start, end, getDefs);

}

}

else {

const obj: { [startMarkerName: string]: ArrayOrSingle<string> } = arg0;

for (const startMarkerName in obj) {

if (ts.hasProperty(obj, startMarkerName)) {

this.verifyGoToXPlain(startMarkerName, obj[startMarkerName], getDefs);

}

}

}

}

private verifyGoToXPlain(startMarkerNames: ArrayOrSingle<string>, endMarkerNames: ArrayOrSingle<string>, getDefs: () => ts.DefinitionInfo[] | ts.DefinitionInfoAndBoundSpan | undefined) {

for (const start of toArray(startMarkerNames)) {

this.verifyGoToXSingle(start, endMarkerNames, getDefs);

}

}

public verifyGoToDefinitionForMarkers(markerNames: string[]) {

for (const markerName of markerNames) {

this.verifyGoToXSingle(`${markerName}Reference`, `${markerName}Definition`, () => this.getGoToDefinition());

}

}

private verifyGoToXSingle(startMarkerName: string, endMarkerNames: ArrayOrSingle<string>, getDefs: () => ReadonlyArray<ts.DefinitionInfo> | ts.DefinitionInfoAndBoundSpan | undefined) {

this.goToMarker(startMarkerName);

this.verifyGoToXWorker(toArray(endMarkerNames), getDefs, startMarkerName);

}

private verifyGoToXWorker(endMarkers: ReadonlyArray<string>, getDefs: () => ReadonlyArray<ts.DefinitionInfo> | ts.DefinitionInfoAndBoundSpan | undefined, startMarkerName?: string) {

const defs = getDefs();

let definitions: ReadonlyArray<ts.DefinitionInfo>;

let testName: string;

if (!defs || ts.isArray(defs)) {

definitions = defs as ts.DefinitionInfo[] || [];

testName = "goToDefinitions";

}

else {

this.verifyDefinitionTextSpan(defs, startMarkerName!);

definitions = defs.definitions!; // TODO: GH#18217

testName = "goToDefinitionsAndBoundSpan";

}

if (endMarkers.length !== definitions.length) {

this.raiseError(`${testName} failed - expected to find ${endMarkers.length} definitions but got ${definitions.length}`);

}

ts.zipWith(endMarkers, definitions, (endMarker, definition, i) => {

const marker = this.getMarkerByName(endMarker);

if (marker.fileName !== definition.fileName || marker.position !== definition.textSpan.start) {

this.raiseError(`${testName} failed for definition ${endMarker} (${i}): expected ${marker.fileName} at ${marker.position}, got ${definition.fileName} at ${definition.textSpan.start}`);

}

});

}

private verifyDefinitionTextSpan(defs: ts.DefinitionInfoAndBoundSpan, startMarkerName: string) {

const range = this.testData.ranges.find(range => this.markerName(range.marker!) === startMarkerName);

if (!range && !defs.textSpan) {

return;

}

if (!range) {

this.raiseError(`goToDefinitionsAndBoundSpan failed - found a TextSpan ${JSON.stringify(defs.textSpan)} when it wasn't expected.`);

}

else if (defs.textSpan.start !== range.pos || defs.textSpan.length !== range.end - range.pos) {

const expected: ts.TextSpan = {

start: range.pos, length: range.end - range.pos

};

this.raiseError(`goToDefinitionsAndBoundSpan failed - expected to find TextSpan ${JSON.stringify(expected)} but got ${JSON.stringify(defs.textSpan)}`);

}

}

public verifyGetEmitOutputForCurrentFile(expected: string): void {

const emit = this.languageService.getEmitOutput(this.activeFile.fileName);

if (emit.outputFiles.length !== 1) {

throw new Error("Expected exactly one output from emit of " + this.activeFile.fileName);

}

const actual = emit.outputFiles[0].text;

if (actual !== expected) {

this.raiseError(`Expected emit output to be "${expected}", but got "${actual}"`);

}

}

public verifyGetEmitOutputContentsForCurrentFile(expected: ts.OutputFile[]): void {

const emit = this.languageService.getEmitOutput(this.activeFile.fileName);

assert.equal(emit.outputFiles.length, expected.length, "Number of emit output files");

ts.zipWith(emit.outputFiles, expected, (outputFile, expected) => {

assert.equal(outputFile.name, expected.name, "FileName");

assert.equal(outputFile.text, expected.text, "Content");

});

}

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

}

else {

for (const marker of toArray(options.marker)) {

this.goToMarker(marker);

this.verifyCompletionsWorker(options);

}

}

}

private verifyCompletionsWorker(options: FourSlashInterface.VerifyCompletionsOptions): void {

const actualCompletions = this.getCompletionListAtCaret({ ...options.preferences, triggerCharacter: options.triggerCharacter })!;

if (!actualCompletions) {

if ("exact" in options && options.exact === undefined) return;

this.raiseError(`No completions at position '${this.currentCaretPosition}'.`);

}

if (actualCompletions.isNewIdentifierLocation !== (options.isNewIdentifierLocation || false)) {

this.raiseError(`Expected 'isNewIdentifierLocation' to be ${options.isNewIdentifierLocation || false}, got ${actualCompletions.isNewIdentifierLocation}`);

}

const actualByName = ts.createMap<ts.CompletionEntry>();

for (const entry of actualCompletions.entries) {

if (actualByName.has(entry.name)) {

// TODO: GH#23587

if (entry.name !== "undefined" && entry.name !== "require") this.raiseError(`Duplicate (${actualCompletions.entries.filter(a => a.name === entry.name).length}) completions for ${entry.name}`);

}

else {

actualByName.set(entry.name, entry);

}

}

if ("exact" in options) {

ts.Debug.assert(!("includes" in options) && !("excludes" in options));

if (options.exact === undefined) throw this.raiseError("Expected no completions");

this.verifyCompletionsAreExactly(actualCompletions.entries, toArray(options.exact));

}

else {

if (options.includes) {

for (const include of toArray(options.includes)) {

const name = typeof include === "string" ? include : include.name;

const found = actualByName.get(name);

if (!found) throw this.raiseError(`No completion ${name} found`);

this.verifyCompletionEntry(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}`);

}

}

}

}

}

}

private verifyCompletionEntry(actual: ts.CompletionEntry, expected: FourSlashInterface.ExpectedCompletionEntry) {

const { insertText, replacementSpan, hasAction, isRecommended, kind, text, documentation, sourceDisplay } = typeof expected === "string"

? { insertText: undefined, replacementSpan: undefined, hasAction: undefined, isRecommended: undefined, kind: undefined, text: undefined, documentation: undefined, sourceDisplay: undefined }

: expected;

if (actual.insertText !== insertText) {

this.raiseError(`Expected completion insert text to be ${insertText}, got ${actual.insertText}`);

}

const convertedReplacementSpan = replacementSpan && ts.createTextSpanFromRange(replacementSpan);

try {

assert.deepEqual(actual.replacementSpan, convertedReplacementSpan);

}

catch {

this.raiseError(`Expected completion replacementSpan to be ${stringify(convertedReplacementSpan)}, got ${stringify(actual.replacementSpan)}`);

}

if (kind !== undefined) assert.equal(actual.kind, kind);

assert.equal(actual.hasAction, hasAction);

assert.equal(actual.isRecommended, isRecommended);

if (text) {

const actualDetails = this.getCompletionEntryDetails(actual.name, actual.source)!;

assert.equal(ts.displayPartsToString(actualDetails.displayParts), text);

assert.equal(ts.displayPartsToString(actualDetails.documentation), documentation || "");

// TODO: GH#23587

// assert.equal(actualDetails.kind, actual.kind);

assert.equal(actualDetails.kindModifiers, actual.kindModifiers);

assert.equal(actualDetails.source && ts.displayPartsToString(actualDetails.source), sourceDisplay);

}

else {

assert(documentation === undefined && sourceDisplay === undefined, "If specifying completion details, should specify 'text'");

}

}

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

}

ts.zipWith(actual, expected, (completion, expectedCompletion, index) => {

const name = typeof expectedCompletion === "string" ? expectedCompletion : expectedCompletion.name;

if (completion.name !== name) {

this.raiseError(`Expected completion at index ${index} to be ${name}, got ${completion.name}`);

}

this.verifyCompletionEntry(completion, expectedCompletion);

});

}

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) {