close(): void;

isVerbose(): boolean;

loggingEnabled(): boolean;

perftrc(s: string): void;

info(s: string): void;

startGroup(): void;

endGroup(): void;

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

var hasOwnProperty = Object.prototype.hasOwnProperty;

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

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

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

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() {

var snap = this.snap();

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

}

getLineInfo(line: number) {

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

compilationSettings: ts.CompilerOptions;

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

roots: ScriptInfo[] = [];

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

private moduleResolutionHost: ts.ModuleResolutionHost;

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

this.resolvedModuleNames = ts.createFileMap<Map<TimestampedResolvedModule>>(ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames))

this.moduleResolutionHost = {

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

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

}

}

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

let currentResolutionsInFile = this.resolvedModuleNames.get(containingFile);

let newResolutions: Map<TimestampedResolvedModule> = {};

let resolvedFileNames: string[] = [];

let compilerOptions = this.getCompilationSettings();

for (let moduleName of moduleNames) {

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

let resolution = lookUp(newResolutions, moduleName);

if (!resolution) {

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

resolvedFileNames.push(resolution.resolvedFileName);

}

// replace old results with a new one

this.resolvedModuleNames.set(containingFile, newResolutions);

return resolvedFileNames;

function moduleResolutionIsValid(resolution: TimestampedResolvedModule): boolean {

if (!resolution) {

return false;

}

if (resolution.resolvedFileName) {

// 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() {

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

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

}

getScriptSnapshot(filename: string): ts.IScriptSnapshot {

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

var info = this.getScriptInfo(filename);

var lineInfo = info.getLineInfo(line);

if (lineInfo && lineInfo.text) {

var 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[info.fileName] = undefined;

this.resolvedModuleNames.remove(info.fileName);

}

}

getScriptInfo(filename: string): ScriptInfo {

var scriptInfo = ts.lookUp(this.filenameToScript, filename);

if (!scriptInfo) {

scriptInfo = this.project.openReferencedFile(filename);

if (scriptInfo) {

this.filenameToScript[scriptInfo.fileName] = scriptInfo;

}

}

else {

}

return scriptInfo;

}

addRoot(info: ScriptInfo) {

var scriptInfo = ts.lookUp(this.filenameToScript, info.fileName);

if (!scriptInfo) {

this.filenameToScript[info.fileName] = info;

this.roots.push(info);

}

}

saveTo(filename: string, tmpfilename: string) {

var script = this.getScriptInfo(filename);

if (script) {

var snap = script.snap();

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

}

}

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

var script = this.getScriptInfo(filename);

if (script) {

script.svc.reloadFromFile(tmpfilename, cb);

}

}

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

var script = this.getScriptInfo(filename);

if (script) {

script.editContent(start, end, newText);

return;

}

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

}

resolvePath(path: string): string {

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

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

return result;

}

fileExists(path: string): boolean {

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

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

return result;

}

directoryExists(path: string): boolean {

return this.host.directoryExists(path);

}

