namespace ts.server {

export enum ProjectKind {

Inferred,

Configured,

External,

AutoImportProvider,

}

/* @internal */

export type Mutable<T> = { -readonly [K in keyof T]: T[K]; };

/* @internal */

export function countEachFileTypes(infos: ScriptInfo[], includeSizes = false): FileStats {

const result: Mutable<FileStats> = {

js: 0, jsSize: 0,

jsx: 0, jsxSize: 0,

ts: 0, tsSize: 0,

tsx: 0, tsxSize: 0,

dts: 0, dtsSize: 0,

deferred: 0, deferredSize: 0,

};

for (const info of infos) {

const fileSize = includeSizes ? info.getTelemetryFileSize() : 0;

switch (info.scriptKind) {

case ScriptKind.JS:

result.js += 1;

result.jsSize! += fileSize;

break;

case ScriptKind.JSX:

result.jsx += 1;

result.jsxSize! += fileSize;

break;

case ScriptKind.TS:

if (fileExtensionIs(info.fileName, Extension.Dts)) {

result.dts += 1;

result.dtsSize! += fileSize;

}

else {

result.ts += 1;

result.tsSize! += fileSize;

}

break;

case ScriptKind.TSX:

result.tsx += 1;

result.tsxSize! += fileSize;

break;

case ScriptKind.Deferred:

result.deferred += 1;

result.deferredSize! += fileSize;

break;

}

}

return result;

}

function hasOneOrMoreJsAndNoTsFiles(project: Project) {

const counts = countEachFileTypes(project.getScriptInfos());

return counts.js > 0 && counts.ts === 0 && counts.tsx === 0;

}

export function allRootFilesAreJsOrDts(project: Project): boolean {

const counts = countEachFileTypes(project.getRootScriptInfos());

return counts.ts === 0 && counts.tsx === 0;

}

export function allFilesAreJsOrDts(project: Project): boolean {

const counts = countEachFileTypes(project.getScriptInfos());

return counts.ts === 0 && counts.tsx === 0;

}

/* @internal */

export function hasNoTypeScriptSource(fileNames: string[]): boolean {

return !fileNames.some(fileName => (fileExtensionIs(fileName, Extension.Ts) && !fileExtensionIs(fileName, Extension.Dts)) || fileExtensionIs(fileName, Extension.Tsx));

}

/* @internal */

export interface ProjectFilesWithTSDiagnostics extends protocol.ProjectFiles {

projectErrors: readonly Diagnostic[];

}

export interface PluginCreateInfo {

project: Project;

languageService: LanguageService;

languageServiceHost: LanguageServiceHost;

serverHost: ServerHost;

session?: Session<unknown>;

config: any;

}

export interface PluginModule {

create(createInfo: PluginCreateInfo): LanguageService;

getExternalFiles?(proj: Project): string[];

onConfigurationChanged?(config: any): void;

}

export interface PluginModuleWithName {

name: string;

module: PluginModule;

}

export type PluginModuleFactory = (mod: { typescript: typeof ts }) => PluginModule;

/**

* The project root can be script info - if root is present,

* or it could be just normalized path if root wasn't present on the host(only for non inferred project)

*/

/* @internal */

export interface ProjectRootFile {

fileName: NormalizedPath;

info?: ScriptInfo;

}

interface GeneratedFileWatcher {

generatedFilePath: Path;

watcher: FileWatcher;

}

type GeneratedFileWatcherMap = GeneratedFileWatcher | ESMap<Path, GeneratedFileWatcher>;

function isGeneratedFileWatcher(watch: GeneratedFileWatcherMap): watch is GeneratedFileWatcher {

return (watch as GeneratedFileWatcher).generatedFilePath !== undefined;

}

/*@internal*/

export interface EmitResult {

emitSkipped: boolean;

diagnostics: readonly Diagnostic[];

}

export abstract class Project implements LanguageServiceHost, ModuleResolutionHost {

private rootFiles: ScriptInfo[] = [];

private rootFilesMap = new Map<string, ProjectRootFile>();

private program: Program | undefined;

private externalFiles: SortedReadonlyArray<string> | undefined;

private missingFilesMap: ESMap<Path, FileWatcher> | undefined;

private generatedFilesMap: GeneratedFileWatcherMap | undefined;

private plugins: PluginModuleWithName[] = [];

/*@internal*/

/**

* This is map from files to unresolved imports in it

* Maop does not contain entries for files that do not have unresolved imports

* This helps in containing the set of files to invalidate

*/

cachedUnresolvedImportsPerFile = new Map<Path, readonly string[]>();

/*@internal*/

lastCachedUnresolvedImportsList: SortedReadonlyArray<string> | undefined;

/*@internal*/

private hasAddedorRemovedFiles = false;

/*@internal*/

private hasAddedOrRemovedSymlinks = false;

/*@internal*/

lastFileExceededProgramSize: string | undefined;

// wrapper over the real language service that will suppress all semantic operations

protected languageService: LanguageService;

public languageServiceEnabled: boolean;

readonly trace?: (s: string) => void;

readonly realpath?: (path: string) => string;

/*@internal*/

hasInvalidatedResolution: HasInvalidatedResolution | undefined;

/*@internal*/

resolutionCache: ResolutionCache;

private builderState: BuilderState | undefined;

/**

* Set of files names that were updated since the last call to getChangesSinceVersion.

*/

private updatedFileNames: Set<string> | undefined;

/**

* Set of files that was returned from the last call to getChangesSinceVersion.

*/

private lastReportedFileNames: ESMap<string, boolean> | undefined;

/**

* Last version that was reported.

*/

private lastReportedVersion = 0;

/**

* Current project's program version. (incremented everytime new program is created that is not complete reuse from the old one)

* This property is changed in 'updateGraph' based on the set of files in program

*/

private projectProgramVersion = 0;

/**

* Current version of the project state. It is changed when:

* - new root file was added/removed

* - edit happen in some file that is currently included in the project.

* This property is different from projectStructureVersion since in most cases edits don't affect set of files in the project

*/

private projectStateVersion = 0;

protected projectErrors: Diagnostic[] | undefined;

protected isInitialLoadPending: () => boolean = returnFalse;

/*@internal*/

dirty = false;

/*@internal*/

typingFiles: SortedReadonlyArray<string> = emptyArray;

/*@internal*/

originalConfiguredProjects: Set<NormalizedPath> | undefined;

/*@internal*/

private packageJsonsForAutoImport: Set<string> | undefined;

/*@internal*/

getResolvedProjectReferenceToRedirect(_fileName: string): ResolvedProjectReference | undefined {

return undefined;

}

/* @internal */ useSourceOfProjectReferenceRedirect?(): boolean;

/* @internal */ getParsedCommandLine?(fileName: string): ParsedCommandLine | undefined;

private readonly cancellationToken: ThrottledCancellationToken;

public isNonTsProject() {

updateProjectIfDirty(this);

return allFilesAreJsOrDts(this);

}

public isJsOnlyProject() {

updateProjectIfDirty(this);

return hasOneOrMoreJsAndNoTsFiles(this);

}

public static resolveModule(moduleName: string, initialDir: string, host: ServerHost, log: (message: string) => void, logErrors?: (message: string) => void): {} | undefined {

const resolvedPath = normalizeSlashes(host.resolvePath(combinePaths(initialDir, "node_modules")));

log(`Loading ${moduleName} from ${initialDir} (resolved to ${resolvedPath})`);

const result = host.require!(resolvedPath, moduleName); // TODO: GH#18217

if (result.error) {

const err = result.error.stack || result.error.message || JSON.stringify(result.error);

(logErrors || log)(`Failed to load module '${moduleName}' from ${resolvedPath}: ${err}`);

return undefined;

}

return result.module;

}

/*@internal*/

readonly currentDirectory: string;

/*@internal*/

public directoryStructureHost: DirectoryStructureHost;

/*@internal*/

public readonly getCanonicalFileName: GetCanonicalFileName;

/*@internal*/

private exportMapCache: ExportInfoMap | undefined;

/*@internal*/

private changedFilesForExportMapCache: Set<Path> | undefined;

/*@internal*/

private moduleSpecifierCache = createModuleSpecifierCache(this);

/*@internal*/

private symlinks: SymlinkCache | undefined;

/*@internal*/

autoImportProviderHost: AutoImportProviderProject | false | undefined;

/*@internal*/

protected typeAcquisition: TypeAcquisition | undefined;

/*@internal*/

constructor(

/*@internal*/ readonly projectName: string,

readonly projectKind: ProjectKind,

readonly projectService: ProjectService,

private documentRegistry: DocumentRegistry,

hasExplicitListOfFiles: boolean,

lastFileExceededProgramSize: string | undefined,

private compilerOptions: CompilerOptions,

public compileOnSaveEnabled: boolean,

protected watchOptions: WatchOptions | undefined,

directoryStructureHost: DirectoryStructureHost,

currentDirectory: string | undefined,

) {

this.directoryStructureHost = directoryStructureHost;

this.currentDirectory = this.projectService.getNormalizedAbsolutePath(currentDirectory || "");

this.getCanonicalFileName = this.projectService.toCanonicalFileName;

this.cancellationToken = new ThrottledCancellationToken(this.projectService.cancellationToken, this.projectService.throttleWaitMilliseconds);

if (!this.compilerOptions) {

this.compilerOptions = getDefaultCompilerOptions();

this.compilerOptions.allowNonTsExtensions = true;

this.compilerOptions.allowJs = true;

}

else if (hasExplicitListOfFiles || getAllowJSCompilerOption(this.compilerOptions) || this.projectService.hasDeferredExtension()) {

// If files are listed explicitly or allowJs is specified, allow all extensions

this.compilerOptions.allowNonTsExtensions = true;

}

switch (projectService.serverMode) {

case LanguageServiceMode.Semantic:

this.languageServiceEnabled = true;

break;

case LanguageServiceMode.PartialSemantic:

this.languageServiceEnabled = true;

this.compilerOptions.noResolve = true;

this.compilerOptions.types = [];

break;

case LanguageServiceMode.Syntactic:

this.languageServiceEnabled = false;

this.compilerOptions.noResolve = true;

this.compilerOptions.types = [];

break;

default:

Debug.assertNever(projectService.serverMode);

}

this.setInternalCompilerOptionsForEmittingJsFiles();

const host = this.projectService.host;

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

this.trace = s => this.writeLog(s);

}

else if (host.trace) {

this.trace = s => host.trace!(s);

}

this.realpath = maybeBind(host, host.realpath);

// Use the current directory as resolution root only if the project created using current directory string

this.resolutionCache = createResolutionCache(

this,

currentDirectory && this.currentDirectory,

/*logChangesWhenResolvingModule*/ true

);

this.languageService = createLanguageService(this, this.documentRegistry, this.projectService.serverMode);

if (lastFileExceededProgramSize) {

this.disableLanguageService(lastFileExceededProgramSize);

}

this.markAsDirty();

if (projectKind !== ProjectKind.AutoImportProvider) {

this.projectService.pendingEnsureProjectForOpenFiles = true;

}

}

isKnownTypesPackageName(name: string): boolean {

return this.typingsCache.isKnownTypesPackageName(name);

}

installPackage(options: InstallPackageOptions): Promise<ApplyCodeActionCommandResult> {

return this.typingsCache.installPackage({ ...options, projectName: this.projectName, projectRootPath: this.toPath(this.currentDirectory) });

}

/*@internal*/

getGlobalTypingsCacheLocation() {

return this.getGlobalCache();

}

private get typingsCache(): TypingsCache {

return this.projectService.typingsCache;

}

/*@internal*/

getSymlinkCache(): SymlinkCache {

if (!this.symlinks) {

this.symlinks = createSymlinkCache(this.getCurrentDirectory(), this.getCanonicalFileName);

}

if (this.program && !this.symlinks.hasProcessedResolutions()) {

this.symlinks.setSymlinksFromResolutions(

this.program.getSourceFiles(),

this.program.getResolvedTypeReferenceDirectives());

}

return this.symlinks;

}

// Method of LanguageServiceHost

getCompilationSettings() {

return this.compilerOptions;

}

// Method to support public API

getCompilerOptions() {

return this.getCompilationSettings();

}

getNewLine() {

return this.projectService.host.newLine;

}

getProjectVersion() {

return this.projectStateVersion.toString();

}

getProjectReferences(): readonly ProjectReference[] | undefined {

return undefined;

}

getScriptFileNames() {

if (!this.rootFiles) {

return ts.emptyArray;

}

let result: string[] | undefined;

this.rootFilesMap.forEach(value => {

if (this.languageServiceEnabled || (value.info && value.info.isScriptOpen())) {

// if language service is disabled - process only files that are open

(result || (result = [])).push(value.fileName);

}

});

return addRange(result, this.typingFiles) || ts.emptyArray;

}

private getOrCreateScriptInfoAndAttachToProject(fileName: string) {

const scriptInfo = this.projectService.getOrCreateScriptInfoNotOpenedByClient(fileName, this.currentDirectory, this.directoryStructureHost);

if (scriptInfo) {

const existingValue = this.rootFilesMap.get(scriptInfo.path);

if (existingValue && existingValue.info !== scriptInfo) {

// This was missing path earlier but now the file exists. Update the root

this.rootFiles.push(scriptInfo);

existingValue.info = scriptInfo;

}

scriptInfo.attachToProject(this);

}

return scriptInfo;

}

getScriptKind(fileName: string) {

const info = this.getOrCreateScriptInfoAndAttachToProject(fileName);

return (info && info.scriptKind)!; // TODO: GH#18217

}

getScriptVersion(filename: string) {

// Don't attach to the project if version is asked

const info = this.projectService.getOrCreateScriptInfoNotOpenedByClient(filename, this.currentDirectory, this.directoryStructureHost);

return (info && info.getLatestVersion())!; // TODO: GH#18217

}

getScriptSnapshot(filename: string): IScriptSnapshot | undefined {

const scriptInfo = this.getOrCreateScriptInfoAndAttachToProject(filename);

if (scriptInfo) {

return scriptInfo.getSnapshot();

}

}

getCancellationToken(): HostCancellationToken {

return this.cancellationToken;

}

getCurrentDirectory(): string {

return this.currentDirectory;

}

getDefaultLibFileName() {

const nodeModuleBinDir = getDirectoryPath(normalizePath(this.projectService.getExecutingFilePath()));

return combinePaths(nodeModuleBinDir, getDefaultLibFileName(this.compilerOptions));

}

useCaseSensitiveFileNames() {

return this.projectService.host.useCaseSensitiveFileNames;

}

readDirectory(path: string, extensions?: readonly string[], exclude?: readonly string[], include?: readonly string[], depth?: number): string[] {

return this.directoryStructureHost.readDirectory!(path, extensions, exclude, include, depth);

}

readFile(fileName: string): string | undefined {

return this.projectService.host.readFile(fileName);

}

writeFile(fileName: string, content: string): void {

return this.projectService.host.writeFile(fileName, content);

}

fileExists(file: string): boolean {

// As an optimization, don't hit the disks for files we already know don't exist

// (because we're watching for their creation).

const path = this.toPath(file);

return !this.isWatchedMissingFile(path) && this.directoryStructureHost.fileExists(file);

}

resolveModuleNames(moduleNames: string[], containingFile: string, reusedNames?: string[], redirectedReference?: ResolvedProjectReference, _options?: CompilerOptions, containingSourceFile?: SourceFile): (ResolvedModuleFull | undefined)[] {

return this.resolutionCache.resolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference, containingSourceFile);

}

