namespace ts.server {

interface StackTraceError extends Error {

stack?: string;

}

export interface ServerCancellationToken extends HostCancellationToken {

setRequest(requestId: number): void;

resetRequest(requestId: number): void;

}

export const nullCancellationToken: ServerCancellationToken = {

isCancellationRequested: () => false,

setRequest: () => void 0,

resetRequest: () => void 0

};

function hrTimeToMilliseconds(time: number[]): number {

const seconds = time[0];

const nanoseconds = time[1];

return ((1e9 * seconds) + nanoseconds) / 1000000.0;

}

function isDeclarationFileInJSOnlyNonConfiguredProject(project: Project, file: NormalizedPath) {

// Checking for semantic diagnostics is an expensive process. We want to avoid it if we

// know for sure it is not needed.

// For instance, .d.ts files injected by ATA automatically do not produce any relevant

// errors to a JS- only project.

//

// Note that configured projects can set skipLibCheck (on by default in jsconfig.json) to

// disable checking for declaration files. We only need to verify for inferred projects (e.g.

// miscellaneous context in VS) and external projects(e.g.VS.csproj project) with only JS

// files.

//

// We still want to check .js files in a JS-only inferred or external project (e.g. if the

// file has '// @ts-check').

if ((isInferredProject(project) || isExternalProject(project)) &&

project.isJsOnlyProject()) {

const scriptInfo = project.getScriptInfoForNormalizedPath(file);

return scriptInfo && !scriptInfo.isJavaScript();

}

return false;

}

function dtsChangeCanAffectEmit(compilationSettings: CompilerOptions) {

return getEmitDeclarations(compilationSettings) || !!compilationSettings.emitDecoratorMetadata;

}

function formatDiag(fileName: NormalizedPath, project: Project, diag: Diagnostic): protocol.Diagnostic {

const scriptInfo = project.getScriptInfoForNormalizedPath(fileName)!; // TODO: GH#18217

return {

start: scriptInfo.positionToLineOffset(diag.start!),

end: scriptInfo.positionToLineOffset(diag.start! + diag.length!), // TODO: GH#18217

text: flattenDiagnosticMessageText(diag.messageText, "\n"),

code: diag.code,

category: diagnosticCategoryName(diag),

reportsUnnecessary: diag.reportsUnnecessary,

reportsDeprecated: diag.reportsDeprecated,

source: diag.source,

relatedInformation: map(diag.relatedInformation, formatRelatedInformation),

};

}

function formatRelatedInformation(info: DiagnosticRelatedInformation): protocol.DiagnosticRelatedInformation {

if (!info.file) {

return {

message: flattenDiagnosticMessageText(info.messageText, "\n"),

category: diagnosticCategoryName(info),

code: info.code

};

}

return {

span: {

start: convertToLocation(getLineAndCharacterOfPosition(info.file, info.start!)),

end: convertToLocation(getLineAndCharacterOfPosition(info.file, info.start! + info.length!)), // TODO: GH#18217

file: info.file.fileName

},

message: flattenDiagnosticMessageText(info.messageText, "\n"),

category: diagnosticCategoryName(info),

code: info.code

};

}

function convertToLocation(lineAndCharacter: LineAndCharacter): protocol.Location {

return { line: lineAndCharacter.line + 1, offset: lineAndCharacter.character + 1 };

}

function formatDiagnosticToProtocol(diag: Diagnostic, includeFileName: true): protocol.DiagnosticWithFileName;

function formatDiagnosticToProtocol(diag: Diagnostic, includeFileName: false): protocol.Diagnostic;

function formatDiagnosticToProtocol(diag: Diagnostic, includeFileName: boolean): protocol.Diagnostic | protocol.DiagnosticWithFileName {

const start = (diag.file && convertToLocation(getLineAndCharacterOfPosition(diag.file, diag.start!)))!; // TODO: GH#18217

const end = (diag.file && convertToLocation(getLineAndCharacterOfPosition(diag.file, diag.start! + diag.length!)))!; // TODO: GH#18217

const text = flattenDiagnosticMessageText(diag.messageText, "\n");

const { code, source } = diag;

const category = diagnosticCategoryName(diag);

const common = {

start,

end,

text,

code,

category,

reportsUnnecessary: diag.reportsUnnecessary,

reportsDeprecated: diag.reportsDeprecated,

source,

relatedInformation: map(diag.relatedInformation, formatRelatedInformation),

};

return includeFileName

? { ...common, fileName: diag.file && diag.file.fileName }

: common;

}

export interface PendingErrorCheck {

fileName: NormalizedPath;

project: Project;

}

function allEditsBeforePos(edits: readonly TextChange[], pos: number): boolean {

return edits.every(edit => textSpanEnd(edit.span) < pos);

}

// CommandNames used to be exposed before TS 2.4 as a namespace

// In TS 2.4 we switched to an enum, keep this for backward compatibility

// The var assignment ensures that even though CommandTypes are a const enum

// we want to ensure the value is maintained in the out since the file is

// built using --preseveConstEnum.

export type CommandNames = protocol.CommandTypes;

export const CommandNames = (protocol as any).CommandTypes;

export function formatMessage<T extends protocol.Message>(msg: T, logger: Logger, byteLength: (s: string, encoding: string) => number, newLine: string): string {

const verboseLogging = logger.hasLevel(LogLevel.verbose);

const json = JSON.stringify(msg);

if (verboseLogging) {

logger.info(`${msg.type}:${indent(json)}`);

}

const len = byteLength(json, "utf8");

return `Content-Length: ${1 + len}\r\n\r\n${json}${newLine}`;

}

/**

* Allows to schedule next step in multistep operation

*/

interface NextStep {

immediate(action: () => void): void;

delay(ms: number, action: () => void): void;

}

/**

* External capabilities used by multistep operation

*/

interface MultistepOperationHost {

getCurrentRequestId(): number;

sendRequestCompletedEvent(requestId: number): void;

getServerHost(): ServerHost;

isCancellationRequested(): boolean;

executeWithRequestId(requestId: number, action: () => void): void;

logError(error: Error, message: string): void;

}

/**

* Represents operation that can schedule its next step to be executed later.

* Scheduling is done via instance of NextStep. If on current step subsequent step was not scheduled - operation is assumed to be completed.

*/

class MultistepOperation implements NextStep {

private requestId: number | undefined;

private timerHandle: any;

private immediateId: number | undefined;

constructor(private readonly operationHost: MultistepOperationHost) { }

public startNew(action: (next: NextStep) => void) {

this.complete();

this.requestId = this.operationHost.getCurrentRequestId();

this.executeAction(action);

}

private complete() {

if (this.requestId !== undefined) {

this.operationHost.sendRequestCompletedEvent(this.requestId);

this.requestId = undefined;

}

this.setTimerHandle(undefined);

this.setImmediateId(undefined);

}

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

const requestId = this.requestId!;

Debug.assert(requestId === this.operationHost.getCurrentRequestId(), "immediate: incorrect request id");

this.setImmediateId(this.operationHost.getServerHost().setImmediate(() => {

this.immediateId = undefined;

this.operationHost.executeWithRequestId(requestId, () => this.executeAction(action));

}));

}

public delay(ms: number, action: () => void) {

const requestId = this.requestId!;

Debug.assert(requestId === this.operationHost.getCurrentRequestId(), "delay: incorrect request id");

this.setTimerHandle(this.operationHost.getServerHost().setTimeout(() => {

this.timerHandle = undefined;

this.operationHost.executeWithRequestId(requestId, () => this.executeAction(action));

}, ms));

}

private executeAction(action: (next: NextStep) => void) {

let stop = false;

try {

if (this.operationHost.isCancellationRequested()) {

stop = true;

tracing?.instant(tracing.Phase.Session, "stepCanceled", { seq: this.requestId, early: true });

}

else {

tracing?.push(tracing.Phase.Session, "stepAction", { seq: this.requestId });

action(this);

tracing?.pop();

}

}

catch (e) {

// Cancellation or an error may have left incomplete events on the tracing stack.

tracing?.popAll();

stop = true;

// ignore cancellation request

if (e instanceof OperationCanceledException) {

tracing?.instant(tracing.Phase.Session, "stepCanceled", { seq: this.requestId });

}

else {

tracing?.instant(tracing.Phase.Session, "stepError", { seq: this.requestId, message: (e as Error).message });

this.operationHost.logError(e, `delayed processing of request ${this.requestId}`);

}

}

if (stop || !this.hasPendingWork()) {

this.complete();

}

}

private setTimerHandle(timerHandle: any) {

if (this.timerHandle !== undefined) {

this.operationHost.getServerHost().clearTimeout(this.timerHandle);

}

this.timerHandle = timerHandle;

}

private setImmediateId(immediateId: number | undefined) {

if (this.immediateId !== undefined) {

this.operationHost.getServerHost().clearImmediate(this.immediateId);

}

this.immediateId = immediateId;

}

private hasPendingWork() {

return !!this.timerHandle || !!this.immediateId;

}

}

