close(): void;

isVerbose(): boolean;

loggingEnabled(): boolean;

perftrc(s: string): void;

info(s: string): void;

startGroup(): void;

endGroup(): void;

msg(s: string, type?: string): void;

const hasOwnProperty = Object.prototype.hasOwnProperty;

Object.keys(formatOptions).forEach((key) => {

const codeKey = key.charAt(0).toUpperCase() + key.substring(1);

if (hasOwnProperty.call(formatCodeOptions, codeKey)) {

formatCodeOptions[codeKey] = formatOptions[key];

}

});

svc: ScriptVersionCache;

children: ScriptInfo[] = []; // files referenced by this file

defaultProject: Project; // project to use by default for file

fileWatcher: FileWatcher;

formatCodeOptions = ts.clone(CompilerService.defaultFormatCodeOptions);

path: Path;

constructor(private host: ServerHost, public fileName: string, public content: string, public isOpen = false) {

this.path = toPath(fileName, host.getCurrentDirectory(), createGetCanonicalFileName(host.useCaseSensitiveFileNames));

this.svc = ScriptVersionCache.fromString(host, content);

}

setFormatOptions(formatOptions: protocol.FormatOptions): void {

if (formatOptions) {

mergeFormatOptions(this.formatCodeOptions, formatOptions);

}

}

close() {

this.isOpen = false;

}

addChild(childInfo: ScriptInfo) {

this.children.push(childInfo);

}

snap() {

return this.svc.getSnapshot();

}

getText() {

const snap = this.snap();

return snap.getText(0, snap.getLength());

}

getLineInfo(line: number) {

const snap = this.snap();

return snap.index.lineNumberToInfo(line);

}

editContent(start: number, end: number, newText: string): void {

this.svc.edit(start, end - start, newText);

}

getTextChangeRangeBetweenVersions(startVersion: number, endVersion: number): ts.TextChangeRange {

return this.svc.getTextChangesBetweenVersions(startVersion, endVersion);

}

getChangeRange(oldSnapshot: ts.IScriptSnapshot): ts.TextChangeRange {

return this.snap().getChangeRange(oldSnapshot);

}

ls: ts.LanguageService;

compilationSettings: ts.CompilerOptions;

filenameToScript: ts.FileMap<ScriptInfo>;

roots: ScriptInfo[] = [];

private resolvedModuleNames: ts.FileMap<Map<TimestampedResolvedModule>>;

private moduleResolutionHost: ts.ModuleResolutionHost;

private getCanonicalFileName: (fileName: string) => string;

constructor(public host: ServerHost, public project: Project) {

this.getCanonicalFileName = createGetCanonicalFileName(host.useCaseSensitiveFileNames);

this.resolvedModuleNames = createFileMap<Map<TimestampedResolvedModule>>();

this.filenameToScript = createFileMap<ScriptInfo>();

this.moduleResolutionHost = {

fileExists: fileName => this.fileExists(fileName),

readFile: fileName => this.host.readFile(fileName)

};

}

resolveModuleNames(moduleNames: string[], containingFile: string): ResolvedModule[] {

const path = toPath(containingFile, this.host.getCurrentDirectory(), this.getCanonicalFileName);

const currentResolutionsInFile = this.resolvedModuleNames.get(path);

const newResolutions: Map<TimestampedResolvedModule> = {};

const resolvedModules: ResolvedModule[] = [];

const compilerOptions = this.getCompilationSettings();

for (const moduleName of moduleNames) {

// check if this is a duplicate entry in the list

let resolution = lookUp(newResolutions, moduleName);

if (!resolution) {

const existingResolution = currentResolutionsInFile && ts.lookUp(currentResolutionsInFile, moduleName);

if (moduleResolutionIsValid(existingResolution)) {

// ok, it is safe to use existing module resolution results

resolution = existingResolution;

}

else {

resolution = <TimestampedResolvedModule>resolveModuleName(moduleName, containingFile, compilerOptions, this.moduleResolutionHost);

resolution.lastCheckTime = Date.now();

newResolutions[moduleName] = resolution;

}

}

ts.Debug.assert(resolution !== undefined);

resolvedModules.push(resolution.resolvedModule);

}

// replace old results with a new one

this.resolvedModuleNames.set(path, newResolutions);

return resolvedModules;

function moduleResolutionIsValid(resolution: TimestampedResolvedModule): boolean {

if (!resolution) {

return false;

}

if (resolution.resolvedModule) {

// TODO: consider checking failedLookupLocations

// TODO: use lastCheckTime to track expiration for module name resolution

return true;

}

// consider situation if we have no candidate locations as valid resolution.

// after all there is no point to invalidate it if we have no idea where to look for the module.

return resolution.failedLookupLocations.length === 0;

}

}

