/** Cryptographically secure hash of project file location. */

readonly projectId: string;

/** Count of file extensions seen in the project. */

readonly fileStats: FileStats;

/**

readonly compilerOptions: CompilerOptions;

// "extends", "files", "include", or "exclude" will be undefined if an external config is used.

// Otherwise, we will use "true" if the property is present and "false" if it is missing.

readonly extends: boolean | undefined;

readonly files: boolean | undefined;

readonly include: boolean | undefined;

readonly exclude: boolean | undefined;

readonly compileOnSave: boolean;

readonly typeAcquisition: ProjectInfoTypeAcquisitionData;

readonly configFileName: "tsconfig.json" | "jsconfig.json" | "other";

readonly projectType: "external" | "configured";

readonly languageServiceEnabled: boolean;

/** TypeScript version used by the server. */

readonly version: string;

readonly enable: boolean;

// Actual values of include/exclude entries are scrubbed.

readonly include: boolean;

readonly exclude: boolean;

readonly js: number;

readonly jsx: number;

readonly ts: number;

readonly tsx: number;

readonly dts: number;

const map: Map<Map<number>> = createMap<Map<number>>();

for (const option of commandLineOptions) {

if (typeof option.type === "object") {

const optionMap = <Map<number>>option.type;

// verify that map contains only numbers

optionMap.forEach(value => {

Debug.assert(typeof value === "number");

});

map.set(option.name, optionMap);

}

}

return map;

if (typeof protocolOptions.indentStyle === "string") {

protocolOptions.indentStyle = indentStyle.get(protocolOptions.indentStyle.toLowerCase());

Debug.assert(protocolOptions.indentStyle !== undefined);

}

return <any>protocolOptions;

compilerOptionConverters.forEach((mappedValues, id) => {

const propertyValue = protocolOptions[id];

if (typeof propertyValue === "string") {

protocolOptions[id] = mappedValues.get(propertyValue.toLowerCase());

}

});

return <any>protocolOptions;

return typeof scriptKindName === "string"

? convertScriptKindName(scriptKindName)

: scriptKindName;

switch (scriptKindName) {

case "JS":

return ScriptKind.JS;

case "JSX":

return ScriptKind.JSX;

case "TS":

return ScriptKind.TS;

case "TSX":

return ScriptKind.TSX;

default:

return ScriptKind.Unknown;

}

formatCodeOptions: FormatCodeSettings;

hostInfo: string;

extraFileExtensions?: JsFileExtensionInfo[];

success: boolean;

configFileErrors?: Diagnostic[];

projectOptions?: ProjectOptions;

success: boolean;

errors?: Diagnostic[];

project?: ConfiguredProject;

getFileName(f: T): string;

getScriptKind(f: T): ScriptKind;

hasMixedContent(f: T, extraFileExtensions: JsFileExtensionInfo[]): boolean;

for (const proj of projects) {

if (proj.getProjectName() === projectName) {

return proj;

}

}

if (info.containingProjects.length === 0) {

return false;

}

return info.containingProjects[0].projectKind === ProjectKind.Inferred && info.containingProjects[0].isRoot(info);