export type Event = <T extends object>(body: T, eventName: string) => void;

export interface EventSender {

event: Event;

}

/** @internal */

export function toEvent(eventName: string, body: object): protocol.Event {

return {

seq: 0,

type: "event",

event: eventName,

body

};

}

type Projects = readonly Project[] | {

readonly projects: readonly Project[];

readonly symLinkedProjects: MultiMap<Path, Project>;

};

/**

* This helper function processes a list of projects and return the concatenated, sortd and deduplicated output of processing each project.

*/

function combineProjectOutput<T, U>(

defaultValue: T,

getValue: (path: Path) => T,

projects: Projects,

action: (project: Project, value: T) => readonly U[] | U | undefined,

): U[] {

const outputs = flatMapToMutable(isArray(projects) ? projects : projects.projects, project => action(project, defaultValue));

if (!isArray(projects) && projects.symLinkedProjects) {

projects.symLinkedProjects.forEach((projects, path) => {

const value = getValue(path);

outputs.push(...flatMap(projects, project => action(project, value)));

});

}

return deduplicate(outputs, equateValues);

}

interface ProjectNavigateToItems {

project: Project;

navigateToItems: readonly NavigateToItem[];

};

function createDocumentSpanSet(): Set<DocumentSpan> {

return createSet(({textSpan}) => textSpan.start + 100003 * textSpan.length, documentSpansEqual);

}