getResolvedModuleWithFailedLookupLocationsFromCache(moduleName: string, containingFile: string, resolutionMode?: ModuleKind.CommonJS | ModuleKind.ESNext): ResolvedModuleWithFailedLookupLocations | undefined {

return this.resolutionCache.getResolvedModuleWithFailedLookupLocationsFromCache(moduleName, containingFile, resolutionMode);

}

resolveTypeReferenceDirectives(typeDirectiveNames: string[], containingFile: string, redirectedReference?: ResolvedProjectReference): (ResolvedTypeReferenceDirective | undefined)[] {

return this.resolutionCache.resolveTypeReferenceDirectives(typeDirectiveNames, containingFile, redirectedReference);

}

directoryExists(path: string): boolean {

return this.directoryStructureHost.directoryExists!(path); // TODO: GH#18217

}

getDirectories(path: string): string[] {

return this.directoryStructureHost.getDirectories!(path); // TODO: GH#18217

}

/*@internal*/

getCachedDirectoryStructureHost(): CachedDirectoryStructureHost {

return undefined!; // TODO: GH#18217

}

/*@internal*/

toPath(fileName: string) {

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

}

/*@internal*/

watchDirectoryOfFailedLookupLocation(directory: string, cb: DirectoryWatcherCallback, flags: WatchDirectoryFlags) {

return this.projectService.watchFactory.watchDirectory(

directory,

cb,

flags,

this.projectService.getWatchOptions(this),

WatchType.FailedLookupLocations,

this

);

}

