/// <reference path="..\compiler\commandLineParser.ts" />

/// <reference path="..\services\services.ts" />

/// <reference path="utilities.ts" />

/// <reference path="session.ts" />

/// <reference path="scriptVersionCache.ts"/>

/// <reference path="project.ts"/>

/// <reference path="typingsCache.ts"/>

namespace ts.server {

export const maxProgramSizeForNonTsFiles = 20 * 1024 * 1024;

// tslint:disable variable-name

export const ProjectsUpdatedInBackgroundEvent = "projectsUpdatedInBackground";

export const ConfigFileDiagEvent = "configFileDiag";

export const ProjectLanguageServiceStateEvent = "projectLanguageServiceState";

export const ProjectInfoTelemetryEvent = "projectInfo";

// tslint:enable variable-name

export interface ProjectsUpdatedInBackgroundEvent {

eventName: typeof ProjectsUpdatedInBackgroundEvent;

data: { openFiles: string[]; };

}

export interface ConfigFileDiagEvent {

eventName: typeof ConfigFileDiagEvent;

data: { triggerFile: string, configFileName: string, diagnostics: ReadonlyArray<Diagnostic> };

}

export interface ProjectLanguageServiceStateEvent {

eventName: typeof ProjectLanguageServiceStateEvent;

data: { project: Project, languageServiceEnabled: boolean };

}

/** This will be converted to the payload of a protocol.TelemetryEvent in session.defaultEventHandler. */

export interface ProjectInfoTelemetryEvent {

readonly eventName: typeof ProjectInfoTelemetryEvent;

readonly data: ProjectInfoTelemetryEventData;

}

export interface ProjectInfoTelemetryEventData {

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

readonly projectId: string;

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

readonly fileStats: FileStats;

/**

* Any compiler options that might contain paths will be taken out.

* Enum compiler options will be converted to strings.

*/

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;

}

export interface ProjectInfoTypeAcquisitionData {

readonly enable: boolean;

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

readonly include: boolean;

readonly exclude: boolean;

}

export interface FileStats {

readonly js: number;

readonly jsx: number;

readonly ts: number;

readonly tsx: number;

readonly dts: number;

}

export type ProjectServiceEvent = ProjectsUpdatedInBackgroundEvent | ConfigFileDiagEvent | ProjectLanguageServiceStateEvent | ProjectInfoTelemetryEvent;

export type ProjectServiceEventHandler = (event: ProjectServiceEvent) => void;

export interface SafeList {

[name: string]: { match: RegExp, exclude?: (string | number)[][], types?: string[] };

}

function prepareConvertersForEnumLikeCompilerOptions(commandLineOptions: CommandLineOption[]): Map<Map<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;

}

const compilerOptionConverters = prepareConvertersForEnumLikeCompilerOptions(optionDeclarations);

const indentStyle = createMapFromTemplate({

none: IndentStyle.None,

block: IndentStyle.Block,

smart: IndentStyle.Smart

});

export interface TypesMapFile {

typesMap: SafeList;

simpleMap: { [libName: string]: string };

}

/**

* How to understand this block:

* * The 'match' property is a regexp that matches a filename.

* * If 'match' is successful, then:

* * All files from 'exclude' are removed from the project. See below.

* * All 'types' are included in ATA

* * What the heck is 'exclude' ?

* * An array of an array of strings and numbers

* * Each array is:

* * An array of strings and numbers

* * The strings are literals

* * The numbers refer to capture group indices from the 'match' regexp

* * Remember that '1' is the first group

* * These are concatenated together to form a new regexp

* * Filenames matching these regexps are excluded from the project

* This default value is tested in tsserverProjectSystem.ts; add tests there

* if you are changing this so that you can be sure your regexp works!

*/