/**

private readonly directoryWatchersForTsconfig: Map<FileWatcher> = createMap<FileWatcher>();

/**

private readonly directoryWatchersRefCount: Map<number> = createMap<number>();

constructor(private readonly projectService: ProjectService) {

}

stopWatchingDirectory(directory: string) {

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

const refCount = this.directoryWatchersRefCount.get(directory) - 1;

this.directoryWatchersRefCount.set(directory, refCount);

if (refCount === 0) {

this.projectService.logger.info(`Close directory watcher for: ${directory}`);

this.directoryWatchersForTsconfig.get(directory).close();

this.directoryWatchersForTsconfig.delete(directory);

}

}

startWatchingContainingDirectoriesForFile(fileName: string, project: InferredProject, callback: (fileName: string) => void) {

let currentPath = getDirectoryPath(fileName);

let parentPath = getDirectoryPath(currentPath);

while (currentPath !== parentPath) {

if (!this.directoryWatchersForTsconfig.has(currentPath)) {

this.projectService.logger.info(`Add watcher for: ${currentPath}`);

this.directoryWatchersForTsconfig.set(currentPath, this.projectService.host.watchDirectory(currentPath, callback));

this.directoryWatchersRefCount.set(currentPath, 1);

}

else {

this.directoryWatchersRefCount.set(currentPath, this.directoryWatchersRefCount.get(currentPath) + 1);

}

project.directoriesWatchedForTsconfig.push(currentPath);

currentPath = parentPath;

parentPath = getDirectoryPath(parentPath);

}

}

host: ServerHost;

logger: Logger;

cancellationToken: HostCancellationToken;

useSingleInferredProject: boolean;

typingsInstaller: ITypingsInstaller;

eventHandler?: ProjectServiceEventHandler;

throttleWaitMilliseconds?: number;

globalPlugins?: string[];

pluginProbeLocations?: string[];

allowLocalPluginLoads?: boolean;

public readonly typingsCache: TypingsCache;

private readonly documentRegistry: DocumentRegistry;

/**

private readonly filenameToScriptInfo = createMap<ScriptInfo>();

/**

private readonly externalProjectToConfiguredProjectMap: Map<NormalizedPath[]> = createMap<NormalizedPath[]>();

/**

readonly externalProjects: ExternalProject[] = [];

/**

readonly inferredProjects: InferredProject[] = [];

/**

readonly configuredProjects: ConfiguredProject[] = [];

/**

readonly openFiles: ScriptInfo[] = [];

private compilerOptionsForInferredProjects: CompilerOptions;

private compileOnSaveForInferredProjects: boolean;

private readonly projectToSizeMap: Map<number> = createMap<number>();

private readonly directoryWatchers: DirectoryWatchers;

private readonly throttledOperations: ThrottledOperations;

private readonly hostConfiguration: HostConfiguration;

private safelist: SafeList = defaultTypeSafeList;

private changedFiles: ScriptInfo[];

readonly toCanonicalFileName: (f: string) => string;

public lastDeletedFile: ScriptInfo;

public readonly host: ServerHost;

public readonly logger: Logger;

public readonly cancellationToken: HostCancellationToken;

public readonly useSingleInferredProject: boolean;

public readonly typingsInstaller: ITypingsInstaller;

public readonly throttleWaitMilliseconds?: number;

private readonly eventHandler?: ProjectServiceEventHandler;

public readonly globalPlugins: ReadonlyArray<string>;

public readonly pluginProbeLocations: ReadonlyArray<string>;

public readonly allowLocalPluginLoads: boolean;

/** Tracks projects that we have already sent telemetry for. */

private readonly seenProjects = createMap<true>();

constructor(opts: ProjectServiceOptions) {

this.host = opts.host;

this.logger = opts.logger;

this.cancellationToken = opts.cancellationToken;

this.useSingleInferredProject = opts.useSingleInferredProject;

this.typingsInstaller = opts.typingsInstaller || nullTypingsInstaller;

this.throttleWaitMilliseconds = opts.throttleWaitMilliseconds;

this.eventHandler = opts.eventHandler;

this.globalPlugins = opts.globalPlugins || emptyArray;

this.pluginProbeLocations = opts.pluginProbeLocations || emptyArray;

this.allowLocalPluginLoads = !!opts.allowLocalPluginLoads;

Debug.assert(!!this.host.createHash, "'ServerHost.createHash' is required for ProjectService");

this.toCanonicalFileName = createGetCanonicalFileName(this.host.useCaseSensitiveFileNames);

this.directoryWatchers = new DirectoryWatchers(this);

this.throttledOperations = new ThrottledOperations(this.host);

this.typingsInstaller.attach(this);

this.typingsCache = new TypingsCache(this.typingsInstaller);

this.hostConfiguration = {

formatCodeOptions: getDefaultFormatCodeSettings(this.host),

hostInfo: "Unknown host",

extraFileExtensions: []

};

this.documentRegistry = createDocumentRegistry(this.host.useCaseSensitiveFileNames, this.host.getCurrentDirectory());

}

/* @internal */

getChangedFiles_TestOnly() {

return this.changedFiles;

}

