import * as ts from "./_namespaces/ts";

import {

addRange,

append,

ApplyCodeActionCommandResult,

arrayFrom,

arrayToMap,

BuilderState,

CachedDirectoryStructureHost,

changesAffectModuleResolution,

clearMap,

cloneCompilerOptions,

closeFileWatcher,

closeFileWatcherOf,

combinePaths,

comparePaths,

CompilerHost,

CompilerOptions,

concatenate,

ConfigFileProgramReloadLevel,

containsPath,

createCacheableExportInfoMap,

createLanguageService,

createResolutionCache,

createSymlinkCache,

Debug,

Diagnostic,

directorySeparator,

DirectoryStructureHost,

DirectoryWatcherCallback,

DocumentPositionMapper,

DocumentRegistry,

enumerateInsertsAndDeletes,

every,

explainFiles,

ExportInfoMap,

Extension,

fileExtensionIs,

FileReference,

FileWatcher,

FileWatcherCallback,

FileWatcherEventKind,

filter,

flatMap,

forEach,

forEachEntry,

forEachKey,

generateDjb2Hash,

getAllowJSCompilerOption,

getAutomaticTypeDirectiveNames,

getBaseFileName,

GetCanonicalFileName,

getDeclarationEmitOutputFilePathWorker,

getDefaultCompilerOptions,

getDefaultLibFileName,

getDefaultLibFilePath,

getDirectoryPath,

getEffectiveTypeRoots,

getEmitDeclarations,

getEntrypointsFromPackageJsonInfo,

getNormalizedAbsolutePath,

getOrUpdate,

getStringComparer,

HasInvalidatedLibResolutions,

HasInvalidatedResolutions,

HostCancellationToken,

inferredTypesContainingFile,

InstallPackageOptions,

IScriptSnapshot,

isDeclarationFileName,

isExternalModuleNameRelative,

isInsideNodeModules,

JsTyping,

LanguageService,

LanguageServiceHost,

LanguageServiceMode,

map,

mapDefined,

maybeBind,

ModuleResolutionCache,

ModuleResolutionHost,

noop,

noopFileWatcher,

normalizePath,

normalizeSlashes,

orderedRemoveItem,

outFile,

PackageJsonAutoImportPreference,

PackageJsonInfo,

ParsedCommandLine,

parsePackageName,

Path,

perfLogger,

PerformanceEvent,

PluginImport,

PollingInterval,

Program,

ProjectPackageJsonInfo,

ProjectReference,

removeFileExtension,

ResolutionCache,

resolutionExtensionIsTSOrJson,

ResolvedModuleWithFailedLookupLocations,

ResolvedProjectReference,

ResolvedTypeReferenceDirectiveWithFailedLookupLocations,

resolvePackageNameToPackageJson,

returnFalse,

returnTrue,

ScriptKind,

some,

sort,

sortAndDeduplicate,

SortedReadonlyArray,

SourceFile,

SourceMapper,

startsWith,

StringLiteralLike,

stripQuotes,

StructureIsReused,

SymlinkCache,

ThrottledCancellationToken,

timestamp,

toPath,

tracing,

TypeAcquisition,

updateErrorForNoInputFiles,

updateMissingFilePathsWatch,

WatchDirectoryFlags,

WatchOptions,

WatchType,

} from "./_namespaces/ts";

import {

ActionInvalidate,

asNormalizedPath,

createModuleSpecifierCache,

emptyArray,

Errors,

FileStats,

forEachResolvedProjectReferenceProject,

LogLevel,

ModuleImportResult,

Msg,

NormalizedPath,

projectContainsInfoDirectly,

ProjectOptions,

ProjectReferenceProjectLoadKind,

ProjectService,

ScriptInfo,

ServerHost,

Session,

toNormalizedPath,

TypingsCache,

updateProjectIfDirty,

} from "./_namespaces/ts.server";

import * as protocol from "./protocol";

export enum ProjectKind {

Inferred,

Configured,

External,

AutoImportProvider,

Auxiliary,

}

/** @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.textStorage.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 (isDeclarationFileName(info.fileName)) {

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) && !isDeclarationFileName(fileName)) || 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;

/** @internal */

export interface PluginImportResult<T> {

pluginConfigEntry: PluginImport;

resolvedModule: T | undefined;

errorLogs: string[] | undefined;

}

/** @internal */

export type BeginEnablePluginResult = PluginImportResult<PluginModuleFactory>;

/**

* 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 | Map<Path, GeneratedFileWatcher>;

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

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

}

/** @internal */

export interface EmitResult {

emitSkipped: boolean;

diagnostics: readonly Diagnostic[];

}

const enum TypingWatcherType {

FileWatcher = "FileWatcher",

DirectoryWatcher = "DirectoryWatcher"

}

type TypingWatchers = Map<Path, FileWatcher> & { isInvoked?: boolean; };

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: Map<Path, FileWatcher> | undefined;

private generatedFilesMap: GeneratedFileWatcherMap | undefined;

/** @internal */

protected readonly plugins: PluginModuleWithName[] = [];

/**

* 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

*

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

hasInvalidatedResolutions: HasInvalidatedResolutions | undefined;

/** @internal */

hasInvalidatedLibResolutions: HasInvalidatedLibResolutions | 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: Map<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 */

private typingWatchers: TypingWatchers | undefined;