const defaultTypeSafeList: SafeList = {

"jquery": {

// jquery files can have names like "jquery-1.10.2.min.js" (or "jquery.intellisense.js")

match: /jquery(-(\.?\d+)+)?(\.intellisense)?(\.min)?\.js$/i,

types: ["jquery"]

},

"WinJS": {

// e.g. c:/temp/UWApp1/lib/winjs-4.0.1/js/base.js

match: /^(.*\/winjs-[.\d]+)\/js\/base\.js$/i, // If the winjs/base.js file is found..

exclude: [["^", 1, "/.*"]], // ..then exclude all files under the winjs folder

types: ["winjs"] // And fetch the @types package for WinJS

},

"Kendo": {

// e.g. /Kendo3/wwwroot/lib/kendo/kendo.all.min.js

match: /^(.*\/kendo(-ui)?)\/kendo\.all(\.min)?\.js$/i,

exclude: [["^", 1, "/.*"]],

types: ["kendo-ui"]

},

"Office Nuget": {

// e.g. /scripts/Office/1/excel-15.debug.js

match: /^(.*\/office\/1)\/excel-\d+\.debug\.js$/i, // Office NuGet package is installed under a "1/office" folder

exclude: [["^", 1, "/.*"]], // Exclude that whole folder if the file indicated above is found in it

types: ["office"] // @types package to fetch instead

},

"References": {

match: /^(.*\/_references\.js)$/i,

exclude: [["^", 1, "$"]]

}

};

export function convertFormatOptions(protocolOptions: protocol.FormatCodeSettings): FormatCodeSettings {

if (isString(protocolOptions.indentStyle)) {

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

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

}

return <any>protocolOptions;

}

export function convertCompilerOptions(protocolOptions: protocol.ExternalProjectCompilerOptions): CompilerOptions & protocol.CompileOnSaveMixin {

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

const propertyValue = protocolOptions[id];

if (isString(propertyValue)) {

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

}

});

return <any>protocolOptions;

}

export function tryConvertScriptKindName(scriptKindName: protocol.ScriptKindName | ScriptKind): ScriptKind {

return isString(scriptKindName) ? convertScriptKindName(scriptKindName) : scriptKindName;

}

export function convertScriptKindName(scriptKindName: protocol.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;

}

}

/**

* This helper function processes a list of projects and return the concatenated, sortd and deduplicated output of processing each project.

*/

export function combineProjectOutput<T>(projects: ReadonlyArray<Project>, action: (project: Project) => ReadonlyArray<T>, comparer?: (a: T, b: T) => number, areEqual?: (a: T, b: T) => boolean) {

const outputs = flatMap(projects, action);

return comparer

? sortAndDeduplicate(outputs, comparer, areEqual)

: deduplicate(outputs, areEqual);

}

export interface HostConfiguration {

formatCodeOptions: FormatCodeSettings;

hostInfo: string;

extraFileExtensions?: JsFileExtensionInfo[];

}

export interface OpenConfiguredProjectResult {

configFileName?: NormalizedPath;

configFileErrors?: ReadonlyArray<Diagnostic>;

}

interface FilePropertyReader<T> {

getFileName(f: T): string;

getScriptKind(f: T, extraFileExtensions?: JsFileExtensionInfo[]): ScriptKind;

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

}

const fileNamePropertyReader: FilePropertyReader<string> = {

getFileName: x => x,

getScriptKind: (fileName, extraFileExtensions) => {

let result: ScriptKind;

if (extraFileExtensions) {

const fileExtension = getAnyExtensionFromPath(fileName);

if (fileExtension) {

some(extraFileExtensions, info => {

if (info.extension === fileExtension) {

result = info.scriptKind;

return true;

}

return false;

});

}

}

return result;

},

hasMixedContent: (fileName, extraFileExtensions) => some(extraFileExtensions, ext => ext.isMixedContent && fileExtensionIs(fileName, ext.extension)),

};

const externalFilePropertyReader: FilePropertyReader<protocol.ExternalFile> = {

getFileName: x => x.fileName,

getScriptKind: x => tryConvertScriptKindName(x.scriptKind),

hasMixedContent: x => x.hasMixedContent,

};

function findProjectByName<T extends Project>(projectName: string, projects: T[]): T {

for (const proj of projects) {

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

return proj;

}

}

}

/* @internal */