/*@internal*/

clearInvalidateResolutionOfFailedLookupTimer() {

return this.projectService.throttledOperations.cancel(`${this.getProjectName()}FailedLookupInvalidation`);

}

/*@internal*/

scheduleInvalidateResolutionsOfFailedLookupLocations() {

this.projectService.throttledOperations.schedule(`${this.getProjectName()}FailedLookupInvalidation`, /*delay*/ 1000, () => {

if (this.resolutionCache.invalidateResolutionsOfFailedLookupLocations()) {

this.projectService.delayUpdateProjectGraphAndEnsureProjectStructureForOpenFiles(this);

}

});

}

/*@internal*/

invalidateResolutionsOfFailedLookupLocations() {

if (this.clearInvalidateResolutionOfFailedLookupTimer() &&

this.resolutionCache.invalidateResolutionsOfFailedLookupLocations()) {

this.markAsDirty();

this.projectService.delayEnsureProjectForOpenFiles();

}

}

/*@internal*/

onInvalidatedResolution() {

this.projectService.delayUpdateProjectGraphAndEnsureProjectStructureForOpenFiles(this);

}

/*@internal*/

watchTypeRootsDirectory(directory: string, cb: DirectoryWatcherCallback, flags: WatchDirectoryFlags) {

return this.projectService.watchFactory.watchDirectory(

directory,

cb,

flags,

this.projectService.getWatchOptions(this),

WatchType.TypeRoots,

this

);

}