getDefaultLibFileName() {

const nodeModuleBinDir = ts.getDirectoryPath(ts.normalizePath(this.host.getExecutingFilePath()));

return ts.combinePaths(nodeModuleBinDir, ts.getDefaultLibFileName(this.compilationSettings));

}

getScriptSnapshot(filename: string): ts.IScriptSnapshot {

const scriptInfo = this.getScriptInfo(filename);

if (scriptInfo) {

return scriptInfo.snap();

}

}

setCompilationSettings(opt: ts.CompilerOptions) {

this.compilationSettings = opt;

// conservatively assume that changing compiler options might affect module resolution strategy

this.resolvedModuleNames.clear();

}

lineAffectsRefs(filename: string, line: number) {

const info = this.getScriptInfo(filename);

const lineInfo = info.getLineInfo(line);

if (lineInfo && lineInfo.text) {

const regex = /reference|import|\/\*|\*\//;

return regex.test(lineInfo.text);

}

}

getCompilationSettings() {

// change this to return active project settings for file

return this.compilationSettings;

}

getScriptFileNames() {

return this.roots.map(root => root.fileName);

}

getScriptVersion(filename: string) {

return this.getScriptInfo(filename).svc.latestVersion().toString();

}

getCurrentDirectory(): string {

return "";

}

getScriptIsOpen(filename: string) {

return this.getScriptInfo(filename).isOpen;

}

removeReferencedFile(info: ScriptInfo) {

if (!info.isOpen) {

this.filenameToScript.remove(info.path);

this.resolvedModuleNames.remove(info.path);

}

}

getScriptInfo(filename: string): ScriptInfo {

const path = toPath(filename, this.host.getCurrentDirectory(), this.getCanonicalFileName);

let scriptInfo = this.filenameToScript.get(path);

if (!scriptInfo) {

scriptInfo = this.project.openReferencedFile(filename);

if (scriptInfo) {

this.filenameToScript.set(path, scriptInfo);

}

}

return scriptInfo;

}

addRoot(info: ScriptInfo) {

if (!this.filenameToScript.contains(info.path)) {

this.filenameToScript.set(info.path, info);

this.roots.push(info);

}

}

removeRoot(info: ScriptInfo) {

if (!this.filenameToScript.contains(info.path)) {

this.filenameToScript.remove(info.path);

this.roots = copyListRemovingItem(info, this.roots);

this.resolvedModuleNames.remove(info.path);

}

}

saveTo(filename: string, tmpfilename: string) {

const script = this.getScriptInfo(filename);

if (script) {

const snap = script.snap();

this.host.writeFile(tmpfilename, snap.getText(0, snap.getLength()));

}

}

reloadScript(filename: string, tmpfilename: string, cb: () => any) {

const script = this.getScriptInfo(filename);

if (script) {

script.svc.reloadFromFile(tmpfilename, cb);

}

}

editScript(filename: string, start: number, end: number, newText: string) {

const script = this.getScriptInfo(filename);

if (script) {

script.editContent(start, end, newText);

return;

}

throw new Error("No script with name '" + filename + "'");

}

resolvePath(path: string): string {

const start = new Date().getTime();

const result = this.host.resolvePath(path);

return result;

}

fileExists(path: string): boolean {

const start = new Date().getTime();

const result = this.host.fileExists(path);

return result;

}

directoryExists(path: string): boolean {

return this.host.directoryExists(path);

}