export const enum WatchType {

ConfigFilePath = "Config file for the program",

MissingFilePath = "Missing file from program",

WildcardDirectories = "Wild card directory",

ClosedScriptInfo = "Closed Script info",

ConfigFileForInferredRoot = "Config file for the inferred project root",

FailedLookupLocation = "Directory of Failed lookup locations in module resolution",

TypeRoots = "Type root directory"

}

const enum ConfigFileWatcherStatus {

ReloadingFiles = "Reloading configured projects for files",

ReloadingInferredRootFiles = "Reloading configured projects for only inferred root files",

UpdatedCallback = "Updated the callback",

OpenFilesImpactedByConfigFileAdd = "File added to open files impacted by this config file",

OpenFilesImpactedByConfigFileRemove = "File removed from open files impacted by this config file",

RootOfInferredProjectTrue = "Open file was set as Inferred root",

RootOfInferredProjectFalse = "Open file was set as not inferred root",

}

interface ConfigFileExistenceInfo {

/**

* Cached value of existence of config file

* It is true if there is configured project open for this file.

* It can be either true or false if this is the config file that is being watched by inferred project

* to decide when to update the structure so that it knows about updating the project for its files

* (config file may include the inferred project files after the change and hence may be wont need to be in inferred project)

*/

exists: boolean;

/**

* openFilesImpactedByConfigFiles is a map of open files that would be impacted by this config file

* because these are the paths being looked up for their default configured project location

* The value in the map is true if the open file is root of the inferred project

* It is false when the open file that would still be impacted by existance of

* this config file but it is not the root of inferred project

*/

openFilesImpactedByConfigFile: Map<boolean>;

/**

* The file watcher watching the config file because there is open script info that is root of

* inferred project and will be impacted by change in the status of the config file

* The watcher is present only when there is no open configured project for the config file

*/

configFileWatcherForRootOfInferredProject?: FileWatcher;

}

export interface ProjectServiceOptions {

host: ServerHost;

logger: Logger;

cancellationToken: HostCancellationToken;

useSingleInferredProject: boolean;

useInferredProjectPerProjectRoot: boolean;

typingsInstaller: ITypingsInstaller;

eventHandler?: ProjectServiceEventHandler;

throttleWaitMilliseconds?: number;

globalPlugins?: ReadonlyArray<string>;

pluginProbeLocations?: ReadonlyArray<string>;

allowLocalPluginLoads?: boolean;

typesMapLocation?: string;

}

type WatchFile = (host: ServerHost, file: string, cb: FileWatcherCallback, watchType: WatchType, project?: Project) => FileWatcher;

type WatchFilePath = (host: ServerHost, file: string, cb: FilePathWatcherCallback, path: Path, watchType: WatchType, project?: Project) => FileWatcher;

type WatchDirectory = (host: ServerHost, directory: string, cb: DirectoryWatcherCallback, flags: WatchDirectoryFlags, watchType: WatchType, project?: Project) => FileWatcher;