/**

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

var script: ScriptInfo = this.filenameToScript[filename];

var index = script.snap().index;

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

var len: number;

if (lineInfo.leaf) {

len = lineInfo.leaf.text.length;

}

else {

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

len = nextLineInfo.offset - lineInfo.offset;

}

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

}

/**

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

var script: ScriptInfo = this.filenameToScript[filename];

var index = script.snap().index;

var lineInfo = index.lineNumberToInfo(line);

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

return (lineInfo.offset + offset - 1);

}

/**

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

var script: ScriptInfo = this.filenameToScript[filename];

var index = script.snap().index;

var lineOffset = index.charOffsetToLineNumberAndPos(position);

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

}

var rootLength = ts.getRootLength(filename);

if (rootLength > 0) {

return filename;

}

else {

var splitFilename = filename.split('/');

var splitDir = directory.split('/');

var i = 0;

var dirTail = 0;

var sflen = splitFilename.length;

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

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

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

}

getFileNames() {

let sourceFiles = this.program.getSourceFiles();

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

}

getSourceFile(info: ScriptInfo) {

return this.filenameToSourceFile[info.fileName];

}

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

var 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 = {};

var sourceFiles = this.program.getSourceFiles();

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

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

info.defaultProject = this;

this.compilerService.host.addRoot(info);

}

filesToString() {

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

var copiedList: T[] = [];

for (var 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[] = [];

hostConfiguration: HostConfiguration;

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

var info = this.filenameToScriptInfo[file];

if (info) {

return info.formatCodeOptions;

}

}

return this.hostConfiguration.formatCodeOptions;

}

watchedFileChanged(fileName: string) {

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

}

}

}

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

this.psLogger.msg(msg, type);

}

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

if (args.file) {

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

var iproj = new Project(this);

iproj.addRoot(root);

iproj.finishGraph();

this.inferredProjects.push(iproj);

return iproj;

}

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;

var referencingProjects = this.findReferencingProjects(info);

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

referencingProjects[i].removeReferencedFile(info);

}

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

var openFile = this.openFileRoots[j];

if (this.eventHandler) {

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

}

}

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

var openFile = this.openFilesReferenced[j];

if (this.eventHandler) {

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

}

}

}

this.printProjects();

}

updateConfiguredProjectList() {

var configuredProjects: Project[] = [];

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

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

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

}

}

this.configuredProjects = configuredProjects;

}

setConfiguredProjectRoot(info: ScriptInfo) {

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

let configuredProject = this.configuredProjects[i];

if (configuredProject.isRoot(info)) {

info.defaultProject = configuredProject;

configuredProject.addOpenRef();

return true;

}

}

return false;

}

addOpenFile(info: ScriptInfo) {

if (this.setConfiguredProjectRoot(info)) {

this.openFileRootsConfigured.push(info);

}

else {

this.findReferencingProjects(info);

if (info.defaultProject) {

this.openFilesReferenced.push(info);

}

else {

// create new inferred project p with the newly opened file as root

info.defaultProject = this.createInferredProject(info);

var openFileRoots: ScriptInfo[] = [];

// for each inferred project root r

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

var r = this.openFileRoots[i];

// if r referenced by the new project

if (info.defaultProject.getSourceFile(r)) {

// remove project rooted at r

this.inferredProjects =

copyListRemovingItem(r.defaultProject, this.inferredProjects);

// put r in referenced open file list

this.openFilesReferenced.push(r);

// set default project of r to the new project

r.defaultProject = info.defaultProject;

}

else {

// otherwise, keep r as root of inferred project

openFileRoots.push(r);

}

}

this.openFileRoots = openFileRoots;

this.openFileRoots.push(info);

}

}

this.updateConfiguredProjectList();

}

/**

closeOpenFile(info: ScriptInfo) {

var openFileRoots: ScriptInfo[] = [];

var removedProject: Project;

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

// if closed file is root of project

if (info === this.openFileRoots[i]) {

// remove that project and remember it

removedProject = info.defaultProject;

}

else {

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

}

}

this.openFileRoots = openFileRoots;

if (!removedProject) {

var openFileRootsConfigured: ScriptInfo[] = [];

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

if (info === this.openFileRootsConfigured[i]) {

if (info.defaultProject.deleteOpenRef() === 0) {

removedProject = info.defaultProject;

}

}

else {

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

}

}

this.openFileRootsConfigured = openFileRootsConfigured;

}

if (removedProject) {

if (removedProject.isConfiguredProject()) {

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

}

else {

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

}

var openFilesReferenced: ScriptInfo[] = [];

var orphanFiles: ScriptInfo[] = [];

// for all open, referenced files f

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

var f = this.openFilesReferenced[i];

// if f was referenced by the removed project, remember it

if (f.defaultProject === removedProject) {

f.defaultProject = undefined;

orphanFiles.push(f);

}

else {

// otherwise add it back to the list of referenced files

openFilesReferenced.push(f);

}

}

this.openFilesReferenced = openFilesReferenced;

// treat orphaned files as newly opened

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

this.addOpenFile(orphanFiles[i]);

}

}

else {

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

}

info.close();

}

findReferencingProjects(info: ScriptInfo, excludedProject?: Project) {

var referencingProjects: Project[] = [];

info.defaultProject = undefined;

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

var inferredProject = this.inferredProjects[i];

inferredProject.updateGraph();

if (inferredProject !== excludedProject) {

if (inferredProject.getSourceFile(info)) {

info.defaultProject = inferredProject;

referencingProjects.push(inferredProject);

}

}

}

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

var configuredProject = this.configuredProjects[i];

configuredProject.updateGraph();

if (configuredProject.getSourceFile(info)) {

info.defaultProject = configuredProject;

}

}

return referencingProjects;

}

updateProjectStructure() {

this.log("updating project structure from ...", "Info");

this.printProjects();

// First loop through all open files that are referenced by projects but are not

// project roots. For each referenced file, see if the default project still

// references that file. If so, then just keep the file in the referenced list.

// If not, add the file to an unattached list, to be rechecked later.

var openFilesReferenced: ScriptInfo[] = [];

var unattachedOpenFiles: ScriptInfo[] = [];

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

var referencedFile = this.openFilesReferenced[i];

referencedFile.defaultProject.updateGraph();

var sourceFile = referencedFile.defaultProject.getSourceFile(referencedFile);

if (sourceFile) {

openFilesReferenced.push(referencedFile);

}

else {

unattachedOpenFiles.push(referencedFile);

}

}

this.openFilesReferenced = openFilesReferenced;

// Then, loop through all of the open files that are project roots.

// For each root file, note the project that it roots. Then see if

// any other projects newly reference the file. If zero projects

// newly reference the file, keep it as a root. If one or more

// projects newly references the file, remove its project from the

// inferred projects list (since it is no longer a root) and add

// the file to the open, referenced file list.

var openFileRoots: ScriptInfo[] = [];

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

var rootFile = this.openFileRoots[i];

var rootedProject = rootFile.defaultProject;

var referencingProjects = this.findReferencingProjects(rootFile, rootedProject);

if (referencingProjects.length === 0) {

rootFile.defaultProject = rootedProject;

openFileRoots.push(rootFile);

}