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 ((project.projectKind === ProjectKind.Inferred || project.projectKind === ProjectKind.External) &&

project.isJsOnlyProject()) {

const scriptInfo = project.getScriptInfoForNormalizedPath(file);

return scriptInfo && !scriptInfo.isJavaScript();

}

return false;

if (a.file < b.file) {

return -1;

}

else if (a.file === b.file) {

const n = compareNumber(a.start.line, b.start.line);

if (n === 0) {

return compareNumber(a.start.offset, b.start.offset);

}

else return n;

}

else {

return 1;

}

const scriptInfo = project.getScriptInfoForNormalizedPath(fileName);

return {

start: scriptInfo.positionToLineOffset(diag.start),

end: scriptInfo.positionToLineOffset(diag.start + diag.length),

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

code: diag.code,

category: DiagnosticCategory[diag.category].toLowerCase(),

source: diag.source

};

const start = diag.file && convertToLocation(getLineAndCharacterOfPosition(diag.file, diag.start));

const end = diag.file && convertToLocation(getLineAndCharacterOfPosition(diag.file, diag.start + diag.length));

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

const { code, source } = diag;

const category = DiagnosticCategory[diag.category].toLowerCase();

return includeFileName ? { start, end, text, code, category, source, fileName: diag.file && diag.file.fileName } :

{ start, end, text, code, category, source };

for (const edit of edits) {

if (textSpanEnd(edit.span) >= pos) {

return false;

}

}

return true;

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;

}

else {

action(this);

}

}

catch (e) {

stop = true;

// ignore cancellation request

if (!(e instanceof OperationCanceledException)) {

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

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

};

const outputs = flatMap(isProjectsArray(projects) ? projects : projects.projects, project => action(project, defaultValue));

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

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

const value = getValue(path as Path);

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

});

}

return comparer

? sortAndDeduplicate(outputs, comparer, areEqual)

: deduplicate(outputs, areEqual);

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;

throttleWaitMilliseconds?: number;

globalPlugins?: ReadonlyArray<string>;

pluginProbeLocations?: ReadonlyArray<string>;

allowLocalPluginLoads?: boolean;

private readonly gcTimer: GcTimer;

protected projectService: ProjectService;

private changeSeq = 0;

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 eventHandler: ProjectServiceEventHandler;

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;

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,

globalPlugins: opts.globalPlugins,

pluginProbeLocations: opts.pluginProbeLocations,

allowLocalPluginLoads: opts.allowLocalPluginLoads

};

this.projectService = new ProjectService(settings);

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

}

private sendRequestCompletedEvent(requestId: number): void {

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

}

private defaultEventHandler(event: ProjectServiceEvent) {

switch (event.eventName) {

case ProjectsUpdatedInBackgroundEvent:

const { openFiles } = event.data;

this.projectsUpdatedInBackgroundEvent(openFiles);

break;

case ConfigFileDiagEvent:

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

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

this.event<protocol.ConfigFileDiagnosticEventBody>({

triggerFile,

configFile,

diagnostics: bakedDiags

}, "configFileDiag");

break;

case ProjectLanguageServiceStateEvent: {

const eventName: protocol.ProjectLanguageServiceStateEventName = "projectLanguageServiceState";

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

const checkList = this.createCheckList(openFiles);

// 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, checkList, 100, /*requireOpen*/ true));

// Send project changed event

this.event<protocol.ProjectsUpdatedInBackgroundEventBody>({

openFiles

}, "projectsUpdatedInBackground");

}

}

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

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

if (err.message) {

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

if ((<StackTraceError>err).stack) {

msg += "\n" + indent((<StackTraceError>err).stack);

}

}

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.host.write(formatMessage(msg, this.logger, this.byteLength, this.host.newLine));

}

public event<T extends object>(body: T, eventName: string): void {

this.send(toEvent(eventName, body));

}

// For backwards-compatibility only.

/** @deprecated */

public output(info: any, cmdName: string, reqSeq?: number, errorMsg?: string): void {

this.doOutput(info, cmdName, reqSeq, /*success*/ !errorMsg, errorMsg);

}

private doOutput(info: {} | undefined, cmdName: string, reqSeq: number, success: boolean, message?: string): void {

const res: protocol.Response = {

seq: 0,

type: "response",

command: cmdName,

request_seq: reqSeq,

success,

};

if (success) {

res.body = info;

}

else {

Debug.assert(info === undefined);

}

if (message) {

res.message = message;

}

this.send(res);

}