export class ProjectService {

public readonly typingsCache: TypingsCache;

private readonly documentRegistry: DocumentRegistry;

/**

* Container of all known scripts

*/

private readonly filenameToScriptInfo = createMap<ScriptInfo>();

/**

* maps external project file name to list of config files that were the part of this project

*/

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

/**

* external projects (configuration and list of root files is not controlled by tsserver)

*/

readonly externalProjects: ExternalProject[] = [];

/**

* projects built from openFileRoots

*/

readonly inferredProjects: InferredProject[] = [];

/**

* projects specified by a tsconfig.json file

*/

readonly configuredProjects = createMap<ConfiguredProject>();

/**

* Open files: with value being project root path, and key being Path of the file that is open

*/

readonly openFiles = createMap<NormalizedPath>();

/**

* Map of open files that are opened without complete path but have projectRoot as current directory

*/

private readonly openFilesWithNonRootedDiskPath = createMap<ScriptInfo>();

private compilerOptionsForInferredProjects: CompilerOptions;

private compilerOptionsForInferredProjectsPerProjectRoot = createMap<CompilerOptions>();

/**

* Project size for configured or external projects

*/

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

/**

* This is a map of config file paths existance that doesnt need query to disk

* - The entry can be present because there is inferred project that needs to watch addition of config file to directory

* In this case the exists could be true/false based on config file is present or not

* - Or it is present if we have configured project open with config file at that location

* In this case the exists property is always true

*/

private readonly configFileExistenceInfoCache = createMap<ConfigFileExistenceInfo>();

private readonly throttledOperations: ThrottledOperations;

private readonly hostConfiguration: HostConfiguration;

private safelist: SafeList = defaultTypeSafeList;

private legacySafelist: { [key: string]: string } = {};

private changedFiles: ScriptInfo[];

private pendingProjectUpdates = createMap<Project>();

private pendingInferredProjectUpdate: boolean;

readonly currentDirectory: string;

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

public readonly host: ServerHost;

public readonly logger: Logger;

public readonly cancellationToken: HostCancellationToken;

public readonly useSingleInferredProject: boolean;

public readonly useInferredProjectPerProjectRoot: 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;

public readonly typesMapLocation: string | undefined;

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

private readonly seenProjects = createMap<true>();

/*@internal*/

readonly watchFile: WatchFile;

/*@internal*/

readonly watchFilePath: WatchFilePath;

/*@internal*/

readonly watchDirectory: WatchDirectory;

constructor(opts: ProjectServiceOptions) {

this.host = opts.host;

this.logger = opts.logger;

this.cancellationToken = opts.cancellationToken;

this.useSingleInferredProject = opts.useSingleInferredProject;

this.useInferredProjectPerProjectRoot = opts.useInferredProjectPerProjectRoot;

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;

this.typesMapLocation = (opts.typesMapLocation === undefined) ? combinePaths(this.getExecutingFilePath(), "../typesMap.json") : opts.typesMapLocation;

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

this.currentDirectory = this.host.getCurrentDirectory();

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

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

if (this.typesMapLocation) {

this.loadTypesMap();

}

else {

this.logger.info("No types map provided; using the default");

}

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

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

this.watchFile = (host, file, cb, watchType, project) => ts.addFileWatcherWithLogging(host, file, cb, this.createWatcherLog(watchType, project));

this.watchFilePath = (host, file, cb, path, watchType, project) => ts.addFilePathWatcherWithLogging(host, file, cb, path, this.createWatcherLog(watchType, project));

this.watchDirectory = (host, dir, cb, flags, watchType, project) => ts.addDirectoryWatcherWithLogging(host, dir, cb, flags, this.createWatcherLog(watchType, project));

}

else if (this.logger.loggingEnabled()) {

this.watchFile = (host, file, cb, watchType, project) => ts.addFileWatcherWithOnlyTriggerLogging(host, file, cb, this.createWatcherLog(watchType, project));

this.watchFilePath = (host, file, cb, path, watchType, project) => ts.addFilePathWatcherWithOnlyTriggerLogging(host, file, cb, path, this.createWatcherLog(watchType, project));

this.watchDirectory = (host, dir, cb, flags, watchType, project) => ts.addDirectoryWatcherWithOnlyTriggerLogging(host, dir, cb, flags, this.createWatcherLog(watchType, project));

}

else {

this.watchFile = ts.addFileWatcher;

this.watchFilePath = ts.addFilePathWatcher;

this.watchDirectory = ts.addDirectoryWatcher;

}

}

private createWatcherLog(watchType: WatchType, project: Project | undefined): (s: string) => void {

const detailedInfo = ` Project: ${project ? project.getProjectName() : ""} WatchType: ${watchType}`;

return s => this.logger.info(s + detailedInfo);

}

toPath(fileName: string) {

return toPath(fileName, this.currentDirectory, this.toCanonicalFileName);

}

/*@internal*/

getExecutingFilePath() {

return this.getNormalizedAbsolutePath(this.host.getExecutingFilePath());

}

/*@internal*/

getNormalizedAbsolutePath(fileName: string) {

return getNormalizedAbsolutePath(fileName, this.host.getCurrentDirectory());

}

/* @internal */

getChangedFiles_TestOnly() {

return this.changedFiles;

}

/* @internal */

