if (!spaceCache[n]) {

var strBuilder = "";

for (var i = 0; i < n; i++) {

strBuilder += " ";

}

spaceCache[n] = strBuilder;

}

return spaceCache[n];

if (editorOptions.ConvertTabsToSpaces) {

return generateSpaces(n);

} else {

var result = "";

for (var i = 0; i < Math.floor(n / editorOptions.TabSize); i++) {

result += "\t";

}

for (var i = 0; i < n % editorOptions.TabSize; i++) {

result += " ";

}

return result;

}

if (a < b) {

return -1;

}

else if (a === b) {

return 0;

}

else return 1;

if (a.file < b.file) {

return -1;

}

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

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

}

return {

start: project.compilerService.host.positionToLineOffset(fileName, diag.start),

end: project.compilerService.host.positionToLineOffset(fileName, diag.start + diag.length),

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

};

for (var i = 0, len = edits.length; i < len; i++) {

if (ts.textSpanEnd(edits[i].span) >= pos) {

return false;

}

}

return true;

export const Brace = "brace";

export const Change = "change";

export const Close = "close";

export const Completions = "completions";

export const CompletionDetails = "completionEntryDetails";

export const Configure = "configure";

export const Definition = "definition";

export const Exit = "exit";

export const Format = "format";

export const Formatonkey = "formatonkey";

export const Geterr = "geterr";

export const GeterrForProject = "geterrForProject";

export const NavBar = "navbar";

export const Navto = "navto";

export const Occurrences = "occurrences";

export const DocumentHighlights = "documentHighlights";

export const Open = "open";

export const Quickinfo = "quickinfo";

export const References = "references";

export const Reload = "reload";

export const Rename = "rename";

export const Saveto = "saveto";

export const SignatureHelp = "signatureHelp";

export const TypeDefinition = "typeDefinition";

export const ProjectInfo = "projectInfo";

export const ReloadProjects = "reloadProjects";

export const Unknown = "unknown";

protected projectService: ProjectService;

private pendingOperation = false;

private fileHash: ts.Map<number> = {};

private nextFileId = 1;

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

private immediateId: any;

private changeSeq = 0;

constructor(

private host: ServerHost,

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

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

private logger: Logger

) {

this.projectService =

new ProjectService(host, logger, (eventName,project,fileName) => {

this.handleEvent(eventName, project, fileName);

});

}

private handleEvent(eventName: string, project: Project, fileName: string) {

if (eventName == "context") {

this.projectService.log("got context event, updating diagnostics for" + fileName, "Info");

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

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

}

}

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

var typedErr = <StackTraceError>err;

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

if (typedErr.message) {

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

if (typedErr.stack) {

msg += "\n" + typedErr.stack;

}

}

this.projectService.log(msg);

}

private sendLineToClient(line: string) {

this.host.write(line + this.host.newLine);

}

public send(msg: protocol.Message) {

var json = JSON.stringify(msg);

if (this.logger.isVerbose()) {

this.logger.info(msg.type + ": " + json);

}

this.sendLineToClient('Content-Length: ' + (1 + this.byteLength(json, 'utf8')) +

'\r\n\r\n' + json);

}

public event(info: any, eventName: string) {

var ev: protocol.Event = {

seq: 0,

type: "event",

event: eventName,

body: info,

};

this.send(ev);

}

private response(info: any, cmdName: string, reqSeq = 0, errorMsg?: string) {

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

}

public output(body: any, commandName: string, requestSequence = 0, errorMessage?: string) {

this.response(body, commandName, requestSequence, errorMessage);

}

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

try {

var diags = project.compilerService.languageService.getSemanticDiagnostics(file);

if (diags) {

var 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: string, project: Project) {

try {

var diags = project.compilerService.languageService.getSyntacticDiagnostics(file);

if (diags) {

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

this.event({ file: file, diagnostics: bakedDiags }, "syntaxDiag");

}

}

catch (err) {

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

}

}

private errorCheck(file: string, project: Project) {

this.syntacticCheck(file, project);

this.semanticCheck(file, project);

}

private reloadProjects() {

this.projectService.reloadProjects();

}

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

setTimeout(() => {

if (matchSeq(seq)) {

this.projectService.updateProjectStructure();

}

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

clearTimeout(this.errorTimer);

}

if (this.immediateId) {

clearImmediate(this.immediateId);

this.immediateId = undefined;

}

var index = 0;

var checkOne = () => {

if (matchSeq(seq)) {

var checkSpec = checkList[index++];

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

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

this.immediateId = setImmediate(() => {

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

this.immediateId = undefined;

if (checkList.length > index) {

this.errorTimer = setTimeout(checkOne, followMs);

}

else {

this.errorTimer = undefined;

}

});

}

}

}

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

this.errorTimer = setTimeout(checkOne, ms);

}

}