/** @internal */

originalConfiguredProjects: Set<NormalizedPath> | undefined;

/** @internal */

private packageJsonsForAutoImport: Set<string> | undefined;

/** @internal */

noDtsResolutionProject?: AuxiliaryProject | 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): {} | undefined {

return Project.importServicePluginSync({ name: moduleName }, [initialDir], host, log).resolvedModule;

}

/** @internal */

public static importServicePluginSync<T = {}>(

pluginConfigEntry: PluginImport,

searchPaths: string[],

host: ServerHost,

log: (message: string) => void,

): PluginImportResult<T> {

Debug.assertIsDefined(host.require);

let errorLogs: string[] | undefined;

let resolvedModule: T | undefined;

for (const initialDir of searchPaths) {

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

log(`Loading ${pluginConfigEntry.name} from ${initialDir} (resolved to ${resolvedPath})`);

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

if (!result.error) {

resolvedModule = result.module as T;

break;

}

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

(errorLogs ??= []).push(`Failed to load module '${pluginConfigEntry.name}' from ${resolvedPath}: ${err}`);

}

return { pluginConfigEntry, resolvedModule, errorLogs };

}

/** @internal */

public static async importServicePluginAsync<T = {}>(

pluginConfigEntry: PluginImport,

searchPaths: string[],

host: ServerHost,

log: (message: string) => void,

): Promise<PluginImportResult<T>> {

Debug.assertIsDefined(host.importPlugin);

let errorLogs: string[] | undefined;

let resolvedModule: T | undefined;

for (const initialDir of searchPaths) {

const resolvedPath = combinePaths(initialDir, "node_modules");

log(`Dynamically importing ${pluginConfigEntry.name} from ${initialDir} (resolved to ${resolvedPath})`);

let result: ModuleImportResult;

try {

result = await host.importPlugin(resolvedPath, pluginConfigEntry.name);

}

catch (e) {

result = { module: undefined, error: e };

}

if (!result.error) {

resolvedModule = result.module as T;

break;

}

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

(errorLogs ??= []).push(`Failed to dynamically import module '${pluginConfigEntry.name}' from ${resolvedPath}: ${err}`);

}

return { pluginConfigEntry, resolvedModule, errorLogs };

}

/** @internal */

readonly currentDirectory: string;

/** @internal */

readonly projectName: 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 */

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

/** @internal */

constructor(

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,

) {

this.projectName = projectName;

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,

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

}

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

}

/** @internal */

resolveModuleNameLiterals(moduleLiterals: readonly StringLiteralLike[], containingFile: string, redirectedReference: ResolvedProjectReference | undefined, options: CompilerOptions, containingSourceFile: SourceFile, reusedNames: readonly StringLiteralLike[] | undefined): readonly ResolvedModuleWithFailedLookupLocations[] {

return this.resolutionCache.resolveModuleNameLiterals(moduleLiterals, containingFile, redirectedReference, options, containingSourceFile, reusedNames);

}

getModuleResolutionCache(): ModuleResolutionCache | undefined {

return this.resolutionCache.getModuleResolutionCache();

}

/** @internal */

resolveTypeReferenceDirectiveReferences<T extends string | FileReference>(typeDirectiveReferences: readonly T[], containingFile: string, redirectedReference: ResolvedProjectReference | undefined, options: CompilerOptions, containingSourceFile: SourceFile | undefined, reusedNames: readonly T[] | undefined): readonly ResolvedTypeReferenceDirectiveWithFailedLookupLocations[] {

return this.resolutionCache.resolveTypeReferenceDirectiveReferences(

typeDirectiveReferences,

containingFile,

redirectedReference,

options,

containingSourceFile,

reusedNames,

);

}

/** @internal */

resolveLibrary(libraryName: string, resolveFrom: string, options: CompilerOptions, libFileName: string): ResolvedModuleWithFailedLookupLocations {

return this.resolutionCache.resolveLibrary(libraryName, resolveFrom, options, libFileName);

}

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

watchAffectingFileLocation(file: string, cb: FileWatcherCallback) {

return this.projectService.watchFactory.watchFile(

file,

cb,

PollingInterval.High,

this.projectService.getWatchOptions(this),

WatchType.AffectingFileLocation,

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.builderState, /*disableUseFileVersionAsSignature*/ true);

return mapDefined(

BuilderState.getFilesAffectedBy(

this.builderState,

this.program!,

scriptInfo.path,

this.cancellationToken,

this.projectService.host,

),

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 => isDeclarationFileName(f.name));

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

}

/** @internal */

cleanupProgram() {

if (this.program) {

// Root files are always attached to the project irrespective of program

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

this.detachScriptInfoIfNotRoot(f.fileName);

}

this.program.forEachResolvedProjectReference(ref =>

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

this.program = undefined;

}

}

disableLanguageService(lastFileExceededProgramSize?: string) {

if (!this.languageServiceEnabled) {

return;

}

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

this.languageService.cleanupSemanticCache();

this.languageServiceEnabled = false;

this.cleanupProgram();

this.lastFileExceededProgramSize = lastFileExceededProgramSize;

this.builderState = undefined;

if (this.autoImportProviderHost) {

this.autoImportProviderHost.close();

}

this.autoImportProviderHost = undefined;

this.resolutionCache.closeTypeRootsWatch();

this.clearGeneratedFileWatch();