ensureInferredProjectsUpToDate_TestOnly() {

this.ensureInferredProjectsUpToDate();

}

getCompilerOptionsForInferredProjects() {

return this.compilerOptionsForInferredProjects;

}

onUpdateLanguageServiceStateForProject(project: Project, languageServiceEnabled: boolean) {

if (!this.eventHandler) {

return;

}

this.eventHandler(<ProjectLanguageServiceStateEvent>{

eventName: ProjectLanguageServiceStateEvent,

data: { project, languageServiceEnabled }

});

}

updateTypingsForProject(response: SetTypings | InvalidateCachedTypings): void {

const project = this.findProject(response.projectName);

if (!project) {

return;

}

switch (response.kind) {

case ActionSet:

this.typingsCache.updateTypingsForProject(response.projectName, response.compilerOptions, response.typeAcquisition, response.unresolvedImports, response.typings);

break;

case ActionInvalidate:

this.typingsCache.deleteTypingsForProject(response.projectName);

break;

}

project.updateGraph();

}

setCompilerOptionsForInferredProjects(projectCompilerOptions: protocol.ExternalProjectCompilerOptions): void {

this.compilerOptionsForInferredProjects = convertCompilerOptions(projectCompilerOptions);

// always set 'allowNonTsExtensions' for inferred projects since user cannot configure it from the outside

// previously we did not expose a way for user to change these settings and this option was enabled by default

this.compilerOptionsForInferredProjects.allowNonTsExtensions = true;

this.compileOnSaveForInferredProjects = projectCompilerOptions.compileOnSave;

for (const proj of this.inferredProjects) {

proj.setCompilerOptions(this.compilerOptionsForInferredProjects);

proj.compileOnSaveEnabled = projectCompilerOptions.compileOnSave;

}

this.updateProjectGraphs(this.inferredProjects);

}

stopWatchingDirectory(directory: string) {

this.directoryWatchers.stopWatchingDirectory(directory);

}

findProject(projectName: string): Project {

if (projectName === undefined) {

return undefined;

}

if (isInferredProjectName(projectName)) {

this.ensureInferredProjectsUpToDate();

return findProjectByName(projectName, this.inferredProjects);

}

return this.findExternalProjectByProjectName(projectName) || this.findConfiguredProjectByProjectName(toNormalizedPath(projectName));

}

getDefaultProjectForFile(fileName: NormalizedPath, refreshInferredProjects: boolean) {

if (refreshInferredProjects) {

this.ensureInferredProjectsUpToDate();

}

const scriptInfo = this.getScriptInfoForNormalizedPath(fileName);

return scriptInfo && scriptInfo.getDefaultProject();

}

private ensureInferredProjectsUpToDate() {

if (this.changedFiles) {

let projectsToUpdate: Project[];

if (this.changedFiles.length === 1) {

// simpliest case - no allocations

projectsToUpdate = this.changedFiles[0].containingProjects;

}

else {

projectsToUpdate = [];

for (const f of this.changedFiles) {

projectsToUpdate = projectsToUpdate.concat(f.containingProjects);

}

}

this.updateProjectGraphs(projectsToUpdate);

this.changedFiles = undefined;

}

}

private findContainingExternalProject(fileName: NormalizedPath): ExternalProject {

for (const proj of this.externalProjects) {

if (proj.containsFile(fileName)) {

return proj;

}

}

return undefined;

}

getFormatCodeOptions(file?: NormalizedPath) {

let formatCodeSettings: FormatCodeSettings;

if (file) {

const info = this.getScriptInfoForNormalizedPath(file);

if (info) {

formatCodeSettings = info.getFormatCodeSettings();

}

}

return formatCodeSettings || this.hostConfiguration.formatCodeOptions;

}

private updateProjectGraphs(projects: Project[]) {

let shouldRefreshInferredProjects = false;

for (const p of projects) {

if (!p.updateGraph()) {

shouldRefreshInferredProjects = true;

}

}

if (shouldRefreshInferredProjects) {

this.refreshInferredProjects();

}

}