ensureInferredProjectsUpToDate_TestOnly() {

this.ensureProjectStructuresUptoDate();

}

/* @internal */

getCompilerOptionsForInferredProjects() {

return this.compilerOptionsForInferredProjects;

}

/* @internal */

onUpdateLanguageServiceStateForProject(project: Project, languageServiceEnabled: boolean) {

if (!this.eventHandler) {

return;

}

const event: ProjectLanguageServiceStateEvent = {

eventName: ProjectLanguageServiceStateEvent,

data: { project, languageServiceEnabled }

};

this.eventHandler(event);

}

private loadTypesMap() {

try {

const fileContent = this.host.readFile(this.typesMapLocation);

if (fileContent === undefined) {

this.logger.info(`Provided types map file "${this.typesMapLocation}" doesn't exist`);

return;

}

const raw: TypesMapFile = JSON.parse(fileContent);

// Parse the regexps

for (const k of Object.keys(raw.typesMap)) {

raw.typesMap[k].match = new RegExp(raw.typesMap[k].match as {} as string, "i");

}

// raw is now fixed and ready

this.safelist = raw.typesMap;

for (const key in raw.simpleMap) {

if (raw.simpleMap.hasOwnProperty(key)) {

this.legacySafelist[key] = raw.simpleMap[key].toLowerCase();

}

}

}

catch (e) {

this.logger.info(`Error loading types map: ${e}`);

this.safelist = defaultTypeSafeList;

this.legacySafelist = {};

}

}

updateTypingsForProject(response: SetTypings | InvalidateCachedTypings | PackageInstalledResponse): void {

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

if (!project) {

return;

}

switch (response.kind) {

case ActionSet:

project.resolutionCache.clear();

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

break;

case ActionInvalidate:

project.resolutionCache.clear();

this.typingsCache.deleteTypingsForProject(response.projectName);

break;

}

this.delayUpdateProjectGraphAndInferredProjectsRefresh(project);

}

private delayInferredProjectsRefresh() {

this.pendingInferredProjectUpdate = true;

this.throttledOperations.schedule("*refreshInferredProjects*", /*delay*/ 250, () => {

if (this.pendingProjectUpdates.size !== 0) {

this.delayInferredProjectsRefresh();

}

else {

if (this.pendingInferredProjectUpdate) {

this.pendingInferredProjectUpdate = false;

this.refreshInferredProjects();

}

// Send the event to notify that there were background project updates

// send current list of open files

this.sendProjectsUpdatedInBackgroundEvent();

}

});

}

private delayUpdateProjectGraph(project: Project) {

const projectName = project.getProjectName();

this.pendingProjectUpdates.set(projectName, project);

this.throttledOperations.schedule(projectName, /*delay*/ 250, () => {

if (this.pendingProjectUpdates.delete(projectName)) {

project.updateGraph();

}

});

}

/*@internal*/

hasPendingProjectUpdate(project: Project) {

return this.pendingProjectUpdates.has(project.getProjectName());

}

private sendProjectsUpdatedInBackgroundEvent() {

if (!this.eventHandler) {

return;

}

const event: ProjectsUpdatedInBackgroundEvent = {

eventName: ProjectsUpdatedInBackgroundEvent,

data: {

openFiles: arrayFrom(this.openFiles.keys(), path => this.getScriptInfoForPath(path as Path).fileName)

}

};

this.eventHandler(event);

}

/* @internal */

delayUpdateProjectGraphAndInferredProjectsRefresh(project: Project) {

project.markAsDirty();

this.delayUpdateProjectGraph(project);

this.delayInferredProjectsRefresh();

}

private delayUpdateProjectGraphs(projects: Project[]) {

for (const project of projects) {

this.delayUpdateProjectGraph(project);

}

this.delayInferredProjectsRefresh();

}