function getRenameLocationsWorker(

projects: Projects,

defaultProject: Project,

initialLocation: DocumentPosition,

findInStrings: boolean,

findInComments: boolean,

{ providePrefixAndSuffixTextForRename }: UserPreferences

): readonly RenameLocation[] {

const perProjectResults = getPerProjectReferences(

projects,

defaultProject,

initialLocation,

/*isForRename*/ true,

(project, position) => project.getLanguageService().findRenameLocations(position.fileName, position.pos, findInStrings, findInComments, providePrefixAndSuffixTextForRename),

(renameLocation, cb) => cb(documentSpanLocation(renameLocation)),

);

// No filtering or dedup'ing is required if there's exactly one project

if (isArray(perProjectResults)) {

return perProjectResults;

}

const results: RenameLocation[] = [];

const seen = createDocumentSpanSet();

perProjectResults.forEach((projectResults, project) => {

for (const result of projectResults) {

// If there's a mapped location, it'll appear in the results for another project

if (!seen.has(result) && !getMappedLocationForProject(documentSpanLocation(result), project)) {

results.push(result);

seen.add(result);

}

}

});

return results;

}

function getDefinitionLocation(defaultProject: Project, initialLocation: DocumentPosition, isForRename: boolean): DocumentPosition | undefined {

const infos = defaultProject.getLanguageService().getDefinitionAtPosition(initialLocation.fileName, initialLocation.pos, /*searchOtherFilesOnly*/ false, /*stopAtAlias*/ isForRename);

const info = infos && firstOrUndefined(infos);

return info && !info.isLocal ? { fileName: info.fileName, pos: info.textSpan.start } : undefined;

}

