/// <reference path="..\compiler\commandLineParser.ts" />

/// <reference path="..\services\services.ts" />

/// <reference path="protocol.ts" />

/// <reference path="editorServices.ts" />

namespace ts.server {

interface StackTraceError extends Error {

stack?: string;

}

export interface ServerCancellationToken extends HostCancellationToken {

setRequest(requestId: number): void;

resetRequest(requestId: number): void;

}

export const nullCancellationToken: ServerCancellationToken = {

isCancellationRequested: () => false,

setRequest: () => void 0,

resetRequest: () => void 0

};

function hrTimeToMilliseconds(time: number[]): number {

const seconds = time[0];

const nanoseconds = time[1];

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

}

function shouldSkipSematicCheck(project: Project) {

if (project.getCompilerOptions().skipLibCheck !== undefined) {

return false;

}

if ((project.projectKind === ProjectKind.Inferred || project.projectKind === ProjectKind.External) && project.isJsOnlyProject()) {

return true;

}

return false;

}

interface FileStart {

file: string;

start: ILineInfo;

}

function compareNumber(a: number, b: number) {

return a - b;

}

function compareFileStart(a: FileStart, b: FileStart) {

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;

}

}

function formatDiag(fileName: NormalizedPath, project: Project, diag: ts.Diagnostic): protocol.Diagnostic {

const scriptInfo = project.getScriptInfoForNormalizedPath(fileName);

return {

start: scriptInfo.positionToLineOffset(diag.start),

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

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

code: diag.code

};

}

function formatConfigFileDiag(diag: ts.Diagnostic): protocol.Diagnostic {

return {

start: undefined,

end: undefined,

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

};

}

export interface PendingErrorCheck {

fileName: NormalizedPath;

project: Project;

}

export interface EventSender {

event(payload: any, eventName: string): void;

}

function allEditsBeforePos(edits: ts.TextChange[], pos: number) {

for (const edit of edits) {

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

return false;

}

}

return true;

}