private onSourceFileChanged(fileName: NormalizedPath) {

const info = this.getScriptInfoForNormalizedPath(fileName);

if (!info) {

this.logger.info(`Error: got watch notification for unknown file: ${fileName}`);

return;

}

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

// File was deleted

this.handleDeletedFile(info);

}

else {

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

if (info.containingProjects.length === 0) {

// Orphan script info, remove it as we can always reload it on next open

info.stopWatcher();

this.filenameToScriptInfo.delete(info.path);

}

else {

// file has been changed which might affect the set of referenced files in projects that include

// this file and set of inferred projects

info.reloadFromFile();

this.updateProjectGraphs(info.containingProjects);

}

}

}

}

private handleDeletedFile(info: ScriptInfo) {

this.logger.info(`${info.fileName} deleted`);

info.stopWatcher();

// TODO: handle isOpen = true case

if (!info.isScriptOpen()) {

this.filenameToScriptInfo.delete(info.path);

this.lastDeletedFile = info;

// capture list of projects since detachAllProjects will wipe out original list

const containingProjects = info.containingProjects.slice();

info.detachAllProjects();

// update projects to make sure that set of referenced files is correct

this.updateProjectGraphs(containingProjects);

this.lastDeletedFile = undefined;

if (!this.eventHandler) {

return;

}

for (const openFile of this.openFiles) {

this.eventHandler(<ContextEvent>{

eventName: ContextEvent,

data: { project: openFile.getDefaultProject(), fileName: openFile.fileName }

});

}

}

this.printProjects();

}

private onTypeRootFileChanged(project: ConfiguredProject, fileName: string) {

this.logger.info(`Type root file ${fileName} changed`);

this.throttledOperations.schedule(project.getConfigFilePath() + " * type root", /*delay*/ 250, () => {

project.updateTypes();

this.updateConfiguredProject(project); // TODO: Figure out why this is needed (should be redundant?)

this.refreshInferredProjects();

});

}

/**

private onSourceFileInDirectoryChangedForConfiguredProject(project: ConfiguredProject, 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 && !isSupportedSourceFileName(fileName, project.getCompilerOptions(), this.hostConfiguration.extraFileExtensions)) {

return;

}

this.logger.info(`Detected source file changes: ${fileName}`);

this.throttledOperations.schedule(

project.getConfigFilePath(),

/*delay*/250,

() => this.handleChangeInSourceFileForConfiguredProject(project, fileName));

}

private handleChangeInSourceFileForConfiguredProject(project: ConfiguredProject, triggerFile: string) {

const { projectOptions, configFileErrors } = this.convertConfigFileContentToProjectOptions(project.getConfigFilePath());

this.reportConfigFileDiagnostics(project.getProjectName(), configFileErrors, triggerFile);

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.sort(), 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.logger.info("Updating configured project");

this.updateConfiguredProject(project);

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

// created for the new files

this.refreshInferredProjects();

}

}

private onConfigChangedForConfiguredProject(project: ConfiguredProject) {

const configFileName = project.getConfigFilePath();

this.logger.info(`Config file changed: ${configFileName}`);

const configFileErrors = this.updateConfiguredProject(project);

this.reportConfigFileDiagnostics(configFileName, configFileErrors, /*triggerFile*/ configFileName);

this.refreshInferredProjects();

}