function getReferencesWorker(

projects: Projects,

defaultProject: Project,

initialLocation: DocumentPosition,

logger: Logger,

): readonly ReferencedSymbol[] {

const perProjectResults = getPerProjectReferences(

projects,

defaultProject,

initialLocation,

/*isForRename*/ false,

(project, position) => {

logger.info(`Finding references to ${position.fileName} position ${position.pos} in project ${project.getProjectName()}`);

return project.getLanguageService().findReferences(position.fileName, position.pos);

},

(referencedSymbol, cb) => {

cb(documentSpanLocation(referencedSymbol.definition));

for (const ref of referencedSymbol.references) {

cb(documentSpanLocation(ref));

}

},

);

// No re-mapping or isDefinition updatses are required if there's exactly one project

if (isArray(perProjectResults)) {

return perProjectResults;

}

// `isDefinition` is only (definitely) correct in `defaultProject` because we might

// have started the other project searches from related symbols. Propagate the

// correct results to all other projects.

const defaultProjectResults = perProjectResults.get(defaultProject)!;

if (defaultProjectResults[0].references[0].isDefinition === undefined) {

// Clear all isDefinition properties

perProjectResults.forEach(projectResults => {

for (const referencedSymbol of projectResults) {

for (const ref of referencedSymbol.references) {

delete ref.isDefinition;

}

}

});

}

else {

// Correct isDefinition properties from projects other than defaultProject

const knownSymbolSpans = createDocumentSpanSet();

for (const referencedSymbol of defaultProjectResults) {

for (const ref of referencedSymbol.references) {

if (ref.isDefinition) {

knownSymbolSpans.add(ref);

// One is enough - updateIsDefinitionOfReferencedSymbols will fill out the set based on symbols

break;

}

}

}

const updatedProjects = new Set<Project>();

while (true) {

let progress = false;

perProjectResults.forEach((referencedSymbols, project) => {

if (updatedProjects.has(project)) return;

const updated = project.getLanguageService().updateIsDefinitionOfReferencedSymbols(referencedSymbols, knownSymbolSpans);

if (updated) {

updatedProjects.add(project);

progress = true;

}

});

if (!progress) break;

}

perProjectResults.forEach((referencedSymbols, project) => {

if (updatedProjects.has(project)) return;

for (const referencedSymbol of referencedSymbols) {

for (const ref of referencedSymbol.references) {

ref.isDefinition = false;

}

}

});

}

// We need to de-duplicate and aggregate the results by choosing an authoritative version

// of each definition and merging references from all the projects where they appear.

const results: ReferencedSymbol[] = [];

const seenRefs = createDocumentSpanSet(); // It doesn't make sense to have a reference in two definition lists, so we de-dup globally

// TODO: We might end up with a more logical allocation of refs to defs if we pre-sorted the defs by descending ref-count.

// Otherwise, it just ends up attached to the first corresponding def we happen to process. The others may or may not be

// dropped later when we check for defs with ref-count 0.

perProjectResults.forEach((projectResults, project) => {

for (const referencedSymbol of projectResults) {

const mappedDefinitionFile = getMappedLocationForProject(documentSpanLocation(referencedSymbol.definition), project);

const definition: ReferencedSymbolDefinitionInfo = mappedDefinitionFile === undefined ?

referencedSymbol.definition :

{

...referencedSymbol.definition,

textSpan: createTextSpan(mappedDefinitionFile.pos, referencedSymbol.definition.textSpan.length), // Why would the length be the same in the original?

fileName: mappedDefinitionFile.fileName,

contextSpan: getMappedContextSpanForProject(referencedSymbol.definition, project)

};

let symbolToAddTo = find(results, o => documentSpansEqual(o.definition, definition));

if (!symbolToAddTo) {

symbolToAddTo = { definition, references: [] };

results.push(symbolToAddTo);

}

for (const ref of referencedSymbol.references) {

if (!seenRefs.has(ref) && !getMappedLocationForProject(documentSpanLocation(ref), project)) {

seenRefs.add(ref);

symbolToAddTo.references.push(ref);

}

}

}

});

return results.filter(o => o.references.length !== 0);

}

interface ProjectAndLocation {

readonly project: Project;

readonly location: DocumentPosition;

}

function forEachProjectInProjects(projects: Projects, path: string | undefined, cb: (project: Project, path: string | undefined) => void): void {

for (const project of isArray(projects) ? projects : projects.projects) {

cb(project, path);

}

if (!isArray(projects) && projects.symLinkedProjects) {

projects.symLinkedProjects.forEach((symlinkedProjects, symlinkedPath) => {

for (const project of symlinkedProjects) {

cb(project, symlinkedPath);

}

});

}

}

/**

* @param projects Projects initially known to contain {@link initialLocation}

* @param defaultProject The default project containing {@link initialLocation}

* @param initialLocation Where the search operation was triggered

* @param getResultsForPosition This is where you plug in `findReferences`, `renameLocation`, etc

* @param forPositionInResult Given an item returned by {@link getResultsForPosition} enumerate the positions referred to by that result

* @returns In the common case where there's only one project, returns an array of results from {@link getResultsForPosition}.

* If multiple projects were searched - even if they didn't return results - the result will be a map from project to per-project results.

*/

