typescript 5.6.0-dev.20240626 → 5.6.0-dev.20240628

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.6";
-var version = `${versionMajorMinor}.0-dev.20240626`;
+var version = `${versionMajorMinor}.0-dev.20240628`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -4902,6 +4902,7 @@ var sys = (() => {
       writeFile: writeFile2,
       watchFile: watchFile2,
       watchDirectory,
+      preferNonRecursiveWatch: !fsSupportsRecursiveFsWatch,
       resolvePath: (path) => _path.resolve(path),
       fileExists,
       directoryExists,
@@ -12544,6 +12545,12 @@ function projectReferenceIsEqualTo(oldRef, newRef) {
 function moduleResolutionIsEqualTo(oldResolution, newResolution) {
   return oldResolution === newResolution || oldResolution.resolvedModule === newResolution.resolvedModule || !!oldResolution.resolvedModule && !!newResolution.resolvedModule && oldResolution.resolvedModule.isExternalLibraryImport === newResolution.resolvedModule.isExternalLibraryImport && oldResolution.resolvedModule.extension === newResolution.resolvedModule.extension && oldResolution.resolvedModule.resolvedFileName === newResolution.resolvedModule.resolvedFileName && oldResolution.resolvedModule.originalPath === newResolution.resolvedModule.originalPath && packageIdIsEqual(oldResolution.resolvedModule.packageId, newResolution.resolvedModule.packageId) && oldResolution.alternateResult === newResolution.alternateResult;
 }
+function getResolvedModuleFromResolution(resolution) {
+  return resolution.resolvedModule;
+}
+function getResolvedTypeReferenceDirectiveFromResolution(resolution) {
+  return resolution.resolvedTypeReferenceDirective;
+}
 function createModuleNotFoundChain(sourceFile, host, moduleReference, mode, packageName) {
   var _a;
   const alternateResult = (_a = host.getResolvedModule(sourceFile, moduleReference, mode)) == null ? void 0 : _a.alternateResult;
@@ -86894,6 +86901,7 @@ function createTypeChecker(host) {
                 }
               case 7 /* ES2022 */:
               case 99 /* ESNext */:
+              case 200 /* Preserve */:
               case 4 /* System */:
                 if (languageVersion >= 4 /* ES2017 */) {
                   break;
@@ -119674,12 +119682,18 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
   }
   function resolveModuleNamesWorker(moduleNames, containingFile, reusedNames) {
     var _a2, _b2;
-    if (!moduleNames.length) return emptyArray;
     const containingFileName = getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory);
     const redirectedReference = getRedirectReferenceForResolution(containingFile);
     (_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Program, "resolveModuleNamesWorker", { containingFileName });
     mark("beforeResolveModule");
-    const result = actualResolveModuleNamesWorker(moduleNames, containingFileName, redirectedReference, options, containingFile, reusedNames);
+    const result = actualResolveModuleNamesWorker(
+      moduleNames,
+      containingFileName,
+      redirectedReference,
+      options,
+      containingFile,
+      reusedNames
+    );
     mark("afterResolveModule");
     measure("ResolveModule", "beforeResolveModule", "afterResolveModule");
     (_b2 = tracing) == null ? void 0 : _b2.pop();
@@ -119687,13 +119701,19 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
   }
   function resolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFile, reusedNames) {
     var _a2, _b2;
-    if (!typeDirectiveNames.length) return [];
     const containingSourceFile = !isString(containingFile) ? containingFile : void 0;
     const containingFileName = !isString(containingFile) ? getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory) : containingFile;
     const redirectedReference = containingSourceFile && getRedirectReferenceForResolution(containingSourceFile);
     (_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Program, "resolveTypeReferenceDirectiveNamesWorker", { containingFileName });
     mark("beforeResolveTypeReference");
-    const result = actualResolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFileName, redirectedReference, options, containingSourceFile, reusedNames);
+    const result = actualResolveTypeReferenceDirectiveNamesWorker(
+      typeDirectiveNames,
+      containingFileName,
+      redirectedReference,
+      options,
+      containingSourceFile,
+      reusedNames
+    );
     mark("afterResolveTypeReference");
     measure("ResolveTypeReference", "beforeResolveTypeReference", "afterResolveTypeReference");
     (_b2 = tracing) == null ? void 0 : _b2.pop();
@@ -119763,144 +119783,123 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     }
     return classifiableNames;
   }