setCompilerOptionsForInferredProjects(projectCompilerOptions: protocol.ExternalProjectCompilerOptions, projectRootPath?: string): void {

Debug.assert(projectRootPath === undefined || this.useInferredProjectPerProjectRoot, "Setting compiler options per project root path is only supported when useInferredProjectPerProjectRoot is enabled");

const compilerOptions = 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

compilerOptions.allowNonTsExtensions = true;

const canonicalProjectRootPath = projectRootPath && this.toCanonicalFileName(projectRootPath);

if (canonicalProjectRootPath) {

this.compilerOptionsForInferredProjectsPerProjectRoot.set(canonicalProjectRootPath, compilerOptions);

}

else {

this.compilerOptionsForInferredProjects = compilerOptions;

}

const projectsToUpdate: Project[] = [];

for (const project of this.inferredProjects) {

// Only update compiler options in the following cases:

// - Inferred projects without a projectRootPath, if the new options do not apply to

// a workspace root

// - Inferred projects with a projectRootPath, if the new options do not apply to a

// workspace root and there is no more specific set of options for that project's

// root path

// - Inferred projects with a projectRootPath, if the new options apply to that

// project root path.

if (canonicalProjectRootPath ?

project.projectRootPath === canonicalProjectRootPath :

!project.projectRootPath || !this.compilerOptionsForInferredProjectsPerProjectRoot.has(project.projectRootPath)) {

project.setCompilerOptions(compilerOptions);

project.compileOnSaveEnabled = compilerOptions.compileOnSave;

project.markAsDirty();

projectsToUpdate.push(project);

}

}

this.delayUpdateProjectGraphs(projectsToUpdate);

}

findProject(projectName: string): Project | undefined {

if (projectName === undefined) {

return undefined;

}

if (isInferredProjectName(projectName)) {

this.ensureProjectStructuresUptoDate();

return findProjectByName(projectName, this.inferredProjects);

}

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

}

getDefaultProjectForFile(fileName: NormalizedPath, ensureProject: boolean) {

let scriptInfo = this.getScriptInfoForNormalizedPath(fileName);

if (ensureProject && !scriptInfo || scriptInfo.isOrphan()) {

this.ensureProjectStructuresUptoDate();

scriptInfo = this.getScriptInfoForNormalizedPath(fileName);

if (!scriptInfo) {

return Errors.ThrowNoProject();

}

return scriptInfo.getDefaultProject();

}

return scriptInfo && !scriptInfo.isOrphan() && scriptInfo.getDefaultProject();

}

getScriptInfoEnsuringProjectsUptoDate(uncheckedFileName: string) {

this.ensureProjectStructuresUptoDate();

return this.getScriptInfo(uncheckedFileName);

}

/**

* Ensures the project structures are upto date

* This means,

* - if there are changedFiles (the files were updated but their containing project graph was not upto date),

* their project graph is updated

* - If there are pendingProjectUpdates (scheduled to be updated with delay so they can batch update the graph if there are several changes in short time span)

* their project graph is updated

* - If there were project graph updates and/or there was pending inferred project update and/or called forced the inferred project structure refresh

* Inferred projects are created/updated/deleted based on open files states

* @param forceInferredProjectsRefresh when true updates the inferred projects even if there is no pending work to update the files/project structures

*/

private ensureProjectStructuresUptoDate(forceInferredProjectsRefresh?: boolean) {

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

addRange(projectsToUpdate, f.containingProjects);

}

}

this.changedFiles = undefined;

this.updateProjectGraphs(projectsToUpdate);

}

if (this.pendingProjectUpdates.size !== 0) {

const projectsToUpdate = arrayFrom(this.pendingProjectUpdates.values());

this.pendingProjectUpdates.clear();

this.updateProjectGraphs(projectsToUpdate);

}

if (this.pendingInferredProjectUpdate || forceInferredProjectsRefresh) {

this.pendingInferredProjectUpdate = false;

this.refreshInferredProjects();

}

}

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

for (const p of projects) {

if (!p.updateGraph()) {

this.pendingInferredProjectUpdate = true;

}

}

}

private onSourceFileChanged(fileName: NormalizedPath, eventKind: FileWatcherEventKind) {

const info = this.getScriptInfoForNormalizedPath(fileName);

if (!info) {

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

}

else if (eventKind === FileWatcherEventKind.Deleted) {

// File was deleted

this.handleDeletedFile(info);

}

else if (!info.isScriptOpen()) {

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

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

this.stopWatchingScriptInfo(info);

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

this.delayUpdateProjectGraphs(info.containingProjects);

}

}

}

