/// <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 isDeclarationFileInJSOnlyNonConfiguredProject(project: Project, file: NormalizedPath) {

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

}

interface FileStart {

file: string;

start: protocol.Location;

}

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: Diagnostic): protocol.Diagnostic {

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

};

}

function convertToLocation(lineAndCharacter: LineAndCharacter): protocol.Location {

return { line: lineAndCharacter.line + 1, offset: lineAndCharacter.character + 1 };

}

function formatConfigFileDiag(diag: Diagnostic, includeFileName: true): protocol.DiagnosticWithFileName;

function formatConfigFileDiag(diag: Diagnostic, includeFileName: false): protocol.Diagnostic;

function formatConfigFileDiag(diag: Diagnostic, includeFileName: boolean): protocol.Diagnostic | protocol.DiagnosticWithFileName {

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

}

export interface PendingErrorCheck {

fileName: NormalizedPath;

project: Project;

}

export interface EventSender {

event<T>(payload: T, eventName: string): void;

}

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

for (const edit of edits) {

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

return false;

}

}

return true;

}

// CommandNames used to be exposed before TS 2.4 as a namespace

// In TS 2.4 we switched to an enum, keep this for backward compatibility

// The var assignment ensures that even though CommandTypes are a const enum

// we want to ensure the value is maintained in the out since the file is

// built using --preseveConstEnum.

export type CommandNames = protocol.CommandTypes;

export const CommandNames = (<any>protocol).CommandTypes;

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 implements NextStep {

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;

}

}

export interface SessionOptions {

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;

}

export class Session implements EventSender {

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 {

const { fileName, highlightSpans } = documentHighlights;

const scriptInfo = project.getScriptInfo(fileName);

return {

file: fileName,

highlightSpans: highlightSpans.map(convertHighlightSpan)

};

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

const { textSpan, kind } = highlightSpan;

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

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

return { start, end, kind };

}

}

}

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

this.projectService.setCompilerOptionsForInferredProjects(args.options, args.projectRootPath);

}

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

return this.getProjectInfoWorker(args.file, args.projectFileName, args.needFileNameList, /*excludeConfigFiles*/ false);

}

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

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

const projectInfo = {

configFileName: project.getProjectName(),

languageServiceDisabled: !project.languageServiceEnabled,

fileNames: needFileNameList ? project.getFileNames(/*excludeFilesFromExternalLibraries*/ false, excludeConfigFiles) : 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;

}

// filter handles case when 'projects' is undefined

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

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

return Errors.ThrowNoProject();

}

return projects;

}

private getDefaultProject(args: protocol.FileRequestArgs) {

if (args.projectFileName) {

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

if (project) {

return project;

}

}

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

return info.getDefaultProject();

}

private getRenameLocations(args: protocol.RenameRequestArgs, simplifiedResult: boolean): protocol.RenameResponseBody | ReadonlyArray<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 = this.getDefaultProject(args);

// 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: emptyArray

};

}

const fileSpans = combineProjectOutput(

projects,

(project: Project) => {

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

if (!renameLocations) {

return emptyArray;

}

return renameLocations.map(location => {

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

return {

file: location.fileName,

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

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

};

});

},

compareRenameLocation,

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

);

const locs: protocol.SpanGroup[] = [];

for (const cur of fileSpans) {

let curFileAccum: protocol.SpanGroup;

if (locs.length > 0) {

curFileAccum = locs[locs.length - 1];

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

curFileAccum = undefined;

}

}

if (!curFileAccum) {

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

locs.push(curFileAccum);

}

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

}

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 | undefined | ReadonlyArray<ReferencedSymbol> {

const file = toNormalizedPath(args.file);

const projects = this.getProjects(args);

const defaultProject = this.getDefaultProject(args);

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 = displayPartsToString(nameInfo.displayParts);

const nameSpan = nameInfo.textSpan;

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

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

const refs = combineProjectOutput<protocol.ReferencesResponseItem>(

projects,

(project: Project) => {

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

if (!references) {

return emptyArray;

}

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, textSpanEnd(refLineSpan)).replace(/\r|\n/g, "");

return {

file: ref.fileName,

start,

lineText,

end: refScriptInfo.positionToLineOffset(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),

/*comparer*/ undefined,

/*areEqual (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, projectRootPath?: NormalizedPath) {

const { configFileName, configFileErrors } = this.projectService.openClientFileWithNormalizedPath(fileName, fileContent, scriptKind, /*hasMixedContent*/ false, projectRootPath);

if (this.eventHandler) {

this.eventHandler({

eventName: "configFileDiag",

data: { triggerFile: fileName, configFileName, diagnostics: configFileErrors || emptyArray }

});

}

}

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

}