private semanticCheck(file: NormalizedPath, project: Project) {

try {

let diags: ReadonlyArray<Diagnostic> = emptyArray;

if (!isDeclarationFileInJSOnlyNonConfiguredProject(project, file)) {

diags = project.getLanguageService().getSemanticDiagnostics(file);

}

const bakedDiags = diags.map((diag) => formatDiag(file, project, diag));

this.event<protocol.DiagnosticEventBody>({ file, diagnostics: bakedDiags }, "semanticDiag");

}

catch (err) {

this.logError(err, "semantic check");

}

}

private syntacticCheck(file: NormalizedPath, project: Project) {

try {

const diags = project.getLanguageService().getSyntacticDiagnostics(file);

if (diags) {

const bakedDiags = diags.map((diag) => formatDiag(file, project, diag));

this.event<protocol.DiagnosticEventBody>({ file, diagnostics: bakedDiags }, "syntaxDiag");

}

}

catch (err) {

this.logError(err, "syntactic check");

}

}

private updateErrorCheck(next: NextStep, checkList: PendingErrorCheck[], ms: number, requireOpen = true) {

const seq = this.changeSeq;

const followMs = Math.min(ms, 200);

let index = 0;

const checkOne = () => {

if (this.changeSeq === seq) {

const checkSpec = checkList[index];

index++;

if (checkSpec.project.containsFile(checkSpec.fileName, requireOpen)) {

this.syntacticCheck(checkSpec.fileName, checkSpec.project);

if (this.changeSeq === seq) {

next.immediate(() => {

this.semanticCheck(checkSpec.fileName, checkSpec.project);

if (checkList.length > index) {

next.delay(followMs, checkOne);

}

});

}

}

}

};

if (checkList.length > index && this.changeSeq === seq) {

next.delay(ms, checkOne);

}

}

private cleanProjects(caption: string, projects: Project[]) {

if (!projects) {

return;

}

this.logger.info(`cleaning ${caption}`);

for (const p of projects) {

p.getLanguageService(/*ensureSynchronized*/ false).cleanupSemanticCache();

}

}

private cleanup() {

this.cleanProjects("inferred projects", this.projectService.inferredProjects);

this.cleanProjects("configured projects", arrayFrom(this.projectService.configuredProjects.values()));

this.cleanProjects("external projects", this.projectService.externalProjects);

if (this.host.gc) {

this.logger.info(`host.gc()`);

this.host.gc();

}

}

private getEncodedSemanticClassifications(args: protocol.EncodedSemanticClassificationsRequestArgs) {

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

return project.getLanguageService().getEncodedSemanticClassifications(file, args);

}

private getProject(projectFileName: string) {

return projectFileName && this.projectService.findProject(projectFileName);

}

private getConfigFileAndProject(args: protocol.FileRequestArgs) {

const project = this.getProject(args.projectFileName);

const file = toNormalizedPath(args.file);

return {

configFile: project && project.hasConfigFile(file) && file,

project

};

}

private getConfigFileDiagnostics(configFile: NormalizedPath, project: Project, includeLinePosition: boolean) {

const projectErrors = project.getAllProjectErrors();

const optionsErrors = project.getLanguageService().getCompilerOptionsDiagnostics();

const diagnosticsForConfigFile = filter(

concatenate(projectErrors, optionsErrors),

diagnostic => diagnostic.file && diagnostic.file.fileName === configFile

);

return includeLinePosition ?

this.convertToDiagnosticsWithLinePositionFromDiagnosticFile(diagnosticsForConfigFile) :

map(

diagnosticsForConfigFile,

diagnostic => formatConfigFileDiag(diagnostic, /*includeFileName*/ false)

);

}

private convertToDiagnosticsWithLinePositionFromDiagnosticFile(diagnostics: ReadonlyArray<Diagnostic>): protocol.DiagnosticWithLinePosition[] {

return diagnostics.map<protocol.DiagnosticWithLinePosition>(d => ({

message: flattenDiagnosticMessageText(d.messageText, this.host.newLine),

start: d.start,

length: d.length,

category: DiagnosticCategory[d.category].toLowerCase(),

code: d.code,

startLocation: d.file && convertToLocation(getLineAndCharacterOfPosition(d.file, d.start)),

endLocation: d.file && convertToLocation(getLineAndCharacterOfPosition(d.file, d.start + d.length))

}));

}

private getCompilerOptionsDiagnostics(args: protocol.CompilerOptionsDiagnosticsRequestArgs) {

const project = this.getProject(args.projectFileName);

// Get diagnostics that dont have associated file with them

// The diagnostics which have file would be in config file and

// would be reported as part of configFileDiagnostics

return this.convertToDiagnosticsWithLinePosition(

filter(

project.getLanguageService().getCompilerOptionsDiagnostics(),

diagnostic => !diagnostic.file

),

/*scriptInfo*/ undefined

);

}

