@zzzen/pyright-internal 1.2.0-dev.20250817 → 1.2.0-dev.20250831

package/dist/analyzer/importResolver.js

@@ -48,6 +48,7 @@ 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 importStatementUtils_1 = require("./importStatementUtils");
 const parentDirectoryCache_1 = require("./parentDirectoryCache");
 const pyTypedUtils_1 = require("./pyTypedUtils");
@@ -91,7 +92,7 @@ class ImportResolver {
         this._cachedEntriesForPath = new Map();
         this._cachedFilesForPath = new Map();
         this._cachedDirExistenceForRoot = new Map();
-        this.cachedParentImportResults = new parentDirectoryCache_1.ParentDirectoryCache(() => this.getPythonSearchPaths([]));
+        this.cachedParentImportResults = new parentDirectoryCache_1.ParentDirectoryCache(() => this.getPythonSearchPaths());
     }
     get fileSystem() {
         return this.serviceProvider.fs();
@@ -245,12 +246,11 @@ class ImportResolver {
         return (0, collectionUtils_1.getOrAdd)(cache, key, () => this._getModuleNameForImport(fileUri, execEnv, allowInvalidModuleName, detectPyTyped));
     }
     getTypeshedStdLibPath(execEnv) {
-        const unused = [];
-        return this._getStdlibTypeshedPath(this._configOptions.typeshedPath, execEnv.pythonVersion, execEnv.pythonPlatform, unused);
+        return this._getStdlibTypeshedPath(this._configOptions.typeshedPath, execEnv.pythonVersion, execEnv.pythonPlatform, 
+        /* logger */ undefined);
     }
     getTypeshedThirdPartyPath(execEnv) {
-        const unused = [];
-        return this._getThirdPartyTypeshedPath(this._configOptions.typeshedPath, unused);
+        return this._getThirdPartyTypeshedPath(this._configOptions.typeshedPath);
     }
     isStdlibModule(module, execEnv) {
         if (!this._stdlibModules) {
@@ -259,9 +259,8 @@ class ImportResolver {
         return this._stdlibModules.has(module.nameParts.join('.'));
     }
     getImportRoots(execEnv, forLogging = false) {
-        const importFailureInfo = [];
         const roots = [];
-        const stdTypeshed = this._getStdlibTypeshedPath(this._configOptions.typeshedPath, execEnv.pythonVersion, execEnv.pythonPlatform, importFailureInfo);
+        const stdTypeshed = this._getStdlibTypeshedPath(this._configOptions.typeshedPath, execEnv.pythonVersion, execEnv.pythonPlatform);
         if (stdTypeshed) {
             roots.push(stdTypeshed);
         }
@@ -277,20 +276,20 @@ class ImportResolver {
             // There's one path for each third party package, which blows up logging.
             // Just get the root directly and show it with `...` to indicate that this
             // is where the third party folder is in the roots.
-            const thirdPartyRoot = this._getThirdPartyTypeshedPath(this._configOptions.typeshedPath, importFailureInfo);
+            const thirdPartyRoot = this._getThirdPartyTypeshedPath(this._configOptions.typeshedPath);
             if (thirdPartyRoot) {
                 roots.push(thirdPartyRoot.resolvePaths('...'));
             }
         }
         else {
-            const thirdPartyPaths = this._getThirdPartyTypeshedPackageRoots(importFailureInfo);
+            const thirdPartyPaths = this._getThirdPartyTypeshedPackageRoots();
             (0, collectionUtils_1.appendArray)(roots, thirdPartyPaths);
         }
-        const typeshedPathEx = this.getTypeshedPathEx(execEnv, importFailureInfo);
+        const typeshedPathEx = this.getTypeshedPathEx(execEnv);
         if (typeshedPathEx) {
             roots.push(typeshedPathEx);
         }
-        const pythonSearchPaths = this.getPythonSearchPaths(importFailureInfo);
+        const pythonSearchPaths = this.getPythonSearchPaths();
         if (pythonSearchPaths.length > 0) {
             (0, collectionUtils_1.appendArray)(roots, pythonSearchPaths);
         }
@@ -304,15 +303,14 @@ class ImportResolver {
             return false;
         }
         const ps = this.partialStubs;
-        const ignored = [];
         const paths = [];
-        const typeshedPathEx = this.getTypeshedPathEx(execEnv, ignored);
+        const typeshedPathEx = this.getTypeshedPathEx(execEnv);
         // Add paths to search stub packages.
         addPaths(this._configOptions.stubPath);
         addPaths(execEnv.root ?? this._configOptions.projectRoot);
         execEnv.extraPaths.forEach((p) => addPaths(p));
         addPaths(typeshedPathEx);
-        this.getPythonSearchPaths(ignored).forEach((p) => addPaths(p));
+        this.getPythonSearchPaths().forEach((p) => addPaths(p));
         this.partialStubs.processPartialStubPackages(paths, this.getImportRoots(execEnv), typeshedPathEx);
         this._invalidateFileSystemCache();
         return true;
@@ -323,27 +321,25 @@ class ImportResolver {
             paths.push(path);
         }
     }
-    getPythonSearchPaths(importFailureInfo) {
+    getPythonSearchPaths(importLogger) {
         // Find the site packages for the configured virtual environment.
         if (!this._cachedPythonSearchPaths) {
-            const info = [];
-            const paths = (PythonPathUtils.findPythonSearchPaths(this.fileSystem, this._configOptions, this.host, info) || []).map((p) => this.fileSystem.realCasePath(p));
+            const paths = (PythonPathUtils.findPythonSearchPaths(this.fileSystem, this._configOptions, this.host, importLogger) ||
+                []).map((p) => this.fileSystem.realCasePath(p));
             // Remove duplicates (yes, it happens).
-            this._cachedPythonSearchPaths = { paths: Array.from(new Set(paths)), failureInfo: info };
+            this._cachedPythonSearchPaths = { paths: Array.from(new Set(paths)), failureInfo: importLogger };
         }
-        // Make sure we cache the logs as well so we can find out why search path failed.
-        importFailureInfo.push(...this._cachedPythonSearchPaths.failureInfo);
         return this._cachedPythonSearchPaths.paths;
     }
     getTypeshedStdlibExcludeList(customTypeshedPath, pythonVersion, pythonPlatform) {
-        const unused = [];
-        const typeshedStdlibPath = this._getStdlibTypeshedPath(customTypeshedPath, pythonVersion, pythonPlatform, unused);
+        const typeshedStdlibPath = this._getStdlibTypeshedPath(customTypeshedPath, pythonVersion, pythonPlatform, 
+        /* importLogger */ undefined);
         const excludes = [];
         if (!typeshedStdlibPath) {
             return excludes;
         }
         if (!this._cachedTypeshedStdLibModuleVersionInfo) {
-            this._cachedTypeshedStdLibModuleVersionInfo = this._readTypeshedStdLibVersions(customTypeshedPath, []);
+            this._cachedTypeshedStdLibModuleVersionInfo = this._readTypeshedStdLibVersions(customTypeshedPath);
         }
         this._cachedTypeshedStdLibModuleVersionInfo.forEach((versionInfo, moduleName) => {
             let shouldExcludeModule = false;
@@ -379,7 +375,7 @@ class ImportResolver {
     }
     // Intended to be overridden by subclasses to provide additional stub
     // path capabilities. Return undefined if no extra stub path were found.
-    getTypeshedPathEx(execEnv, importFailureInfo) {
+    getTypeshedPathEx(execEnv, importLogger) {
         return undefined;
     }
     readdirEntriesCached(uri) {
@@ -387,23 +383,35 @@ class ImportResolver {
         if (cachedValue) {
             return cachedValue;
         }
-        let newCacheValue;
+        const newCachedDir = {
+            entries: new Map(),
+            resolvableNames: new Set(),
+        };
         try {
-            newCacheValue = this.fileSystem.readdirEntriesSync(uri);
+            const entries = this.fileSystem.readdirEntriesSync(uri);
+            entries.forEach((entry) => {
+                newCachedDir.entries.set(entry.name, entry);
+                const resolvableName = entry.isFile()
+                    ? (0, pathUtils_1.stripFileExtension)(entry.name, /* multiDotExtension */ true)
+                    : entry.name;
+                newCachedDir.resolvableNames.add(resolvableName);
+                if (entry.isDirectory() && entry.name.endsWith(pathConsts_1.stubsSuffix)) {
+                    newCachedDir.resolvableNames.add(resolvableName.substring(0, resolvableName.length - pathConsts_1.stubsSuffix.length));
+                }
+            });
         }
         catch {
-            newCacheValue = [];
+            // Swallow error
         }
-        // Populate cache for next time.
-        this._cachedEntriesForPath.set(uri.key, newCacheValue);
-        return newCacheValue;
+        // 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) {
         const importName = formatImportName(moduleDescriptor);
-        const importFailureInfo = [];
-        const importResult = this._resolveImportStrict(importName, sourceFileUri, execEnv, moduleDescriptor, importFailureInfo);
+        const importResult = this._resolveImportStrict(importName, sourceFileUri, execEnv, moduleDescriptor);
         if (importResult.isImportFound || moduleDescriptor.leadingDots > 0) {
             return importResult;
         }
@@ -421,18 +429,19 @@ class ImportResolver {
         if (!this.cachedParentImportResults.checkValidPath(this.fileSystem, sourceFileUri, root)) {
             return importResult;
         }
-        const localImportFailureInfo = [`Attempting to resolve using local imports: ${importName}`];
+        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;
         while (this._shouldWalkUp(current, root, execEnv) && current) {
-            const result = this.resolveAbsoluteImport(sourceFileUri, current, execEnv, moduleDescriptor, importName, localImportFailureInfo, 
+            const result = this.resolveAbsoluteImport(sourceFileUri, current, execEnv, moduleDescriptor, importName, importLogger, 
             /* allowPartial */ undefined, 
             /* allowNativeLib */ undefined, 
             /* useStubPackage */ false, 
             /* allowPyi */ true);
             this.cachedParentImportResults.checked(current, importName, importPath);
-            if (result.isImportFound) {
+            if (result?.isImportFound) {
                 // This will make cache to point to actual path that contains the module we found
                 importPath.importPath = current;
                 this.cachedParentImportResults.add({
@@ -447,9 +456,9 @@ class ImportResolver {
         if (current) {
             this.cachedParentImportResults.checked(current, importName, importPath);
         }
-        if (this._configOptions.verboseOutput) {
+        if (importLogger) {
             const console = this.serviceProvider.console();
-            localImportFailureInfo.forEach((diag) => console.log(diag));
+            importLogger.getLogs().forEach((diag) => console.log(diag));
         }
         return importResult;
     }
@@ -459,9 +468,8 @@ class ImportResolver {
             // Started at root, so this can't be a file.
             return false;
         }
-        const fileName = uri.fileName;
-        const entries = this.readdirEntriesCached(directory);
-        const entry = entries.find((entry) => entry.name === fileName);
+        const cachedDir = this.readdirEntriesCached(directory);
+        const entry = cachedDir.entries.get(uri.fileName);
         if (entry?.isFile()) {
             return true;
         }
@@ -487,9 +495,8 @@ class ImportResolver {
         }
         // Otherwise not a root, so read the entries we have cached to see if
         // the directory exists or not.
-        const directoryName = uri.fileName;
-        const entries = this.readdirEntriesCached(parent);
-        const entry = entries.find((entry) => entry.name === directoryName);
+        const cachedDir = this.readdirEntriesCached(parent);
+        const entry = cachedDir.entries.get(uri.fileName);
         if (entry?.isDirectory()) {
             return true;
         }
@@ -509,12 +516,17 @@ class ImportResolver {
     }
     // Follows import resolution algorithm defined in PEP-420:
     // https://www.python.org/dev/peps/pep-0420/
-    resolveAbsoluteImport(sourceFileUri, rootPath, execEnv, moduleDescriptor, importName, importFailureInfo, allowPartial = false, allowNativeLib = false, useStubPackage = false, allowPyi = true, lookForPyTyped = false) {
+    resolveAbsoluteImport(sourceFileUri, rootPath, execEnv, moduleDescriptor, importName, importLogger, allowPartial = false, allowNativeLib = false, useStubPackage = false, allowPyi = true, lookForPyTyped = false) {
+        // Before we do additional work, see if this directory can possibly
+        // resolve this import.
+        if (!this._isPossibleImportDir(rootPath, moduleDescriptor)) {
+            return undefined;
+        }
         if (allowPyi && useStubPackage) {
             // Look for packaged stubs first. PEP 561 indicates that package authors can ship
             // their stubs separately from their package implementation by appending the string
             // '-stubs' to its top - level directory name. We'll look there first.
-            const importResult = this._resolveAbsoluteImport(rootPath, execEnv, moduleDescriptor, importName, importFailureInfo, allowPartial, 
+            const importResult = this._resolveAbsoluteImport(rootPath, execEnv, moduleDescriptor, importName, importLogger, allowPartial, 
             /* allowNativeLib */ false, 
             /* useStubPackage */ true, 
             /* allowPyi */ true, 
@@ -528,19 +540,19 @@ class ImportResolver {
                 }
             }
         }
-        return this._resolveAbsoluteImport(rootPath, execEnv, moduleDescriptor, importName, importFailureInfo, allowPartial, allowNativeLib, 
+        return this._resolveAbsoluteImport(rootPath, execEnv, moduleDescriptor, importName, importLogger, allowPartial, allowNativeLib, 
         /* useStubPackage */ false, allowPyi, lookForPyTyped);
     }
     // Intended to be overridden by subclasses to provide additional stub
     // resolving capabilities. Return undefined if no stubs were found for
     // this import.
-    resolveImportEx(sourceFileUri, execEnv, moduleDescriptor, importName, importFailureInfo = [], allowPyi = true) {
+    resolveImportEx(sourceFileUri, execEnv, moduleDescriptor, importName, importLogger, allowPyi = true) {
         return undefined;
     }
     // Intended to be overridden by subclasses to provide additional stub
     // resolving capabilities for native (compiled) modules. Returns undefined
     // if no stubs were found for this import.
-    resolveNativeImportEx(libraryFileUri, importName, importFailureInfo = []) {
+    resolveNativeImportEx(libraryFileUri, importName, importLogger) {
         return undefined;
     }
     getNativeModuleName(uri) {
@@ -555,13 +567,13 @@ class ImportResolver {
     filterImplicitImports(importResult, importedSymbols) {
         if (importedSymbols === undefined) {
             const newImportResult = Object.assign({}, importResult);
-            newImportResult.filteredImplicitImports = new Map();
+            newImportResult.filteredImplicitImports = undefined;
             return newImportResult;
         }
-        if (importedSymbols.size === 0) {
+        if (importedSymbols === undefined || importedSymbols.size === 0) {
             return importResult;
         }
-        if (importResult.implicitImports.size === 0) {
+        if (importResult.implicitImports === undefined || importResult.implicitImports.size === 0) {
             return importResult;
         }
         const filteredImplicitImports = new Map();
@@ -580,7 +592,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), this.fileSystem, dirPath);
+        const entries = (0, uriUtils_1.getFileSystemEntriesFromDirEntries)(this.readdirEntriesCached(dirPath).entries.values(), this.fileSystem, dirPath);
         // Add implicit file-based modules.
         for (const filePath of entries.files) {
             const fileExt = filePath.lastExtension;
@@ -612,7 +624,7 @@ class ImportResolver {
                     // Try resolving resolving native lib to a custom stub.
                     if (isNativeLib) {
                         const nativeLibPath = filePath;
-                        const nativeStubPath = this.resolveNativeImportEx(nativeLibPath, `${importingModuleName}.${strippedFileName}`, []);
+                        const nativeStubPath = this.resolveNativeImportEx(nativeLibPath, `${importingModuleName}.${strippedFileName}`);
                         if (nativeStubPath) {
                             implicitImport.uri = nativeStubPath;
                             implicitImport.isNativeLib = false;
@@ -648,9 +660,26 @@ class ImportResolver {
                 }
             }
         }
-        return implicitImportMap;
+        return implicitImportMap.size > 0 ? implicitImportMap : undefined;
+    }
+    _isPossibleImportDir(rootPath, moduleDescriptor) {
+        const cachedDir = this.readdirEntriesCached(rootPath);
+        const isPotentialMatch = (name) => {
+            return cachedDir.resolvableNames.has(name);
+        };
+        if (moduleDescriptor.nameParts.length > 0) {
+            return isPotentialMatch(moduleDescriptor.nameParts[0]);
+        }
+        if (moduleDescriptor.importedSymbols) {
+            for (const key of moduleDescriptor.importedSymbols) {
+                if (isPotentialMatch(key)) {
+                    return true;
+                }
+            }
+        }
+        return isPotentialMatch('__init__');
     }
-    _resolveImportStrict(importName, sourceFileUri, execEnv, moduleDescriptor, importFailureInfo) {
+    _resolveImportStrict(importName, sourceFileUri, execEnv, moduleDescriptor, importLogger) {
         const fromUserFile = (0, configOptions_1.matchFileSpecs)(this._configOptions, sourceFileUri);
         const notFoundResult = {
             importName,
@@ -660,13 +689,13 @@ class ImportResolver {
             isNamespacePackage: false,
             isInitFilePresent: false,
             isStubPackage: false,
-            importFailureInfo,
+            importFailureInfo: importLogger?.getLogs(),
             resolvedUris: [],
             importType: 2 /* ImportType.Local */,
             isStubFile: false,
             isNativeLib: false,
-            implicitImports: new Map(),
-            filteredImplicitImports: new Map(),
+            implicitImports: undefined,
+            filteredImplicitImports: undefined,
             nonStubImportResult: undefined,
         };
         this.ensurePartialStubPackages(execEnv);
@@ -676,7 +705,7 @@ class ImportResolver {
             if (cachedResults) {
                 return cachedResults;
             }
-            const relativeImport = this._resolveRelativeImport(sourceFileUri, execEnv, moduleDescriptor, importName, importFailureInfo);
+            const relativeImport = this._resolveRelativeImport(sourceFileUri, execEnv, moduleDescriptor, importName, importLogger);
             if (relativeImport) {
                 relativeImport.isRelative = true;
                 return this.addResultsToCache(sourceFileUri, execEnv, importName, relativeImport, moduleDescriptor, fromUserFile);
@@ -712,7 +741,6 @@ class ImportResolver {
         /* moduleDescriptor */ undefined, fromUserFile);
     }
     _getCompletionSuggestionsStrict(sourceFileUri, execEnv, moduleDescriptor) {
-        const importFailureInfo = [];
         const suggestions = new Map();
         // Is it a relative import?
         if (moduleDescriptor.leadingDots > 0) {
@@ -737,7 +765,7 @@ class ImportResolver {
             // Check for a typeshed file.
             this._getCompletionSuggestionsTypeshedPath(sourceFileUri, execEnv, moduleDescriptor, false, suggestions);
             // Look for the import in the list of third-party packages.
-            const pythonSearchPaths = this.getPythonSearchPaths(importFailureInfo);
+            const pythonSearchPaths = this.getPythonSearchPaths();
             for (const searchPath of pythonSearchPaths) {
                 this._getCompletionSuggestionsAbsolute(sourceFileUri, execEnv, searchPath, moduleDescriptor, suggestions);
             }
@@ -750,14 +778,13 @@ class ImportResolver {
         let isLocalTypingsFile = false;
         let isThirdPartyPyTypedPresent = false;
         let isTypeshedFile = false;
-        const importFailureInfo = [];
         // If we cannot find a fully-qualified module name with legal characters,
         // look for one with invalid characters (e.g. "-"). This is important to
         // differentiate between different modules in a project in case they
         // declare types with the same (local) name.
         let moduleNameWithInvalidCharacters;
         // Is this a stdlib typeshed path?
-        const stdLibTypeshedPath = this._getStdlibTypeshedPath(this._configOptions.typeshedPath, execEnv.pythonVersion, execEnv.pythonPlatform, importFailureInfo);
+        const stdLibTypeshedPath = this._getStdlibTypeshedPath(this._configOptions.typeshedPath, execEnv.pythonVersion, execEnv.pythonPlatform);
         if (stdLibTypeshedPath) {
             moduleName = getModuleNameFromPath(stdLibTypeshedPath, fileUri);
             if (moduleName) {
@@ -766,7 +793,7 @@ class ImportResolver {
                     nameParts: moduleName.split('.'),
                     importedSymbols: undefined,
                 };
-                if (this._isStdlibTypeshedStubValidForVersion(moduleDescriptor, this._configOptions.typeshedPath, execEnv.pythonVersion, execEnv.pythonPlatform, [])) {
+                if (this._isStdlibTypeshedStubValidForVersion(moduleDescriptor, this._configOptions.typeshedPath, execEnv.pythonVersion, execEnv.pythonPlatform)) {
                     return {
                         moduleName,
                         importType,
@@ -828,7 +855,7 @@ class ImportResolver {
             }
         }
         // Check for a typeshed file.
-        const thirdPartyTypeshedPath = this._getThirdPartyTypeshedPath(this._configOptions.typeshedPath, importFailureInfo);
+        const thirdPartyTypeshedPath = this._getThirdPartyTypeshedPath(this._configOptions.typeshedPath);
         if (thirdPartyTypeshedPath) {
             const candidateModuleName = getModuleNameFromPath(thirdPartyTypeshedPath, fileUri, 
             /* stripTopContainerDir */ true);
@@ -840,7 +867,7 @@ class ImportResolver {
                 isTypeshedFile = true;
             }
         }
-        const thirdPartyTypeshedPathEx = this.getTypeshedPathEx(execEnv, importFailureInfo);
+        const thirdPartyTypeshedPathEx = this.getTypeshedPathEx(execEnv);
         if (thirdPartyTypeshedPathEx) {
             const candidateModuleName = getModuleNameFromPath(thirdPartyTypeshedPathEx, fileUri);
             // Does this candidate look better than the previous best module name?
@@ -852,7 +879,7 @@ class ImportResolver {
             }
         }
         // Look for the import in the list of third-party packages.
-        const pythonSearchPaths = this.getPythonSearchPaths(importFailureInfo);
+        const pythonSearchPaths = this.getPythonSearchPaths();
         for (const searchPath of pythonSearchPaths) {
             const candidateModuleNameInfo = _getModuleNameInfoFromPath(searchPath, fileUri);
             if (candidateModuleNameInfo) {
@@ -912,12 +939,12 @@ class ImportResolver {
         this._cachedFilesForPath.clear();
         this._cachedDirExistenceForRoot.clear();
     }
-    _resolveAbsoluteImport(rootPath, execEnv, moduleDescriptor, importName, importFailureInfo, allowPartial, allowNativeLib, useStubPackage, allowPyi, lookForPyTyped) {
+    _resolveAbsoluteImport(rootPath, execEnv, moduleDescriptor, importName, importLogger, allowPartial, allowNativeLib, useStubPackage, allowPyi, lookForPyTyped) {
         if (useStubPackage) {
-            importFailureInfo.push(`Attempting to resolve stub package using root path '${rootPath}'`);
+            importLogger?.log(`Attempting to resolve stub package using root path '${rootPath}'`);
         }
         else {
-            importFailureInfo.push(`Attempting to resolve using root path '${rootPath}'`);
+            importLogger?.log(`Attempting to resolve using root path '${rootPath}'`);
         }
         // Starting at the specified path, walk the file system to find the
         // specified module.
@@ -928,7 +955,7 @@ class ImportResolver {
         let isStubPackage = false;
         let isStubFile = false;
         let isNativeLib = false;
-        let implicitImports = new Map();
+        let implicitImports;
         let packageDirectory;
         let pyTypedInfo;
         // Handle the "from . import XXX" case.
@@ -936,16 +963,16 @@ class ImportResolver {
             const pyFilePath = dirPath.initPyUri;
             const pyiFilePath = dirPath.initPyiUri;
             if (allowPyi && this.fileExistsCached(pyiFilePath)) {
-                importFailureInfo.push(`Resolved import with file '${pyiFilePath}'`);
+                importLogger?.log(`Resolved import with file '${pyiFilePath}'`);
                 resolvedPaths.push(pyiFilePath);
                 isStubFile = true;
             }
             else if (this.fileExistsCached(pyFilePath)) {
-                importFailureInfo.push(`Resolved import with file '${pyFilePath}'`);
+                importLogger?.log(`Resolved import with file '${pyFilePath}'`);
                 resolvedPaths.push(pyFilePath);
             }
             else {
-                importFailureInfo.push(`Partially resolved import with directory '${dirPath}'`);
+                importLogger?.log(`Partially resolved import with directory '${dirPath}'`);
                 resolvedPaths.push(uri_1.Uri.empty());
                 isNamespacePackage = true;
             }
@@ -970,7 +997,7 @@ class ImportResolver {
                     const pyiFilePath = dirPath.initPyiUri;
                     isInitFilePresent = false;
                     if (allowPyi && this.fileExistsCached(pyiFilePath)) {
-                        importFailureInfo.push(`Resolved import with file '${pyiFilePath}'`);
+                        importLogger?.log(`Resolved import with file '${pyiFilePath}'`);
                         resolvedPaths.push(pyiFilePath);
                         if (isLastPart) {
                             isStubFile = true;
@@ -978,7 +1005,7 @@ class ImportResolver {
                         isInitFilePresent = true;
                     }
                     else if (this.fileExistsCached(pyFilePath)) {
-                        importFailureInfo.push(`Resolved import with file '${pyFilePath}'`);
+                        importLogger?.log(`Resolved import with file '${pyFilePath}'`);
                         resolvedPaths.push(pyFilePath);
                         isInitFilePresent = true;
                     }
@@ -1005,20 +1032,20 @@ class ImportResolver {
                 const pyiFilePath = dirPath.packageStubUri;
                 const fileDirectory = dirPath.getDirectory();
                 if (allowPyi && this.fileExistsCached(pyiFilePath)) {
-                    importFailureInfo.push(`Resolved import with file '${pyiFilePath}'`);
+                    importLogger?.log(`Resolved import with file '${pyiFilePath}'`);
                     resolvedPaths.push(pyiFilePath);
                     if (isLastPart) {
                         isStubFile = true;
                     }
                 }
                 else if (this.fileExistsCached(pyFilePath)) {
-                    importFailureInfo.push(`Resolved import with file '${pyFilePath}'`);
+                    importLogger?.log(`Resolved import with file '${pyFilePath}'`);
                     resolvedPaths.push(pyFilePath);
                 }
                 else if (allowNativeLib &&
-                    this._findAndResolveNativeModule(fileDirectory, dirPath, execEnv, importName, moduleDescriptor, importFailureInfo, resolvedPaths)) {
+                    this._findAndResolveNativeModule(fileDirectory, dirPath, execEnv, importName, moduleDescriptor, importLogger, resolvedPaths)) {
                     isNativeLib = true;
-                    importFailureInfo.push(`Did not find file '${pyiFilePath}' or '${pyFilePath}'`);
+                    importLogger?.log(`Did not find file '${pyiFilePath}' or '${pyFilePath}'`);
                 }
                 else if (foundDirectory) {
                     if (!isLastPart) {
@@ -1030,7 +1057,7 @@ class ImportResolver {
                         pyTypedInfo = undefined;
                         continue;
                     }
-                    importFailureInfo.push(`Partially resolved import with directory '${dirPath}'`);
+                    importLogger?.log(`Partially resolved import with directory '${dirPath}'`);
                     resolvedPaths.push(uri_1.Uri.empty());
                     if (isLastPart) {
                         implicitImports = this.findImplicitImports(importName, dirPath, [pyFilePath, pyiFilePath]);
@@ -1059,7 +1086,7 @@ class ImportResolver {
             isStubPackage,
             isImportFound: importFound,
             isPartlyResolved,
-            importFailureInfo,
+            importFailureInfo: importLogger?.getLogs(),
             importType: 2 /* ImportType.Local */,
             resolvedUris: resolvedPaths,
             searchPath: rootPath,
@@ -1094,27 +1121,27 @@ class ImportResolver {
     // are all satisfied by submodules (as listed in the implicit imports).
     _isNamespacePackageResolved(moduleDescriptor, implicitImports) {
         if (moduleDescriptor.importedSymbols) {
-            if (!Array.from(moduleDescriptor.importedSymbols.keys()).some((symbol) => implicitImports.has(symbol))) {
+            if (!Array.from(moduleDescriptor.importedSymbols.keys()).some((symbol) => implicitImports?.has(symbol))) {
                 return false;
             }
         }
-        else if (implicitImports.size === 0) {
+        else if (!implicitImports || implicitImports.size === 0) {
             return false;
         }
         return true;
     }
     _resolveBestAbsoluteImport(sourceFileUri, execEnv, moduleDescriptor, allowPyi) {
         const importName = formatImportName(moduleDescriptor);
-        const importFailureInfo = [];
+        const importLogger = this._configOptions.verboseOutput ? new importLogger_1.ImportLogger() : undefined;
         // Check for a local stub file using stubPath.
         if (allowPyi && this._configOptions.stubPath) {
-            importFailureInfo.push(`Looking in stubPath '${this._configOptions.stubPath}'`);
-            const typingsImport = this.resolveAbsoluteImport(sourceFileUri, this._configOptions.stubPath, execEnv, moduleDescriptor, importName, importFailureInfo, 
+            importLogger?.log(`Looking in stubPath '${this._configOptions.stubPath}'`);
+            const typingsImport = this.resolveAbsoluteImport(sourceFileUri, this._configOptions.stubPath, execEnv, moduleDescriptor, importName, importLogger, 
             /* allowPartial */ undefined, 
             /* allowNativeLib */ false, 
             /* useStubPackage */ true, allowPyi, 
             /* lookForPyTyped */ false);
-            if (typingsImport.isImportFound) {
+            if (typingsImport?.isImportFound) {
                 // We will treat typings files as "local" rather than "third party".
                 typingsImport.importType = 2 /* ImportType.Local */;
                 typingsImport.isLocalTypingsFile = true;
@@ -1136,8 +1163,8 @@ class ImportResolver {
         let localImport;
         // Look for it in the root directory of the execution environment.
         if (execEnv.root) {
-            importFailureInfo.push(`Looking in root directory of execution environment ` + `'${execEnv.root}'`);
-            localImport = this.resolveAbsoluteImport(sourceFileUri, execEnv.root, execEnv, moduleDescriptor, importName, importFailureInfo, 
+            importLogger?.log(`Looking in root directory of execution environment ` + `'${execEnv.root}'`);
+            localImport = this.resolveAbsoluteImport(sourceFileUri, execEnv.root, execEnv, moduleDescriptor, importName, importLogger, 
             /* allowPartial */ undefined, 
             /* allowNativeLib */ true, 
             /* useStubPackage */ true, allowPyi, 
@@ -1145,8 +1172,8 @@ class ImportResolver {
             bestResultSoFar = localImport;
         }
         for (const extraPath of execEnv.extraPaths) {
-            importFailureInfo.push(`Looking in extraPath '${extraPath}'`);
-            localImport = this.resolveAbsoluteImport(sourceFileUri, extraPath, execEnv, moduleDescriptor, importName, importFailureInfo, 
+            importLogger?.log(`Looking in extraPath '${extraPath}'`);
+            localImport = this.resolveAbsoluteImport(sourceFileUri, extraPath, execEnv, moduleDescriptor, importName, importLogger, 
             /* allowPartial */ undefined, 
             /* allowNativeLib */ true, 
             /* useStubPackage */ true, allowPyi, 
@@ -1155,20 +1182,20 @@ class ImportResolver {
         }
         // Check for a stdlib typeshed file.
         if (allowPyi && moduleDescriptor.nameParts.length > 0) {
-            importFailureInfo.push(`Looking for typeshed stdlib path`);
+            importLogger?.log(`Looking for typeshed stdlib path`);
             const typeshedStdlibImport = this._findTypeshedPath(execEnv, moduleDescriptor, importName, 
-            /* isStdLib */ true, importFailureInfo);
+            /* isStdLib */ true, importLogger);
             if (typeshedStdlibImport) {
                 typeshedStdlibImport.isStdlibTypeshedFile = true;
                 return typeshedStdlibImport;
             }
         }
         // Look for the import in the list of third-party packages.
-        const pythonSearchPaths = this.getPythonSearchPaths(importFailureInfo);
+        const pythonSearchPaths = this.getPythonSearchPaths(importLogger);
         if (pythonSearchPaths.length > 0) {
             for (const searchPath of pythonSearchPaths) {
-                importFailureInfo.push(`Looking in python search path '${searchPath}'`);
-                const thirdPartyImport = this.resolveAbsoluteImport(sourceFileUri, searchPath, execEnv, moduleDescriptor, importName, importFailureInfo, 
+                importLogger?.log(`Looking in python search path '${searchPath}'`);
+                const thirdPartyImport = this.resolveAbsoluteImport(sourceFileUri, searchPath, execEnv, moduleDescriptor, importName, importLogger, 
                 /* allowPartial */ allowPartialResolutionForThirdPartyPackages, 
                 /* allowNativeLib */ true, 
                 /* useStubPackage */ true, allowPyi, 
@@ -1180,26 +1207,26 @@ class ImportResolver {
             }
         }
         else {
-            importFailureInfo.push('No python interpreter search path');
+            importLogger?.log('No python interpreter search path');
         }
         // 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, importFailureInfo)) {
+        if (execEnv.root !== this._getTypeshedRoot(this._configOptions.typeshedPath, importLogger)) {
             if (bestResultSoFar?.pyTypedInfo && !bestResultSoFar.isPartlyResolved) {
                 return bestResultSoFar;
             }
         }
         // Call the extensibility hook for subclasses.
-        const extraResults = this.resolveImportEx(sourceFileUri, execEnv, moduleDescriptor, importName, importFailureInfo, allowPyi);
+        const extraResults = this.resolveImportEx(sourceFileUri, execEnv, moduleDescriptor, importName, importLogger, allowPyi);
         if (extraResults) {
             return extraResults;
         }
         // Check for a third-party typeshed file.
         if (allowPyi && moduleDescriptor.nameParts.length > 0) {
-            importFailureInfo.push(`Looking for typeshed third-party path`);
+            importLogger?.log(`Looking for typeshed third-party path`);
             const typeshedImport = this._findTypeshedPath(execEnv, moduleDescriptor, importName, 
-            /* isStdLib */ false, importFailureInfo);
+            /* isStdLib */ false, importLogger);
             if (typeshedImport) {
                 typeshedImport.isThirdPartyTypeshedFile = true;
                 bestResultSoFar = this._pickBestImport(bestResultSoFar, typeshedImport, moduleDescriptor);
@@ -1301,23 +1328,23 @@ class ImportResolver {
         }
         return bestImportSoFar;
     }
-    _findTypeshedPath(execEnv, moduleDescriptor, importName, isStdLib, importFailureInfo) {
-        importFailureInfo.push(`Looking for typeshed ${isStdLib ? PythonPathUtils.stdLibFolderName : PythonPathUtils.thirdPartyFolderName} path`);
+    _findTypeshedPath(execEnv, moduleDescriptor, importName, isStdLib, importLogger) {
+        importLogger?.log(`Looking for typeshed ${isStdLib ? PythonPathUtils.stdLibFolderName : PythonPathUtils.thirdPartyFolderName} path`);
         let typeshedPaths;
         if (isStdLib) {
-            const path = this._getStdlibTypeshedPath(this._configOptions.typeshedPath, execEnv.pythonVersion, execEnv.pythonPlatform, importFailureInfo, moduleDescriptor);
+            const path = this._getStdlibTypeshedPath(this._configOptions.typeshedPath, execEnv.pythonVersion, execEnv.pythonPlatform, importLogger, moduleDescriptor);
             if (path) {
                 typeshedPaths = [path];
             }
         }
         else {
-            typeshedPaths = this._getThirdPartyTypeshedPackagePaths(moduleDescriptor, importFailureInfo);
+            typeshedPaths = this._getThirdPartyTypeshedPackagePaths(moduleDescriptor, importLogger);
         }
         if (typeshedPaths) {
             for (const typeshedPath of typeshedPaths) {
                 if (this.dirExistsCached(typeshedPath)) {
-                    const importInfo = this.resolveAbsoluteImport(undefined, typeshedPath, execEnv, moduleDescriptor, importName, importFailureInfo);
-                    if (importInfo.isImportFound) {
+                    const importInfo = this.resolveAbsoluteImport(undefined, typeshedPath, execEnv, moduleDescriptor, importName, importLogger);
+                    if (importInfo?.isImportFound) {
                         let importType = isStdLib ? 0 /* ImportType.BuiltIn */ : 1 /* ImportType.ThirdParty */;
                         // Handle 'typing_extensions' as a special case because it's
                         // part of stdlib typeshed stubs, but it's not part of stdlib.
@@ -1330,7 +1357,7 @@ class ImportResolver {
                 }
             }
         }
-        importFailureInfo.push(`Typeshed path not found`);
+        importLogger?.log(`Typeshed path not found`);
         return undefined;
     }
     // Finds all of the stdlib modules and returns a Set containing all of their names.
@@ -1338,7 +1365,7 @@ class ImportResolver {
         const cache = new Set();
         if (stdlibRoot) {
             const readDir = (root, prefix) => {
-                this.readdirEntriesCached(root).forEach((entry) => {
+                this.readdirEntriesCached(root).entries.forEach((entry) => {
                     if (entry.isDirectory()) {
                         const dirRoot = root.combinePaths(entry.name);
                         readDir(dirRoot, prefix ? `${prefix}.${entry.name}` : entry.name);
@@ -1347,7 +1374,7 @@ class ImportResolver {
                         const stripped = (0, pathUtils_1.stripFileExtension)(entry.name);
                         // Skip anything starting with an underscore.
                         if (!stripped.startsWith('_')) {
-                            if (this._isStdlibTypeshedStubValidForVersion(createImportedModuleDescriptor(stripped), root, executionEnvironment.pythonVersion, executionEnvironment.pythonPlatform, [])) {
+                            if (this._isStdlibTypeshedStubValidForVersion(createImportedModuleDescriptor(stripped), root, executionEnvironment.pythonVersion, executionEnvironment.pythonPlatform)) {
                                 cache.add(prefix ? `${prefix}.${stripped}` : stripped);
                             }
                         }
@@ -1366,10 +1393,10 @@ class ImportResolver {
     _buildTypeshedThirdPartyPackageMap(thirdPartyDir) {
         this._cachedTypeshedThirdPartyPackagePaths = new Map();
         if (thirdPartyDir) {
-            this.readdirEntriesCached(thirdPartyDir).forEach((outerEntry) => {
+            this.readdirEntriesCached(thirdPartyDir).entries.forEach((outerEntry) => {
                 if (outerEntry.isDirectory()) {
                     const innerDirPath = thirdPartyDir.combinePaths(outerEntry.name);
-                    this.readdirEntriesCached(innerDirPath).forEach((innerEntry) => {
+                    this.readdirEntriesCached(innerDirPath).entries.forEach((innerEntry) => {
                         if (innerEntry.name === '@python2') {
                             return;
                         }
@@ -1402,18 +1429,19 @@ class ImportResolver {
         this._cachedTypeshedThirdPartyPackageRoots = Array.from(new Set(flattenPaths)).sort();
     }
     _getCompletionSuggestionsTypeshedPath(sourceFileUri, execEnv, moduleDescriptor, isStdLib, suggestions) {
-        const importFailureInfo = [];
         let typeshedPaths;
         if (isStdLib) {
-            const path = this._getStdlibTypeshedPath(this._configOptions.typeshedPath, execEnv.pythonVersion, execEnv.pythonPlatform, importFailureInfo, moduleDescriptor);
+            const path = this._getStdlibTypeshedPath(this._configOptions.typeshedPath, execEnv.pythonVersion, execEnv.pythonPlatform, 
+            /* importLogger */ undefined, moduleDescriptor);
             if (path) {
                 typeshedPaths = [path];
             }
         }
         else {
-            typeshedPaths = this._getThirdPartyTypeshedPackagePaths(moduleDescriptor, importFailureInfo, 
+            typeshedPaths = this._getThirdPartyTypeshedPackagePaths(moduleDescriptor, 
+            /* importLogger */ undefined, 
             /* includeMatchOnly */ false);
-            const typeshedPathEx = this.getTypeshedPathEx(execEnv, importFailureInfo);
+            const typeshedPathEx = this.getTypeshedPathEx(execEnv);
             if (typeshedPathEx) {
                 typeshedPaths = typeshedPaths ?? [];
                 typeshedPaths.push(typeshedPathEx);
@@ -1431,21 +1459,21 @@ class ImportResolver {
     // Returns the directory for a module within the stdlib typeshed directory.
     // If moduleDescriptor is provided, it is filtered based on the VERSIONS
     // file in the typeshed stubs.
-    _getStdlibTypeshedPath(customTypeshedPath, pythonVersion, pythonPlatform, importFailureInfo, moduleDescriptor) {
-        const subdirectory = this._getTypeshedSubdirectory(/* isStdLib */ true, customTypeshedPath, importFailureInfo);
+    _getStdlibTypeshedPath(customTypeshedPath, pythonVersion, pythonPlatform, importLogger, moduleDescriptor) {
+        const subdirectory = this._getTypeshedSubdirectory(/* isStdLib */ true, customTypeshedPath, importLogger);
         if (subdirectory &&
             moduleDescriptor &&
-            !this._isStdlibTypeshedStubValidForVersion(moduleDescriptor, customTypeshedPath, pythonVersion, pythonPlatform, importFailureInfo)) {
+            !this._isStdlibTypeshedStubValidForVersion(moduleDescriptor, customTypeshedPath, pythonVersion, pythonPlatform, importLogger)) {
             return undefined;
         }
         return subdirectory;
     }
-    _getThirdPartyTypeshedPath(customTypeshedPath, importFailureInfo) {
-        return this._getTypeshedSubdirectory(/* isStdLib */ false, customTypeshedPath, importFailureInfo);
+    _getThirdPartyTypeshedPath(customTypeshedPath, importLogger) {
+        return this._getTypeshedSubdirectory(/* isStdLib */ false, customTypeshedPath, importLogger);
     }
-    _isStdlibTypeshedStubValidForVersion(moduleDescriptor, customTypeshedPath, pythonVersion, pythonPlatform, importFailureInfo) {
+    _isStdlibTypeshedStubValidForVersion(moduleDescriptor, customTypeshedPath, pythonVersion, pythonPlatform, importLogger) {
         if (!this._cachedTypeshedStdLibModuleVersionInfo) {
-            this._cachedTypeshedStdLibModuleVersionInfo = this._readTypeshedStdLibVersions(customTypeshedPath, importFailureInfo);
+            this._cachedTypeshedStdLibModuleVersionInfo = this._readTypeshedStdLibVersions(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.
@@ -1476,11 +1504,10 @@ class ImportResolver {
         }
         return true;
     }
-    _readTypeshedStdLibVersions(customTypeshedPath, importFailureInfo) {
+    _readTypeshedStdLibVersions(customTypeshedPath, importLogger) {
         const versionRangeMap = new Map();
         // Read the VERSIONS file from typeshed.
-        const typeshedStdLibPath = this._getTypeshedSubdirectory(
-        /* isStdLib */ true, customTypeshedPath, importFailureInfo);
+        const typeshedStdLibPath = this._getTypeshedSubdirectory(/* isStdLib */ true, customTypeshedPath, importLogger);
         if (typeshedStdLibPath) {
             const versionsFilePath = typeshedStdLibPath.combinePaths('VERSIONS');
             try {
@@ -1554,17 +1581,17 @@ class ImportResolver {
                     });
                 }
                 else {
-                    importFailureInfo.push(`Typeshed stdlib VERSIONS file is unexpectedly large`);
+                    importLogger?.log(`Typeshed stdlib VERSIONS file is unexpectedly large`);
                 }
             }
             catch (e) {
-                importFailureInfo.push(`Could not read typeshed stdlib VERSIONS file: '${JSON.stringify(e)}'`);
+                importLogger?.log(`Could not read typeshed stdlib VERSIONS file: '${JSON.stringify(e)}'`);
             }
         }
         return versionRangeMap;
     }
-    _getThirdPartyTypeshedPackagePaths(moduleDescriptor, importFailureInfo, includeMatchOnly = true) {
-        const typeshedPath = this._getThirdPartyTypeshedPath(this._configOptions.typeshedPath, importFailureInfo);
+    _getThirdPartyTypeshedPackagePaths(moduleDescriptor, importLogger, includeMatchOnly = true) {
+        const typeshedPath = this._getThirdPartyTypeshedPath(this._configOptions.typeshedPath, importLogger);
         if (!this._cachedTypeshedThirdPartyPackagePaths) {
             this._buildTypeshedThirdPartyPackageMap(typeshedPath);
         }
@@ -1577,14 +1604,14 @@ class ImportResolver {
         }
         return [];
     }
-    _getThirdPartyTypeshedPackageRoots(importFailureInfo) {
-        const typeshedPath = this._getThirdPartyTypeshedPath(this._configOptions.typeshedPath, importFailureInfo);
+    _getThirdPartyTypeshedPackageRoots(importLogger) {
+        const typeshedPath = this._getThirdPartyTypeshedPath(this._configOptions.typeshedPath, importLogger);
         if (!this._cachedTypeshedThirdPartyPackagePaths) {
             this._buildTypeshedThirdPartyPackageMap(typeshedPath);
         }
         return this._cachedTypeshedThirdPartyPackageRoots;
     }
-    _getTypeshedRoot(customTypeshedPath, importFailureInfo) {
+    _getTypeshedRoot(customTypeshedPath, importLogger) {
         if (this._cachedTypeshedRoot === undefined) {
             let typeshedPath = undefined;
             // Did the user specify a typeshed path? If not, we'll look in the
@@ -1602,7 +1629,7 @@ class ImportResolver {
         }
         return this._cachedTypeshedRoot.isEmpty() ? undefined : this._cachedTypeshedRoot;
     }
-    _getTypeshedSubdirectory(isStdLib, customTypeshedPath, importFailureInfo) {
+    _getTypeshedSubdirectory(isStdLib, customTypeshedPath, importLogger) {
         // See if we have it cached.
         if (isStdLib) {
             if (this._cachedTypeshedStdLibPath !== undefined) {
@@ -1614,7 +1641,7 @@ class ImportResolver {
                 return this._cachedTypeshedThirdPartyPath;
             }
         }
-        let typeshedPath = this._getTypeshedRoot(customTypeshedPath, importFailureInfo);
+        let typeshedPath = this._getTypeshedRoot(customTypeshedPath, importLogger);
         if (typeshedPath === undefined) {
             return undefined;
         }
@@ -1631,40 +1658,40 @@ class ImportResolver {
         }
         return typeshedPath;
     }
-    _resolveRelativeImport(sourceFileUri, execEnv, moduleDescriptor, importName, importFailureInfo) {
-        importFailureInfo.push('Attempting to resolve relative import');
+    _resolveRelativeImport(sourceFileUri, execEnv, moduleDescriptor, importName, importLogger) {
+        importLogger?.log('Attempting to resolve relative import');
         // Determine which search path this file is part of.
         const directory = (0, importStatementUtils_1.getDirectoryLeadingDotsPointsTo)(sourceFileUri.getDirectory(), moduleDescriptor.leadingDots);
         if (!directory) {
-            importFailureInfo.push(`Invalid relative path '${importName}'`);
+            importLogger?.log(`Invalid relative path '${importName}'`);
             return undefined;
         }
         // Now try to match the module parts from the current directory location.
-        const absImport = this.resolveAbsoluteImport(sourceFileUri, directory, execEnv, moduleDescriptor, importName, importFailureInfo, 
+        const absImport = this.resolveAbsoluteImport(sourceFileUri, directory, execEnv, moduleDescriptor, importName, importLogger, 
         /* allowPartial */ false, 
         /* allowNativeLib */ true);
         if (absImport && absImport.isStubFile) {
             // If we found a stub for a relative import, only search
             // the same folder for the real module. Otherwise, it will
             // error out on runtime.
-            absImport.nonStubImportResult = this.resolveAbsoluteImport(sourceFileUri, directory, execEnv, moduleDescriptor, importName, importFailureInfo, 
+            absImport.nonStubImportResult = this.resolveAbsoluteImport(sourceFileUri, directory, execEnv, moduleDescriptor, importName, importLogger, 
             /* allowPartial */ false, 
             /* allowNativeLib */ true, 
             /* useStubPackage */ false, 
-            /* allowPyi */ false) || {
+            /* allowPyi */ false) ?? {
                 importName,
                 isRelative: true,
                 isImportFound: false,
                 isPartlyResolved: false,
                 isNamespacePackage: false,
                 isStubPackage: false,
-                importFailureInfo,
+                isInitFilePresent: false,
                 resolvedUris: [],
                 importType: 2 /* ImportType.Local */,
                 isStubFile: false,
                 isNativeLib: false,
-                implicitImports: [],
-                filteredImplicitImports: [],
+                implicitImports: undefined,
+                filteredImplicitImports: undefined,
                 nonStubImportResult: undefined,
             };
         }
@@ -1687,10 +1714,13 @@ class ImportResolver {
         let newCacheValue = [];
         try {
             const entriesInDir = this.readdirEntriesCached(dirPath);
-            const filesInDir = entriesInDir.filter((f) => f.isFile());
-            // Add any symbolic links that point to files.
-            entriesInDir.forEach((f) => {
-                if (f.isSymbolicLink() && (0, uriUtils_1.tryStat)(this.fileSystem, dirPath.combinePaths(f.name))?.isFile()) {
+            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);
                 }
             });
@@ -1737,7 +1767,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), this.fileSystem, currentPath);
+        const entries = (0, uriUtils_1.getFileSystemEntriesFromDirEntries)(this.readdirEntriesCached(currentPath).entries.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.
@@ -1792,8 +1822,7 @@ class ImportResolver {
         let importResult;
         if (strictOnly) {
             const importName = formatImportName(moduleDescriptor);
-            const importFailureInfo = [];
-            importResult = this._resolveImportStrict(importName, sourceFileUri, execEnv, moduleDescriptor, importFailureInfo);
+            importResult = this._resolveImportStrict(importName, sourceFileUri, execEnv, moduleDescriptor);
         }
         else {
             importResult = this.resolveImportInternal(sourceFileUri, execEnv, moduleDescriptor);
@@ -1829,7 +1858,7 @@ class ImportResolver {
         }
         return (0, pyTypedUtils_1.getPyTypedInfoForPyTypedFile)(this.fileSystem, filePath.pytypedUri);
     }
-    _findAndResolveNativeModule(fileDirectory, dirPath, execEnv, importName, moduleDescriptor, importFailureInfo, resolvedPaths) {
+    _findAndResolveNativeModule(fileDirectory, dirPath, execEnv, importName, moduleDescriptor, importLogger, resolvedPaths) {
         let isNativeLib = false;
         if (!execEnv.skipNativeLibraries && this.dirExistsCached(fileDirectory)) {
             const filesInDir = this._getFilesInDirectory(fileDirectory);
@@ -1837,28 +1866,28 @@ class ImportResolver {
             const nativeLibPath = filesInDir.find((f) => this._isNativeModuleFileName(dirName, f));
             if (nativeLibPath) {
                 // Try resolving native library to a custom stub.
-                isNativeLib = this._resolveNativeModuleWithStub(nativeLibPath, execEnv, importName, moduleDescriptor, importFailureInfo, resolvedPaths);
+                isNativeLib = this._resolveNativeModuleWithStub(nativeLibPath, execEnv, importName, moduleDescriptor, importLogger, resolvedPaths);
                 if (isNativeLib) {
-                    importFailureInfo.push(`Resolved with native lib '${nativeLibPath.toUserVisibleString()}'`);
+                    importLogger?.log(`Resolved with native lib '${nativeLibPath.toUserVisibleString()}'`);
                 }
             }
         }
         return isNativeLib;
     }
-    _resolveNativeModuleWithStub(nativeLibPath, execEnv, importName, moduleDescriptor, importFailureInfo, resolvedPaths) {
+    _resolveNativeModuleWithStub(nativeLibPath, execEnv, importName, moduleDescriptor, importLogger, resolvedPaths) {
         let moduleFullName = importName;
         if (moduleDescriptor.leadingDots > 0) {
             // Relative path. Convert `.mtrand` to `numpy.random.mtrand` based on search path.
             const info = this.getModuleNameForImport(nativeLibPath, execEnv);
             moduleFullName = info.moduleName.length > 0 ? info.moduleName : moduleFullName;
         }
-        const compiledStubPath = this.resolveNativeImportEx(nativeLibPath, moduleFullName, importFailureInfo);
+        const compiledStubPath = this.resolveNativeImportEx(nativeLibPath, moduleFullName, importLogger);
         if (compiledStubPath) {
-            importFailureInfo.push(`Resolved native import ${importName} with stub '${compiledStubPath}'`);
+            importLogger?.log(`Resolved native import ${importName} with stub '${compiledStubPath}'`);
             resolvedPaths.push(compiledStubPath);
             return false; // Resolved to a stub.
         }
-        importFailureInfo.push(`Resolved import with file '${nativeLibPath}'`);
+        importLogger?.log(`Resolved import with file '${nativeLibPath}'`);
         resolvedPaths.push(nativeLibPath);
         return true;
     }