private getDefinition(line: number, offset: number, fileName: string): protocol.FileSpan[] {

var file = ts.normalizePath(fileName);

var project = this.projectService.getProjectForFile(file);

if (!project) {

throw Errors.NoProject;

}

var compilerService = project.compilerService;

var position = compilerService.host.lineOffsetToPosition(file, line, offset);

var definitions = compilerService.languageService.getDefinitionAtPosition(file, position);

if (!definitions) {

return undefined;

}

return definitions.map(def => ({

file: def.fileName,

start: compilerService.host.positionToLineOffset(def.fileName, def.textSpan.start),

end: compilerService.host.positionToLineOffset(def.fileName, ts.textSpanEnd(def.textSpan))

}));

}

private getTypeDefinition(line: number, offset: number, fileName: string): protocol.FileSpan[] {

var file = ts.normalizePath(fileName);

var project = this.projectService.getProjectForFile(file);

if (!project) {

throw Errors.NoProject;

}

var compilerService = project.compilerService;

var position = compilerService.host.lineOffsetToPosition(file, line, offset);

var definitions = compilerService.languageService.getTypeDefinitionAtPosition(file, position);

if (!definitions) {

return undefined;

}

return definitions.map(def => ({

file: def.fileName,

start: compilerService.host.positionToLineOffset(def.fileName, def.textSpan.start),

end: compilerService.host.positionToLineOffset(def.fileName, ts.textSpanEnd(def.textSpan))

}));

}

private getOccurrences(line: number, offset: number, fileName: string): protocol.OccurrencesResponseItem[] {

fileName = ts.normalizePath(fileName);

let project = this.projectService.getProjectForFile(fileName);

if (!project) {

throw Errors.NoProject;

}

let { compilerService } = project;

let position = compilerService.host.lineOffsetToPosition(fileName, line, offset);

let occurrences = compilerService.languageService.getOccurrencesAtPosition(fileName, position);

if (!occurrences) {

return undefined;

}

return occurrences.map(occurrence => {

let { fileName, isWriteAccess, textSpan } = occurrence;

let start = compilerService.host.positionToLineOffset(fileName, textSpan.start);

let end = compilerService.host.positionToLineOffset(fileName, ts.textSpanEnd(textSpan));

return {

start,

end,

file: fileName,

isWriteAccess

}

});

}

private getDocumentHighlights(line: number, offset: number, fileName: string, filesToSearch: string[]): protocol.DocumentHighlightsItem[] {

fileName = ts.normalizePath(fileName);

let project = this.projectService.getProjectForFile(fileName);

if (!project) {

throw Errors.NoProject;

}

let { compilerService } = project;

let position = compilerService.host.lineOffsetToPosition(fileName, line, offset);

let documentHighlights = compilerService.languageService.getDocumentHighlights(fileName, position, filesToSearch);

if (!documentHighlights) {

return undefined;

}

return documentHighlights.map(convertToDocumentHighlightsItem);

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

let { fileName, highlightSpans } = documentHighlights;

return {

file: fileName,

highlightSpans: highlightSpans.map(convertHighlightSpan)

};

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

let { textSpan, kind } = highlightSpan;

let start = compilerService.host.positionToLineOffset(fileName, textSpan.start);

let end = compilerService.host.positionToLineOffset(fileName, ts.textSpanEnd(textSpan));

return { start, end, kind };

}

}

}

private getProjectInfo(fileName: string, needFileNameList: boolean): protocol.ProjectInfo {

fileName = ts.normalizePath(fileName)

let project = this.projectService.getProjectForFile(fileName)

let projectInfo: protocol.ProjectInfo = {

configFileName: project.projectFilename

}

if (needFileNameList) {

projectInfo.fileNames = project.getFileNames();

}

return projectInfo;

}

