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[];

rangesByText?: ts.MultiMap<Range>;

}

export interface Marker {

fileName: string;

position: number;

data?: {};

}

export interface Range extends ts.TextRange {

fileName: string;

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;

private assertTextConsistent: ((fileName: string) => void) | undefined;

// 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: readonly 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 (this.testType === FourSlashTestType.Server) {

this.assertTextConsistent = fileName => (languageServiceAdapter as Harness.LanguageService.ServerLanguageServiceAdapter).assertTextConsistent(fileName);

}

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 = ts.testFormatSettings;

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

const keys = ts.getAllKeys(ls);

for (const k of keys) {

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: readonly 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: (range: Range) => void) {

const ranges = this.getRanges();

assert(ranges.length);

for (const range of ranges) {

this.selectRange(range);

action(range);

}

}

public markerName(m: Marker): string {

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

if (marker === m) {

return name;

}

})!;

}

public goToPosition(positionOrLineAndCharacter: number | ts.LineAndCharacter) {

const pos = typeof positionOrLineAndCharacter === "number"

? positionOrLineAndCharacter

: this.languageServiceAdapterHost.lineAndCharacterToPosition(this.activeFile.fileName, positionOrLineAndCharacter);

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 selectLine(index: number) {

const lineStart = this.languageServiceAdapterHost.lineAndCharacterToPosition(this.activeFile.fileName, { line: index, character: 0 });

const lineEnd = lineStart + this.getLineContent(index).length;

this.selectRange({ fileName: this.activeFile.fileName, pos: lineStart, end: lineEnd });

}

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(): readonly 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: readonly ts.Diagnostic[]): void {

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)

|| Harness.getConfigNameFromFileName(fileName)