export namespace CommandNames {

export const Brace: protocol.CommandTypes.Brace = "brace";

/* @internal */

export const BraceFull: protocol.CommandTypes.BraceFull = "brace-full";

export const BraceCompletion: protocol.CommandTypes.BraceCompletion = "braceCompletion";

export const Change: protocol.CommandTypes.Change = "change";

export const Close: protocol.CommandTypes.Close = "close";

export const Completions: protocol.CommandTypes.Completions = "completions";

/* @internal */

export const CompletionsFull: protocol.CommandTypes.CompletionsFull = "completions-full";

export const CompletionDetails: protocol.CommandTypes.CompletionDetails = "completionEntryDetails";

export const CompileOnSaveAffectedFileList: protocol.CommandTypes.CompileOnSaveAffectedFileList = "compileOnSaveAffectedFileList";

export const CompileOnSaveEmitFile: protocol.CommandTypes.CompileOnSaveEmitFile = "compileOnSaveEmitFile";

export const Configure: protocol.CommandTypes.Configure = "configure";

export const Definition: protocol.CommandTypes.Definition = "definition";

/* @internal */

export const DefinitionFull: protocol.CommandTypes.DefinitionFull = "definition-full";

export const Exit: protocol.CommandTypes.Exit = "exit";

export const Format: protocol.CommandTypes.Format = "format";

export const Formatonkey: protocol.CommandTypes.Formatonkey = "formatonkey";

/* @internal */

export const FormatFull: protocol.CommandTypes.FormatFull = "format-full";

/* @internal */

export const FormatonkeyFull: protocol.CommandTypes.FormatonkeyFull = "formatonkey-full";

/* @internal */

export const FormatRangeFull: protocol.CommandTypes.FormatRangeFull = "formatRange-full";

export const Geterr: protocol.CommandTypes.Geterr = "geterr";

export const GeterrForProject: protocol.CommandTypes.GeterrForProject = "geterrForProject";

export const Implementation: protocol.CommandTypes.Implementation = "implementation";

/* @internal */

export const ImplementationFull: protocol.CommandTypes.ImplementationFull = "implementation-full";

export const SemanticDiagnosticsSync: protocol.CommandTypes.SemanticDiagnosticsSync = "semanticDiagnosticsSync";

export const SyntacticDiagnosticsSync: protocol.CommandTypes.SyntacticDiagnosticsSync = "syntacticDiagnosticsSync";

export const NavBar: protocol.CommandTypes.NavBar = "navbar";

/* @internal */

export const NavBarFull: protocol.CommandTypes.NavBarFull = "navbar-full";

export const NavTree: protocol.CommandTypes.NavTree = "navtree";

export const NavTreeFull: protocol.CommandTypes.NavTreeFull = "navtree-full";

export const Navto: protocol.CommandTypes.Navto = "navto";

/* @internal */

export const NavtoFull: protocol.CommandTypes.NavtoFull = "navto-full";

export const Occurrences: protocol.CommandTypes.Occurrences = "occurrences";

export const DocumentHighlights: protocol.CommandTypes.DocumentHighlights = "documentHighlights";

/* @internal */

export const DocumentHighlightsFull: protocol.CommandTypes.DocumentHighlightsFull = "documentHighlights-full";

export const Open: protocol.CommandTypes.Open = "open";

export const Quickinfo: protocol.CommandTypes.Quickinfo = "quickinfo";

/* @internal */

export const QuickinfoFull: protocol.CommandTypes.QuickinfoFull = "quickinfo-full";

export const References: protocol.CommandTypes.References = "references";

/* @internal */

export const ReferencesFull: protocol.CommandTypes.ReferencesFull = "references-full";

export const Reload: protocol.CommandTypes.Reload = "reload";

export const Rename: protocol.CommandTypes.Rename = "rename";

/* @internal */

export const RenameInfoFull: protocol.CommandTypes.RenameInfoFull = "rename-full";

/* @internal */

export const RenameLocationsFull: protocol.CommandTypes.RenameLocationsFull = "renameLocations-full";

export const Saveto: protocol.CommandTypes.Saveto = "saveto";

export const SignatureHelp: protocol.CommandTypes.SignatureHelp = "signatureHelp";

/* @internal */

export const SignatureHelpFull: protocol.CommandTypes.SignatureHelpFull = "signatureHelp-full";

export const TypeDefinition: protocol.CommandTypes.TypeDefinition = "typeDefinition";

export const ProjectInfo: protocol.CommandTypes.ProjectInfo = "projectInfo";

export const ReloadProjects: protocol.CommandTypes.ReloadProjects = "reloadProjects";

export const Unknown: protocol.CommandTypes.Unknown = "unknown";

export const OpenExternalProject: protocol.CommandTypes.OpenExternalProject = "openExternalProject";

export const OpenExternalProjects: protocol.CommandTypes.OpenExternalProjects = "openExternalProjects";

export const CloseExternalProject: protocol.CommandTypes.CloseExternalProject = "closeExternalProject";

/* @internal */

export const SynchronizeProjectList: protocol.CommandTypes.SynchronizeProjectList = "synchronizeProjectList";

/* @internal */

export const ApplyChangedToOpenFiles: protocol.CommandTypes.ApplyChangedToOpenFiles = "applyChangedToOpenFiles";

/* @internal */

export const EncodedSemanticClassificationsFull: protocol.CommandTypes.EncodedSemanticClassificationsFull = "encodedSemanticClassifications-full";

/* @internal */

export const Cleanup: protocol.CommandTypes.Cleanup = "cleanup";

/* @internal */

export const OutliningSpans: protocol.CommandTypes.OutliningSpans = "outliningSpans";

export const TodoComments: protocol.CommandTypes.TodoComments = "todoComments";

export const Indentation: protocol.CommandTypes.Indentation = "indentation";

export const DocCommentTemplate: protocol.CommandTypes.DocCommentTemplate = "docCommentTemplate";

/* @internal */

export const CompilerOptionsDiagnosticsFull: protocol.CommandTypes.CompilerOptionsDiagnosticsFull = "compilerOptionsDiagnostics-full";

/* @internal */

export const NameOrDottedNameSpan: protocol.CommandTypes.NameOrDottedNameSpan = "nameOrDottedNameSpan";

/* @internal */

export const BreakpointStatement: protocol.CommandTypes.BreakpointStatement = "breakpointStatement";

export const CompilerOptionsForInferredProjects: protocol.CommandTypes.CompilerOptionsForInferredProjects = "compilerOptionsForInferredProjects";

export const GetCodeFixes: protocol.CommandTypes.GetCodeFixes = "getCodeFixes";

/* @internal */

export const GetCodeFixesFull: protocol.CommandTypes.GetCodeFixesFull = "getCodeFixes-full";

export const GetSupportedCodeFixes: protocol.CommandTypes.GetSupportedCodeFixes = "getSupportedCodeFixes";

}