private getRenameLocations(line: number, offset: number, fileName: string,findInComments: boolean, findInStrings: boolean): protocol.RenameResponseBody {

var file = ts.normalizePath(fileName);

var project = this.projectService.getProjectForFile(file);

if (!project) {

throw Errors.NoProject;

}

var compilerService = project.compilerService;

var position = compilerService.host.lineOffsetToPosition(file, line, offset);

var renameInfo = compilerService.languageService.getRenameInfo(file, position);

if (!renameInfo) {

return undefined;

}

if (!renameInfo.canRename) {

return {

info: renameInfo,

locs: []

};

}

var renameLocations = compilerService.languageService.findRenameLocations(file, position, findInStrings, findInComments);

if (!renameLocations) {

return undefined;

}

var bakedRenameLocs = renameLocations.map(location => (<protocol.FileSpan>{

file: location.fileName,

start: compilerService.host.positionToLineOffset(location.fileName, location.textSpan.start),

end: compilerService.host.positionToLineOffset(location.fileName, ts.textSpanEnd(location.textSpan)),

})).sort((a, b) => {

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;

}

}

}).reduce<protocol.SpanGroup[]>((accum: protocol.SpanGroup[], cur: protocol.FileSpan) => {

var 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: bakedRenameLocs };

}

private getReferences(line: number, offset: number, fileName: string): protocol.ReferencesResponseBody {

// TODO: get all projects for this file; report refs for all projects deleting duplicates

// can avoid duplicates by eliminating same ref file from subsequent projects

var file = ts.normalizePath(fileName);

var project = this.projectService.getProjectForFile(file);

if (!project) {

throw Errors.NoProject;

}

var compilerService = project.compilerService;

var position = compilerService.host.lineOffsetToPosition(file, line, offset);

var references = compilerService.languageService.getReferencesAtPosition(file, position);

if (!references) {

return undefined;

}

var nameInfo = compilerService.languageService.getQuickInfoAtPosition(file, position);

if (!nameInfo) {

return undefined;

}

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

var nameSpan = nameInfo.textSpan;

var nameColStart = compilerService.host.positionToLineOffset(file, nameSpan.start).offset;

var nameText = compilerService.host.getScriptSnapshot(file).getText(nameSpan.start, ts.textSpanEnd(nameSpan));

var bakedRefs: protocol.ReferencesResponseItem[] = references.map(ref => {

var start = compilerService.host.positionToLineOffset(ref.fileName, ref.textSpan.start);

var refLineSpan = compilerService.host.lineToTextSpan(ref.fileName, start.line - 1);

var snap = compilerService.host.getScriptSnapshot(ref.fileName);

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

return {

file: ref.fileName,

start: start,

lineText: lineText,

end: compilerService.host.positionToLineOffset(ref.fileName, ts.textSpanEnd(ref.textSpan)),

isWriteAccess: ref.isWriteAccess

};

}).sort(compareFileStart);

return {

refs: bakedRefs,

symbolName: nameText,

symbolStartOffset: nameColStart,

symbolDisplayString: displayString

};

}

private openClientFile(fileName: string) {

var file = ts.normalizePath(fileName);

this.projectService.openClientFile(file);

}

private getQuickInfo(line: number, offset: number, fileName: string): protocol.QuickInfoResponseBody {

var file = ts.normalizePath(fileName);

var project = this.projectService.getProjectForFile(file);

if (!project) {

throw Errors.NoProject;

}

var compilerService = project.compilerService;

var position = compilerService.host.lineOffsetToPosition(file, line, offset);

var quickInfo = compilerService.languageService.getQuickInfoAtPosition(file, position);

if (!quickInfo) {

return undefined;

}

var displayString = ts.displayPartsToString(quickInfo.displayParts);

var docString = ts.displayPartsToString(quickInfo.documentation);

return {

kind: quickInfo.kind,

kindModifiers: quickInfo.kindModifiers,

start: compilerService.host.positionToLineOffset(file, quickInfo.textSpan.start),

end: compilerService.host.positionToLineOffset(file, ts.textSpanEnd(quickInfo.textSpan)),

displayString: displayString,

documentation: docString,

};

}

private getFormattingEditsForRange(line: number, offset: number, endLine: number, endOffset: number, fileName: string): protocol.CodeEdit[] {

var file = ts.normalizePath(fileName);

var project = this.projectService.getProjectForFile(file);

if (!project) {

throw Errors.NoProject;

}

var compilerService = project.compilerService;

var startPosition = compilerService.host.lineOffsetToPosition(file, line, offset);

var endPosition = compilerService.host.lineOffsetToPosition(file, endLine, endOffset);

// TODO: avoid duplicate code (with formatonkey)

var edits = compilerService.languageService.getFormattingEditsForRange(file, startPosition, endPosition,

this.projectService.getFormatCodeOptions(file));

if (!edits) {

return undefined;

}

return edits.map((edit) => {

return {

start: compilerService.host.positionToLineOffset(file, edit.span.start),

end: compilerService.host.positionToLineOffset(file, ts.textSpanEnd(edit.span)),

newText: edit.newText ? edit.newText : ""

};

});

}