/**

lineToTextSpan(filename: string, line: number): ts.TextSpan {

const path = toPath(filename, this.host.getCurrentDirectory(), this.getCanonicalFileName);

const script: ScriptInfo = this.filenameToScript.get(path);

const index = script.snap().index;

const lineInfo = index.lineNumberToInfo(line + 1);

let len: number;

if (lineInfo.leaf) {

len = lineInfo.leaf.text.length;

}

else {

const nextLineInfo = index.lineNumberToInfo(line + 2);

len = nextLineInfo.offset - lineInfo.offset;

}

return ts.createTextSpan(lineInfo.offset, len);

}

/**

lineOffsetToPosition(filename: string, line: number, offset: number): number {

const path = toPath(filename, this.host.getCurrentDirectory(), this.getCanonicalFileName);

const script: ScriptInfo = this.filenameToScript.get(path);

const index = script.snap().index;

const lineInfo = index.lineNumberToInfo(line);

// TODO: assert this offset is actually on the line

return (lineInfo.offset + offset - 1);

}

/**

positionToLineOffset(filename: string, position: number): ILineInfo {

const path = toPath(filename, this.host.getCurrentDirectory(), this.getCanonicalFileName);

const script: ScriptInfo = this.filenameToScript.get(path);

const index = script.snap().index;

const lineOffset = index.charOffsetToLineNumberAndPos(position);

return { line: lineOffset.line, offset: lineOffset.offset + 1 };

}

const rootLength = ts.getRootLength(filename);

if (rootLength > 0) {

return filename;

}

else {

const splitFilename = filename.split("/");

const splitDir = directory.split("/");

let i = 0;

let dirTail = 0;

const sflen = splitFilename.length;

while ((i < sflen) && (splitFilename[i].charAt(0) == ".")) {

const dots = splitFilename[i];

if (dots == "..") {

dirTail++;

}

else if (dots != ".") {

return undefined;

}

i++;

}

return splitDir.slice(0, splitDir.length - dirTail).concat(splitFilename.slice(i)).join("/");

}

// these fields can be present in the project file

files?: string[];

compilerOptions?: ts.CompilerOptions;

compilerService: CompilerService;

projectFilename: string;

projectFileWatcher: FileWatcher;

directoryWatcher: FileWatcher;

// Used to keep track of what directories are watched for this project

directoriesWatchedForTsconfig: string[] = [];

program: ts.Program;

filenameToSourceFile: ts.Map<ts.SourceFile> = {};

updateGraphSeq = 0;

/** Used for configured projects which may have multiple open roots */

openRefCount = 0;

constructor(public projectService: ProjectService, public projectOptions?: ProjectOptions) {

this.compilerService = new CompilerService(this, projectOptions && projectOptions.compilerOptions);

}

addOpenRef() {

this.openRefCount++;

}

deleteOpenRef() {

this.openRefCount--;

return this.openRefCount;

}

openReferencedFile(filename: string) {

return this.projectService.openFile(filename, false);

}

getRootFiles() {

return this.compilerService.host.roots.map(info => info.fileName);

}

getFileNames() {

const sourceFiles = this.program.getSourceFiles();

return sourceFiles.map(sourceFile => sourceFile.fileName);

}

getSourceFile(info: ScriptInfo) {

return this.filenameToSourceFile[info.fileName];

}

getSourceFileFromName(filename: string, requireOpen?: boolean) {

const info = this.projectService.getScriptInfo(filename);

if (info) {

if ((!requireOpen) || info.isOpen) {

return this.getSourceFile(info);

}

}

}

isRoot(info: ScriptInfo) {

return this.compilerService.host.roots.some(root => root === info);

}

removeReferencedFile(info: ScriptInfo) {

this.compilerService.host.removeReferencedFile(info);

this.updateGraph();

}

updateFileMap() {

this.filenameToSourceFile = {};

const sourceFiles = this.program.getSourceFiles();

for (let i = 0, len = sourceFiles.length; i < len; i++) {

const normFilename = ts.normalizePath(sourceFiles[i].fileName);

this.filenameToSourceFile[normFilename] = sourceFiles[i];

}

}

finishGraph() {

this.updateGraph();

this.compilerService.languageService.getNavigateToItems(".*");

}

updateGraph() {

this.program = this.compilerService.languageService.getProgram();

this.updateFileMap();

}

isConfiguredProject() {

return this.projectFilename;

}

// add a root file to project

addRoot(info: ScriptInfo) {

this.compilerService.host.addRoot(info);

}

// remove a root file from project

removeRoot(info: ScriptInfo) {

this.compilerService.host.removeRoot(info);

}

filesToString() {

let strBuilder = "";

ts.forEachValue(this.filenameToSourceFile,

sourceFile => { strBuilder += sourceFile.fileName + "\n"; });

return strBuilder;

}

setProjectOptions(projectOptions: ProjectOptions) {

this.projectOptions = projectOptions;

if (projectOptions.compilerOptions) {

this.compilerService.setCompilerOptions(projectOptions.compilerOptions);

}

}

success?: boolean;

errorMsg?: string;

project?: Project;

const copiedList: T[] = [];

for (let i = 0, len = list.length; i < len; i++) {

if (list[i] != item) {

copiedList.push(list[i]);

}

}

return copiedList;

filenameToScriptInfo: ts.Map<ScriptInfo> = {};