private handleDeletedFile(info: ScriptInfo) {

this.stopWatchingScriptInfo(info);

// TODO: handle isOpen = true case

if (!info.isScriptOpen()) {

this.filenameToScriptInfo.delete(info.path);

// 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.delayUpdateProjectGraphs(containingProjects);

}

}

/**

* This is to watch whenever files are added or removed to the wildcard directories

*/

/*@internal*/

watchWildcardDirectory(directory: Path, flags: WatchDirectoryFlags, project: ConfiguredProject) {

return this.watchDirectory(

this.host,

directory,

fileOrDirectory => {

const fileOrDirectoryPath = this.toPath(fileOrDirectory);

project.getCachedDirectoryStructureHost().addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath);

const configFilename = project.getConfigFilePath();

// If the the added or created file or directory is not supported file name, ignore the file

// But when watched directory is added/removed, we need to reload the file list

if (fileOrDirectoryPath !== directory && hasExtension(fileOrDirectoryPath) && !isSupportedSourceFileName(fileOrDirectory, project.getCompilationSettings(), this.hostConfiguration.extraFileExtensions)) {

this.logger.info(`Project: ${configFilename} Detected file add/remove of non supported extension: ${fileOrDirectory}`);

return;

}

// Reload is pending, do the reload

if (project.pendingReload !== ConfigFileProgramReloadLevel.Full) {

project.pendingReload = ConfigFileProgramReloadLevel.Partial;

this.delayUpdateProjectGraphAndInferredProjectsRefresh(project);

}

},

flags,

WatchType.WildcardDirectories,

project

);

}

/** Gets the config file existence info for the configured project */

/*@internal*/

getConfigFileExistenceInfo(project: ConfiguredProject) {

return this.configFileExistenceInfoCache.get(project.canonicalConfigFilePath);

}

private onConfigChangedForConfiguredProject(project: ConfiguredProject, eventKind: FileWatcherEventKind) {

const configFileExistenceInfo = this.getConfigFileExistenceInfo(project);

if (eventKind === FileWatcherEventKind.Deleted) {

// Update the cached status

// We arent updating or removing the cached config file presence info as that will be taken care of by

// setConfigFilePresenceByClosedConfigFile when the project is closed (depending on tracking open files)

configFileExistenceInfo.exists = false;

this.removeProject(project);

// Reload the configured projects for the open files in the map as they are affectected by this config file

// Since the configured project was deleted, we want to reload projects for all the open files including files

// that are not root of the inferred project

this.logConfigFileWatchUpdate(project.getConfigFilePath(), project.canonicalConfigFilePath, configFileExistenceInfo, ConfigFileWatcherStatus.ReloadingFiles);

this.delayReloadConfiguredProjectForFiles(configFileExistenceInfo, /*ignoreIfNotInferredProjectRoot*/ false);

}

else {

this.logConfigFileWatchUpdate(project.getConfigFilePath(), project.canonicalConfigFilePath, configFileExistenceInfo, ConfigFileWatcherStatus.ReloadingInferredRootFiles);

project.pendingReload = ConfigFileProgramReloadLevel.Full;

this.delayUpdateProjectGraph(project);

// As we scheduled the update on configured project graph,

// we would need to schedule the project reload for only the root of inferred projects

this.delayReloadConfiguredProjectForFiles(configFileExistenceInfo, /*ignoreIfNotInferredProjectRoot*/ true);

}

}

/**

* This is the callback function for the config file add/remove/change at any location

* that matters to open script info but doesnt have configured project open

* for the config file

*/

