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}:${stringifyIndented(msg)}`);

}

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(actionType: string, 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));

}, actionType),

);

}

public delay(actionType: string, 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,

actionType,

),

);

}

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,

preferences: protocol.UserPreferences,

useCaseSensitiveFileNames: boolean,

): readonly RenameLocation[] {

const perProjectResults = getPerProjectReferences(

projects,

defaultProject,

initialLocation,

/*isForRename*/ true,

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

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

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;

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

const info = infos && firstOrUndefined(infos);

// Note that the value of `isLocal` may depend on whether or not the checker has run on the containing file

// (implying that FAR cascading behavior may depend on request order)

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

projects: Projects,

defaultProject: Project,

initialLocation: DocumentPosition,

useCaseSensitiveFileNames: boolean,

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

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(useCaseSensitiveFileNames); // 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, useCaseSensitiveFileNames));

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

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

}

});

}

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[] | Map<Project, readonly TResult[]> {

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

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

const queue = createQueue<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.enqueue({ 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.enqueue({ 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!)

);

// The keys of resultsMap allow us to check which projects have already been searched, but we also

// maintain a set of strings because that's what `loadAncestorProjectTree` wants.

const searchedProjectKeys = new Set<string>();

onCancellation:

while (!queue.isEmpty()) {

while (!queue.isEmpty()) {

if (cancellationToken.isCancellationRequested()) break onCancellation;

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

if (resultsMap.has(project)) continue;

if (isLocationProjectReferenceRedirect(project, location)) continue;

// The project could be dirty and could no longer contain the location's file after it's updated,

// so we need to update the project and check if it still contains the file.

updateProjectIfDirty(project);

if (!project.containsFile(toNormalizedPath(location.fileName))) {

continue;

}

const projectResults = searchPosition(project, location);

resultsMap.set(project, projectResults ?? emptyArray);

searchedProjectKeys.add(getProjectKey(project));

}

// 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(searchedProjectKeys);

projectService.forEachEnabledProject(project => {

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

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

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

if (location) {

queue.enqueue({ 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 (resultsMap.size === 1) {

return firstIterator(resultsMap.values());

}

return resultsMap;

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() && !resultsMap.has(project)) { // Optimization: don't enqueue if will be discarded

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

}

}

const symlinkedProjectsMap = projectService.getSymlinkedProjects(originalScriptInfo);

if (symlinkedProjectsMap) {

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

for (const symlinkedProject of symlinkedProjects) {

if (!symlinkedProject.isOrphan() && !resultsMap.has(symlinkedProject)) { // Optimization: don't enqueue if will be discarded

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

}

}

});

}

});

}

return projectResults;

}

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