// open, non-configured root files

openFileRoots: ScriptInfo[] = [];

// projects built from openFileRoots

inferredProjects: Project[] = [];

// projects specified by a tsconfig.json file

configuredProjects: Project[] = [];

// open files referenced by a project

openFilesReferenced: ScriptInfo[] = [];

// open files that are roots of a configured project

openFileRootsConfigured: ScriptInfo[] = [];

// a path to directory watcher map that detects added tsconfig files

directoryWatchersForTsconfig: ts.Map<FileWatcher> = {};

// count of how many projects are using the directory watcher. If the

// number becomes 0 for a watcher, then we should close it.

directoryWatchersRefCount: ts.Map<number> = {};

hostConfiguration: HostConfiguration;

timerForDetectingProjectFilelistChanges: Map<NodeJS.Timer> = {};

constructor(public host: ServerHost, public psLogger: Logger, public eventHandler?: ProjectServiceEventHandler) {

// ts.disableIncrementalParsing = true;

this.addDefaultHostConfiguration();

}

addDefaultHostConfiguration() {

this.hostConfiguration = {

formatCodeOptions: ts.clone(CompilerService.defaultFormatCodeOptions),

hostInfo: "Unknown host"

};

}

getFormatCodeOptions(file?: string) {

if (file) {

const info = this.filenameToScriptInfo[file];

if (info) {

return info.formatCodeOptions;

}

}

return this.hostConfiguration.formatCodeOptions;

}

watchedFileChanged(fileName: string) {

const info = this.filenameToScriptInfo[fileName];

if (!info) {

this.psLogger.info("Error: got watch notification for unknown file: " + fileName);

}

if (!this.host.fileExists(fileName)) {

// File was deleted

this.fileDeletedInFilesystem(info);

}

else {

if (info && (!info.isOpen)) {

info.svc.reloadFromFile(info.fileName);

}

}

}