export function formatMessage<T extends protocol.Message>(msg: T, logger: server.Logger, byteLength: (s: string, encoding: string) => number, newLine: string): string {

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

}

/**

* Allows to schedule next step in multistep operation

*/

interface NextStep {

immediate(action: () => void): void;

delay(ms: number, action: () => void): void;

}

/**

* External capabilities used by multistep operation

*/

interface MultistepOperationHost {

getCurrentRequestId(): number;

sendRequestCompletedEvent(requestId: number): void;

getServerHost(): ServerHost;

isCancellationRequested(): boolean;

executeWithRequestId(requestId: number, action: () => void): void;

logError(error: Error, message: string): void;

}

/**

* Represents operation that can schedule its next step to be executed later.

* Scheduling is done via instance of NextStep. If on current step subsequent step was not scheduled - operation is assumed to be completed.

*/

class MultistepOperation {

private requestId: number;

private timerHandle: any;

private immediateId: any;

private completed = true;

private readonly next: NextStep;

constructor(private readonly operationHost: MultistepOperationHost) {

this.next = {

immediate: action => this.immediate(action),

delay: (ms, action) => this.delay(ms, action)

};

}

public startNew(action: (next: NextStep) => void) {

this.complete();

this.requestId = this.operationHost.getCurrentRequestId();

this.completed = false;

this.executeAction(action);

}

private complete() {

if (!this.completed) {

if (this.requestId) {

this.operationHost.sendRequestCompletedEvent(this.requestId);

}

this.completed = true;

}

this.setTimerHandle(undefined);

this.setImmediateId(undefined);

}

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

}));

}

private 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.next);

}

}

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;

}

}

export class Session implements EventSender {

private readonly gcTimer: GcTimer;

protected projectService: ProjectService;

private changeSeq = 0;

private currentRequestId: number;

private errorCheck: MultistepOperation;

private eventHander: ProjectServiceEventHandler;

constructor(

private host: ServerHost,

private readonly cancellationToken: ServerCancellationToken,

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,

eventHandler?: ProjectServiceEventHandler) {

this.eventHander = canUseEvents

? 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: () => cancellationToken.isCancellationRequested()

};

this.errorCheck = new MultistepOperation(multistepOperationHost);

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

this.gcTimer = new GcTimer(host, /*delay*/ 7000, 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 }], this.changeSeq, (n) => n === this.changeSeq, 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;

}

}

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 {

let diags: Diagnostic[] = [];

if (!shouldSkipSematicCheck(project)) {

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

}

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(next: NextStep, checkList: PendingErrorCheck[], seq: number, matchSeq: (seq: number) => boolean, ms = 1500, followMs = 200, requireOpen = true) {

if (followMs > ms) {

followMs = ms;

}

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

next.immediate(() => {

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

if (checkList.length > index) {

next.delay(followMs, checkOne);

}

});

}

}

};

