const seconds = time[0];

const nanoseconds = time[1];

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

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

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

};

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

};

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;

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

getCurrentRequestId(): number;

sendRequestCompletedEvent(requestId: number): void;

getServerHost(): ServerHost;

isCancellationRequested(): boolean;

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

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

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;

}

return {

seq: 0,

type: "event",

event: eventName,

body

};

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

projects: Projects,

defaultProject: Project,

initialLocation: DocumentPosition,

findInStrings: boolean,

findInComments: boolean,

{ providePrefixAndSuffixTextForRename }: UserPreferences

): readonly RenameLocation[] {

const outputs: RenameLocation[] = [];

const seen = createDocumentSpanSet();

combineProjectOutputWorker(

projects,

defaultProject,

initialLocation,

(project, location, tryAddToTodo) => {

const projectOutputs = project.getLanguageService().findRenameLocations(location.fileName, location.pos, findInStrings, findInComments, providePrefixAndSuffixTextForRename);

if (projectOutputs) {

for (const output of projectOutputs) {

if (!seen.has(output) && !tryAddToTodo(project, documentSpanLocation(output))) {

seen.add(output);

outputs.push(output);

}

}

}

},

);

return outputs;

const infos = defaultProject.getLanguageService().getDefinitionAtPosition(initialLocation.fileName, initialLocation.pos);

const info = infos && firstOrUndefined(infos);

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

projects: Projects,

defaultProject: Project,

initialLocation: DocumentPosition,

logger: Logger,

): readonly ReferencedSymbol[] {

const outputs: ReferencedSymbol[] = [];

combineProjectOutputWorker(

projects,

defaultProject,

initialLocation,

(project, location, getMappedLocation) => {

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

const projectOutputs = project.getLanguageService().findReferences(location.fileName, location.pos);

if (projectOutputs) {

for (const referencedSymbol of projectOutputs) {

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

const definition: ReferencedSymbolDefinitionInfo = mappedDefinitionFile === undefined ?

referencedSymbol.definition :

{

...referencedSymbol.definition,

textSpan: createTextSpan(mappedDefinitionFile.pos, referencedSymbol.definition.textSpan.length),

fileName: mappedDefinitionFile.fileName,

contextSpan: getMappedContextSpan(referencedSymbol.definition, project)

};

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

if (!symbolToAddTo) {

symbolToAddTo = { definition, references: [] };

outputs.push(symbolToAddTo);

}

for (const ref of referencedSymbol.references) {

// If it's in a mapped file, that is added to the todo list by `getMappedLocation`.

if (!contains(symbolToAddTo.references, ref, documentSpansEqual) && !getMappedLocation(project, documentSpanLocation(ref))) {

symbolToAddTo.references.push(ref);

}

}

}

}

},

);

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

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

}

});

}

project: Project,

location: TLocation,

getMappedLocation: (project: Project, location: DocumentPosition) => DocumentPosition | undefined,

projects: Projects,

defaultProject: Project,

initialLocation: TLocation,

cb: CombineProjectOutputCallback<TLocation>

): void {

const projectService = defaultProject.projectService;

let toDo: ProjectAndLocation<TLocation>[] | undefined;

const seenProjects = new Set<string>();

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

// TLocation should be either `DocumentPosition` or `undefined`. Since `initialLocation` is `TLocation` this cast should be valid.

const location = (initialLocation ? { fileName: path, pos: initialLocation.pos } : undefined) as TLocation;

toDo = callbackProjectAndLocation(project, location, projectService, toDo, seenProjects, cb);

});

// After initial references are collected, go over every other project and see if it has a reference for the symbol definition.

if (initialLocation) {

const defaultDefinition = getDefinitionLocation(defaultProject, initialLocation);

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

projectService.loadAncestorProjectTree(seenProjects);

projectService.forEachEnabledProject(project => {

if (!addToSeen(seenProjects, project)) return;

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

if (definition) {

toDo = callbackProjectAndLocation<TLocation>(project, definition as TLocation, projectService, toDo, seenProjects, cb);

}

});

}

}

while (toDo && toDo.length) {

const next = toDo.pop();

Debug.assertIsDefined(next);

toDo = callbackProjectAndLocation(next.project, next.location, projectService, toDo, seenProjects, cb);

}

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;

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

project: Project,

location: TLocation,

projectService: ProjectService,

toDo: ProjectAndLocation<TLocation>[] | undefined,

seenProjects: Set<string>,

cb: CombineProjectOutputCallback<TLocation>,

): ProjectAndLocation<TLocation>[] | undefined {

if (project.getCancellationToken().isCancellationRequested()) return undefined; // Skip rest of toDo if cancelled

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

if (isLocationProjectReferenceRedirect(project, location)) return toDo;

cb(project, location, (innerProject, location) => {

addToSeen(seenProjects, project);

const originalLocation = projectService.getOriginalLocationEnsuringConfiguredProject(innerProject, location);

if (!originalLocation) return undefined;

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

toDo = toDo || [];

for (const project of originalScriptInfo.containingProjects) {

addToTodo(project, originalLocation as TLocation, toDo, seenProjects);

}

const symlinkedProjectsMap = projectService.getSymlinkedProjects(originalScriptInfo);

if (symlinkedProjectsMap) {

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

for (const symlinkedProject of symlinkedProjects) {

addToTodo(symlinkedProject, { fileName: symlinkedPath as string, pos: originalLocation.pos } as TLocation, toDo!, seenProjects);

}

});

}

return originalLocation === location ? undefined : originalLocation;

});

return toDo;

const newPosition = getMappedLocation(documentSpanLocation(documentSpan), project);

if (!newPosition) return undefined;

return {

fileName: newPosition.fileName,

textSpan: {

start: newPosition.pos,

length: documentSpan.textSpan.length

},

originalFileName: documentSpan.fileName,

originalTextSpan: documentSpan.textSpan,

contextSpan: getMappedContextSpan(documentSpan, project),

originalContextSpan: documentSpan.contextSpan

};

const contextSpanStart = documentSpan.contextSpan && getMappedLocation(

{ fileName: documentSpan.fileName, pos: documentSpan.contextSpan.start },

project

);

const contextSpanEnd = documentSpan.contextSpan && getMappedLocation(

{ fileName: documentSpan.fileName, pos: documentSpan.contextSpan.start + documentSpan.contextSpan.length },

project

);

return contextSpanStart && contextSpanEnd ?

{ start: contextSpanStart.pos, length: contextSpanEnd.pos - contextSpanStart.pos } :

undefined;

host: ServerHost;

cancellationToken: ServerCancellationToken;

useSingleInferredProject: boolean;

useInferredProjectPerProjectRoot: boolean;

typingsInstaller: ITypingsInstaller;

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

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

logger: Logger;

/**

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;

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;