private onConfigFileChangeForOpenScriptInfo(configFileName: NormalizedPath, eventKind: FileWatcherEventKind) {

// This callback is called only if we dont have config file project for this config file

const canonicalConfigPath = normalizedPathToPath(configFileName, this.currentDirectory, this.toCanonicalFileName);

const configFileExistenceInfo = this.configFileExistenceInfoCache.get(canonicalConfigPath);

configFileExistenceInfo.exists = (eventKind !== FileWatcherEventKind.Deleted);

this.logConfigFileWatchUpdate(configFileName, canonicalConfigPath, configFileExistenceInfo, ConfigFileWatcherStatus.ReloadingFiles);

// Because there is no configured project open for the config file, the tracking open files map

// will only have open files that need the re-detection of the project and hence

// reload projects for all the tracking open files in the map

this.delayReloadConfiguredProjectForFiles(configFileExistenceInfo, /*ignoreIfNotInferredProjectRoot*/ false);

}

private removeProject(project: Project) {

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

project.close();

if (Debug.shouldAssert(AssertionLevel.Normal)) {

this.filenameToScriptInfo.forEach(info => Debug.assert(!info.isAttached(project)));

}

// Remove the project from pending project updates

this.pendingProjectUpdates.delete(project.getProjectName());

switch (project.projectKind) {

case ProjectKind.External:

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

this.projectToSizeMap.delete(project.getProjectName());

break;

case ProjectKind.Configured:

this.configuredProjects.delete((<ConfiguredProject>project).canonicalConfigFilePath);

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

this.setConfigFileExistenceInfoByClosedConfiguredProject(<ConfiguredProject>project);

break;

case ProjectKind.Inferred:

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

break;

}

}

/*@internal*/

assignOrphanScriptInfoToInferredProject(info: ScriptInfo, projectRootPath: NormalizedPath | undefined) {

Debug.assert(info.isOrphan());

const project = this.getOrCreateInferredProjectForProjectRootPathIfEnabled(info, projectRootPath) ||

this.getOrCreateSingleInferredProjectIfEnabled() ||

this.createInferredProject(getDirectoryPath(info.path));

project.addRoot(info);

project.updateGraph();

if (!this.useSingleInferredProject && !project.projectRootPath) {

// Note that we need to create a copy of the array since the list of project can change

for (const inferredProject of this.inferredProjects.slice(0, this.inferredProjects.length - 1)) {

Debug.assert(inferredProject !== project);

// Remove the inferred project if the root of it is now part of newly created inferred project

// e.g through references

// Which means if any root of inferred project is part of more than 1 project can be removed

// This logic is same as iterating over all open files and calling

// this.removeRootOfInferredProjectIfNowPartOfOtherProject(f);

// Since this is also called from refreshInferredProject and closeOpen file

// to update inferred projects of the open file, this iteration might be faster

// instead of scanning all open files

const roots = inferredProject.getRootScriptInfos();

Debug.assert(roots.length === 1 || !!inferredProject.projectRootPath);

if (roots.length === 1 && roots[0].containingProjects.length > 1) {

this.removeProject(inferredProject);

}

}

}

return project;

}

/**

* Remove this file from the set of open, non-configured files.

* @param info The file that has been closed or newly configured

*/

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.

const fileExists = this.host.fileExists(info.fileName);

info.close(fileExists);

this.stopWatchingConfigFilesForClosedScriptInfo(info);

this.openFiles.delete(info.path);

const canonicalFileName = this.toCanonicalFileName(info.fileName);

if (this.openFilesWithNonRootedDiskPath.get(canonicalFileName) === info) {

this.openFilesWithNonRootedDiskPath.delete(canonicalFileName);

}

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

}

// Do not remove the project so that we can reuse this project

// if it would need to be re-created with next file open

}

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

// If this was the open root file of inferred project

if ((p as InferredProject).isProjectWithSingleRoot()) {

// - when useSingleInferredProject is not set, we can guarantee that this will be the only root

// - other wise remove the project if it is the only root

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

}

else {

p.removeFile(info, fileExists, /*detachFromProject*/ true);

}

}

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

}

// collect orphaned files and assign them to inferred project just like we treat open of a file

this.openFiles.forEach((projectRootPath, path) => {

const f = this.getScriptInfoForPath(path as Path);

if (f.isOrphan()) {

this.assignOrphanScriptInfoToInferredProject(f, projectRootPath);

}

});