Inferred,

Configured,

External,

AutoImportProvider,

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;

project: Project;

languageService: LanguageService;

languageServiceHost: LanguageServiceHost;

serverHost: ServerHost;

config: any;

create(createInfo: PluginCreateInfo): LanguageService;

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

onConfigurationChanged?(config: any): void;

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*/

/**

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;

/**

private updatedFileNames: Set<string> | undefined;

/**

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

/**

private lastReportedVersion = 0;

/**

private projectProgramVersion = 0;

/**

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

/*@internal*/

private changedFilesForExportMapCache: Set<Path> | undefined;

/*@internal*/

private moduleSpecifierCache = createModuleSpecifierCache();

/*@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 {

return this.symlinks || (this.symlinks = discoverProbableSymlinks(

this.program?.getSourceFiles() || emptyArray,

this.getCanonicalFileName,

this.getCurrentDirectory()));

}

// 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): (ResolvedModuleFull | undefined)[] {

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

}

getResolvedModuleWithFailedLookupLocationsFromCache(moduleName: string, containingFile: string): ResolvedModuleWithFailedLookupLocations | undefined {

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

}

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;

}

}

/**

getGlobalProjectErrors(): readonly Diagnostic[] {

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

}

/**

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

);

}

/**

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.directoryStructureHost = 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;

}