/**

private onConfigFileAddedForInferredProject(fileName: string) {

// TODO: check directory separators

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

this.logger.info(`${fileName} is not tsconfig.json`);

return;

}

const { configFileErrors } = this.convertConfigFileContentToProjectOptions(fileName);

this.reportConfigFileDiagnostics(fileName, configFileErrors, fileName);

this.logger.info(`Detected newly added tsconfig file: ${fileName}`);

this.reloadProjects();

}

private getCanonicalFileName(fileName: string) {

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

return normalizePath(name);

}

private removeProject(project: Project) {

this.logger.info(`remove project: ${project.getRootFiles().toString()}`);

project.close();

switch (project.projectKind) {

case ProjectKind.External:

unorderedRemoveItem(this.externalProjects, <ExternalProject>project);

this.projectToSizeMap.delete((project as ExternalProject).externalProjectName);

break;

case ProjectKind.Configured:

unorderedRemoveItem(this.configuredProjects, <ConfiguredProject>project);

this.projectToSizeMap.delete((project as ConfiguredProject).canonicalConfigFilePath);

break;

case ProjectKind.Inferred:

unorderedRemoveItem(this.inferredProjects, <InferredProject>project);

break;

}

}

private assignScriptInfoToInferredProjectIfNecessary(info: ScriptInfo, addToListOfOpenFiles: boolean): void {

const externalProject = this.findContainingExternalProject(info.fileName);

if (externalProject) {

// file is already included in some external project - do nothing

if (addToListOfOpenFiles) {

this.openFiles.push(info);

}

return;

}

let foundConfiguredProject = false;

for (const p of info.containingProjects) {

// file is the part of configured project

if (p.projectKind === ProjectKind.Configured) {

foundConfiguredProject = true;

if (addToListOfOpenFiles) {

((<ConfiguredProject>p)).addOpenRef();

}

}

}

if (foundConfiguredProject) {

if (addToListOfOpenFiles) {

this.openFiles.push(info);

}

return;

}

if (info.containingProjects.length === 0) {

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

// or add root to existing inferred project if 'useOneInferredProject' is true

const inferredProject = this.createInferredProjectWithRootFileIfNecessary(info);

if (!this.useSingleInferredProject) {

// if useOneInferredProject is not set then try to fixup ownership of open files

// check 'defaultProject !== inferredProject' is necessary to handle cases

// when creation inferred project for some file has added other open files into this project (i.e. as referenced files)

// we definitely don't want to delete the project that was just created

for (const f of this.openFiles) {

if (f.containingProjects.length === 0 || !inferredProject.containsScriptInfo(f)) {

// this is orphaned file that we have not processed yet - skip it

continue;

}

for (const fContainingProject of f.containingProjects) {

if (fContainingProject.projectKind === ProjectKind.Inferred &&

fContainingProject.isRoot(f) &&

fContainingProject !== inferredProject) {

// open file used to be root in inferred project,

// this inferred project is different from the one we've just created for current file

// and new inferred project references this open file.

// We should delete old inferred project and attach open file to the new one

this.removeProject(fContainingProject);

f.attachToProject(inferredProject);

}

}

}

}

}

if (addToListOfOpenFiles) {

this.openFiles.push(info);

}

}

/**

private closeOpenFile(info: ScriptInfo): void {

// Closing file should trigger re-reading the file content from disk. This is

// because the user may chose to discard the buffer content before saving

// to the disk, and the server's version of the file can be out of sync.

info.close();

unorderedRemoveItem(this.openFiles, info);

// collect all projects that should be removed

let projectsToRemove: Project[];

for (const p of info.containingProjects) {

if (p.projectKind === ProjectKind.Configured) {

if (info.hasMixedContent) {

info.registerFileUpdate();

}

// last open file in configured project - close it

if ((<ConfiguredProject>p).deleteOpenRef() === 0) {

(projectsToRemove || (projectsToRemove = [])).push(p);

}

}

else if (p.projectKind === ProjectKind.Inferred && p.isRoot(info)) {

// open file in inferred project

(projectsToRemove || (projectsToRemove = [])).push(p);

}

if (!p.languageServiceEnabled) {

// if project language service is disabled then we create a program only for open files.

// this means that project should be marked as dirty to force rebuilding of the program

// on the next request

p.markAsDirty();

}

}

if (projectsToRemove) {

for (const project of projectsToRemove) {

this.removeProject(project);

}

let orphanFiles: ScriptInfo[];

// for all open files

for (const f of this.openFiles) {

// collect orphanted files and try to re-add them as newly opened

if (f.containingProjects.length === 0) {

(orphanFiles || (orphanFiles = [])).push(f);

}

}

// treat orphaned files as newly opened

if (orphanFiles) {

for (const f of orphanFiles) {

this.assignScriptInfoToInferredProjectIfNecessary(f, /*addToListOfOpenFiles*/ false);

}

}

// Cleanup script infos that arent part of any project is postponed to

// next file open so that if file from same project is opened we wont end up creating same script infos

}

// If the current info is being just closed - add the watcher file to track changes

// But if file was deleted, handle that part

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