if ((checkList.length > index) && (matchSeq(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 getCompilerOptionsDiagnostics(args: protocol.CompilerOptionsDiagnosticsRequestArgs) {

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, isSemantic: boolean, selector: (project: Project, file: string) => Diagnostic[], includeLinePosition: boolean) {

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

if (isSemantic && shouldSkipSematicCheck(project)) {

return [];

}

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 position = this.getPosition(args, project.getScriptInfoForNormalizedPath(file));

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

if (!implementations) {

return [];

}

if (simplifiedResult) {

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

const scriptInfo = project.getScriptInfo(fileName);

return {

file: fileName,

start: scriptInfo.positionToLineOffset(textSpan.start),

end: scriptInfo.positionToLineOffset(ts.textSpanEnd(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, /*isSemantic*/ false, (project, file) => project.getLanguageService().getSyntacticDiagnostics(file), args.includeLinePosition);

}

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

return this.getDiagnosticsWorker(args, /*isSemantic*/ true, (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.getSnapshot().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.getSnapshot().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(

projects,

project => project.getLanguageService().findReferences(file, position),

undefined,

// TODO: fixme

undefined

);

}

function areReferencesResponseItemsForTheSameLocation(a: protocol.ReferencesResponseItem, b: protocol.ReferencesResponseItem) {

if (a && b) {

return a.file === b.file &&

a.start === b.start &&

a.end === b.end;

}

return false;

}

}

/**

* @param fileName is the name of the file to be opened

* @param fileContent is a version of the file content that is known to be more up to date than the one on disk

*/

private openClientFile(fileName: NormalizedPath, fileContent?: string, scriptKind?: ScriptKind) {

const { configFileName, configFileErrors } = this.projectService.openClientFileWithNormalizedPath(fileName, fileContent, scriptKind);

if (this.eventHander) {

this.eventHander({

eventName: "configFileDiag",

data: { triggerFile: fileName, configFileName, diagnostics: configFileErrors || [] }

});

}

}

private getPosition(args: protocol.FileLocationRequestArgs, scriptInfo: ScriptInfo): number {

return args.position !== undefined ? args.position : scriptInfo.lineOffsetToPosition(args.line, args.offset);

}

private getFileAndProject(args: protocol.FileRequestArgs, errorOnMissingProject = true) {

return this.getFileAndProjectWorker(args.file, args.projectFileName, /*refreshInferredProjects*/ true, errorOnMissingProject);

}

private getFileAndProjectWithoutRefreshingInferredProjects(args: protocol.FileRequestArgs, errorOnMissingProject = true) {

return this.getFileAndProjectWorker(args.file, args.projectFileName, /*refreshInferredProjects*/ false, errorOnMissingProject);

}

private getFileAndProjectWorker(uncheckedFileName: string, projectFileName: string, refreshInferredProjects: boolean, errorOnMissingProject: boolean) {

const file = toNormalizedPath(uncheckedFileName);

const project: Project = this.getProject(projectFileName) || this.projectService.getDefaultProjectForFile(file, refreshInferredProjects);

if (!project && errorOnMissingProject) {

return Errors.ThrowNoProject();

}

return { file, project };

}

private getOutliningSpans(args: protocol.FileRequestArgs) {

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

return project.getLanguageService(/*ensureSynchronized*/ false).getOutliningSpans(file);

}

private getTodoComments(args: protocol.TodoCommentRequestArgs) {

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

return project.getLanguageService().getTodoComments(file, args.descriptors);

}

private getDocCommentTemplate(args: protocol.FileLocationRequestArgs) {

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

const scriptInfo = project.getScriptInfoForNormalizedPath(file);

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

return project.getLanguageService(/*ensureSynchronized*/ false).getDocCommentTemplateAtPosition(file, position);

}

private getIndentation(args: protocol.IndentationRequestArgs) {

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

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

const options = args.options ? convertFormatOptions(args.options) : this.projectService.getFormatCodeOptions(file);

const indentation = project.getLanguageService(/*ensureSynchronized*/ false).getIndentationAtPosition(file, position, options);

return { position, indentation };

}

private getBreakpointStatement(args: protocol.FileLocationRequestArgs) {

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

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

return project.getLanguageService(/*ensureSynchronized*/ false).getBreakpointStatementAtPosition(file, position);

}

private getNameOrDottedNameSpan(args: protocol.FileLocationRequestArgs) {

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

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

return project.getLanguageService(/*ensureSynchronized*/ false).getNameOrDottedNameSpan(file, position, position);

}

private isValidBraceCompletion(args: protocol.BraceCompletionRequestArgs) {