|| !this.getProgram().getCompilerOptions().allowJs && !ts.resolutionExtensionIsTSOrJson(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 verifyErrorExistsAtRange(range: Range, code: number, expectedMessage?: string) {

const span = ts.createTextSpanFromRange(range);

const hasMatchingError = ts.some(

this.getDiagnostics(range.fileName),

({ code, messageText, start, length }) =>

code === code &&

(!expectedMessage || expectedMessage === messageText) &&

ts.isNumber(start) && ts.isNumber(length) &&

ts.textSpansEqual(span, { start, length }));

if (!hasMatchingError) {

this.raiseError(`No error with code ${code} found at provided range.`);

}

}

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});`)(); // eslint-disable-line no-new-func

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(): readonly 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: () => readonly ts.DefinitionInfo[] | ts.DefinitionInfoAndBoundSpan | undefined) {

if (endMarkerNames) {

this.verifyGoToXPlain(arg0, endMarkerNames, getDefs);

}

else if (ts.isArray(arg0)) {

const pairs = arg0 as readonly [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: () => readonly 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: () => readonly ts.DefinitionInfo[] | ts.DefinitionInfoAndBoundSpan | undefined) {

this.goToMarker(startMarkerName);

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

}

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

const defs = getDefs();

let definitions: readonly 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 (ts.comparePaths(marker.fileName, definition.fileName, /*ignoreCase*/ true) !== ts.Comparison.EqualTo || 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 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 (ts.hasProperty(options, "exact") && (options.exact === undefined || ts.isArray(options.exact) && !options.exact.length)) {

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

}

if (ts.hasProperty(options, "isGlobalCompletion") && 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) {

const entries = nameToEntries.get(entry.name);

if (!entries) {

nameToEntries.set(entry.name, [entry]);

}

else {

if (entries.some(e => e.source === entry.source)) {

this.raiseError(`Duplicate completions for ${entry.name}`);

}

entries.push(entry);

}

}

if (ts.hasProperty(options, "exact")) {

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

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

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

}

else {

if (options.includes) {

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

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

const found = nameToEntries.get(name);

if (!found) throw this.raiseError(`Includes: completion '${name}' not found.`);

assert(found.length === 1, `Must use 'exact' for multiple completions with same name: '${name}'`);

this.verifyCompletionEntry(ts.first(found), include);

}

}

if (options.excludes) {

for (const exclude of toArray(options.excludes)) {

assert(typeof exclude === "string");

if (nameToEntries.has(exclude)) {

this.raiseError(`Excludes: unexpected completion '${exclude}' found.`);

}

}

}

}

}

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

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

? { insertText: undefined, replacementSpan: undefined, hasAction: undefined, isRecommended: undefined, kind: undefined, kindModifiers: undefined, text: undefined, documentation: undefined, tags: undefined, source: undefined, sourceDisplay: undefined, sortText: 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 || kindModifiers !== undefined) {

if (actual.kind !== kind) {

this.raiseError(`Unexpected kind for ${actual.name}: Expected ${kind}, actual ${actual.kind}`);

}

if (actual.kindModifiers !== (kindModifiers || "")) {

this.raiseError(`Bad kind modifiers for ${actual.name}: Expected ${kindModifiers || ""}, actual ${actual.kindModifiers}`);

}

}

assert.equal(actual.hasAction, hasAction);

assert.equal(actual.isRecommended, isRecommended);

assert.equal(actual.source, source);

assert.equal(actual.sortText, sortText || ts.Completions.SortText.LocationPriority, this.messageAtLastKnownMarker(`Actual entry: ${JSON.stringify(actual)}`));

if (text !== undefined) {

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

assert.deepEqual(actualDetails.tags, tags);

}

else {

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

}

}

private verifyCompletionsAreExactly(actual: readonly ts.CompletionEntry[], expected: readonly FourSlashInterface.ExpectedCompletionEntry[], marker?: ArrayOrSingle<string | Marker>) {

// 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), marker ? "At marker " + JSON.stringify(marker) : undefined);

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

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

if (completion.name !== name) {

this.raiseError(`${marker ? JSON.stringify(marker) : ""} Expected completion at index ${index} to be ${name}, got ${completion.name}`);

}

this.verifyCompletionEntry(completion, expectedCompletion);

});

}

/** Use `getProgram` instead of accessing this directly. */

private _program: ts.Program | undefined;

/** Use `getChecker` instead of accessing this directly. */

private _checker: ts.TypeChecker | undefined;

private getProgram(): ts.Program {

return this._program || (this._program = this.languageService.getProgram()!); // TODO: GH#18217

}

private getChecker() {

return this._checker || (this._checker = this.getProgram().getTypeChecker());

}

private getSourceFile(): ts.SourceFile {

const { fileName } = this.activeFile;

const result = this.getProgram().getSourceFile(fileName);

if (!result) {

throw new Error(`Could not get source file ${fileName}`);

}

return result;

}

private getNode(): ts.Node {

return ts.getTouchingPropertyName(this.getSourceFile(), this.currentCaretPosition);

}

private goToAndGetNode(range: Range): ts.Node {

this.goToRangeStart(range);

const node = this.getNode();

this.verifyRange("touching property name", range, node);

return node;

}

private verifyRange(desc: string, expected: ts.TextRange, actual: ts.Node) {

const actualStart = actual.getStart();

const actualEnd = actual.getEnd();

if (actualStart !== expected.pos || actualEnd !== expected.end) {

this.raiseError(`${desc} should be ${expected.pos}-${expected.end}, got ${actualStart}-${actualEnd}`);

}

}

private verifySymbol(symbol: ts.Symbol, declarationRanges: Range[]) {

const { declarations } = symbol;

if (declarations.length !== declarationRanges.length) {

this.raiseError(`Expected to get ${declarationRanges.length} declarations, got ${declarations.length}`);

}

ts.zipWith(declarations, declarationRanges, (decl, range) => {

this.verifyRange("symbol declaration", range, decl);

});

}

public verifySymbolAtLocation(startRange: Range, declarationRanges: Range[]): void {

const node = this.goToAndGetNode(startRange);

const symbol = this.getChecker().getSymbolAtLocation(node)!;

if (!symbol) {

this.raiseError("Could not get symbol at location");

}

this.verifySymbol(symbol, declarationRanges);

}

public symbolsInScope(range: Range): ts.Symbol[] {

const node = this.goToAndGetNode(range);

return this.getChecker().getSymbolsInScope(node, ts.SymbolFlags.Value | ts.SymbolFlags.Type | ts.SymbolFlags.Namespace);

}

public setTypesRegistry(map: ts.MapLike<void>): void {

this.languageServiceAdapterHost.typesRegistry = ts.createMapFromTemplate(map);

}

public verifyTypeOfSymbolAtLocation(range: Range, symbol: ts.Symbol, expected: string): void {

const node = this.goToAndGetNode(range);

const checker = this.getChecker();

const type = checker.getTypeOfSymbolAtLocation(symbol, node);

const actual = checker.typeToString(type);

if (actual !== expected) {

this.raiseError(displayExpectedAndActualString(expected, actual));

}

}

private verifyDocumentHighlightsRespectFilesList(files: readonly string[]): void {

const startFile = this.activeFile.fileName;

for (const fileName of files) {

const searchFileNames = startFile === fileName ? [startFile] : [startFile, fileName];

const highlights = this.getDocumentHighlightsAtCurrentPosition(searchFileNames);

if (highlights && !highlights.every(dh => ts.contains(searchFileNames, dh.fileName))) {

this.raiseError(`When asking for document highlights only in files ${searchFileNames}, got document highlights in ${unique(highlights, dh => dh.fileName)}`);

}

}

}

public verifyReferenceGroups(starts: ArrayOrSingle<string> | ArrayOrSingle<Range>, parts: readonly FourSlashInterface.ReferenceGroup[]): void {

interface ReferenceGroupJson {

definition: string | { text: string, range: ts.TextSpan };

references: ts.ReferenceEntry[];

}

const fullExpected = ts.map<FourSlashInterface.ReferenceGroup, ReferenceGroupJson>(parts, ({ definition, ranges }) => ({

definition: typeof definition === "string" ? definition : { ...definition, range: ts.createTextSpanFromRange(definition.range) },

references: ranges.map<ts.ReferenceEntry>(r => {

const { isWriteAccess = false, isDefinition = false, isInString, contextRangeIndex } = (r.marker && r.marker.data || {}) as { isWriteAccess?: boolean, isDefinition?: boolean, isInString?: true, contextRangeIndex?: number };

return {

fileName: r.fileName,

textSpan: ts.createTextSpanFromRange(r),

isWriteAccess,

isDefinition,

...(contextRangeIndex !== undefined ?

{ contextSpan: ts.createTextSpanFromRange(this.getRanges()[contextRangeIndex]) } :

undefined),

...(isInString ? { isInString: true } : undefined),

};