-  function resolveModuleNamesReusingOldState(moduleNames, file) {
-    if (structureIsReused === 0 /* Not */ && !file.ambientModuleNames.length) {
-      return resolveModuleNamesWorker(
-        moduleNames,
-        file,
-        /*reusedNames*/
-        void 0
-      );
-    }
-    let unknownModuleNames;
-    let result;
-    let reusedNames;
-    const predictedToResolveToAmbientModuleMarker = emptyResolution;
-    const oldSourceFile = oldProgram && oldProgram.getSourceFile(file.fileName);
-    for (let i = 0; i < moduleNames.length; i++) {
-      const moduleName = moduleNames[i];
-      if (file === oldSourceFile && !hasInvalidatedResolutions(file.path)) {
-        const oldResolution = oldProgram == null ? void 0 : oldProgram.getResolvedModule(file, moduleName.text, getModeForUsageLocation2(file, moduleName));
-        if (oldResolution == null ? void 0 : oldResolution.resolvedModule) {
-          if (isTraceEnabled(options, host)) {
-            trace(
-              host,
-              oldResolution.resolvedModule.packageId ? Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2,
-              moduleName.text,
-              getNormalizedAbsolutePath(file.originalFileName, currentDirectory),
-              oldResolution.resolvedModule.resolvedFileName,
-              oldResolution.resolvedModule.packageId && packageIdToString(oldResolution.resolvedModule.packageId)
-            );
-          }
-          (result ?? (result = new Array(moduleNames.length)))[i] = oldResolution;
-          (reusedNames ?? (reusedNames = [])).push(moduleName);
-          continue;
-        }
-      }
-      let resolvesToAmbientModuleInNonModifiedFile = false;
-      if (contains(file.ambientModuleNames, moduleName.text)) {
-        resolvesToAmbientModuleInNonModifiedFile = true;
-        if (isTraceEnabled(options, host)) {
-          trace(host, Diagnostics.Module_0_was_resolved_as_locally_declared_ambient_module_in_file_1, moduleName.text, getNormalizedAbsolutePath(file.originalFileName, currentDirectory));
-        }
-      } else {
-        resolvesToAmbientModuleInNonModifiedFile = moduleNameResolvesToAmbientModuleInNonModifiedFile(moduleName);
-      }
-      if (resolvesToAmbientModuleInNonModifiedFile) {
-        (result || (result = new Array(moduleNames.length)))[i] = predictedToResolveToAmbientModuleMarker;
-      } else {
-        (unknownModuleNames ?? (unknownModuleNames = [])).push(moduleName);
+  function resolveModuleNamesReusingOldState(moduleNames, containingFile) {
+    return resolveNamesReusingOldState({
+      entries: moduleNames,
+      containingFile,
+      containingSourceFile: containingFile,
+      redirectedReference: getRedirectReferenceForResolution(containingFile),
+      nameAndModeGetter: moduleResolutionNameAndModeGetter,
+      resolutionWorker: resolveModuleNamesWorker,
+      getResolutionFromOldProgram: (name, mode) => oldProgram == null ? void 0 : oldProgram.getResolvedModule(containingFile, name, mode),
+      getResolved: getResolvedModuleFromResolution,
+      canReuseResolutionsInFile: () => containingFile === (oldProgram == null ? void 0 : oldProgram.getSourceFile(containingFile.fileName)) && !hasInvalidatedResolutions(containingFile.path),
+      isEntryResolvingToAmbientModule: moduleNameResolvesToAmbientModule
+    });
+  }
+  function moduleNameResolvesToAmbientModule(moduleName, file) {
+    if (contains(file.ambientModuleNames, moduleName.text)) {
+      if (isTraceEnabled(options, host)) {
+        trace(host, Diagnostics.Module_0_was_resolved_as_locally_declared_ambient_module_in_file_1, moduleName.text, getNormalizedAbsolutePath(file.originalFileName, currentDirectory));
       }
+      return true;
+    } else {
+      return moduleNameResolvesToAmbientModuleInNonModifiedFile(moduleName, file);
     }
-    const resolutions = unknownModuleNames && unknownModuleNames.length ? resolveModuleNamesWorker(unknownModuleNames, file, reusedNames) : emptyArray;
-    if (!result) {
-      Debug.assert(resolutions.length === moduleNames.length);
-      return resolutions;
+  }
+  function moduleNameResolvesToAmbientModuleInNonModifiedFile(moduleName, file) {
+    var _a2;
+    const resolutionToFile = (_a2 = oldProgram == null ? void 0 : oldProgram.getResolvedModule(file, moduleName.text, getModeForUsageLocation2(file, moduleName))) == null ? void 0 : _a2.resolvedModule;
+    const resolvedFile = resolutionToFile && oldProgram.getSourceFile(resolutionToFile.resolvedFileName);
+    if (resolutionToFile && resolvedFile) {
+      return false;
     }
-    let j = 0;
-    for (let i = 0; i < result.length; i++) {
-      if (!result[i]) {
-        result[i] = resolutions[j];
-        j++;
-      }
+    const unmodifiedFile = ambientModuleNameToUnmodifiedFileName.get(moduleName.text);
+    if (!unmodifiedFile) {
+      return false;
     }
-    Debug.assert(j === resolutions.length);
-    return result;
-    function moduleNameResolvesToAmbientModuleInNonModifiedFile(moduleName) {
-      var _a2;
-      const resolutionToFile = (_a2 = oldProgram == null ? void 0 : oldProgram.getResolvedModule(file, moduleName.text, getModeForUsageLocation2(file, moduleName))) == null ? void 0 : _a2.resolvedModule;
-      const resolvedFile = resolutionToFile && oldProgram.getSourceFile(resolutionToFile.resolvedFileName);
-      if (resolutionToFile && resolvedFile) {
-        return false;
-      }
-      const unmodifiedFile = ambientModuleNameToUnmodifiedFileName.get(moduleName.text);
-      if (!unmodifiedFile) {
-        return false;
-      }
-      if (isTraceEnabled(options, host)) {
-        trace(host, Diagnostics.Module_0_was_resolved_as_ambient_module_declared_in_1_since_this_file_was_not_modified, moduleName.text, unmodifiedFile);
-      }
-      return true;
+    if (isTraceEnabled(options, host)) {
+      trace(host, Diagnostics.Module_0_was_resolved_as_ambient_module_declared_in_1_since_this_file_was_not_modified, moduleName.text, unmodifiedFile);
     }
+    return true;
   }
   function resolveTypeReferenceDirectiveNamesReusingOldState(typeDirectiveNames, containingFile) {
-    var _a2;
-    if (structureIsReused === 0 /* Not */) {
-      return resolveTypeReferenceDirectiveNamesWorker(
-        typeDirectiveNames,
+    const containingSourceFile = !isString(containingFile) ? containingFile : void 0;
+    return resolveNamesReusingOldState({
+      entries: typeDirectiveNames,
+      containingFile,
+      containingSourceFile,
+      redirectedReference: containingSourceFile && getRedirectReferenceForResolution(containingSourceFile),
+      nameAndModeGetter: typeReferenceResolutionNameAndModeGetter,
+      resolutionWorker: resolveTypeReferenceDirectiveNamesWorker,
+      getResolutionFromOldProgram: (name, mode) => {
+        var _a2;
+        return containingSourceFile ? oldProgram == null ? void 0 : oldProgram.getResolvedTypeReferenceDirective(containingSourceFile, name, mode) : (_a2 = oldProgram == null ? void 0 : oldProgram.getAutomaticTypeDirectiveResolutions()) == null ? void 0 : _a2.get(name, mode);
+      },
+      getResolved: getResolvedTypeReferenceDirectiveFromResolution,
+      canReuseResolutionsInFile: () => containingSourceFile ? containingSourceFile === (oldProgram == null ? void 0 : oldProgram.getSourceFile(containingSourceFile.fileName)) && !hasInvalidatedResolutions(containingSourceFile.path) : !hasInvalidatedResolutions(toPath3(containingFile))
+    });
+  }
+  function resolveNamesReusingOldState({
+    entries,
+    containingFile,
+    containingSourceFile,
+    redirectedReference,
+    nameAndModeGetter,
+    resolutionWorker,
+    getResolutionFromOldProgram,
+    getResolved,
+    canReuseResolutionsInFile,
+    isEntryResolvingToAmbientModule
+  }) {
+    if (!entries.length) return emptyArray;
+    if (structureIsReused === 0 /* Not */ && (!isEntryResolvingToAmbientModule || !containingSourceFile.ambientModuleNames.length)) {
+      return resolutionWorker(
+        entries,
         containingFile,
         /*reusedNames*/
         void 0
       );
     }
-    let unknownTypeReferenceDirectiveNames;
+    let unknownEntries;
+    let unknownEntryIndices;
     let result;
     let reusedNames;
-    const containingSourceFile = !isString(containingFile) ? containingFile : void 0;
-    const oldSourceFile = !isString(containingFile) ? oldProgram && oldProgram.getSourceFile(containingFile.fileName) : void 0;
-    const canReuseResolutions = !isString(containingFile) ? containingFile === oldSourceFile && !hasInvalidatedResolutions(containingFile.path) : !hasInvalidatedResolutions(toPath3(containingFile));
-    for (let i = 0; i < typeDirectiveNames.length; i++) {
-      const entry = typeDirectiveNames[i];
-      if (canReuseResolutions) {
-        const typeDirectiveName = getTypeReferenceResolutionName(entry);
-        const mode = getModeForFileReference(entry, containingSourceFile == null ? void 0 : containingSourceFile.impliedNodeFormat);
-        const oldResolution = !isString(containingFile) ? oldProgram == null ? void 0 : oldProgram.getResolvedTypeReferenceDirective(containingFile, typeDirectiveName, mode) : (_a2 = oldProgram == null ? void 0 : oldProgram.getAutomaticTypeDirectiveResolutions()) == null ? void 0 : _a2.get(typeDirectiveName, mode);
-        if (oldResolution == null ? void 0 : oldResolution.resolvedTypeReferenceDirective) {
+    const reuseResolutions = canReuseResolutionsInFile();
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      if (reuseResolutions) {
+        const name = nameAndModeGetter.getName(entry);
+        const mode = nameAndModeGetter.getMode(entry, containingSourceFile, (redirectedReference == null ? void 0 : redirectedReference.commandLine.options) ?? options);
+        const oldResolution = getResolutionFromOldProgram(name, mode);
+        const oldResolved = oldResolution && getResolved(oldResolution);
+        if (oldResolved) {
           if (isTraceEnabled(options, host)) {
             trace(
               host,
-              oldResolution.resolvedTypeReferenceDirective.packageId ? Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2,
-              typeDirectiveName,
-              !isString(containingFile) ? getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory) : containingFile,
-              oldResolution.resolvedTypeReferenceDirective.resolvedFileName,
-              oldResolution.resolvedTypeReferenceDirective.packageId && packageIdToString(oldResolution.resolvedTypeReferenceDirective.packageId)
+              resolutionWorker === resolveModuleNamesWorker ? oldResolved.packageId ? Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2 : oldResolved.packageId ? Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2,
+              name,
+              containingSourceFile ? getNormalizedAbsolutePath(containingSourceFile.originalFileName, currentDirectory) : containingFile,
+              oldResolved.resolvedFileName,
+              oldResolved.packageId && packageIdToString(oldResolved.packageId)
             );
           }
-          (result ?? (result = new Array(typeDirectiveNames.length)))[i] = oldResolution;
+          (result ?? (result = new Array(entries.length)))[i] = oldResolution;
           (reusedNames ?? (reusedNames = [])).push(entry);
           continue;
         }
       }
-      (unknownTypeReferenceDirectiveNames ?? (unknownTypeReferenceDirectiveNames = [])).push(entry);
-    }
-    if (!unknownTypeReferenceDirectiveNames) return result || emptyArray;
-    const resolutions = resolveTypeReferenceDirectiveNamesWorker(
-      unknownTypeReferenceDirectiveNames,
-      containingFile,
-      reusedNames
-    );
-    if (!result) {
-      Debug.assert(resolutions.length === typeDirectiveNames.length);
-      return resolutions;
-    }
-    let j = 0;
-    for (let i = 0; i < result.length; i++) {
-      if (!result[i]) {
-        result[i] = resolutions[j];
-        j++;
+      if (isEntryResolvingToAmbientModule == null ? void 0 : isEntryResolvingToAmbientModule(entry, containingFile)) {
+        (result ?? (result = new Array(entries.length)))[i] = emptyResolution;
+      } else {
+        (unknownEntries ?? (unknownEntries = [])).push(entry);
+        (unknownEntryIndices ?? (unknownEntryIndices = [])).push(i);
       }
     }
-    Debug.assert(j === resolutions.length);
+    if (!unknownEntries) return result;
+    const resolutions = resolutionWorker(unknownEntries, containingFile, reusedNames);
+    if (!result) return resolutions;
+    resolutions.forEach((resolution, index) => result[unknownEntryIndices[index]] = resolution);
     return result;
   }
   function canReuseProjectReferences() {
@@ -124308,7 +124307,7 @@ function canWatchAffectedPackageJsonOrNodeModulesOfAtTypes(fileOrDirPath) {
 function canWatchAffectingLocation(filePath) {
   return canWatchAffectedPackageJsonOrNodeModulesOfAtTypes(filePath);
 }
-function getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLookupLocationPath, rootDir, rootPath, rootPathComponents, getCurrentDirectory) {
+function getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLookupLocationPath, rootDir, rootPath, rootPathComponents, getCurrentDirectory, preferNonRecursiveWatch) {
   const failedLookupPathComponents = getPathComponents(failedLookupLocationPath);
   failedLookupLocation = isRootedDiskPath(failedLookupLocation) ? normalizePath(failedLookupLocation) : getNormalizedAbsolutePath(failedLookupLocation, getCurrentDirectory());
   const failedLookupComponents = getPathComponents(failedLookupLocation);
@@ -124340,10 +124339,11 @@ function getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLoo
     perceivedOsRootLength,
     nodeModulesIndex,
     rootPathComponents,
-    lastNodeModulesIndex
+    lastNodeModulesIndex,
+    preferNonRecursiveWatch
   );
 }
-function getDirectoryToWatchFromFailedLookupLocationDirectory(dirComponents, dirPathComponents, dirPathComponentsLength, perceivedOsRootLength, nodeModulesIndex, rootPathComponents, lastNodeModulesIndex) {
+function getDirectoryToWatchFromFailedLookupLocationDirectory(dirComponents, dirPathComponents, dirPathComponentsLength, perceivedOsRootLength, nodeModulesIndex, rootPathComponents, lastNodeModulesIndex, preferNonRecursiveWatch) {
   if (nodeModulesIndex !== -1) {
     return getDirectoryOfFailedLookupWatch(
       dirComponents,
@@ -124354,11 +124354,13 @@ function getDirectoryToWatchFromFailedLookupLocationDirectory(dirComponents, dir
   }
   let nonRecursive = true;
   let length2 = dirPathComponentsLength;
-  for (let i = 0; i < dirPathComponentsLength; i++) {
-    if (dirPathComponents[i] !== rootPathComponents[i]) {
-      nonRecursive = false;
-      length2 = Math.max(i + 1, perceivedOsRootLength + 1);
-      break;
+  if (!preferNonRecursiveWatch) {
+    for (let i = 0; i < dirPathComponentsLength; i++) {
+      if (dirPathComponents[i] !== rootPathComponents[i]) {
+        nonRecursive = false;
+        length2 = Math.max(i + 1, perceivedOsRootLength + 1);
+        break;
+      }
     }
   }
   return getDirectoryOfFailedLookupWatch(
@@ -124386,7 +124388,7 @@ function getDirectoryOfFailedLookupWatch(dirComponents, dirPathComponents, lengt
     packageDirPath: packageDirLength !== void 0 ? getPathFromPathComponents(dirPathComponents, packageDirLength) : void 0
   };
 }
-function getDirectoryToWatchFailedLookupLocationFromTypeRoot(typeRoot, typeRootPath, rootPath, rootPathComponents, getCurrentDirectory, filterCustomPath) {
+function getDirectoryToWatchFailedLookupLocationFromTypeRoot(typeRoot, typeRootPath, rootPath, rootPathComponents, getCurrentDirectory, preferNonRecursiveWatch, filterCustomPath) {
   const typeRootPathComponents = getPathComponents(typeRootPath);
   if (isInDirectoryPath(rootPathComponents, typeRootPathComponents)) {
     return rootPath;
@@ -124399,7 +124401,8 @@ function getDirectoryToWatchFailedLookupLocationFromTypeRoot(typeRoot, typeRootP
     perceivedOsRootLengthForWatching(typeRootPathComponents, typeRootPathComponents.length),
     typeRootPathComponents.indexOf("node_modules"),
     rootPathComponents,
-    typeRootPathComponents.lastIndexOf("node_modules")
+    typeRootPathComponents.lastIndexOf("node_modules"),
+    preferNonRecursiveWatch
   );
   return toWatch && filterCustomPath(toWatch.dirPath) ? toWatch.dirPath : void 0;
 }
@@ -124536,12 +124539,6 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
     clear: clear2,
     onChangesAffectModuleResolution
   };
-  function getResolvedModule(resolution) {
-    return resolution.resolvedModule;
-  }
-  function getResolvedTypeReferenceDirective(resolution) {
-    return resolution.resolvedTypeReferenceDirective;
-  }
   function clear2() {
     clearMap(directoryWatchesOfFailedLookups, closeFileWatcherOf);
     clearMap(fileWatchesOfAffectingLocations, closeFileWatcherOf);
@@ -124623,7 +124620,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
         stopWatchFailedLookupLocationOfResolution(
           resolution,
           resolutionHost.toPath(getInferredLibraryNameResolveFrom(resolutionHost.getCompilationSettings(), getCurrentDirectory(), libFileName)),
-          getResolvedModule
+          getResolvedModuleFromResolution
         );
         resolvedLibraries.delete(libFileName);
       }
@@ -124803,7 +124800,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
         getModuleResolutionHost(resolutionHost),
         typeReferenceDirectiveResolutionCache
       ),
-      getResolutionWithResolvedFileName: getResolvedTypeReferenceDirective,
+      getResolutionWithResolvedFileName: getResolvedTypeReferenceDirectiveFromResolution,
       shouldRetryResolution: (resolution) => resolution.resolvedTypeReferenceDirective === void 0,
       deferWatchingNonRelativeResolution: false
     });
@@ -124824,7 +124821,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
         resolutionHost,
         moduleResolutionCache
       ),
-      getResolutionWithResolvedFileName: getResolvedModule,
+      getResolutionWithResolvedFileName: getResolvedModuleFromResolution,
       shouldRetryResolution: (resolution) => !resolution.resolvedModule || !resolutionExtensionIsTSOrJson(resolution.resolvedModule.extension),
       logChanges: logChangesWhenResolvingModule,
       deferWatchingNonRelativeResolution: true
@@ -124842,17 +124839,17 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
         libraryName,
         resolution,
         path,
-        getResolvedModule,
+        getResolvedModuleFromResolution,
         /*deferWatchingNonRelativeResolution*/
         false
       );
       resolvedLibraries.set(libFileName, resolution);
       if (existingResolution) {
-        stopWatchFailedLookupLocationOfResolution(existingResolution, path, getResolvedModule);
+        stopWatchFailedLookupLocationOfResolution(existingResolution, path, getResolvedModuleFromResolution);
       }
     } else {
       if (isTraceEnabled(options, host)) {
-        const resolved = getResolvedModule(resolution);
+        const resolved = getResolvedModuleFromResolution(resolution);
         trace(
           host,
           (resolved == null ? void 0 : resolved.resolvedFileName) ? resolved.packageId ? Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2 : Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_not_resolved,
@@ -124891,27 +124888,20 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
     return endsWith(dirPath, "/node_modules/@types");
   }
   function watchFailedLookupLocationsOfExternalModuleResolutions(name, resolution, filePath, getResolutionWithResolvedFileName, deferWatchingNonRelativeResolution) {
-    var _a;
-    if (resolution.refCount) {
-      resolution.refCount++;
-      Debug.assertIsDefined(resolution.files);
+    (resolution.files ?? (resolution.files = /* @__PURE__ */ new Set())).add(filePath);
+    if (resolution.files.size !== 1) return;
+    if (!deferWatchingNonRelativeResolution || isExternalModuleNameRelative(name)) {
+      watchFailedLookupLocationOfResolution(resolution);
     } else {
-      resolution.refCount = 1;
-      Debug.assert(!((_a = resolution.files) == null ? void 0 : _a.size));
-      if (!deferWatchingNonRelativeResolution || isExternalModuleNameRelative(name)) {
-        watchFailedLookupLocationOfResolution(resolution);
-      } else {
-        nonRelativeExternalModuleResolutions.add(name, resolution);
-      }
-      const resolved = getResolutionWithResolvedFileName(resolution);
-      if (resolved && resolved.resolvedFileName) {
-        const key = resolutionHost.toPath(resolved.resolvedFileName);
-        let resolutions = resolvedFileToResolution.get(key);
-        if (!resolutions) resolvedFileToResolution.set(key, resolutions = /* @__PURE__ */ new Set());
-        resolutions.add(resolution);
-      }
+      nonRelativeExternalModuleResolutions.add(name, resolution);
+    }
+    const resolved = getResolutionWithResolvedFileName(resolution);
+    if (resolved && resolved.resolvedFileName) {
+      const key = resolutionHost.toPath(resolved.resolvedFileName);
+      let resolutions = resolvedFileToResolution.get(key);
+      if (!resolutions) resolvedFileToResolution.set(key, resolutions = /* @__PURE__ */ new Set());
+      resolutions.add(resolution);
     }
-    (resolution.files ?? (resolution.files = /* @__PURE__ */ new Set())).add(filePath);
   }
   function watchFailedLookupLocation(failedLookupLocation, setAtRoot) {
     const failedLookupLocationPath = resolutionHost.toPath(failedLookupLocation);
@@ -124921,7 +124911,8 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
       rootDir,
       rootPath,
       rootPathComponents,
-      getCurrentDirectory
+      getCurrentDirectory,
+      resolutionHost.preferNonRecursiveWatch
     );
     if (toWatch) {
       const { dir, dirPath, nonRecursive, packageDir, packageDirPath } = toWatch;
@@ -124936,7 +124927,8 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
     return setAtRoot;
   }
   function watchFailedLookupLocationOfResolution(resolution) {
-    Debug.assert(!!resolution.refCount);
+    var _a;
+    Debug.assert(!!((_a = resolution.files) == null ? void 0 : _a.size));
     const { failedLookupLocations, affectingLocations, alternateResult } = resolution;
     if (!(failedLookupLocations == null ? void 0 : failedLookupLocations.length) && !(affectingLocations == null ? void 0 : affectingLocations.length) && !alternateResult) return;
     if ((failedLookupLocations == null ? void 0 : failedLookupLocations.length) || alternateResult) resolutionsWithFailedLookups.add(resolution);
@@ -124962,7 +124954,8 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
     watchAffectingLocationsOfResolution(resolution, !(failedLookupLocations == null ? void 0 : failedLookupLocations.length) && !alternateResult);
   }
   function watchAffectingLocationsOfResolution(resolution, addToResolutionsWithOnlyAffectingLocations) {
-    Debug.assert(!!resolution.refCount);
+    var _a;
+    Debug.assert(!!((_a = resolution.files) == null ? void 0 : _a.size));
     const { affectingLocations } = resolution;
     if (!(affectingLocations == null ? void 0 : affectingLocations.length)) return;
     if (addToResolutionsWithOnlyAffectingLocations) resolutionsWithOnlyAffectingLocations.add(resolution);
@@ -125118,7 +125111,8 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
       rootDir,
       rootPath,
       rootPathComponents,
-      getCurrentDirectory
+      getCurrentDirectory,
+      resolutionHost.preferNonRecursiveWatch
     );
     if (toWatch) {
       const { dirPath, packageDirPath } = toWatch;
@@ -125149,10 +125143,8 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
   }
   function stopWatchFailedLookupLocationOfResolution(resolution, filePath, getResolutionWithResolvedFileName, syncDirWatcherRemove) {
     Debug.checkDefined(resolution.files).delete(filePath);
-    resolution.refCount--;
-    if (resolution.refCount) {
-      return;
-    }
+    if (resolution.files.size) return;
+    resolution.files = void 0;
     const resolved = getResolutionWithResolvedFileName(resolution);
     if (resolved && resolved.resolvedFileName) {
       const key = resolutionHost.toPath(resolved.resolvedFileName);
@@ -125217,8 +125209,8 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
     resolvedProjectReference.commandLine.fileNames.forEach((f) => removeResolutionsOfFile(resolutionHost.toPath(f)));
   }
   function removeResolutionsOfFile(filePath, syncDirWatcherRemove) {
-    removeResolutionsOfFileFromCache(resolvedModuleNames, filePath, getResolvedModule, syncDirWatcherRemove);
-    removeResolutionsOfFileFromCache(resolvedTypeReferenceDirectives, filePath, getResolvedTypeReferenceDirective, syncDirWatcherRemove);
+    removeResolutionsOfFileFromCache(resolvedModuleNames, filePath, getResolvedModuleFromResolution, syncDirWatcherRemove);
+    removeResolutionsOfFileFromCache(resolvedTypeReferenceDirectives, filePath, getResolvedTypeReferenceDirectiveFromResolution, syncDirWatcherRemove);
   }
   function invalidateResolutions(resolutions, canInvalidate) {
     if (!resolutions) return false;
@@ -125348,6 +125340,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
         rootPath,
         rootPathComponents,
         getCurrentDirectory,
+        resolutionHost.preferNonRecursiveWatch,
         (dirPath2) => directoryWatchesOfFailedLookups.has(dirPath2) || dirPathToSymlinkPackageRefCount.has(dirPath2)
       );
       if (dirPath) {
@@ -125816,7 +125809,8 @@ function createWatchHost(system = sys, reportWatchStatus2) {
     watchFile: maybeBind(system, system.watchFile) || returnNoopFileWatcher,
     watchDirectory: maybeBind(system, system.watchDirectory) || returnNoopFileWatcher,
     setTimeout: maybeBind(system, system.setTimeout) || noop,
-    clearTimeout: maybeBind(system, system.clearTimeout) || noop
+    clearTimeout: maybeBind(system, system.clearTimeout) || noop,
+    preferNonRecursiveWatch: system.preferNonRecursiveWatch
   };
 }
 var WatchType = {
@@ -126122,6 +126116,7 @@ function createWatchProgram(host) {
   compilerHost.toPath = toPath3;
   compilerHost.getCompilationSettings = () => compilerOptions;
   compilerHost.useSourceOfProjectReferenceRedirect = maybeBind(host, host.useSourceOfProjectReferenceRedirect);
+  compilerHost.preferNonRecursiveWatch = host.preferNonRecursiveWatch;
   compilerHost.watchDirectoryOfFailedLookupLocation = (dir, cb, flags) => watchDirectory(dir, cb, flags, watchOptions, WatchType.FailedLookupLocations);
   compilerHost.watchAffectingFileLocation = (file, cb) => watchFile2(file, cb, 2e3 /* High */, watchOptions, WatchType.AffectingFileLocation);
   compilerHost.watchTypeRootsDirectory = (dir, cb, flags) => watchDirectory(dir, cb, flags, watchOptions, WatchType.TypeRoots);

package/lib/typescript.d.ts

@@ -2651,6 +2651,7 @@ declare namespace ts {
         interface ServerHost extends System {
             watchFile(path: string, callback: FileWatcherCallback, pollingInterval?: number, options?: WatchOptions): FileWatcher;
             watchDirectory(path: string, callback: DirectoryWatcherCallback, recursive?: boolean, options?: WatchOptions): FileWatcher;
+            preferNonRecursiveWatch?: boolean;
             setTimeout(callback: (...args: any[]) => void, ms: number, ...args: any[]): any;
             clearTimeout(timeoutId: any): void;
             setImmediate(callback: (...args: any[]) => void, ...args: any[]): any;
@@ -2659,6 +2660,18 @@ declare namespace ts {
             trace?(s: string): void;
             require?(initialPath: string, moduleName: string): ModuleImportResult;
         }
+        interface InstallPackageOptionsWithProject extends InstallPackageOptions {
+            projectName: string;
+            projectRootPath: Path;
+        }
+        interface ITypingsInstaller {
+            isKnownTypesPackageName(name: string): boolean;
+            installPackage(options: InstallPackageOptionsWithProject): Promise<ApplyCodeActionCommandResult>;
+            enqueueInstallTypingsRequest(p: Project, typeAcquisition: TypeAcquisition, unresolvedImports: SortedReadonlyArray<string> | undefined): void;
+            attach(projectService: ProjectService): void;
+            onProjectClosed(p: Project): void;
+            readonly globalTypingsCacheLocation: string | undefined;
+        }
         function createInstallTypingsRequest(project: Project, typeAcquisition: TypeAcquisition, unresolvedImports: SortedReadonlyArray<string>, cachePath?: string): DiscoverTypings;
         function toNormalizedPath(fileName: string): NormalizedPath;
         function normalizedPathToPath(normalizedPath: NormalizedPath, currentDirectory: string, getCanonicalFileName: (f: string) => string): Path;
@@ -2751,19 +2764,6 @@ declare namespace ts {
             positionToLineOffset(position: number): protocol.Location;
             isJavaScript(): boolean;
         }
-        interface InstallPackageOptionsWithProject extends InstallPackageOptions {
-            projectName: string;
-            projectRootPath: Path;
-        }
-        interface ITypingsInstaller {
-            isKnownTypesPackageName(name: string): boolean;
-            installPackage(options: InstallPackageOptionsWithProject): Promise<ApplyCodeActionCommandResult>;
-            enqueueInstallTypingsRequest(p: Project, typeAcquisition: TypeAcquisition, unresolvedImports: SortedReadonlyArray<string> | undefined): void;
-            attach(projectService: ProjectService): void;
-            onProjectClosed(p: Project): void;
-            readonly globalTypingsCacheLocation: string | undefined;
-        }
-        const nullTypingsInstaller: ITypingsInstaller;
         function allRootFilesAreJsOrDts(project: Project): boolean;
         function allFilesAreJsOrDts(project: Project): boolean;
         enum ProjectKind {
@@ -2817,6 +2817,7 @@ declare namespace ts {
             private lastReportedVersion;
             protected projectErrors: Diagnostic[] | undefined;
             protected isInitialLoadPending: () => boolean;
+            private typingsCache;
             private typingWatchers;
             private readonly cancellationToken;
             isNonTsProject(): boolean;
@@ -2829,7 +2830,6 @@ declare namespace ts {
             readonly jsDocParsingMode: JSDocParsingMode | undefined;
             isKnownTypesPackageName(name: string): boolean;
             installPackage(options: InstallPackageOptions): Promise<ApplyCodeActionCommandResult>;
-            private get typingsCache();
             getCompilationSettings(): ts.CompilerOptions;
             getCompilerOptions(): ts.CompilerOptions;
             getNewLine(): string;
@@ -3148,6 +3148,7 @@ declare namespace ts {
             configFileName?: NormalizedPath;
             configFileErrors?: readonly Diagnostic[];
         }
+        const nullTypingsInstaller: ITypingsInstaller;
         interface ProjectServiceOptions {
             host: ServerHost;
             logger: Logger;
@@ -9591,6 +9592,7 @@ declare namespace ts {
         setTimeout?(callback: (...args: any[]) => void, ms: number, ...args: any[]): any;
         /** If provided, will be used to reset existing delayed compilation */
         clearTimeout?(timeoutId: any): void;
+        preferNonRecursiveWatch?: boolean;
     }
     interface ProgramHost<T extends BuilderProgram> {
         /**