@zzzen/pyright-internal 1.2.0-dev.20260222 → 1.2.0-dev.20260422

package/dist/analyzer/importResolver.js

@@ -43,15 +43,18 @@ const configOptions_1 = require("../common/configOptions");
 const pathConsts_1 = require("../common/pathConsts");
 const pathUtils_1 = require("../common/pathUtils");
 const pythonVersion_1 = require("../common/pythonVersion");
+const serviceKeys_1 = require("../common/serviceKeys");
 const StringUtils = __importStar(require("../common/stringUtils"));
 const stringUtils_1 = require("../common/stringUtils");
 const uri_1 = require("../common/uri/uri");
 const uriUtils_1 = require("../common/uri/uriUtils");
 const tokenizer_1 = require("../parser/tokenizer");
 const importLogger_1 = require("./importLogger");
+const importResolverFileSystem_1 = require("./importResolverFileSystem");
 const importStatementUtils_1 = require("./importStatementUtils");
 const parentDirectoryCache_1 = require("./parentDirectoryCache");
 const pyTypedUtils_1 = require("./pyTypedUtils");
+const typeshedInfoProvider_1 = require("./typeshedInfoProvider");
 const PythonPathUtils = __importStar(require("./pythonPathUtils"));
 const SymbolNameUtils = __importStar(require("./symbolNameUtils"));
 const symbolNameUtils_1 = require("./symbolNameUtils");