/*@internal*/

hasChangedAutomaticTypeDirectiveNames() {

return this.resolutionCache.hasChangedAutomaticTypeDirectiveNames();

}

/*@internal*/

onChangedAutomaticTypeDirectiveNames() {

this.projectService.delayUpdateProjectGraphAndEnsureProjectStructureForOpenFiles(this);

}

/*@internal*/

getGlobalCache() {

return this.getTypeAcquisition().enable ? this.projectService.typingsInstaller.globalTypingsCacheLocation : undefined;

}

/*@internal*/

globalCacheResolutionModuleName = JsTyping.nonRelativeModuleNameForTypingCache;

/*@internal*/

fileIsOpen(filePath: Path) {

return this.projectService.openFiles.has(filePath);

}

/*@internal*/

writeLog(s: string) {

this.projectService.logger.info(s);

}

log(s: string) {

this.writeLog(s);

}

error(s: string) {

this.projectService.logger.msg(s, Msg.Err);

}

private setInternalCompilerOptionsForEmittingJsFiles() {

if (this.projectKind === ProjectKind.Inferred || this.projectKind === ProjectKind.External) {

this.compilerOptions.noEmitForJsFiles = true;

}

}

/**

* Get the errors that dont have any file name associated

*/

getGlobalProjectErrors(): readonly Diagnostic[] {

return filter(this.projectErrors, diagnostic => !diagnostic.file) || emptyArray;

}