/**

directoryWatchedForSourceFilesChanged(project: Project, fileName: string) {

// If a change was made inside "folder/file", node will trigger the callback twice:

// one with the fileName being "folder/file", and the other one with "folder".

// We don't respond to the second one.

if (fileName && !ts.isSupportedSourceFileName(fileName)) {

return;

}

this.log("Detected source file changes: " + fileName);

this.startTimerForDetectingProjectFilelistChanges(project);

}

startTimerForDetectingProjectFilelistChanges(project: Project) {

if (this.timerForDetectingProjectFilelistChanges[project.projectFilename]) {

clearTimeout(this.timerForDetectingProjectFilelistChanges[project.projectFilename]);

}

this.timerForDetectingProjectFilelistChanges[project.projectFilename] = setTimeout(

() => this.handleProjectFilelistChanges(project),

250

);

}

handleProjectFilelistChanges(project: Project) {

const { succeeded, projectOptions, error } = this.configFileToProjectOptions(project.projectFilename);

const newRootFiles = projectOptions.files.map((f => this.getCanonicalFileName(f)));

const currentRootFiles = project.getRootFiles().map((f => this.getCanonicalFileName(f)));

// We check if the project file list has changed. If so, we update the project.

if (!arrayIsEqualTo(currentRootFiles && currentRootFiles.sort(), newRootFiles && newRootFiles.sort())) {

// For configured projects, the change is made outside the tsconfig file, and

// it is not likely to affect the project for other files opened by the client. We can

// just update the current project.

this.updateConfiguredProject(project);

// Call updateProjectStructure to clean up inferred projects we may have

// created for the new files

this.updateProjectStructure();

}

}

/**

directoryWatchedForTsconfigChanged(fileName: string) {

if (ts.getBaseFileName(fileName) != "tsconfig.json") {

this.log(fileName + " is not tsconfig.json");

return;

}

this.log("Detected newly added tsconfig file: " + fileName);

const { succeeded, projectOptions, error } = this.configFileToProjectOptions(fileName);

const rootFilesInTsconfig = projectOptions.files.map(f => this.getCanonicalFileName(f));

const openFileRoots = this.openFileRoots.map(s => this.getCanonicalFileName(s.fileName));

// We should only care about the new tsconfig file if it contains any

// opened root files of existing inferred projects

for (const openFileRoot of openFileRoots) {

if (rootFilesInTsconfig.indexOf(openFileRoot) >= 0) {

this.reloadProjects();

return;

}

}

}

getCanonicalFileName(fileName: string) {

const name = this.host.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase();

return ts.normalizePath(name);

}

watchedProjectConfigFileChanged(project: Project) {

this.log("Config file changed: " + project.projectFilename);

this.updateConfiguredProject(project);

this.updateProjectStructure();

}

log(msg: string, type = "Err") {

this.psLogger.msg(msg, type);

}

setHostConfiguration(args: ts.server.protocol.ConfigureRequestArguments) {

if (args.file) {

const info = this.filenameToScriptInfo[args.file];

if (info) {

info.setFormatOptions(args.formatOptions);

this.log("Host configuration update for file " + args.file, "Info");

}

}

else {

if (args.hostInfo !== undefined) {

this.hostConfiguration.hostInfo = args.hostInfo;

this.log("Host information " + args.hostInfo, "Info");

}

if (args.formatOptions) {

mergeFormatOptions(this.hostConfiguration.formatCodeOptions, args.formatOptions);

this.log("Format host information updated", "Info");

}

}

}

closeLog() {

this.psLogger.close();

}

createInferredProject(root: ScriptInfo) {

const project = new Project(this);

project.addRoot(root);

let currentPath = ts.getDirectoryPath(root.fileName);

let parentPath = ts.getDirectoryPath(currentPath);

while (currentPath != parentPath) {

if (!project.projectService.directoryWatchersForTsconfig[currentPath]) {

this.log("Add watcher for: " + currentPath);

project.projectService.directoryWatchersForTsconfig[currentPath] =

this.host.watchDirectory(currentPath, fileName => this.directoryWatchedForTsconfigChanged(fileName));

project.projectService.directoryWatchersRefCount[currentPath] = 1;

}

else {

project.projectService.directoryWatchersRefCount[currentPath] += 1;

}

project.directoriesWatchedForTsconfig.push(currentPath);

currentPath = parentPath;

parentPath = ts.getDirectoryPath(parentPath);

}

project.finishGraph();

this.inferredProjects.push(project);

return project;

}

fileDeletedInFilesystem(info: ScriptInfo) {

this.psLogger.info(info.fileName + " deleted");

if (info.fileWatcher) {

info.fileWatcher.close();

info.fileWatcher = undefined;

}

if (!info.isOpen) {

this.filenameToScriptInfo[info.fileName] = undefined;

const referencingProjects = this.findReferencingProjects(info);

if (info.defaultProject) {

info.defaultProject.removeRoot(info);

}

for (let i = 0, len = referencingProjects.length; i < len; i++) {

referencingProjects[i].removeReferencedFile(info);

}

for (let j = 0, flen = this.openFileRoots.length; j < flen; j++) {

const openFile = this.openFileRoots[j];

if (this.eventHandler) {

this.eventHandler("context", openFile.defaultProject, openFile.fileName);

}

}

for (let j = 0, flen = this.openFilesReferenced.length; j < flen; j++) {

const openFile = this.openFilesReferenced[j];

if (this.eventHandler) {

this.eventHandler("context", openFile.defaultProject, openFile.fileName);

}

}

}

this.printProjects();

}

updateConfiguredProjectList() {

const configuredProjects: Project[] = [];

for (let i = 0, len = this.configuredProjects.length; i < len; i++) {

if (this.configuredProjects[i].openRefCount > 0) {

configuredProjects.push(this.configuredProjects[i]);

}

}

this.configuredProjects = configuredProjects;

}

removeProject(project: Project) {

this.log("remove project: " + project.getRootFiles().toString());

if (project.isConfiguredProject()) {

project.projectFileWatcher.close();

project.directoryWatcher.close();

this.configuredProjects = copyListRemovingItem(project, this.configuredProjects);

}

else {

for (const directory of project.directoriesWatchedForTsconfig) {

// if the ref count for this directory watcher drops to 0, it's time to close it

if (!(--project.projectService.directoryWatchersRefCount[directory])) {

this.log("Close directory watcher for: " + directory);

project.projectService.directoryWatchersForTsconfig[directory].close();

delete project.projectService.directoryWatchersForTsconfig[directory];

}

}

this.inferredProjects = copyListRemovingItem(project, this.inferredProjects);

}

const fileNames = project.getFileNames();

for (const fileName of fileNames) {

const info = this.getScriptInfo(fileName);

if (info.defaultProject == project) {

info.defaultProject = undefined;

}

}

}

setConfiguredProjectRoot(info: ScriptInfo) {

for (let i = 0, len = this.configuredProjects.length; i < len; i++) {

const configuredProject = this.configuredProjects[i];

if (configuredProject.isRoot(info)) {