private convertToDiagnosticsWithLinePosition(diagnostics: ReadonlyArray<Diagnostic>, scriptInfo: ScriptInfo): protocol.DiagnosticWithLinePosition[] {

return diagnostics.map(d => <protocol.DiagnosticWithLinePosition>{

message: flattenDiagnosticMessageText(d.messageText, this.host.newLine),

start: d.start,

length: d.length,

category: DiagnosticCategory[d.category].toLowerCase(),

code: d.code,

source: d.source,

startLocation: scriptInfo && scriptInfo.positionToLineOffset(d.start),

endLocation: scriptInfo && scriptInfo.positionToLineOffset(d.start + d.length)

});

}

private getDiagnosticsWorker(

args: protocol.FileRequestArgs, isSemantic: boolean, selector: (project: Project, file: string) => ReadonlyArray<Diagnostic>, includeLinePosition: boolean

): ReadonlyArray<protocol.DiagnosticWithLinePosition> | ReadonlyArray<protocol.Diagnostic> {

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

if (isSemantic && isDeclarationFileInJSOnlyNonConfiguredProject(project, file)) {

return emptyArray;

}

const scriptInfo = project.getScriptInfoForNormalizedPath(file);

const diagnostics = selector(project, file);

return includeLinePosition

? this.convertToDiagnosticsWithLinePosition(diagnostics, scriptInfo)

: diagnostics.map(d => formatDiag(file, project, d));

}

private getDefinition(args: protocol.FileLocationRequestArgs, simplifiedResult: boolean): ReadonlyArray<protocol.FileSpan> | ReadonlyArray<DefinitionInfo> {

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

const position = this.getPositionInFile(args, file);

const definitions = project.getLanguageService().getDefinitionAtPosition(file, position);

if (!definitions) {

return emptyArray;

}

if (simplifiedResult) {

return this.mapDefinitionInfo(definitions, project);

}

else {

return definitions;

}

}

private getDefinitionAndBoundSpan(args: protocol.FileLocationRequestArgs, simplifiedResult: boolean): protocol.DefinitionInfoAndBoundSpan | DefinitionInfoAndBoundSpan {

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

const position = this.getPositionInFile(args, file);

const scriptInfo = project.getScriptInfo(file);

const definitionAndBoundSpan = project.getLanguageService().getDefinitionAndBoundSpan(file, position);

if (!definitionAndBoundSpan || !definitionAndBoundSpan.definitions) {

return {

definitions: emptyArray,

textSpan: undefined

};

}

if (simplifiedResult) {

return {

definitions: this.mapDefinitionInfo(definitionAndBoundSpan.definitions, project),

textSpan: this.toLocationTextSpan(definitionAndBoundSpan.textSpan, scriptInfo)

};

}

return definitionAndBoundSpan;

}

private mapDefinitionInfo(definitions: ReadonlyArray<DefinitionInfo>, project: Project): ReadonlyArray<protocol.FileSpan> {

return definitions.map(def => this.toFileSpan(def.fileName, def.textSpan, project));

}

private toFileSpan(fileName: string, textSpan: TextSpan, project: Project): protocol.FileSpan {

const scriptInfo = project.getScriptInfo(fileName);

return {

file: fileName,

start: scriptInfo.positionToLineOffset(textSpan.start),

end: scriptInfo.positionToLineOffset(textSpanEnd(textSpan))

};

}

private getTypeDefinition(args: protocol.FileLocationRequestArgs): ReadonlyArray<protocol.FileSpan> {

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

const position = this.getPositionInFile(args, file);

const definitions = project.getLanguageService().getTypeDefinitionAtPosition(file, position);

if (!definitions) {

return emptyArray;

}

return this.mapDefinitionInfo(definitions, project);

}

private getImplementation(args: protocol.FileLocationRequestArgs, simplifiedResult: boolean): ReadonlyArray<protocol.FileSpan> | ReadonlyArray<ImplementationLocation> {

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

const position = this.getPositionInFile(args, file);

const implementations = project.getLanguageService().getImplementationAtPosition(file, position);

if (!implementations) {

return emptyArray;

}

if (simplifiedResult) {

return implementations.map(({ fileName, textSpan }) => this.toFileSpan(fileName, textSpan, project));

}

else {

return implementations;

}

}

private getOccurrences(args: protocol.FileLocationRequestArgs): ReadonlyArray<protocol.OccurrencesResponseItem> {

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

const position = this.getPositionInFile(args, file);

const occurrences = project.getLanguageService().getOccurrencesAtPosition(file, position);

if (!occurrences) {

return emptyArray;

}

return occurrences.map(occurrence => {

const { fileName, isWriteAccess, textSpan, isInString } = occurrence;

const scriptInfo = project.getScriptInfo(fileName);

const result: protocol.OccurrencesResponseItem = {