function getPerProjectReferences<TResult>(

projects: Projects,

defaultProject: Project,

initialLocation: DocumentPosition,

isForRename: boolean,

getResultsForPosition: (project: Project, location: DocumentPosition) => readonly TResult[] | undefined,

forPositionInResult: (result: TResult, cb: (location: DocumentPosition) => void) => void,

): readonly TResult[] | ESMap<Project, readonly TResult[]> {

// If `getResultsForPosition` returns results for a project, they go in here

const resultsMap = new Map<Project, readonly TResult[]>();

const queue: ProjectAndLocation[] = [];

// In order to get accurate isDefinition values for `defaultProject`,

// we need to ensure that it is searched from `initialLocation`.

// The easiest way to do this is to search it first.

queue.push({ project: defaultProject, location: initialLocation });

// This will queue `defaultProject` a second time, but it will be dropped

// as a dup when it is dequeued.

forEachProjectInProjects(projects, initialLocation.fileName, (project, path) => {

const location = { fileName: path!, pos: initialLocation.pos };

queue.push({ project, location });

});

const projectService = defaultProject.projectService;

const cancellationToken = defaultProject.getCancellationToken();

const defaultDefinition = getDefinitionLocation(defaultProject, initialLocation, isForRename);

// Don't call these unless !!defaultDefinition

const getGeneratedDefinition = memoize(() => defaultProject.isSourceOfProjectReferenceRedirect(defaultDefinition!.fileName) ?

defaultDefinition :

defaultProject.getLanguageService().getSourceMapper().tryGetGeneratedPosition(defaultDefinition!));

const getSourceDefinition = memoize(() => defaultProject.isSourceOfProjectReferenceRedirect(defaultDefinition!.fileName) ?

defaultDefinition :

defaultProject.getLanguageService().getSourceMapper().tryGetSourcePosition(defaultDefinition!));

// Track which projects we have already searched so that we don't repeat searches.

// We store the project key, rather than the project, because that's what `loadAncestorProjectTree` wants.

// (For that same reason, we don't use `resultsMap` for this check.)

const searchedProjects = new Set<string>();

onCancellation:

while (queue.length) {

while (queue.length) {

if (cancellationToken.isCancellationRequested()) break onCancellation;

const { project, location } = queue.shift()!;

if (isLocationProjectReferenceRedirect(project, location)) continue;

if (!tryAddToSet(searchedProjects, getProjectKey(project))) continue;

const projectResults = searchPosition(project, location);

if (projectResults) {

resultsMap.set(project, projectResults);

}

}

// At this point, we know about all projects passed in as arguments and any projects in which

// `getResultsForPosition` has returned results. We expand that set to include any projects

// downstream from any of these and then queue new initial-position searches for any new project

// containing `initialLocation`.

if (defaultDefinition) {

// This seems to mean "load all projects downstream from any member of `seenProjects`".

projectService.loadAncestorProjectTree(searchedProjects);

projectService.forEachEnabledProject(project => {

if (cancellationToken.isCancellationRequested()) return; // There's no mechanism for skipping the remaining projects

if (searchedProjects.has(getProjectKey(project))) return; // Can loop forever without this (enqueue here, dequeue above, repeat)

const location = mapDefinitionInProject(defaultDefinition, project, getGeneratedDefinition, getSourceDefinition);

if (location) {

queue.push({ project, location });

}

});

}

}

// In the common case where there's only one project, return a simpler result to make

// it easier for the caller to skip post-processing.

if (searchedProjects.size === 1) {

const it = resultsMap.values().next();

Debug.assert(!it.done);

return it.value;

}

return resultsMap;

// May enqueue to otherPositionQueue

function searchPosition(project: Project, location: DocumentPosition): readonly TResult[] | undefined {

const projectResults = getResultsForPosition(project, location);

if (!projectResults) return undefined;

for (const result of projectResults) {

forPositionInResult(result, position => {

// This may trigger a search for a tsconfig, but there are several layers of caching that make it inexpensive

const originalLocation = projectService.getOriginalLocationEnsuringConfiguredProject(project, position);

if (!originalLocation) return;

const originalScriptInfo = projectService.getScriptInfo(originalLocation.fileName)!;

for (const project of originalScriptInfo.containingProjects) {

if (!project.isOrphan()) {

queue.push({ project, location: originalLocation });

}

}

const symlinkedProjectsMap = projectService.getSymlinkedProjects(originalScriptInfo);

if (symlinkedProjectsMap) {

symlinkedProjectsMap.forEach((symlinkedProjects, symlinkedPath) => {

for (const symlinkedProject of symlinkedProjects) {

if (!symlinkedProject.isOrphan()) {

queue.push({ project: symlinkedProject, location: { fileName: symlinkedPath as string, pos: originalLocation.pos } });

}

}

});

}

});

}

return projectResults;

}

}

function mapDefinitionInProject(

definition: DocumentPosition,

project: Project,

getGeneratedDefinition: () => DocumentPosition | undefined,

getSourceDefinition: () => DocumentPosition | undefined

): DocumentPosition | undefined {

// If the definition is actually from the project, definition is correct as is

if (project.containsFile(toNormalizedPath(definition.fileName)) &&

!isLocationProjectReferenceRedirect(project, definition)) {

return definition;

}

const generatedDefinition = getGeneratedDefinition();

if (generatedDefinition && project.containsFile(toNormalizedPath(generatedDefinition.fileName))) return generatedDefinition;

const sourceDefinition = getSourceDefinition();

return sourceDefinition && project.containsFile(toNormalizedPath(sourceDefinition.fileName)) ? sourceDefinition : undefined;

}

function isLocationProjectReferenceRedirect(project: Project, location: DocumentPosition | undefined) {

if (!location) return false;

const program = project.getLanguageService().getProgram();

if (!program) return false;

const sourceFile = program.getSourceFile(location.fileName);

// It is possible that location is attached to project but

// the program actually includes its redirect instead.

// This happens when rootFile in project is one of the file from referenced project

// Thus root is attached but program doesnt have the actual .ts file but .d.ts

// If this is not the file we were actually looking, return rest of the toDo

return !!sourceFile &&

sourceFile.resolvedPath !== sourceFile.path &&

sourceFile.resolvedPath !== project.toPath(location.fileName);

}