/**

* Get all the project errors

*/

getAllProjectErrors(): readonly Diagnostic[] {

return this.projectErrors || emptyArray;

}

setProjectErrors(projectErrors: Diagnostic[] | undefined) {

this.projectErrors = projectErrors;

}

getLanguageService(ensureSynchronized = true): LanguageService {

if (ensureSynchronized) {

updateProjectIfDirty(this);

}

return this.languageService;

}

/** @internal */

getSourceMapper(): SourceMapper {

return this.getLanguageService().getSourceMapper();

}

/** @internal */

clearSourceMapperCache() {

this.languageService.clearSourceMapperCache();

}

/*@internal*/

getDocumentPositionMapper(generatedFileName: string, sourceFileName?: string): DocumentPositionMapper | undefined {

return this.projectService.getDocumentPositionMapper(this, generatedFileName, sourceFileName);

}

/*@internal*/

getSourceFileLike(fileName: string) {

return this.projectService.getSourceFileLike(fileName, this);

}

/*@internal*/

shouldEmitFile(scriptInfo: ScriptInfo | undefined) {

return scriptInfo &&

!scriptInfo.isDynamicOrHasMixedContent() &&

!this.program!.isSourceOfProjectReferenceRedirect(scriptInfo.path);

}

getCompileOnSaveAffectedFileList(scriptInfo: ScriptInfo): string[] {

if (!this.languageServiceEnabled) {

return [];

}

updateProjectIfDirty(this);

this.builderState = BuilderState.create(this.program!, this.projectService.toCanonicalFileName, this.builderState, /*disableUseFileVersionAsSignature*/ true);

return mapDefined(

BuilderState.getFilesAffectedBy(

this.builderState,

this.program!,

scriptInfo.path,

this.cancellationToken,

maybeBind(this.projectService.host, this.projectService.host.createHash)

),

sourceFile => this.shouldEmitFile(this.projectService.getScriptInfoForPath(sourceFile.path)) ? sourceFile.fileName : undefined

);

}

