const seconds = time[0];

const nanoseconds = time[1];

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

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: ts.flattenDiagnosticMessageText(diag.messageText, "\n")

};

return {

start: undefined,

end: undefined,

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

};

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

private readonly gcTimer: GcTimer;

protected projectService: ProjectService;

private errorTimer: any; /*NodeJS.Timer | number*/

private immediateId: any;

private changeSeq = 0;

constructor(

private host: ServerHost,

cancellationToken: HostCancellationToken,

useSingleInferredProject: boolean,

protected readonly typingsInstaller: ITypingsInstaller,

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

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

protected logger: Logger,

protected readonly canUseEvents: boolean) {

const eventHandler: ProjectServiceEventHandler = canUseEvents

? event => this.handleEvent(event)

: undefined;

this.projectService = new ProjectService(host, logger, cancellationToken, useSingleInferredProject, typingsInstaller, eventHandler);

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

}

private handleEvent(event: ProjectServiceEvent) {

switch (event.eventName) {

case "context":

const { project, fileName } = event.data;

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

this.updateErrorCheck([{ fileName, project }], this.changeSeq,

(n) => n === this.changeSeq, 100);

break;

case "configFileDiag":

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

this.configFileDiagnosticEvent(triggerFile, configFileName, diagnostics);

}

}

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: ts.Diagnostic[]) {

const bakedDiags = ts.map(diagnostics, formatConfigFileDiag);

const ev: protocol.ConfigFileDiagnosticEvent = {

seq: 0,

type: "event",

event: "configFileDiag",

body: {

triggerFile,

configFile,

diagnostics: bakedDiags

}

};

this.send(ev);

}

public event(info: any, 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 {

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

if (diags) {

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

this.event({ file: 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({ file: file, diagnostics: bakedDiags }, "syntaxDiag");

}

}

catch (err) {

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

}

}

private updateProjectStructure(seq: number, matchSeq: (seq: number) => boolean, ms = 1500) {

this.host.setTimeout(() => {

if (matchSeq(seq)) {

this.projectService.refreshInferredProjects();

}

}, ms);

}

private updateErrorCheck(checkList: PendingErrorCheck[], seq: number,

matchSeq: (seq: number) => boolean, ms = 1500, followMs = 200, requireOpen = true) {

if (followMs > ms) {

followMs = ms;

}

if (this.errorTimer) {

this.host.clearTimeout(this.errorTimer);

}

if (this.immediateId) {

this.host.clearImmediate(this.immediateId);

this.immediateId = undefined;

}

let index = 0;

const checkOne = () => {

if (matchSeq(seq)) {

const checkSpec = checkList[index];

index++;

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

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

this.immediateId = this.host.setImmediate(() => {

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

this.immediateId = undefined;

if (checkList.length > index) {

this.errorTimer = this.host.setTimeout(checkOne, followMs);

}

else {

this.errorTimer = undefined;

}

});

}

}

};

if ((checkList.length > index) && (matchSeq(seq))) {

this.errorTimer = this.host.setTimeout(checkOne, ms);

}

}

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

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

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

}

private getProject(projectFileName: string) {

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

}

private getCompilerOptionsDiagnostics(args: protocol.ProjectRequestArgs) {

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

return this.convertToDiagnosticsWithLinePosition(project.getLanguageService().getCompilerOptionsDiagnostics(), /*scriptInfo*/ undefined);

}

private convertToDiagnosticsWithLinePosition(diagnostics: Diagnostic[], scriptInfo: ScriptInfo) {

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,

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

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

});

}

private getDiagnosticsWorker(args: protocol.FileRequestArgs, selector: (project: Project, file: string) => Diagnostic[], includeLinePosition: boolean) {

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

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): protocol.FileSpan[] | 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 undefined;

}

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(ts.textSpanEnd(def.textSpan))

};

});

}

else {

return definitions;

}

}

private getTypeDefinition(args: protocol.FileLocationRequestArgs): 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 undefined;

}

return definitions.map(def => {

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

return {

file: def.fileName,

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

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

};

});

}

