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?: FileExtensionInfo[];

success: boolean;

configFileErrors?: Diagnostic[];

projectOptions?: ProjectOptions;

success: boolean;

errors?: Diagnostic[];

project?: ConfiguredProject;

getFileName(f: T): string;

getScriptKind(f: T): ScriptKind;

hasMixedContent(f: T, extraFileExtensions: FileExtensionInfo[]): 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);

}

}

public readonly typingsCache: TypingsCache;

private readonly documentRegistry: DocumentRegistry;

/**

private readonly filenameToScriptInfo = createFileMap<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 directoryWatchers: DirectoryWatchers;

private readonly throttledOperations: ThrottledOperations;

private readonly hostConfiguration: HostConfiguration;

private changedFiles: ScriptInfo[];

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

public lastDeletedFile: ScriptInfo;

constructor(public readonly host: ServerHost,

public readonly logger: Logger,

public readonly cancellationToken: HostCancellationToken,

public readonly useSingleInferredProject: boolean,

readonly typingsInstaller: ITypingsInstaller = nullTypingsInstaller,

private readonly eventHandler?: ProjectServiceEventHandler) {

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

this.toCanonicalFileName = createGetCanonicalFileName(host.useCaseSensitiveFileNames);

this.directoryWatchers = new DirectoryWatchers(this);

this.throttledOperations = new ThrottledOperations(host);

this.typingsInstaller.attach(this);

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

// ts.disableIncrementalParsing = true;

this.hostConfiguration = {

formatCodeOptions: getDefaultFormatCodeSettings(this.host),

hostInfo: "Unknown host",

extraFileExtensions: []

};

this.documentRegistry = createDocumentRegistry(host.useCaseSensitiveFileNames, 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())) {

// 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.remove(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 && !ts.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:

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

break;

case ProjectKind.Configured:

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

break;

case ProjectKind.Inferred:

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

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

continue;

}

const defaultProject = f.getDefaultProject();

if (isRootFileInInferredProject(info) && defaultProject !== inferredProject && inferredProject.containsScriptInfo(f)) {

// 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(defaultProject);

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

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

}

}

}

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

// if there are not projects that include this script info - delete it

this.filenameToScriptInfo.remove(info.path);

}

}

/**

private openOrUpdateConfiguredProjectForFile(fileName: NormalizedPath): OpenConfiguredProjectResult {

const searchPath = getDirectoryPath(fileName);

this.logger.info(`Search path: ${searchPath}`);

// check if this file is already included in one of external projects

const configFileName = this.findConfigFile(asNormalizedPath(searchPath));

if (!configFileName) {

this.logger.info("No config files found.");

return {};

}

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

const project = this.findConfiguredProjectByProjectName(configFileName);

if (!project) {

const { success, errors } = this.openConfigFile(configFileName, fileName);

if (!success) {

return { configFileName, configFileErrors: errors };

}

// even if opening config file was successful, it could still

// contain errors that were tolerated.

this.logger.info(`Opened configuration file ${configFileName}`);

if (errors && errors.length > 0) {

return { configFileName, configFileErrors: errors };

}

}

else {

this.updateConfiguredProject(project);

}

return { configFileName };

}

// This is different from the method the compiler uses because

// the compiler can assume it will always start searching in the

// current directory (the directory in which tsc was invoked).

// The server must start searching from the directory containing

// the newly opened file.

private findConfigFile(searchPath: NormalizedPath): NormalizedPath {

while (true) {

const tsconfigFileName = asNormalizedPath(combinePaths(searchPath, "tsconfig.json"));

if (this.host.fileExists(tsconfigFileName)) {

return tsconfigFileName;

}

const jsconfigFileName = asNormalizedPath(combinePaths(searchPath, "jsconfig.json"));

if (this.host.fileExists(jsconfigFileName)) {

return jsconfigFileName;

}

const parentPath = asNormalizedPath(getDirectoryPath(searchPath));

if (parentPath === searchPath) {

break;

}

searchPath = parentPath;

}

return undefined;

}

private printProjects() {

if (!this.logger.hasLevel(LogLevel.verbose)) {

return;

}

this.logger.startGroup();

let counter = 0;

counter = printProjects(this.logger, this.externalProjects, counter);

counter = printProjects(this.logger, this.configuredProjects, counter);

counter = printProjects(this.logger, this.inferredProjects, counter);

this.logger.info("Open files: ");

for (const rootFile of this.openFiles) {

this.logger.info(rootFile.fileName);

}

this.logger.endGroup();

function printProjects(logger: Logger, projects: Project[], counter: number) {

for (const project of projects) {

project.updateGraph();

logger.info(`Project '${project.getProjectName()}' (${ProjectKind[project.projectKind]}) ${counter}`);

logger.info(project.filesToString());

logger.info("-----------------------------------------------");

counter++;

}

return counter;

}

}

private findConfiguredProjectByProjectName(configFileName: NormalizedPath) {

// make sure that casing of config file name is consistent

configFileName = asNormalizedPath(this.toCanonicalFileName(configFileName));

for (const proj of this.configuredProjects) {

if (proj.canonicalConfigFilePath === configFileName) {

return proj;

}

}

}

private findExternalProjectByProjectName(projectFileName: string) {

return findProjectByName(projectFileName, this.externalProjects);

}

private convertConfigFileContentToProjectOptions(configFilename: string): ConfigFileConversionResult {

configFilename = normalizePath(configFilename);

const configFileContent = this.host.readFile(configFilename);

let errors: Diagnostic[];

const result = parseConfigFileTextToJson(configFilename, configFileContent);

let config = result.config;

if (result.error) {

// try to reparse config file

const { configJsonObject: sanitizedConfig, diagnostics } = sanitizeConfigFile(configFilename, configFileContent);

config = sanitizedConfig;

errors = diagnostics.length ? diagnostics : [result.error];

}

const parsedCommandLine = parseJsonConfigFileContent(

config,

this.host,

getDirectoryPath(configFilename),

/*existingOptions*/ {},

configFilename,

/*resolutionStack*/ [],

this.hostConfiguration.extraFileExtensions);

if (parsedCommandLine.errors.length) {

errors = concatenate(errors, parsedCommandLine.errors);

}

Debug.assert(!!parsedCommandLine.fileNames);