/**

* Returns true if emit was conducted

*/

emitFile(scriptInfo: ScriptInfo, writeFile: (path: string, data: string, writeByteOrderMark?: boolean) => void): EmitResult {

if (!this.languageServiceEnabled || !this.shouldEmitFile(scriptInfo)) {

return { emitSkipped: true, diagnostics: emptyArray };

}

const { emitSkipped, diagnostics, outputFiles } = this.getLanguageService().getEmitOutput(scriptInfo.fileName);

if (!emitSkipped) {

for (const outputFile of outputFiles) {

const outputFileAbsoluteFileName = getNormalizedAbsolutePath(outputFile.name, this.currentDirectory);

writeFile(outputFileAbsoluteFileName, outputFile.text, outputFile.writeByteOrderMark);

}

// Update the signature

if (this.builderState && getEmitDeclarations(this.compilerOptions)) {

const dtsFiles = outputFiles.filter(f => fileExtensionIs(f.name, Extension.Dts));

if (dtsFiles.length === 1) {

const sourceFile = this.program!.getSourceFile(scriptInfo.fileName)!;

const signature = this.projectService.host.createHash ?

this.projectService.host.createHash(dtsFiles[0].text) :

generateDjb2Hash(dtsFiles[0].text);

BuilderState.updateSignatureOfFile(this.builderState, signature, sourceFile.resolvedPath);

}

}

}

return { emitSkipped, diagnostics };

}

enableLanguageService() {

if (this.languageServiceEnabled || this.projectService.serverMode === LanguageServiceMode.Syntactic) {

return;

}

this.languageServiceEnabled = true;

this.lastFileExceededProgramSize = undefined;

this.projectService.onUpdateLanguageServiceStateForProject(this, /*languageServiceEnabled*/ true);

}

disableLanguageService(lastFileExceededProgramSize?: string) {

if (!this.languageServiceEnabled) {

return;

}

Debug.assert(this.projectService.serverMode !== LanguageServiceMode.Syntactic);

this.languageService.cleanupSemanticCache();

this.languageServiceEnabled = false;

this.lastFileExceededProgramSize = lastFileExceededProgramSize;

this.builderState = undefined;

if (this.autoImportProviderHost) {

this.autoImportProviderHost.close();

}

this.autoImportProviderHost = undefined;

this.resolutionCache.closeTypeRootsWatch();

this.clearGeneratedFileWatch();

this.projectService.onUpdateLanguageServiceStateForProject(this, /*languageServiceEnabled*/ false);

}

getProjectName() {

return this.projectName;

}