function getProjectKey(project: Project) {

return isConfiguredProject(project) ? project.canonicalConfigFilePath : project.getProjectName();

}

function documentSpanLocation({ fileName, textSpan }: DocumentSpan): DocumentPosition {

return { fileName, pos: textSpan.start };

}

function getMappedLocationForProject(location: DocumentPosition, project: Project): DocumentPosition | undefined {

return getMappedLocation(location, project.getSourceMapper(), p => project.projectService.fileExists(p as NormalizedPath));

}

function getMappedDocumentSpanForProject(documentSpan: DocumentSpan, project: Project): DocumentSpan | undefined {

return getMappedDocumentSpan(documentSpan, project.getSourceMapper(), p => project.projectService.fileExists(p as NormalizedPath));

}

function getMappedContextSpanForProject(documentSpan: DocumentSpan, project: Project): TextSpan | undefined {

return getMappedContextSpan(documentSpan, project.getSourceMapper(), p => project.projectService.fileExists(p as NormalizedPath));

}

const invalidPartialSemanticModeCommands: readonly CommandNames[] = [

CommandNames.OpenExternalProject,

CommandNames.OpenExternalProjects,

CommandNames.CloseExternalProject,

CommandNames.SynchronizeProjectList,

CommandNames.EmitOutput,

CommandNames.CompileOnSaveAffectedFileList,

CommandNames.CompileOnSaveEmitFile,

CommandNames.CompilerOptionsDiagnosticsFull,

CommandNames.EncodedSemanticClassificationsFull,

CommandNames.SemanticDiagnosticsSync,

CommandNames.SuggestionDiagnosticsSync,

CommandNames.GeterrForProject,

CommandNames.Reload,

CommandNames.ReloadProjects,

CommandNames.GetCodeFixes,

CommandNames.GetCodeFixesFull,

CommandNames.GetCombinedCodeFix,

CommandNames.GetCombinedCodeFixFull,

CommandNames.ApplyCodeActionCommand,

CommandNames.GetSupportedCodeFixes,

CommandNames.GetApplicableRefactors,

CommandNames.GetEditsForRefactor,

CommandNames.GetEditsForRefactorFull,

CommandNames.OrganizeImports,

CommandNames.OrganizeImportsFull,

CommandNames.GetEditsForFileRename,

CommandNames.GetEditsForFileRenameFull,

CommandNames.ConfigurePlugin,

CommandNames.PrepareCallHierarchy,

CommandNames.ProvideCallHierarchyIncomingCalls,

CommandNames.ProvideCallHierarchyOutgoingCalls,

];

const invalidSyntacticModeCommands: readonly CommandNames[] = [

...invalidPartialSemanticModeCommands,

CommandNames.Definition,

CommandNames.DefinitionFull,

CommandNames.DefinitionAndBoundSpan,

CommandNames.DefinitionAndBoundSpanFull,

CommandNames.TypeDefinition,

CommandNames.Implementation,

CommandNames.ImplementationFull,

CommandNames.References,

CommandNames.ReferencesFull,

CommandNames.Rename,

CommandNames.RenameLocationsFull,

CommandNames.RenameInfoFull,

CommandNames.Quickinfo,

CommandNames.QuickinfoFull,

CommandNames.CompletionInfo,

CommandNames.Completions,

CommandNames.CompletionsFull,

CommandNames.CompletionDetails,

CommandNames.CompletionDetailsFull,

CommandNames.SignatureHelp,

CommandNames.SignatureHelpFull,

CommandNames.Navto,

CommandNames.NavtoFull,

CommandNames.Occurrences,

CommandNames.DocumentHighlights,

CommandNames.DocumentHighlightsFull,

];

export interface SessionOptions {

host: ServerHost;

cancellationToken: ServerCancellationToken;

useSingleInferredProject: boolean;

useInferredProjectPerProjectRoot: boolean;

typingsInstaller: ITypingsInstaller;

byteLength: (buf: string, encoding?: string) => number;

hrtime: (start?: number[]) => number[];

logger: Logger;

/**

* If falsy, all events are suppressed.

*/

canUseEvents: boolean;

eventHandler?: ProjectServiceEventHandler;

/** Has no effect if eventHandler is also specified. */

suppressDiagnosticEvents?: boolean;

/** @deprecated use serverMode instead */

syntaxOnly?: boolean;

serverMode?: LanguageServiceMode;

throttleWaitMilliseconds?: number;

noGetErrOnBackgroundUpdate?: boolean;

globalPlugins?: readonly string[];

pluginProbeLocations?: readonly string[];

allowLocalPluginLoads?: boolean;

typesMapLocation?: string;

}