private getImplementation(args: protocol.FileLocationRequestArgs, simplifiedResult: boolean): protocol.FileSpan[] | ImplementationLocation[] {

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

const scriptInfo = project.getScriptInfoForNormalizedPath(file);

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

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

if (!implementations) {

return [];

}

if (simplifiedResult) {

return implementations.map(impl => ({

file: impl.fileName,

start: scriptInfo.positionToLineOffset(impl.textSpan.start),

end: scriptInfo.positionToLineOffset(ts.textSpanEnd(impl.textSpan))

}));

}

else {

return implementations;

}

}

private getOccurrences(args: protocol.FileLocationRequestArgs): 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 undefined;

}

return occurrences.map(occurrence => {

const { fileName, isWriteAccess, textSpan } = occurrence;

const scriptInfo = project.getScriptInfo(fileName);

const start = scriptInfo.positionToLineOffset(textSpan.start);

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

return {

start,

end,

file: fileName,

isWriteAccess,

};

});

}

private getSyntacticDiagnosticsSync(args: protocol.SyntacticDiagnosticsSyncRequestArgs): protocol.Diagnostic[] | protocol.DiagnosticWithLinePosition[] {

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

}

private getSemanticDiagnosticsSync(args: protocol.SemanticDiagnosticsSyncRequestArgs): protocol.Diagnostic[] | protocol.DiagnosticWithLinePosition[] {

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

}

private getDocumentHighlights(args: protocol.DocumentHighlightsRequestArgs, simplifiedResult: boolean): protocol.DocumentHighlightsItem[] | 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 undefined;

}

if (simplifiedResult) {

return documentHighlights.map(convertToDocumentHighlightsItem);

}

else {

return documentHighlights;

}

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

const { fileName, highlightSpans } = documentHighlights;

const scriptInfo = project.getScriptInfo(fileName);

return {

file: fileName,

highlightSpans: highlightSpans.map(convertHighlightSpan)

};

function convertHighlightSpan(highlightSpan: ts.HighlightSpan): ts.server.protocol.HighlightSpan {

const { textSpan, kind } = highlightSpan;

const start = scriptInfo.positionToLineOffset(textSpan.start);

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

return { start, end, kind };

}

}

}

private setCompilerOptionsForInferredProjects(args: protocol.SetCompilerOptionsForInferredProjectsArgs): void {

this.projectService.setCompilerOptionsForInferredProjects(args.options);

}

private getProjectInfo(args: protocol.ProjectInfoRequestArgs): protocol.ProjectInfo {

return this.getProjectInfoWorker(args.file, args.projectFileName, args.needFileNameList);

}

private getProjectInfoWorker(uncheckedFileName: string, projectFileName: string, needFileNameList: boolean) {

const { project } = this.getFileAndProjectWorker(uncheckedFileName, projectFileName, /*refreshInferredProjects*/ true, /*errorOnMissingProject*/ true);

const projectInfo = {

configFileName: project.getProjectName(),

languageServiceDisabled: !project.languageServiceEnabled,

fileNames: needFileNameList ? project.getFileNames() : undefined

};

return projectInfo;

}

private getRenameInfo(args: protocol.FileLocationRequestArgs) {

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

const scriptInfo = project.getScriptInfoForNormalizedPath(file);

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

return project.getLanguageService().getRenameInfo(file, position);

}

private getProjects(args: protocol.FileRequestArgs) {

let projects: Project[];

if (args.projectFileName) {

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

if (project) {

projects = [project];

}

}

else {

const scriptInfo = this.projectService.getScriptInfo(args.file);

projects = scriptInfo.containingProjects;

}

// ts.filter handles case when 'projects' is undefined

projects = filter(projects, p => p.languageServiceEnabled);

if (!projects || !projects.length) {

return Errors.ThrowNoProject();

}

return projects;

}