protected removeLocalTypingsFromTypeAcquisition(newTypeAcquisition: TypeAcquisition): TypeAcquisition {

if (!newTypeAcquisition || !newTypeAcquisition.include) {

// Nothing to filter out, so just return as-is

return newTypeAcquisition;

}

return { ...newTypeAcquisition, include: this.removeExistingTypings(newTypeAcquisition.include) };

}

getExternalFiles(): SortedReadonlyArray<string> {

return sort(flatMap(this.plugins, plugin => {

if (typeof plugin.module.getExternalFiles !== "function") return;

try {

return plugin.module.getExternalFiles(this);

}

catch (e) {

this.projectService.logger.info(`A plugin threw an exception in getExternalFiles: ${e}`);

if (e.stack) {

this.projectService.logger.info(e.stack);

}

}

}));

}

getSourceFile(path: Path) {

if (!this.program) {

return undefined;

}

return this.program.getSourceFileByPath(path);

}

/* @internal */

getSourceFileOrConfigFile(path: Path): SourceFile | undefined {

const options = this.program!.getCompilerOptions();

return path === options.configFilePath ? options.configFile : this.getSourceFile(path);

}

close() {

if (this.program) {

// if we have a program - release all files that are enlisted in program but arent root

// The releasing of the roots happens later

// The project could have pending update remaining and hence the info could be in the files but not in program graph

for (const f of this.program.getSourceFiles()) {

this.detachScriptInfoIfNotRoot(f.fileName);

}

this.program.forEachResolvedProjectReference(ref =>

this.detachScriptInfoFromProject(ref.sourceFile.fileName));

}

// Release external files

forEach(this.externalFiles, externalFile => this.detachScriptInfoIfNotRoot(externalFile));

// Always remove root files from the project

for (const root of this.rootFiles) {

root.detachFromProject(this);

}

this.projectService.pendingEnsureProjectForOpenFiles = true;

this.rootFiles = undefined!;

this.rootFilesMap = undefined!;

this.externalFiles = undefined;

this.program = undefined;

this.builderState = undefined;

this.resolutionCache.clear();

this.resolutionCache = undefined!;

this.cachedUnresolvedImportsPerFile = undefined!;

this.moduleSpecifierCache = undefined!;

this.directoryStructureHost = undefined!;

this.exportMapCache = undefined;

this.projectErrors = undefined;

// Clean up file watchers waiting for missing files

if (this.missingFilesMap) {

clearMap(this.missingFilesMap, closeFileWatcher);

this.missingFilesMap = undefined;

}

this.clearGeneratedFileWatch();

this.clearInvalidateResolutionOfFailedLookupTimer();

if (this.autoImportProviderHost) {

this.autoImportProviderHost.close();

}

this.autoImportProviderHost = undefined;

// signal language service to release source files acquired from document registry

this.languageService.dispose();

this.languageService = undefined!;

}

private detachScriptInfoIfNotRoot(uncheckedFilename: string) {

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

// We might not find the script info in case its not associated with the project any more

// and project graph was not updated (eg delayed update graph in case of files changed/deleted on the disk)

if (info && !this.isRoot(info)) {

info.detachFromProject(this);

}

}

isClosed() {

return this.rootFiles === undefined;

}

hasRoots() {

return this.rootFiles && this.rootFiles.length > 0;

}

/*@internal*/

isOrphan() {

return false;

}

getRootFiles() {

return this.rootFiles && this.rootFiles.map(info => info.fileName);

}

/*@internal*/

getRootFilesMap() {

return this.rootFilesMap;

}

getRootScriptInfos() {

return this.rootFiles;

}

getScriptInfos(): ScriptInfo[] {

if (!this.languageServiceEnabled) {

// if language service is not enabled - return just root files

return this.rootFiles;

}

return map(this.program!.getSourceFiles(), sourceFile => {

const scriptInfo = this.projectService.getScriptInfoForPath(sourceFile.resolvedPath);

Debug.assert(!!scriptInfo, "getScriptInfo", () => `scriptInfo for a file '${sourceFile.fileName}' Path: '${sourceFile.path}' / '${sourceFile.resolvedPath}' is missing.`);

return scriptInfo;

});

}

