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 + ": " + 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;

}

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;

private eventHandler: ProjectServiceEventHandler;

private host: ServerHost;

private readonly cancellationToken: ServerCancellationToken;

protected readonly typingsInstaller: ITypingsInstaller;

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

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

protected logger: Logger;

private canUseEvents: 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;

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 {

const event: protocol.RequestCompletedEvent = {

seq: 0,

type: "event",

event: "requestCompleted",

body: { request_seq: requestId }

};

this.send(event);

}

private defaultEventHandler(event: ProjectServiceEvent) {

switch (event.eventName) {

case ContextEvent:

const { project, fileName } = event.data;

this.projectService.logger.info(`got context event, updating diagnostics for ${fileName}`);

this.errorCheck.startNew(next => this.updateErrorCheck(next, [{ fileName, project }], 100));

break;

case ConfigFileDiagEvent:

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

this.configFileDiagnosticEvent(triggerFile, configFileName, diagnostics);

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;

}

}

}

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

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

if (err.message) {

msg += ":\n" + err.message;

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

msg += "\n" + (<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 configFileDiagnosticEvent(triggerFile: string, configFile: string, diagnostics: ReadonlyArray<Diagnostic>) {

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

const ev: protocol.ConfigFileDiagnosticEvent = {

seq: 0,

type: "event",

event: "configFileDiag",

body: {

triggerFile,

configFile,

diagnostics: bakedDiags

}

};

this.send(ev);

}

public event<T>(info: T, eventName: string) {

const ev: protocol.Event = {

seq: 0,

type: "event",

event: eventName,

body: info

};

this.send(ev);

}

public output(info: any, cmdName: string, reqSeq = 0, errorMsg?: string) {

const res: protocol.Response = {

seq: 0,

type: "response",

command: cmdName,

request_seq: reqSeq,

success: !errorMsg,

};

if (!errorMsg) {

res.body = info;

}

else {

res.message = errorMsg;

}

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

const ms = 1500;

const seq = this.changeSeq;

this.host.setTimeout(() => {

if (this.changeSeq === seq) {

this.projectService.refreshInferredProjects();

}

}, ms);

}

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

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", this.projectService.configuredProjects);

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 scriptInfo = project.getScriptInfoForNormalizedPath(file);

const position = this.getPosition(args, scriptInfo);

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

if (!definitions) {

return emptyArray;

}

if (simplifiedResult) {

return definitions.map(def => {

const defScriptInfo = project.getScriptInfo(def.fileName);

return {

file: def.fileName,

start: defScriptInfo.positionToLineOffset(def.textSpan.start),

end: defScriptInfo.positionToLineOffset(textSpanEnd(def.textSpan))

};

});

}

else {

return definitions;

}

}

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

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

const scriptInfo = project.getScriptInfoForNormalizedPath(file);

const position = this.getPosition(args, scriptInfo);

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

if (!definitions) {

return emptyArray;

}

return definitions.map(def => {

const defScriptInfo = project.getScriptInfo(def.fileName);

return {

file: def.fileName,

start: defScriptInfo.positionToLineOffset(def.textSpan.start),

end: defScriptInfo.positionToLineOffset(textSpanEnd(def.textSpan))

};

});

}

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

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

const position = this.getPosition(args, project.getScriptInfoForNormalizedPath(file));

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

if (!implementations) {

return emptyArray;

}

if (simplifiedResult) {

return implementations.map(({ fileName, textSpan }) => {

const scriptInfo = project.getScriptInfo(fileName);

return {

file: fileName,

start: scriptInfo.positionToLineOffset(textSpan.start),

end: scriptInfo.positionToLineOffset(textSpanEnd(textSpan))

};

});

}

else {

return implementations;

}

}

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

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

const scriptInfo = project.getScriptInfoForNormalizedPath(file);

const position = this.getPosition(args, scriptInfo);

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 start = scriptInfo.positionToLineOffset(textSpan.start);

const end = scriptInfo.positionToLineOffset(textSpanEnd(textSpan));

const result: protocol.OccurrencesResponseItem = {

start,

end,

file: fileName,

isWriteAccess,

};

// no need to serialize the property if it is not true

if (isInString) {

result.isInString = isInString;

}

return result;

});

}

private getSyntacticDiagnosticsSync(args: protocol.SyntacticDiagnosticsSyncRequestArgs): ReadonlyArray<protocol.Diagnostic> | ReadonlyArray<protocol.DiagnosticWithLinePosition> {

const { configFile } = this.getConfigFileAndProject(args);

if (configFile) {

// all the config file errors are reported as part of semantic check so nothing to report here

return emptyArray;

}

return this.getDiagnosticsWorker(args, /*isSemantic*/ false, (project, file) => project.getLanguageService().getSyntacticDiagnostics(file), args.includeLinePosition);

}

private getSemanticDiagnosticsSync(args: protocol.SemanticDiagnosticsSyncRequestArgs): ReadonlyArray<protocol.Diagnostic> | ReadonlyArray<protocol.DiagnosticWithLinePosition> {

const { configFile, project } = this.getConfigFileAndProject(args);

if (configFile) {

return this.getConfigFileDiagnostics(configFile, project, args.includeLinePosition);

}

return this.getDiagnosticsWorker(args, /*isSemantic*/ true, (project, file) => project.getLanguageService().getSemanticDiagnostics(file), args.includeLinePosition);

}

private getDocumentHighlights(args: protocol.DocumentHighlightsRequestArgs, simplifiedResult: boolean): ReadonlyArray<protocol.DocumentHighlightsItem> | ReadonlyArray<DocumentHighlights> {

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

const scriptInfo = project.getScriptInfoForNormalizedPath(file);

const position = this.getPosition(args, scriptInfo);

const documentHighlights = project.getLanguageService().getDocumentHighlights(file, position, args.filesToSearch);

if (!documentHighlights) {

return emptyArray;

}

if (simplifiedResult) {

return documentHighlights.map(convertToDocumentHighlightsItem);

}

else {

return documentHighlights;

}

function convertToDocumentHighlightsItem(documentHighlights: DocumentHighlights): protocol.DocumentHighlightsItem {