private getFormattingEditsAfterKeystroke(line: number, offset: number, key: string, fileName: string): protocol.CodeEdit[] {

var file = ts.normalizePath(fileName);

var project = this.projectService.getProjectForFile(file);

if (!project) {

throw Errors.NoProject;

}

var compilerService = project.compilerService;

var position = compilerService.host.lineOffsetToPosition(file, line, offset);

var formatOptions = this.projectService.getFormatCodeOptions(file);

var edits = compilerService.languageService.getFormattingEditsAfterKeystroke(file, position, key,

formatOptions);

// Check whether we should auto-indent. This will be when

// the position is on a line containing only whitespace.

// This should leave the edits returned from

// getFormattingEditsAfterKeytroke either empty or pertaining

// only to the previous line. If all this is true, then

// add edits necessary to properly indent the current line.

if ((key == "\n") && ((!edits) || (edits.length === 0) || allEditsBeforePos(edits, position))) {

var scriptInfo = compilerService.host.getScriptInfo(file);

if (scriptInfo) {

var lineInfo = scriptInfo.getLineInfo(line);

if (lineInfo && (lineInfo.leaf) && (lineInfo.leaf.text)) {

var lineText = lineInfo.leaf.text;

if (lineText.search("\\S") < 0) {

// TODO: get these options from host

var editorOptions: ts.EditorOptions = {

IndentSize: formatOptions.IndentSize,

TabSize: formatOptions.TabSize,

NewLineCharacter: "\n",

ConvertTabsToSpaces: formatOptions.ConvertTabsToSpaces,

IndentStyle: ts.IndentStyle.Smart,

};

var preferredIndent = compilerService.languageService.getIndentationAtPosition(file, position, editorOptions);

var hasIndent = 0;

for (var i = 0, len = lineText.length; i < len; i++) {

if (lineText.charAt(i) == " ") {

hasIndent++;

}

else if (lineText.charAt(i) == "\t") {

hasIndent += editorOptions.TabSize;

}

else {

break;

}

}

// i points to the first non whitespace character

if (preferredIndent !== hasIndent) {

var firstNoWhiteSpacePosition = lineInfo.offset + i;

edits.push({

span: ts.createTextSpanFromBounds(lineInfo.offset, firstNoWhiteSpacePosition),

newText: generateIndentString(preferredIndent, editorOptions)

});

}

}

}

}

}

if (!edits) {

return undefined;

}

return edits.map((edit) => {

return {

start: compilerService.host.positionToLineOffset(file,

edit.span.start),

end: compilerService.host.positionToLineOffset(file,

ts.textSpanEnd(edit.span)),

newText: edit.newText ? edit.newText : ""

};

});

}

private getCompletions(line: number, offset: number, prefix: string, fileName: string): protocol.CompletionEntry[] {

if (!prefix) {

prefix = "";

}

var file = ts.normalizePath(fileName);

var project = this.projectService.getProjectForFile(file);

if (!project) {

throw Errors.NoProject;

}

var compilerService = project.compilerService;

var position = compilerService.host.lineOffsetToPosition(file, line, offset);

var completions = compilerService.languageService.getCompletionsAtPosition(file, position);

if (!completions) {

return undefined;

}

return completions.entries.reduce((result: protocol.CompletionEntry[], entry: ts.CompletionEntry) => {

if (completions.isMemberCompletion || (entry.name.toLowerCase().indexOf(prefix.toLowerCase()) === 0)) {

result.push(entry);

}

return result;

}, []).sort((a, b) => a.name.localeCompare(b.name));

}

private getCompletionEntryDetails(line: number, offset: number,

entryNames: string[], fileName: string): protocol.CompletionEntryDetails[] {

var file = ts.normalizePath(fileName);

var project = this.projectService.getProjectForFile(file);

if (!project) {

throw Errors.NoProject;

}

var compilerService = project.compilerService;

var position = compilerService.host.lineOffsetToPosition(file, line, offset);

return entryNames.reduce((accum: protocol.CompletionEntryDetails[], entryName: string) => {

var details = compilerService.languageService.getCompletionEntryDetails(file, position, entryName);

if (details) {

accum.push(details);

}

return accum;

}, []);

}

private getSignatureHelpItems(line: number, offset: number, fileName: string): protocol.SignatureHelpItems {

var file = ts.normalizePath(fileName);

var project = this.projectService.getProjectForFile(file);

if (!project) {

throw Errors.NoProject;

}