getExcludedFiles(): readonly NormalizedPath[] {

return emptyArray;

}

getFileNames(excludeFilesFromExternalLibraries?: boolean, excludeConfigFiles?: boolean) {

if (!this.program) {

return [];

}

if (!this.languageServiceEnabled) {

// if language service is disabled assume that all files in program are root files + default library

let rootFiles = this.getRootFiles();

if (this.compilerOptions) {

const defaultLibrary = getDefaultLibFilePath(this.compilerOptions);

if (defaultLibrary) {

(rootFiles || (rootFiles = [])).push(asNormalizedPath(defaultLibrary));

}

}

return rootFiles;

}

const result: NormalizedPath[] = [];

for (const f of this.program.getSourceFiles()) {

if (excludeFilesFromExternalLibraries && this.program.isSourceFileFromExternalLibrary(f)) {

continue;

}

result.push(asNormalizedPath(f.fileName));

}

if (!excludeConfigFiles) {

const configFile = this.program.getCompilerOptions().configFile;

if (configFile) {

result.push(asNormalizedPath(configFile.fileName));

if (configFile.extendedSourceFiles) {

for (const f of configFile.extendedSourceFiles) {

result.push(asNormalizedPath(f));

}

}

}

}

return result;

}

/* @internal */

getFileNamesWithRedirectInfo(includeProjectReferenceRedirectInfo: boolean) {

return this.getFileNames().map((fileName): protocol.FileWithProjectReferenceRedirectInfo => ({

fileName,

isSourceOfProjectReferenceRedirect: includeProjectReferenceRedirectInfo && this.isSourceOfProjectReferenceRedirect(fileName)

}));

}

hasConfigFile(configFilePath: NormalizedPath) {

if (this.program && this.languageServiceEnabled) {

const configFile = this.program.getCompilerOptions().configFile;

if (configFile) {

if (configFilePath === asNormalizedPath(configFile.fileName)) {

return true;

}

if (configFile.extendedSourceFiles) {

for (const f of configFile.extendedSourceFiles) {

if (configFilePath === asNormalizedPath(f)) {

return true;

}

}

}

}

}

return false;

}

containsScriptInfo(info: ScriptInfo): boolean {

if (this.isRoot(info)) return true;

if (!this.program) return false;

const file = this.program.getSourceFileByPath(info.path);

return !!file && file.resolvedPath === info.path;

}

containsFile(filename: NormalizedPath, requireOpen?: boolean): boolean {

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

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

return this.containsScriptInfo(info);

}

return false;

}

isRoot(info: ScriptInfo) {

return this.rootFilesMap && this.rootFilesMap.get(info.path)?.info === info;

}

// add a root file to project

addRoot(info: ScriptInfo, fileName?: NormalizedPath) {

Debug.assert(!this.isRoot(info));

this.rootFiles.push(info);

this.rootFilesMap.set(info.path, { fileName: fileName || info.fileName, info });

info.attachToProject(this);

this.markAsDirty();

}

// add a root file that doesnt exist on host

addMissingFileRoot(fileName: NormalizedPath) {

const path = this.projectService.toPath(fileName);

this.rootFilesMap.set(path, { fileName });

this.markAsDirty();

}

removeFile(info: ScriptInfo, fileExists: boolean, detachFromProject: boolean) {

if (this.isRoot(info)) {

this.removeRoot(info);

}

if (fileExists) {

// If file is present, just remove the resolutions for the file

this.resolutionCache.removeResolutionsOfFile(info.path);

}

else {

this.resolutionCache.invalidateResolutionOfFile(info.path);

}

this.cachedUnresolvedImportsPerFile.delete(info.path);

if (detachFromProject) {

info.detachFromProject(this);

}

this.markAsDirty();

}

registerFileUpdate(fileName: string) {

(this.updatedFileNames || (this.updatedFileNames = new Set<string>())).add(fileName);

}

/*@internal*/

markFileAsDirty(changedFile: Path) {

this.markAsDirty();

if (this.exportMapCache && !this.exportMapCache.isEmpty()) {

(this.changedFilesForExportMapCache ||= new Set()).add(changedFile);

}

}

markAsDirty() {

if (!this.dirty) {