export class Session<TMessage = string> implements EventSender {

private readonly gcTimer: GcTimer;

protected projectService: ProjectService;

private changeSeq = 0;

private performanceData: protocol.PerformanceData | undefined;

private currentRequestId!: number;

private errorCheck: MultistepOperation;

protected host: ServerHost;

private readonly cancellationToken: ServerCancellationToken;

protected readonly typingsInstaller: ITypingsInstaller;

protected byteLength: (buf: string, encoding?: string) => number;

private hrtime: (start?: number[]) => number[];

protected logger: Logger;

protected canUseEvents: boolean;

private suppressDiagnosticEvents?: boolean;

private eventHandler: ProjectServiceEventHandler | undefined;

private readonly noGetErrOnBackgroundUpdate?: boolean;

constructor(opts: SessionOptions) {

this.host = opts.host;

this.cancellationToken = opts.cancellationToken;

this.typingsInstaller = opts.typingsInstaller;

this.byteLength = opts.byteLength;

this.hrtime = opts.hrtime;

this.logger = opts.logger;

this.canUseEvents = opts.canUseEvents;

this.suppressDiagnosticEvents = opts.suppressDiagnosticEvents;

this.noGetErrOnBackgroundUpdate = opts.noGetErrOnBackgroundUpdate;

const { throttleWaitMilliseconds } = opts;

this.eventHandler = this.canUseEvents

? opts.eventHandler || (event => this.defaultEventHandler(event))

: undefined;

const multistepOperationHost: MultistepOperationHost = {

executeWithRequestId: (requestId, action) => this.executeWithRequestId(requestId, action),

getCurrentRequestId: () => this.currentRequestId,

getServerHost: () => this.host,

logError: (err, cmd) => this.logError(err, cmd),

sendRequestCompletedEvent: requestId => this.sendRequestCompletedEvent(requestId),

isCancellationRequested: () => this.cancellationToken.isCancellationRequested()

};

this.errorCheck = new MultistepOperation(multistepOperationHost);

const settings: ProjectServiceOptions = {

host: this.host,

logger: this.logger,

cancellationToken: this.cancellationToken,

useSingleInferredProject: opts.useSingleInferredProject,

useInferredProjectPerProjectRoot: opts.useInferredProjectPerProjectRoot,

typingsInstaller: this.typingsInstaller,

throttleWaitMilliseconds,

eventHandler: this.eventHandler,

suppressDiagnosticEvents: this.suppressDiagnosticEvents,

globalPlugins: opts.globalPlugins,

pluginProbeLocations: opts.pluginProbeLocations,

allowLocalPluginLoads: opts.allowLocalPluginLoads,

typesMapLocation: opts.typesMapLocation,

syntaxOnly: opts.syntaxOnly,

serverMode: opts.serverMode,

session: this

};

this.projectService = new ProjectService(settings);

this.projectService.setPerformanceEventHandler(this.performanceEventHandler.bind(this));

this.gcTimer = new GcTimer(this.host, /*delay*/ 7000, this.logger);

// Make sure to setup handlers to throw error for not allowed commands on syntax server

switch (this.projectService.serverMode) {

case LanguageServiceMode.Semantic:

break;

case LanguageServiceMode.PartialSemantic:

invalidPartialSemanticModeCommands.forEach(commandName =>

this.handlers.set(commandName, request => {

throw new Error(`Request: ${request.command} not allowed in LanguageServiceMode.PartialSemantic`);

})

);

break;

case LanguageServiceMode.Syntactic:

invalidSyntacticModeCommands.forEach(commandName =>

this.handlers.set(commandName, request => {

throw new Error(`Request: ${request.command} not allowed in LanguageServiceMode.Syntactic`);

})

);

break;

default:

Debug.assertNever(this.projectService.serverMode);

}

}

private sendRequestCompletedEvent(requestId: number): void {

this.event<protocol.RequestCompletedEventBody>({ request_seq: requestId }, "requestCompleted");

}

private addPerformanceData(key: keyof protocol.PerformanceData, value: number) {

if (!this.performanceData) {

this.performanceData = {};

}

this.performanceData[key] = (this.performanceData[key] ?? 0) + value;

}

private performanceEventHandler(event: PerformanceEvent) {

switch (event.kind) {

case "UpdateGraph":

this.addPerformanceData("updateGraphDurationMs", event.durationMs);

break;

case "CreatePackageJsonAutoImportProvider":

this.addPerformanceData("createAutoImportProviderProgramDurationMs", event.durationMs);

break;

}

}

private defaultEventHandler(event: ProjectServiceEvent) {

switch (event.eventName) {

case ProjectsUpdatedInBackgroundEvent:

const { openFiles } = event.data;

this.projectsUpdatedInBackgroundEvent(openFiles);

break;

case ProjectLoadingStartEvent:

const { project, reason } = event.data;

this.event<protocol.ProjectLoadingStartEventBody>(

{ projectName: project.getProjectName(), reason },

ProjectLoadingStartEvent);

break;

case ProjectLoadingFinishEvent:

const { project: finishProject } = event.data;

this.event<protocol.ProjectLoadingFinishEventBody>({ projectName: finishProject.getProjectName() }, ProjectLoadingFinishEvent);

break;

case LargeFileReferencedEvent:

const { file, fileSize, maxFileSize } = event.data;

this.event<protocol.LargeFileReferencedEventBody>({ file, fileSize, maxFileSize }, LargeFileReferencedEvent);

break;

case ConfigFileDiagEvent:

const { triggerFile, configFileName: configFile, diagnostics } = event.data;

const bakedDiags = map(diagnostics, diagnostic => formatDiagnosticToProtocol(diagnostic, /*includeFileName*/ true));

this.event<protocol.ConfigFileDiagnosticEventBody>({

triggerFile,

configFile,

diagnostics: bakedDiags

}, ConfigFileDiagEvent);

break;

case ProjectLanguageServiceStateEvent: {

const eventName: protocol.ProjectLanguageServiceStateEventName = ProjectLanguageServiceStateEvent;

this.event<protocol.ProjectLanguageServiceStateEventBody>({

projectName: event.data.project.getProjectName(),

languageServiceEnabled: event.data.languageServiceEnabled

}, eventName);

break;

}

case ProjectInfoTelemetryEvent: {

const eventName: protocol.TelemetryEventName = "telemetry";

this.event<protocol.TelemetryEventBody>({

telemetryEventName: event.eventName,

payload: event.data,

}, eventName);

break;

}

}

}

private projectsUpdatedInBackgroundEvent(openFiles: string[]): void {

this.projectService.logger.info(`got projects updated in background, updating diagnostics for ${openFiles}`);

if (openFiles.length) {

if (!this.suppressDiagnosticEvents && !this.noGetErrOnBackgroundUpdate) {

// For now only queue error checking for open files. We can change this to include non open files as well

this.errorCheck.startNew(next => this.updateErrorCheck(next, openFiles, 100, /*requireOpen*/ true));

}

// Send project changed event

this.event<protocol.ProjectsUpdatedInBackgroundEventBody>({

openFiles

}, ProjectsUpdatedInBackgroundEvent);

}

}

public logError(err: Error, cmd: string): void {

this.logErrorWorker(err, cmd);

}

private logErrorWorker(err: Error & PossibleProgramFileInfo, cmd: string, fileRequest?: protocol.FileRequestArgs): void {

let msg = "Exception on executing command " + cmd;

if (err.message) {

msg += ":\n" + indent(err.message);

if ((err as StackTraceError).stack) {

msg += "\n" + indent((err as StackTraceError).stack!);

}

}

if (this.logger.hasLevel(LogLevel.verbose)) {

if (fileRequest) {

try {

const { file, project } = this.getFileAndProject(fileRequest);

const scriptInfo = project.getScriptInfoForNormalizedPath(file);

if (scriptInfo) {

const text = getSnapshotText(scriptInfo.getSnapshot());

msg += `\n\nFile text of ${fileRequest.file}:${indent(text)}\n`;

}

}

catch { } // eslint-disable-line no-empty

}

if (err.ProgramFiles) {

msg += `\n\nProgram files: ${JSON.stringify(err.ProgramFiles)}\n`;

msg += `\n\nProjects::\n`;

let counter = 0;

const addProjectInfo = (project: Project) => {

msg += `\nProject '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter}\n`;

msg += project.filesToString(/*writeProjectFileNames*/ true);

msg += "\n-----------------------------------------------\n";

counter++;

};

this.projectService.externalProjects.forEach(addProjectInfo);

this.projectService.configuredProjects.forEach(addProjectInfo);

this.projectService.inferredProjects.forEach(addProjectInfo);

}

}

this.logger.msg(msg, Msg.Err);

}

public send(msg: protocol.Message) {

if (msg.type === "event" && !this.canUseEvents) {

if (this.logger.hasLevel(LogLevel.verbose)) {

this.logger.info(`Session does not support events: ignored event: ${JSON.stringify(msg)}`);

}

return;

}

this.writeMessage(msg);

}

protected writeMessage(msg: protocol.Message) {

const msgText = formatMessage(msg, this.logger, this.byteLength, this.host.newLine);

perfLogger.logEvent(`Response message size: ${msgText.length}`);