@@ -89,10 +92,16 @@ class ImportResolver {
         this.host = host;
         this._cachedImportResults = new Map();
         this._cachedModuleNameResults = new Map();
-        this._cachedEntriesForPath = new Map();
-        this._cachedFilesForPath = new Map();
-        this._cachedDirExistenceForRoot = new Map();
         this.cachedParentImportResults = new parentDirectoryCache_1.ParentDirectoryCache(() => this.getPythonSearchPaths());
+        // These are optionally provided via the ServiceProvider so callers/tests can share
+        // caching across ImportResolver/Typeshed operations and avoid re-walking the same
+        // filesystem paths when multiple resolvers are created.
+        this._fileSystemCache =
+            serviceProvider.tryGet(serviceKeys_1.ServiceKeys.importResolverFileSystem) ??
+                (0, importResolverFileSystem_1.createImportResolverFileSystem)(this.fileSystem);
+        this._typeshedInfoProvider =
+            serviceProvider.tryGet(serviceKeys_1.ServiceKeys.typeshedInfoProvider) ??
+                (0, typeshedInfoProvider_1.createDefaultTypeshedInfoProvider)(this._fileSystemCache);
     }
     get fileSystem() {
         return this.serviceProvider.fs();
@@ -338,10 +347,8 @@ class ImportResolver {
         if (!typeshedStdlibPath) {
             return excludes;
         }
-        if (!this._cachedTypeshedStdLibModuleVersionInfo) {
-            this._cachedTypeshedStdLibModuleVersionInfo = this._readTypeshedStdLibVersions(customTypeshedPath);
-        }
-        this._cachedTypeshedStdLibModuleVersionInfo.forEach((versionInfo, moduleName) => {
+        const versions = this._getTypeshedInfoProvider().getStdLibModuleVersionInfo(customTypeshedPath);
+        versions.forEach((versionInfo, moduleName) => {
             let shouldExcludeModule = false;
             if (versionInfo.max !== undefined && pythonVersion_1.PythonVersion.isGreaterThan(pythonVersion, versionInfo.max)) {
                 shouldExcludeModule = true;
@@ -378,42 +385,6 @@ class ImportResolver {
     getTypeshedPathEx(execEnv, importLogger) {
         return undefined;
     }
-    readdirEntriesCached(uri) {
-        const cachedValue = this._cachedEntriesForPath.get(uri.key);
-        if (cachedValue) {
-            return cachedValue;
-        }
-        const newCachedDir = {
-            entries: new Map(),
-            resolvableNames: new Set(),
-        };
-        try {
-            const entries = this.fileSystem.readdirEntriesSync(uri);
-            entries.forEach((entry) => {
-                newCachedDir.entries.set(entry.name, entry);
-                let isFile = entry.isFile();
-                let isDirectory = entry.isDirectory();
-                if (entry.isSymbolicLink()) {
-                    const stat = (0, uriUtils_1.tryStat)(this.fileSystem, uri.combinePaths(entry.name));
-                    isFile = !!stat?.isFile();
-                    isDirectory = !!stat?.isDirectory();
-                }
-                const resolvableName = isFile
-                    ? (0, pathUtils_1.stripFileExtension)(entry.name, /* multiDotExtension */ true)
-                    : entry.name;
-                newCachedDir.resolvableNames.add(resolvableName);
-                if (isDirectory && entry.name.endsWith(pathConsts_1.stubsSuffix)) {
-                    newCachedDir.resolvableNames.add(resolvableName.substring(0, resolvableName.length - pathConsts_1.stubsSuffix.length));
-                }
-            });
-        }
-        catch {
-            // Swallow error
-        }
-        // Populate cache.
-        this._cachedEntriesForPath.set(uri.key, newCachedDir);
-        return newCachedDir;
-    }
     // Resolves the import and returns the path if it exists, otherwise
     // returns undefined.
     resolveImportInternal(sourceFileUri, execEnv, moduleDescriptor) {
@@ -437,7 +408,6 @@ class ImportResolver {
             return importResult;
         }
         const importLogger = this._configOptions.verboseOutput ? new importLogger_1.ImportLogger() : undefined;
-        importLogger?.log(`Attempting to resolve using local imports: ${importName}`);
         const importPath = { importPath: undefined };
         // Going up the given folder one by one until we can resolve the import.
         let current = origin;
@@ -470,50 +440,10 @@ class ImportResolver {
         return importResult;
     }
     fileExistsCached(uri) {
-        const directory = uri.getDirectory();
-        if (directory.equals(uri)) {
-            // Started at root, so this can't be a file.
-            return false;
-        }
-        const cachedDir = this.readdirEntriesCached(directory);
-        const entry = cachedDir.entries.get(uri.fileName);
-        if (entry?.isFile()) {
-            return true;
-        }
-        if (entry?.isSymbolicLink()) {
-            const realPath = (0, uriUtils_1.tryRealpath)(this.fileSystem, uri);
-            if (realPath && this.fileSystem.existsSync(realPath) && (0, uriUtils_1.isFile)(this.fileSystem, realPath)) {
-                return true;
-            }
-        }
-        return false;
+        return this._fileSystemCache.fileExists(uri);
     }
     dirExistsCached(uri) {
-        const parent = uri.getDirectory();
-        if (parent.equals(uri)) {
-            // Started at root. No entries to read, so have to check ourselves.
-            let cachedExistence = this._cachedDirExistenceForRoot.get(uri.key);
-            // Check if the value was in the cache or not. Undefined means it wasn't.
-            if (cachedExistence === undefined) {
-                cachedExistence = (0, uriUtils_1.tryStat)(this.fileSystem, uri)?.isDirectory() ?? false;
-                this._cachedDirExistenceForRoot.set(uri.key, cachedExistence);
-            }
-            return cachedExistence;
-        }
-        // Otherwise not a root, so read the entries we have cached to see if
-        // the directory exists or not.
-        const cachedDir = this.readdirEntriesCached(parent);
-        const entry = cachedDir.entries.get(uri.fileName);
-        if (entry?.isDirectory()) {
-            return true;
-        }
-        if (entry?.isSymbolicLink()) {
-            const realPath = (0, uriUtils_1.tryRealpath)(this.fileSystem, uri);
-            if (realPath && this.fileSystem.existsSync(realPath) && (0, uriUtils_1.isDirectory)(this.fileSystem, realPath)) {
-                return true;
-            }
-        }
-        return false;
+        return this._fileSystemCache.dirExists(uri);
     }
     addResultsToCache(sourceFileUri, execEnv, importName, importResult, moduleDescriptor, fromUserFile) {
         // If the import is relative, include the source file path in the key.
@@ -599,7 +529,7 @@ class ImportResolver {
     findImplicitImports(importingModuleName, dirPath, exclusions) {
         const implicitImportMap = new Map();
         // Enumerate all of the files and directories in the path, expanding links.
-        const entries = (0, uriUtils_1.getFileSystemEntriesFromDirEntries)(this.readdirEntriesCached(dirPath).entries.values(), this.fileSystem, dirPath);
+        const entries = (0, uriUtils_1.getFileSystemEntriesFromDirEntries)(this._fileSystemCache.readdirEntriesSync(dirPath), this.fileSystem, dirPath);
         // Add implicit file-based modules.
         for (const filePath of entries.files) {
             const fileExt = filePath.lastExtension;
@@ -670,9 +600,9 @@ class ImportResolver {
         return implicitImportMap.size > 0 ? implicitImportMap : undefined;
     }
     _isPossibleImportDir(rootPath, moduleDescriptor) {
-        const cachedDir = this.readdirEntriesCached(rootPath);
+        const resolvableNames = this._fileSystemCache.getResolvableNamesInDirectory(rootPath);
         const isPotentialMatch = (name) => {
-            return cachedDir.resolvableNames.has(name);
+            return resolvableNames.has(name);
         };
         if (moduleDescriptor.nameParts.length > 0) {
             return isPotentialMatch(moduleDescriptor.nameParts[0]);
@@ -942,9 +872,7 @@ class ImportResolver {
         };
     }
     _invalidateFileSystemCache() {
-        this._cachedEntriesForPath.clear();
-        this._cachedFilesForPath.clear();
-        this._cachedDirExistenceForRoot.clear();
+        this._fileSystemCache.invalidateCache();
     }
     _resolveAbsoluteImport(rootPath, execEnv, moduleDescriptor, importName, importLogger, allowPartial, allowNativeLib, useStubPackage, allowPyi, lookForPyTyped) {
         if (useStubPackage) {
@@ -1219,7 +1147,8 @@ class ImportResolver {
         // If a library is fully py.typed, then we have found the best match,
         // unless the execution environment is typeshed itself, in which case
         // we don't want to favor py.typed libraries. Use the typeshed lookup below.
-        if (execEnv.root !== this._getTypeshedRoot(this._configOptions.typeshedPath, importLogger)) {
+        if (execEnv.root !==
+            this._getTypeshedInfoProvider().getTypeshedRoot(this._configOptions.typeshedPath, importLogger)) {
             if (bestResultSoFar?.pyTypedInfo && !bestResultSoFar.isPartlyResolved) {
                 return bestResultSoFar;
             }
@@ -1372,7 +1301,7 @@ class ImportResolver {
         const cache = new Set();
         if (stdlibRoot) {
             const readDir = (root, prefix) => {
-                this.readdirEntriesCached(root).entries.forEach((entry) => {
+                this._fileSystemCache.readdirEntriesSync(root).forEach((entry) => {
                     if (entry.isDirectory()) {
                         const dirRoot = root.combinePaths(entry.name);
                         readDir(dirRoot, prefix ? `${prefix}.${entry.name}` : entry.name);
@@ -1397,46 +1326,9 @@ class ImportResolver {
     // the pypi-registered name of the package and an inner directory contains
     // the name of the package as it is referenced by import statements. These
     // don't always match.
-    _buildTypeshedThirdPartyPackageMap(thirdPartyDir) {
-        this._cachedTypeshedThirdPartyPackagePaths = new Map();
-        if (thirdPartyDir) {
-            this.readdirEntriesCached(thirdPartyDir).entries.forEach((outerEntry) => {
-                if (outerEntry.isDirectory()) {
-                    const innerDirPath = thirdPartyDir.combinePaths(outerEntry.name);
-                    this.readdirEntriesCached(innerDirPath).entries.forEach((innerEntry) => {
-                        if (innerEntry.name === '@python2') {
-                            return;
-                        }
-                        if (innerEntry.isDirectory()) {
-                            const pathList = this._cachedTypeshedThirdPartyPackagePaths.get(innerEntry.name);
-                            if (pathList) {
-                                pathList.push(innerDirPath);
-                            }
-                            else {
-                                this._cachedTypeshedThirdPartyPackagePaths.set(innerEntry.name, [innerDirPath]);
-                            }
-                        }
-                        else if (innerEntry.isFile()) {
-                            if (innerEntry.name.endsWith('.pyi')) {
-                                const strippedFileName = (0, pathUtils_1.stripFileExtension)(innerEntry.name);
-                                const pathList = this._cachedTypeshedThirdPartyPackagePaths.get(strippedFileName);
-                                if (pathList) {
-                                    pathList.push(innerDirPath);
-                                }
-                                else {
-                                    this._cachedTypeshedThirdPartyPackagePaths.set(strippedFileName, [innerDirPath]);
-                                }
-                            }
-                        }
-                    });
-                }
-            });
-        }
-        const flattenPaths = Array.from(this._cachedTypeshedThirdPartyPackagePaths.values()).flatMap((v) => v);
-        this._cachedTypeshedThirdPartyPackageRoots = Array.from(new Set(flattenPaths)).sort();
-    }
     _getCompletionSuggestionsTypeshedPath(sourceFileUri, execEnv, moduleDescriptor, isStdLib, suggestions) {
         let typeshedPaths;
+        let typeshedPathEx;
         if (isStdLib) {
             const path = this._getStdlibTypeshedPath(this._configOptions.typeshedPath, execEnv.pythonVersion, execEnv.pythonPlatform, 
             /* importLogger */ undefined, moduleDescriptor);
@@ -1448,16 +1340,12 @@ class ImportResolver {
             typeshedPaths = this._getThirdPartyTypeshedPackagePaths(moduleDescriptor, 
             /* importLogger */ undefined, 
             /* includeMatchOnly */ false);
-            const typeshedPathEx = this.getTypeshedPathEx(execEnv);
-            if (typeshedPathEx) {
-                typeshedPaths = typeshedPaths ?? [];
-                typeshedPaths.push(typeshedPathEx);
-            }
+            typeshedPathEx = this.getTypeshedPathEx(execEnv);
         }
-        if (!typeshedPaths) {
+        if (!typeshedPaths && !typeshedPathEx) {
             return;
         }
-        typeshedPaths.forEach((typeshedPath) => {
+        (typeshedPaths ?? []).concat(typeshedPathEx ?? []).forEach((typeshedPath) => {
             if (this.dirExistsCached(typeshedPath)) {
                 this._getCompletionSuggestionsAbsolute(sourceFileUri, execEnv, typeshedPath, moduleDescriptor, suggestions);
             }
@@ -1467,7 +1355,8 @@ class ImportResolver {
     // If moduleDescriptor is provided, it is filtered based on the VERSIONS
     // file in the typeshed stubs.
     _getStdlibTypeshedPath(customTypeshedPath, pythonVersion, pythonPlatform, importLogger, moduleDescriptor) {
-        const subdirectory = this._getTypeshedSubdirectory(/* isStdLib */ true, customTypeshedPath, importLogger);
+        const subdirectory = this._getTypeshedInfoProvider().getTypeshedSubdirectory(
+        /* isStdLib */ true, customTypeshedPath, importLogger);
         if (subdirectory &&
             moduleDescriptor &&
             !this._isStdlibTypeshedStubValidForVersion(moduleDescriptor, customTypeshedPath, pythonVersion, pythonPlatform, importLogger)) {
@@ -1476,17 +1365,16 @@ class ImportResolver {
         return subdirectory;
     }
     _getThirdPartyTypeshedPath(customTypeshedPath, importLogger) {
-        return this._getTypeshedSubdirectory(/* isStdLib */ false, customTypeshedPath, importLogger);
+        return this._getTypeshedInfoProvider().getTypeshedSubdirectory(
+        /* isStdLib */ false, customTypeshedPath, importLogger);
     }
     _isStdlibTypeshedStubValidForVersion(moduleDescriptor, customTypeshedPath, pythonVersion, pythonPlatform, importLogger) {
-        if (!this._cachedTypeshedStdLibModuleVersionInfo) {
-            this._cachedTypeshedStdLibModuleVersionInfo = this._readTypeshedStdLibVersions(customTypeshedPath, importLogger);
-        }
+        const versions = this._getTypeshedInfoProvider().getStdLibModuleVersionInfo(customTypeshedPath, importLogger);
         // Loop through the name parts to make sure the module and submodules
         // referenced in the import statement are valid for this version of Python.
         for (let namePartCount = 1; namePartCount <= moduleDescriptor.nameParts.length; namePartCount++) {
             const namePartsToConsider = moduleDescriptor.nameParts.slice(0, namePartCount);
-            const versionInfo = this._cachedTypeshedStdLibModuleVersionInfo.get(namePartsToConsider.join('.'));
+            const versionInfo = versions.get(namePartsToConsider.join('.'));
             if (versionInfo) {
                 if (pythonVersion_1.PythonVersion.isLessThan(pythonVersion, versionInfo.min)) {
                     return false;
@@ -1511,159 +1399,23 @@ class ImportResolver {
         }
         return true;
     }
-    _readTypeshedStdLibVersions(customTypeshedPath, importLogger) {
-        const versionRangeMap = new Map();
-        // Read the VERSIONS file from typeshed.
-        const typeshedStdLibPath = this._getTypeshedSubdirectory(/* isStdLib */ true, customTypeshedPath, importLogger);
-        if (typeshedStdLibPath) {
-            const versionsFilePath = typeshedStdLibPath.combinePaths('VERSIONS');
-            try {
-                const fileStats = this.fileSystem.statSync(versionsFilePath);
-                if (fileStats.size > 0 && fileStats.size < 256 * 1024) {
-                    const fileContents = this.fileSystem.readFileSync(versionsFilePath, 'utf8');
-                    fileContents.split(/\r?\n/).forEach((line) => {
-                        const commentSplit = line.split('#');
-                        // Platform-specific information can be specified after a semicolon.
-                        const semicolonSplit = commentSplit[0].split(';').map((s) => s.trim());
-                        // Version information is found after a colon.
-                        const colonSplit = semicolonSplit[0].split(':');
-                        if (colonSplit.length !== 2) {
-                            return;
-                        }
-                        const versionSplit = colonSplit[1].split('-');
-                        if (versionSplit.length > 2) {
-                            return;
-                        }
-                        const moduleName = colonSplit[0].trim();
-                        if (!moduleName) {
-                            return;
-                        }
-                        let minVersionString = versionSplit[0].trim();
-                        if (minVersionString.endsWith('+')) {
-                            // If the version ends in "+", strip it off.
-                            minVersionString = minVersionString.substr(0, minVersionString.length - 1);
-                        }
-                        let minVersion = pythonVersion_1.PythonVersion.fromString(minVersionString);
-                        if (!minVersion) {
-                            minVersion = pythonVersion_1.pythonVersion3_0;
-                        }
-                        let maxVersion;
-                        if (versionSplit.length > 1) {
-                            maxVersion = pythonVersion_1.PythonVersion.fromString(versionSplit[1].trim());
-                        }
-                        // A semicolon can be followed by a semicolon-delimited list of other
-                        // exclusions. The "platform" exclusion is a comma delimited list platforms
-                        // that are supported or not supported.
-                        let supportedPlatforms;
-                        let unsupportedPlatforms;
-                        const platformsHeader = 'platforms=';
-                        let platformExclusions = semicolonSplit.slice(1).find((s) => s.startsWith(platformsHeader));
-                        if (platformExclusions) {
-                            platformExclusions = platformExclusions.trim().substring(platformsHeader.length);
-                            const commaSplit = platformExclusions.split(',');
-                            for (let platform of commaSplit) {
-                                platform = platform.trim();
-                                let isUnsupported = false;
-                                // Remove the '!' from the start if it's an exclusion.
-                                if (platform.startsWith('!')) {
-                                    isUnsupported = true;
-                                    platform = platform.substring(1);
-                                }
-                                if (isUnsupported) {
-                                    unsupportedPlatforms = unsupportedPlatforms ?? [];
-                                    unsupportedPlatforms.push(platform);
-                                }
-                                else {
-                                    supportedPlatforms = supportedPlatforms ?? [];
-                                    supportedPlatforms.push(platform);
-                                }
-                            }
-                        }
-                        versionRangeMap.set(moduleName, {
-                            min: minVersion,
-                            max: maxVersion,
-                            supportedPlatforms,
-                            unsupportedPlatforms,
-                        });
-                    });
-                }
-                else {
-                    importLogger?.log(`Typeshed stdlib VERSIONS file is unexpectedly large`);
-                }
-            }
-            catch (e) {
-                importLogger?.log(`Could not read typeshed stdlib VERSIONS file: '${JSON.stringify(e)}'`);
-            }
-        }
-        return versionRangeMap;
-    }
     _getThirdPartyTypeshedPackagePaths(moduleDescriptor, importLogger, includeMatchOnly = true) {
-        const typeshedPath = this._getThirdPartyTypeshedPath(this._configOptions.typeshedPath, importLogger);
-        if (!this._cachedTypeshedThirdPartyPackagePaths) {
-            this._buildTypeshedThirdPartyPackageMap(typeshedPath);
-        }
+        const [packagePaths] = this._getTypeshedInfoProvider().getThirdPartyPackageMap(this._configOptions.typeshedPath, importLogger);
         const firstNamePart = moduleDescriptor.nameParts.length > 0 ? moduleDescriptor.nameParts[0] : '';
         if (includeMatchOnly) {
-            return this._cachedTypeshedThirdPartyPackagePaths.get(firstNamePart);
+            return packagePaths.get(firstNamePart);
         }
         if (firstNamePart) {
-            return (0, collectionUtils_1.flatten)((0, collectionUtils_1.getMapValues)(this._cachedTypeshedThirdPartyPackagePaths, (k) => k.startsWith(firstNamePart)));
+            return (0, collectionUtils_1.flatten)((0, collectionUtils_1.getMapValues)(packagePaths, (k) => k.startsWith(firstNamePart)));
         }
         return [];
     }
     _getThirdPartyTypeshedPackageRoots(importLogger) {
-        const typeshedPath = this._getThirdPartyTypeshedPath(this._configOptions.typeshedPath, importLogger);
-        if (!this._cachedTypeshedThirdPartyPackagePaths) {
-            this._buildTypeshedThirdPartyPackageMap(typeshedPath);
-        }
-        return this._cachedTypeshedThirdPartyPackageRoots;
-    }
-    _getTypeshedRoot(customTypeshedPath, importLogger) {
-        if (this._cachedTypeshedRoot === undefined) {
-            let typeshedPath = undefined;
-            // Did the user specify a typeshed path? If not, we'll look in the
-            // python search paths, then in the typeshed-fallback directory.
-            if (customTypeshedPath) {
-                if (this.dirExistsCached(customTypeshedPath)) {
-                    typeshedPath = customTypeshedPath;
-                }
-            }
-            // If typeshed directory wasn't found in other locations, use the fallback.
-            if (!typeshedPath) {
-                typeshedPath = PythonPathUtils.getTypeShedFallbackPath(this.fileSystem) ?? uri_1.Uri.empty();
-            }
-            this._cachedTypeshedRoot = typeshedPath;
-        }
-        return this._cachedTypeshedRoot.isEmpty() ? undefined : this._cachedTypeshedRoot;
+        const [, packageRoots] = this._getTypeshedInfoProvider().getThirdPartyPackageMap(this._configOptions.typeshedPath, importLogger);
+        return packageRoots;
     }
-    _getTypeshedSubdirectory(isStdLib, customTypeshedPath, importLogger) {
-        // See if we have it cached.
-        if (isStdLib) {
-            if (this._cachedTypeshedStdLibPath !== undefined) {
-                return this._cachedTypeshedStdLibPath;
-            }
-        }
-        else {
-            if (this._cachedTypeshedThirdPartyPath !== undefined) {
-                return this._cachedTypeshedThirdPartyPath;
-            }
-        }
-        let typeshedPath = this._getTypeshedRoot(customTypeshedPath, importLogger);
-        if (typeshedPath === undefined) {
-            return undefined;
-        }
-        typeshedPath = PythonPathUtils.getTypeshedSubdirectory(typeshedPath, isStdLib);
-        if (!this.dirExistsCached(typeshedPath)) {
-            return undefined;
-        }
-        // Cache the results.
-        if (isStdLib) {
-            this._cachedTypeshedStdLibPath = typeshedPath;
-        }
-        else {
-            this._cachedTypeshedThirdPartyPath = typeshedPath;
-        }
-        return typeshedPath;
+    _getTypeshedInfoProvider() {
+        return this._typeshedInfoProvider;
     }
     _resolveRelativeImport(sourceFileUri, execEnv, moduleDescriptor, importName, importLogger) {
         importLogger?.log('Attempting to resolve relative import');
@@ -1713,32 +1465,6 @@ class ImportResolver {
         // Now try to match the module parts from the current directory location.
         this._getCompletionSuggestionsAbsolute(sourceFileUri, execEnv, directory, moduleDescriptor, suggestions);
     }
-    _getFilesInDirectory(dirPath) {
-        const cachedValue = this._cachedFilesForPath.get(dirPath.key);
-        if (cachedValue) {
-            return cachedValue;
-        }
-        let newCacheValue = [];
-        try {
-            const entriesInDir = this.readdirEntriesCached(dirPath);
-            const filesInDir = [];
-            // Add any files or symbolic links that point to files.
-            entriesInDir.entries.forEach((f) => {
-                if (f.isFile()) {
-                    filesInDir.push(f);
-                }
-                else if (f.isSymbolicLink() && (0, uriUtils_1.tryStat)(this.fileSystem, dirPath.combinePaths(f.name))?.isFile()) {
-                    filesInDir.push(f);
-                }
-            });
-            newCacheValue = filesInDir.map((f) => dirPath.combinePaths(f.name));
-        }
-        catch {
-            newCacheValue = [];
-        }
-        this._cachedFilesForPath.set(dirPath.key, newCacheValue);
-        return newCacheValue;
-    }
     _getCompletionSuggestionsAbsolute(sourceFileUri, execEnv, rootPath, moduleDescriptor, suggestions, strictOnly = true) {
         // Starting at the specified path, walk the file system to find the
         // specified module.
@@ -1774,7 +1500,7 @@ class ImportResolver {
     }
     _addFilteredSuggestionsAbsolute(sourceFileUri, execEnv, currentPath, filter, suggestions, leadingDots, parentNameParts, strictOnly) {
         // Enumerate all of the files and directories in the path, expanding links.
-        const entries = (0, uriUtils_1.getFileSystemEntriesFromDirEntries)(this.readdirEntriesCached(currentPath).entries.values(), this.fileSystem, currentPath);
+        const entries = (0, uriUtils_1.getFileSystemEntriesFromDirEntries)(this._fileSystemCache.readdirEntriesSync(currentPath).values(), this.fileSystem, currentPath);
         entries.files.forEach((file) => {
             // Strip multi-dot extensions to handle file names like "foo.cpython-32m.so". We want
             // to detect the ".so" but strip off the entire ".cpython-32m.so" extension.
@@ -1868,7 +1594,7 @@ class ImportResolver {
     _findAndResolveNativeModule(fileDirectory, dirPath, execEnv, importName, moduleDescriptor, importLogger, resolvedPaths) {
         let isNativeLib = false;
         if (!execEnv.skipNativeLibraries && this.dirExistsCached(fileDirectory)) {
-            const filesInDir = this._getFilesInDirectory(fileDirectory);
+            const filesInDir = this._fileSystemCache.getFilesInDirectory(fileDirectory);
             const dirName = dirPath.fileName;
             const nativeLibPath = filesInDir.find((f) => this._isNativeModuleFileName(dirName, f));
             if (nativeLibPath) {