private getRenameLocations(args: protocol.RenameRequestArgs, simplifiedResult: boolean): protocol.RenameResponseBody | RenameLocation[] {

const file = toNormalizedPath(args.file);

const info = this.projectService.getScriptInfoForNormalizedPath(file);

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

const projects = this.getProjects(args);

if (simplifiedResult) {

const defaultProject = projects[0];

// The rename info should be the same for every project

const renameInfo = defaultProject.getLanguageService().getRenameInfo(file, position);

if (!renameInfo) {

return undefined;

}

if (!renameInfo.canRename) {

return {

info: renameInfo,

locs: []

};

}

const fileSpans = combineProjectOutput(

projects,

(project: Project) => {

const renameLocations = project.getLanguageService().findRenameLocations(file, position, args.findInStrings, args.findInComments);

if (!renameLocations) {

return [];

}

return renameLocations.map(location => {

const locationScriptInfo = project.getScriptInfo(location.fileName);

return <protocol.FileSpan>{

file: location.fileName,

start: locationScriptInfo.positionToLineOffset(location.textSpan.start),

end: locationScriptInfo.positionToLineOffset(ts.textSpanEnd(location.textSpan)),

};

});

},

compareRenameLocation,

(a, b) => a.file === b.file && a.start.line === b.start.line && a.start.offset === b.start.offset

);

const locs = fileSpans.reduce<protocol.SpanGroup[]>((accum, cur) => {

let curFileAccum: protocol.SpanGroup;

if (accum.length > 0) {

curFileAccum = accum[accum.length - 1];

if (curFileAccum.file !== cur.file) {

curFileAccum = undefined;

}

}

if (!curFileAccum) {

curFileAccum = { file: cur.file, locs: [] };

accum.push(curFileAccum);

}

curFileAccum.locs.push({ start: cur.start, end: cur.end });

return accum;

}, []);

return { info: renameInfo, locs };

}

else {

return combineProjectOutput(

projects,

p => p.getLanguageService().findRenameLocations(file, position, args.findInStrings, args.findInComments),

/*comparer*/ undefined,

renameLocationIsEqualTo

);

}

function renameLocationIsEqualTo(a: RenameLocation, b: RenameLocation) {

if (a === b) {

return true;

}

if (!a || !b) {

return false;

}

return a.fileName === b.fileName &&

a.textSpan.start === b.textSpan.start &&

a.textSpan.length === b.textSpan.length;

}

function compareRenameLocation(a: protocol.FileSpan, b: protocol.FileSpan) {

if (a.file < b.file) {

return -1;

}

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

return 1;

}

else {

// reverse sort assuming no overlap

if (a.start.line < b.start.line) {

return 1;

}

else if (a.start.line > b.start.line) {

return -1;

}

else {

return b.start.offset - a.start.offset;

}

}

}

}

private getReferences(args: protocol.FileLocationRequestArgs, simplifiedResult: boolean): protocol.ReferencesResponseBody | ReferencedSymbol[] {

const file = toNormalizedPath(args.file);

const projects = this.getProjects(args);

const defaultProject = projects[0];

const scriptInfo = defaultProject.getScriptInfoForNormalizedPath(file);

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

if (simplifiedResult) {

const nameInfo = defaultProject.getLanguageService().getQuickInfoAtPosition(file, position);

if (!nameInfo) {

return undefined;

}

const displayString = ts.displayPartsToString(nameInfo.displayParts);

const nameSpan = nameInfo.textSpan;

const nameColStart = scriptInfo.positionToLineOffset(nameSpan.start).offset;

const nameText = scriptInfo.snap().getText(nameSpan.start, ts.textSpanEnd(nameSpan));

const refs = combineProjectOutput<protocol.ReferencesResponseItem>(

projects,

(project: Project) => {

const references = project.getLanguageService().getReferencesAtPosition(file, position);

if (!references) {

return [];

}

return references.map(ref => {

const refScriptInfo = project.getScriptInfo(ref.fileName);

const start = refScriptInfo.positionToLineOffset(ref.textSpan.start);

const refLineSpan = refScriptInfo.lineToTextSpan(start.line - 1);

const lineText = refScriptInfo.snap().getText(refLineSpan.start, ts.textSpanEnd(refLineSpan)).replace(/\r|\n/g, "");

return {

file: ref.fileName,

start: start,

lineText: lineText,

end: refScriptInfo.positionToLineOffset(ts.textSpanEnd(ref.textSpan)),

isWriteAccess: ref.isWriteAccess,

isDefinition: ref.isDefinition

};

});

},

compareFileStart,

areReferencesResponseItemsForTheSameLocation

);

return {

refs,

symbolName: nameText,

symbolStartOffset: nameColStart,

symbolDisplayString: displayString

};

}

else {

return combineProjectOutput(