@zzzen/pyright-internal 1.2.0-dev.20230416 → 1.2.0-dev.20230430

package/dist/analyzer/importResolver.js

@@ -34,8 +34,8 @@ 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 stringUtils_1 = require("../common/stringUtils");
 const StringUtils = __importStar(require("../common/stringUtils"));
+const stringUtils_1 = require("../common/stringUtils");
 const characters_1 = require("../parser/characters");
 const pyrightFileSystem_1 = require("../pyrightFileSystem");
 const importStatementUtils_1 = require("./importStatementUtils");
@@ -94,120 +94,9 @@ class ImportResolver {
     // Resolves the import and returns the path if it exists, otherwise
     // returns undefined.
     resolveImport(sourceFilePath, execEnv, moduleDescriptor) {
-        // Wrap internal call to _resolveImport() to prevent calling any
+        // Wrap internal call to resolveImportInternal() to prevent calling any
         // child class version of resolveImport().
-        return this._resolveImport(sourceFilePath, execEnv, moduleDescriptor);
-    }
-    // Resolves the import and returns the path if it exists, otherwise
-    // returns undefined.
-    _resolveImport(sourceFilePath, execEnv, moduleDescriptor) {
-        const importName = this.formatImportName(moduleDescriptor);
-        const importFailureInfo = [];
-        const importResult = this._resolveImportStrict(importName, sourceFilePath, execEnv, moduleDescriptor, importFailureInfo);
-        if (importResult.isImportFound || moduleDescriptor.leadingDots > 0) {
-            return importResult;
-        }
-        // If the import is absolute and no other method works, try resolving the
-        // absolute in the importing file's directory, then the parent directory,
-        // and so on, until the import root is reached.
-        sourceFilePath = (0, pathUtils_1.normalizePathCase)(this.fileSystem, (0, pathUtils_1.normalizePath)(sourceFilePath));
-        const origin = (0, pathUtils_1.ensureTrailingDirectorySeparator)((0, pathUtils_1.getDirectoryPath)(sourceFilePath));
-        const result = this.cachedParentImportResults.getImportResult(origin, importName, importResult);
-        if (result) {
-            // Already ran the parent directory resolution for this import name on this location.
-            return this.filterImplicitImports(result, moduleDescriptor.importedSymbols);
-        }
-        // Check whether the given file is in the parent directory import resolution cache.
-        const root = this.getParentImportResolutionRoot(sourceFilePath, execEnv.root);
-        if (!this.cachedParentImportResults.checkValidPath(this.fileSystem, sourceFilePath, root)) {
-            return importResult;
-        }
-        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)) {
-            const result = this.resolveAbsoluteImport(sourceFilePath, current, execEnv, moduleDescriptor, importName, [], 
-            /* allowPartial */ undefined, 
-            /* allowNativeLib */ undefined, 
-            /* useStubPackage */ false, 
-            /* allowPyi */ true);
-            this.cachedParentImportResults.checked(current, importName, importPath);
-            if (result.isImportFound) {
-                // This will make cache to point to actual path that contains the module we found
-                importPath.importPath = current;
-                this.cachedParentImportResults.add({
-                    importResult: result,
-                    path: current,
-                    importName,
-                });
-                return this.filterImplicitImports(result, moduleDescriptor.importedSymbols);
-            }
-            let success;
-            [success, current] = this._tryWalkUp(current);
-            if (!success) {
-                break;
-            }
-        }
-        this.cachedParentImportResults.checked(current, importName, importPath);
-        return importResult;
-    }
-    _resolveImportStrict(importName, sourceFilePath, execEnv, moduleDescriptor, importFailureInfo) {
-        const fromUserFile = (0, configOptions_1.matchFileSpecs)(this._configOptions, sourceFilePath);
-        const notFoundResult = {
-            importName,
-            isRelative: false,
-            isImportFound: false,
-            isPartlyResolved: false,
-            isNamespacePackage: false,
-            isInitFilePresent: false,
-            isStubPackage: false,
-            importFailureInfo,
-            resolvedPaths: [],
-            importType: 2 /* Local */,
-            isStubFile: false,
-            isNativeLib: false,
-            implicitImports: [],
-            filteredImplicitImports: [],
-            nonStubImportResult: undefined,
-        };
-        this.ensurePartialStubPackages(execEnv);
-        // Is it a relative import?
-        if (moduleDescriptor.leadingDots > 0) {
-            const relativeImport = this._resolveRelativeImport(sourceFilePath, execEnv, moduleDescriptor, importName, importFailureInfo);
-            if (relativeImport) {
-                relativeImport.isRelative = true;
-                return relativeImport;
-            }
-        }
-        else {
-            // Is it already cached?
-            const cachedResults = this._lookUpResultsInCache(execEnv, importName, moduleDescriptor.importedSymbols, fromUserFile);
-            if (cachedResults) {
-                // In most cases, we can simply return a cached entry. However, there are cases
-                // where the cached entry refers to a previously-resolved namespace package
-                // that does not resolve the symbols specified in the module descriptor.
-                // In this case, we will ignore the cached value and run the full import
-                // resolution again to try to find a package that resolves the import.
-                const isUnresolvedNamespace = cachedResults.isImportFound &&
-                    cachedResults.isNamespacePackage &&
-                    !this._isNamespacePackageResolved(moduleDescriptor, cachedResults.implicitImports);
-                if (!isUnresolvedNamespace) {
-                    return cachedResults;
-                }
-            }
-            const bestImport = this._resolveBestAbsoluteImport(sourceFilePath, execEnv, moduleDescriptor, 
-            /* allowPyi */ true);
-            if (bestImport) {
-                if (bestImport.isStubFile) {
-                    bestImport.nonStubImportResult =
-                        this._resolveBestAbsoluteImport(sourceFilePath, execEnv, moduleDescriptor, 
-                        /* allowPyi */ false) || notFoundResult;
-                }
-                return this.addResultsToCache(execEnv, importName, bestImport, moduleDescriptor.importedSymbols, fromUserFile);
-            }
-        }
-        return this.addResultsToCache(execEnv, importName, notFoundResult, 
-        /* importedSymbols */ undefined, fromUserFile);
+        return this.resolveImportInternal(sourceFilePath, execEnv, moduleDescriptor);
     }
     getCompletionSuggestions(sourceFilePath, execEnv, moduleDescriptor) {
         const suggestions = this._getCompletionSuggestionsStrict(sourceFilePath, execEnv, moduleDescriptor);
@@ -236,39 +125,6 @@ class ImportResolver {
         this._configOptions = configOptions;
         this.invalidateCache();
     }
-    _getCompletionSuggestionsStrict(sourceFilePath, execEnv, moduleDescriptor) {
-        const importFailureInfo = [];
-        const suggestions = new Map();
-        // Is it a relative import?
-        if (moduleDescriptor.leadingDots > 0) {
-            this._getCompletionSuggestionsRelative(sourceFilePath, execEnv, moduleDescriptor, suggestions);
-        }
-        else {
-            // First check for a typeshed file.
-            if (moduleDescriptor.nameParts.length > 0) {
-                this._getCompletionSuggestionsTypeshedPath(sourceFilePath, execEnv, moduleDescriptor, true, suggestions);
-            }
-            // Look for it in the root directory of the execution environment.
-            if (execEnv.root) {
-                this._getCompletionSuggestionsAbsolute(sourceFilePath, execEnv, execEnv.root, moduleDescriptor, suggestions);
-            }
-            for (const extraPath of execEnv.extraPaths) {
-                this._getCompletionSuggestionsAbsolute(sourceFilePath, execEnv, extraPath, moduleDescriptor, suggestions);
-            }
-            // Check for a typings file.
-            if (this._configOptions.stubPath) {
-                this._getCompletionSuggestionsAbsolute(sourceFilePath, execEnv, this._configOptions.stubPath, moduleDescriptor, suggestions);
-            }
-            // Check for a typeshed file.
-            this._getCompletionSuggestionsTypeshedPath(sourceFilePath, execEnv, moduleDescriptor, false, suggestions);
-            // Look for the import in the list of third-party packages.
-            const pythonSearchPaths = this.getPythonSearchPaths(importFailureInfo);
-            for (const searchPath of pythonSearchPaths) {
-                this._getCompletionSuggestionsAbsolute(sourceFilePath, execEnv, searchPath, moduleDescriptor, suggestions);
-            }
-        }
-        return suggestions;
-    }
     // Returns the implementation file(s) for the given stub file.
     getSourceFilesFromStub(stubFilePath, execEnv, _mapCompiled) {
         const sourceFilePaths = [];
@@ -369,167 +225,42 @@ class ImportResolver {
         const cache = (0, collectionUtils_1.getOrAdd)(this._cachedModuleNameResults, execEnv.root, () => new Map());
         return (0, collectionUtils_1.getOrAdd)(cache, filePath, () => this._getModuleNameForImport(filePath, execEnv, allowInvalidModuleName));
     }
-    _getModuleNameForImport(filePath, execEnv, allowInvalidModuleName) {
-        let moduleName;
-        let importType = 0 /* BuiltIn */;
-        let isLocalTypingsFile = false;
+    getTypeshedStdLibPath(execEnv) {
+        const unused = [];
+        return this._getStdlibTypeshedPath(execEnv, unused);
+    }
+    getTypeshedThirdPartyPath(execEnv) {
+        const unused = [];
+        return this._getThirdPartyTypeshedPath(execEnv, unused);
+    }
+    isStdlibModule(module, execEnv) {
+        if (!this._stdlibModules) {
+            this._stdlibModules = this._buildStdlibCache(this.getTypeshedStdLibPath(execEnv));
+        }
+        return this._stdlibModules.has(module.nameParts.join('.'));
+    }
+    getImportRoots(execEnv, forLogging = 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(execEnv, importFailureInfo);
-        if (stdLibTypeshedPath) {
-            moduleName = this.getModuleNameFromPath(stdLibTypeshedPath, filePath);
-            if (moduleName) {
-                const moduleDescriptor = {
-                    leadingDots: 0,
-                    nameParts: moduleName.split('.'),
-                    importedSymbols: undefined,
-                };
-                if (this._isStdlibTypeshedStubValidForVersion(moduleDescriptor, execEnv, [])) {
-                    return { moduleName, importType, isLocalTypingsFile };
-                }
-            }
+        const roots = [];
+        const stdTypeshed = this._getStdlibTypeshedPath(execEnv, importFailureInfo);
+        if (stdTypeshed) {
+            roots.push(stdTypeshed);
         }
-        // Look for it in the root directory of the execution environment.
+        // The "default" workspace has a root-less execution environment; ignore it.
         if (execEnv.root) {
-            const candidateModuleNameInfo = this.getModuleNameInfoFromPath(execEnv.root, filePath);
-            if (candidateModuleNameInfo) {
-                if (candidateModuleNameInfo.containsInvalidCharacters) {
-                    moduleNameWithInvalidCharacters = candidateModuleNameInfo.moduleName;
-                }
-                else {
-                    moduleName = candidateModuleNameInfo.moduleName;
-                }
-            }
-            importType = 2 /* Local */;
-        }
-        for (const extraPath of execEnv.extraPaths) {
-            const candidateModuleNameInfo = this.getModuleNameInfoFromPath(extraPath, filePath);
-            if (candidateModuleNameInfo) {
-                if (candidateModuleNameInfo.containsInvalidCharacters) {
-                    moduleNameWithInvalidCharacters = candidateModuleNameInfo.moduleName;
-                }
-                else {
-                    // Does this candidate look better than the previous best module name?
-                    // We'll always try to use the shortest version.
-                    const candidateModuleName = candidateModuleNameInfo.moduleName;
-                    if (!moduleName || (candidateModuleName && candidateModuleName.length < moduleName.length)) {
-                        moduleName = candidateModuleName;
-                        importType = 2 /* Local */;
-                    }
-                }
-            }
+            roots.push(execEnv.root);
         }
-        // Check for a typings file.
+        (0, collectionUtils_1.appendArray)(roots, execEnv.extraPaths);
         if (this._configOptions.stubPath) {
-            const candidateModuleNameInfo = this.getModuleNameInfoFromPath(this._configOptions.stubPath, filePath);
-            if (candidateModuleNameInfo) {
-                if (candidateModuleNameInfo.containsInvalidCharacters) {
-                    moduleNameWithInvalidCharacters = candidateModuleNameInfo.moduleName;
-                }
-                else {
-                    // Does this candidate look better than the previous best module name?
-                    // We'll always try to use the shortest version.
-                    const candidateModuleName = candidateModuleNameInfo.moduleName;
-                    if (!moduleName || (candidateModuleName && candidateModuleName.length < moduleName.length)) {
-                        moduleName = candidateModuleName;
-                        // Treat the typings path as a local import so errors are reported for it.
-                        importType = 2 /* Local */;
-                        isLocalTypingsFile = true;
-                    }
-                }
-            }
+            roots.push(this._configOptions.stubPath);
         }
-        // Check for a typeshed file.
-        const thirdPartyTypeshedPath = this._getThirdPartyTypeshedPath(execEnv, importFailureInfo);
-        if (thirdPartyTypeshedPath) {
-            const candidateModuleName = this.getModuleNameFromPath(thirdPartyTypeshedPath, filePath, 
-            /* stripTopContainerDir */ true);
-            // Does this candidate look better than the previous best module name?
-            // We'll always try to use the shortest version.
-            if (!moduleName || (candidateModuleName && candidateModuleName.length < moduleName.length)) {
-                moduleName = candidateModuleName;
-                importType = 1 /* ThirdParty */;
-            }
-        }
-        const thirdPartyTypeshedPathEx = this.getTypeshedPathEx(execEnv, importFailureInfo);
-        if (thirdPartyTypeshedPathEx) {
-            const candidateModuleName = this.getModuleNameFromPath(thirdPartyTypeshedPathEx, filePath);
-            // Does this candidate look better than the previous best module name?
-            // We'll always try to use the shortest version.
-            if (!moduleName || (candidateModuleName && candidateModuleName.length < moduleName.length)) {
-                moduleName = candidateModuleName;
-                importType = 1 /* ThirdParty */;
-            }
-        }
-        // Look for the import in the list of third-party packages.
-        const pythonSearchPaths = this.getPythonSearchPaths(importFailureInfo);
-        for (const searchPath of pythonSearchPaths) {
-            const candidateModuleNameInfo = this.getModuleNameInfoFromPath(searchPath, filePath);
-            if (candidateModuleNameInfo) {
-                if (candidateModuleNameInfo.containsInvalidCharacters) {
-                    moduleNameWithInvalidCharacters = candidateModuleNameInfo.moduleName;
-                }
-                else {
-                    // Does this candidate look better than the previous best module name?
-                    // We'll always try to use the shortest version.
-                    const candidateModuleName = candidateModuleNameInfo.moduleName;
-                    if (!moduleName || (candidateModuleName && candidateModuleName.length < moduleName.length)) {
-                        moduleName = candidateModuleName;
-                        importType = 1 /* ThirdParty */;
-                    }
-                }
-            }
-        }
-        if (moduleName) {
-            return { moduleName, importType, isLocalTypingsFile };
-        }
-        if (allowInvalidModuleName && moduleNameWithInvalidCharacters) {
-            return { moduleName: moduleNameWithInvalidCharacters, importType, isLocalTypingsFile };
-        }
-        // We didn't find any module name.
-        return { moduleName: '', importType: 2 /* Local */, isLocalTypingsFile };
-    }
-    getTypeshedStdLibPath(execEnv) {
-        const unused = [];
-        return this._getStdlibTypeshedPath(execEnv, unused);
-    }
-    getTypeshedThirdPartyPath(execEnv) {
-        const unused = [];
-        return this._getThirdPartyTypeshedPath(execEnv, unused);
-    }
-    isStdlibModule(module, execEnv) {
-        if (!this._stdlibModules) {
-            this._stdlibModules = this._buildStdlibCache(this.getTypeshedStdLibPath(execEnv));
-        }
-        return this._stdlibModules.has(module.nameParts.join('.'));
-    }
-    getImportRoots(execEnv, forLogging = false) {
-        const importFailureInfo = [];
-        const roots = [];
-        const stdTypeshed = this._getStdlibTypeshedPath(execEnv, importFailureInfo);
-        if (stdTypeshed) {
-            roots.push(stdTypeshed);
-        }
-        // The "default" workspace has a root-less execution environment; ignore it.
-        if (execEnv.root) {
-            roots.push(execEnv.root);
-        }
-        (0, collectionUtils_1.appendArray)(roots, execEnv.extraPaths);
-        if (this._configOptions.stubPath) {
-            roots.push(this._configOptions.stubPath);
-        }
-        if (forLogging) {
-            // 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(execEnv, importFailureInfo);
-            if (thirdPartyRoot) {
-                roots.push((0, pathUtils_1.combinePaths)(thirdPartyRoot, '...'));
+        if (forLogging) {
+            // 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(execEnv, importFailureInfo);
+            if (thirdPartyRoot) {
+                roots.push((0, pathUtils_1.combinePaths)(thirdPartyRoot, '...'));
             }
         }
         else {
@@ -546,6 +277,45 @@ class ImportResolver {
         }
         return roots;
     }
+    ensurePartialStubPackages(execEnv) {
+        if (!pyrightFileSystem_1.SupportPartialStubs.is(this.fileSystem)) {
+            return false;
+        }
+        if (this.fileSystem.isPartialStubPackagesScanned(execEnv)) {
+            return false;
+        }
+        const fs = this.fileSystem;
+        const ignored = [];
+        const paths = [];
+        const typeshedPathEx = this.getTypeshedPathEx(execEnv, ignored);
+        // Add paths to search stub packages.
+        addPaths(this._configOptions.stubPath);
+        addPaths(execEnv.root);
+        execEnv.extraPaths.forEach((p) => addPaths(p));
+        addPaths(typeshedPathEx);
+        this.getPythonSearchPaths(ignored).forEach((p) => addPaths(p));
+        this.fileSystem.processPartialStubPackages(paths, this.getImportRoots(execEnv), typeshedPathEx);
+        this._invalidateFileSystemCache();
+        return true;
+        function addPaths(path) {
+            if (!path || fs.isPathScanned(path)) {
+                return;
+            }
+            paths.push(path);
+        }
+    }
+    getPythonSearchPaths(importFailureInfo) {
+        // 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));
+            // Remove duplicates (yes, it happens).
+            this._cachedPythonSearchPaths = { paths: [...new Set(paths)], failureInfo: info };
+        }
+        // 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;
+    }
     readdirEntriesCached(path) {
         const cachedValue = this._cachedEntriesForPath.get(path);
         if (cachedValue) {
@@ -562,6 +332,59 @@ class ImportResolver {
         this._cachedEntriesForPath.set(path, newCacheValue);
         return newCacheValue;
     }
+    // Resolves the import and returns the path if it exists, otherwise
+    // returns undefined.
+    resolveImportInternal(sourceFilePath, execEnv, moduleDescriptor) {
+        const importName = this.formatImportName(moduleDescriptor);
+        const importFailureInfo = [];
+        const importResult = this._resolveImportStrict(importName, sourceFilePath, execEnv, moduleDescriptor, importFailureInfo);
+        if (importResult.isImportFound || moduleDescriptor.leadingDots > 0) {
+            return importResult;
+        }
+        // If the import is absolute and no other method works, try resolving the
+        // absolute in the importing file's directory, then the parent directory,
+        // and so on, until the import root is reached.
+        sourceFilePath = (0, pathUtils_1.normalizePathCase)(this.fileSystem, (0, pathUtils_1.normalizePath)(sourceFilePath));
+        const origin = (0, pathUtils_1.ensureTrailingDirectorySeparator)((0, pathUtils_1.getDirectoryPath)(sourceFilePath));
+        const result = this.cachedParentImportResults.getImportResult(origin, importName, importResult);
+        if (result) {
+            // Already ran the parent directory resolution for this import name on this location.
+            return this.filterImplicitImports(result, moduleDescriptor.importedSymbols);
+        }
+        // Check whether the given file is in the parent directory import resolution cache.
+        const root = this.getParentImportResolutionRoot(sourceFilePath, execEnv.root);
+        if (!this.cachedParentImportResults.checkValidPath(this.fileSystem, sourceFilePath, root)) {
+            return importResult;
+        }
+        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)) {
+            const result = this.resolveAbsoluteImport(sourceFilePath, current, execEnv, moduleDescriptor, importName, [], 
+            /* allowPartial */ undefined, 
+            /* allowNativeLib */ undefined, 
+            /* useStubPackage */ false, 
+            /* allowPyi */ true);
+            this.cachedParentImportResults.checked(current, importName, importPath);
+            if (result.isImportFound) {
+                // This will make cache to point to actual path that contains the module we found
+                importPath.importPath = current;
+                this.cachedParentImportResults.add({
+                    importResult: result,
+                    path: current,
+                    importName,
+                });
+                return this.filterImplicitImports(result, moduleDescriptor.importedSymbols);
+            }
+            let success;
+            [success, current] = this._tryWalkUp(current);
+            if (!success) {
+                break;
+            }
+        }
+        this.cachedParentImportResults.checked(current, importName, importPath);
+        return importResult;
+    }
     fileExistsCached(path) {
         var _a, _b;
         const splitPath = this._splitPath(path);
@@ -591,75 +414,367 @@ class ImportResolver {
             if (!this.fileSystem.existsSync(path)) {
                 return false;
             }
-            return (_b = (_a = (0, pathUtils_1.tryStat)(this.fileSystem, path)) === null || _a === void 0 ? void 0 : _a.isDirectory()) !== null && _b !== void 0 ? _b : false;
-        }
-        const entries = this.readdirEntriesCached(splitPath[0]);
-        const entry = entries.find((entry) => entry.name === splitPath[1]);
-        if (entry === null || entry === void 0 ? void 0 : entry.isDirectory()) {
-            return true;
+            return (_b = (_a = (0, pathUtils_1.tryStat)(this.fileSystem, path)) === null || _a === void 0 ? void 0 : _a.isDirectory()) !== null && _b !== void 0 ? _b : false;
+        }
+        const entries = this.readdirEntriesCached(splitPath[0]);
+        const entry = entries.find((entry) => entry.name === splitPath[1]);
+        if (entry === null || entry === void 0 ? void 0 : entry.isDirectory()) {
+            return true;
+        }
+        if (entry === null || entry === void 0 ? void 0 : entry.isSymbolicLink()) {
+            const realPath = (0, pathUtils_1.tryRealpath)(this.fileSystem, path);
+            if (realPath && this.fileSystem.existsSync(realPath) && (0, pathUtils_1.isDirectory)(this.fileSystem, realPath)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    addResultsToCache(execEnv, importName, importResult, importedSymbols, fromUserFile) {
+        (0, collectionUtils_1.getOrAdd)(this._cachedImportResults, execEnv.root, () => new Map()).set(this._getCacheKey(importName, fromUserFile), importResult);
+        return this.filterImplicitImports(importResult, importedSymbols);
+    }
+    // Follows import resolution algorithm defined in PEP-420:
+    // https://www.python.org/dev/peps/pep-0420/
+    resolveAbsoluteImport(sourceFilePath, rootPath, execEnv, moduleDescriptor, importName, importFailureInfo, allowPartial = false, allowNativeLib = false, useStubPackage = false, allowPyi = true, lookForPyTyped = false) {
+        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(sourceFilePath, rootPath, execEnv, moduleDescriptor, importName, importFailureInfo, allowPartial, 
+            /* allowNativeLib */ false, 
+            /* useStubPackage */ true, 
+            /* allowPyi */ true, 
+            /* lookForPyTyped */ true);
+            // We found fully typed stub packages.
+            if (importResult.packageDirectory) {
+                // If this is a namespace package that wasn't resolved, assume that
+                // it's a partial stub package and continue looking for a real package.
+                if (!importResult.isNamespacePackage || importResult.isImportFound) {
+                    return importResult;
+                }
+            }
+        }
+        return this._resolveAbsoluteImport(sourceFilePath, rootPath, execEnv, moduleDescriptor, importName, importFailureInfo, allowPartial, allowNativeLib, 
+        /* useStubPackage */ false, allowPyi, lookForPyTyped);
+    }
+    // Intended to be overridden by subclasses to provide additional stub
+    // path capabilities. Return undefined if no extra stub path were found.
+    getTypeshedPathEx(execEnv, importFailureInfo) {
+        return undefined;
+    }
+    // Intended to be overridden by subclasses to provide additional stub
+    // resolving capabilities. Return undefined if no stubs were found for
+    // this import.
+    resolveImportEx(sourceFilePath, execEnv, moduleDescriptor, importName, importFailureInfo = [], 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(libraryFilePath, importName, importFailureInfo = []) {
+        return undefined;
+    }
+    getNativeModuleName(fileName) {
+        const fileExtension = (0, pathUtils_1.getFileExtension)(fileName, /* multiDotExtension */ false).toLowerCase();
+        if (this._isNativeModuleFileExtension(fileExtension)) {
+            return (0, pathUtils_1.stripFileExtension)((0, pathUtils_1.stripFileExtension)(fileName));
+        }
+        return undefined;
+    }
+    getModuleNameFromPath(containerPath, filePath, stripTopContainerDir = false) {
+        const moduleNameInfo = this.getModuleNameInfoFromPath(containerPath, filePath, stripTopContainerDir);
+        if (!moduleNameInfo || moduleNameInfo.containsInvalidCharacters) {
+            return undefined;
+        }
+        return moduleNameInfo.moduleName;
+    }
+    getModuleNameInfoFromPath(containerPath, filePath, stripTopContainerDir = false) {
+        containerPath = (0, pathUtils_1.ensureTrailingDirectorySeparator)(containerPath);
+        let filePathWithoutExtension = (0, pathUtils_1.stripFileExtension)(filePath);
+        // If module is native, strip platform part, such as 'cp36-win_amd64' in 'mtrand.cp36-win_amd64'.
+        if (this._isNativeModuleFileExtension((0, pathUtils_1.getFileExtension)(filePath))) {
+            filePathWithoutExtension = (0, pathUtils_1.stripFileExtension)(filePathWithoutExtension);
+        }
+        if (!filePathWithoutExtension.startsWith(containerPath)) {
+            return undefined;
+        }
+        // Strip off the '/__init__' if it's present.
+        if (filePathWithoutExtension.endsWith('__init__')) {
+            filePathWithoutExtension = filePathWithoutExtension.substr(0, filePathWithoutExtension.length - 9);
+        }
+        const relativeFilePath = filePathWithoutExtension.substr(containerPath.length);
+        const parts = (0, pathUtils_1.getPathComponents)(relativeFilePath);
+        parts.shift();
+        if (stripTopContainerDir) {
+            if (parts.length === 0) {
+                return undefined;
+            }
+            parts.shift();
+        }
+        if (parts.length === 0) {
+            return undefined;
+        }
+        // Handle the case where the symbol was resolved to a stubs package
+        // rather than the real package. We'll strip off the "-stubs" suffix
+        // in this case.
+        if (parts[0].endsWith(pathConsts_1.stubsSuffix)) {
+            parts[0] = parts[0].substr(0, parts[0].length - pathConsts_1.stubsSuffix.length);
+        }
+        // Check whether parts contains invalid characters.
+        const containsInvalidCharacters = parts.some((p) => !this._isIdentifier(p));
+        return {
+            moduleName: parts.join('.'),
+            containsInvalidCharacters,
+        };
+    }
+    // Potentially modifies the ImportResult by removing some or all of the
+    // implicit import entries. Only the imported symbols should be included.
+    filterImplicitImports(importResult, importedSymbols) {
+        if (importedSymbols === undefined) {
+            const newImportResult = Object.assign({}, importResult);
+            newImportResult.filteredImplicitImports = [];
+            return newImportResult;
+        }
+        if (importedSymbols.length === 0) {
+            return importResult;
+        }
+        if (importResult.implicitImports.length === 0) {
+            return importResult;
+        }
+        const filteredImplicitImports = importResult.implicitImports.filter((implicitImport) => {
+            return importedSymbols.some((sym) => sym === implicitImport.name);
+        });
+        if (filteredImplicitImports.length === importResult.implicitImports.length) {
+            return importResult;
+        }
+        const newImportResult = Object.assign({}, importResult);
+        newImportResult.filteredImplicitImports = filteredImplicitImports;
+        return newImportResult;
+    }
+    formatImportName(moduleDescriptor) {
+        return '.'.repeat(moduleDescriptor.leadingDots) + moduleDescriptor.nameParts.join('.');
+    }
+    getParentImportResolutionRoot(sourceFilePath, executionRoot) {
+        if (executionRoot) {
+            return (0, pathUtils_1.ensureTrailingDirectorySeparator)((0, pathUtils_1.normalizePathCase)(this.fileSystem, (0, pathUtils_1.normalizePath)(executionRoot)));
+        }
+        return (0, pathUtils_1.ensureTrailingDirectorySeparator)((0, pathUtils_1.getDirectoryPath)(sourceFilePath));
+    }
+    _resolveImportStrict(importName, sourceFilePath, execEnv, moduleDescriptor, importFailureInfo) {
+        const fromUserFile = (0, configOptions_1.matchFileSpecs)(this._configOptions, sourceFilePath);
+        const notFoundResult = {
+            importName,
+            isRelative: false,
+            isImportFound: false,
+            isPartlyResolved: false,
+            isNamespacePackage: false,
+            isInitFilePresent: false,
+            isStubPackage: false,
+            importFailureInfo,
+            resolvedPaths: [],
+            importType: 2 /* Local */,
+            isStubFile: false,
+            isNativeLib: false,
+            implicitImports: [],
+            filteredImplicitImports: [],
+            nonStubImportResult: undefined,
+        };
+        this.ensurePartialStubPackages(execEnv);
+        // Is it a relative import?
+        if (moduleDescriptor.leadingDots > 0) {
+            const relativeImport = this._resolveRelativeImport(sourceFilePath, execEnv, moduleDescriptor, importName, importFailureInfo);
+            if (relativeImport) {
+                relativeImport.isRelative = true;
+                return relativeImport;
+            }
+        }
+        else {
+            // Is it already cached?
+            const cachedResults = this._lookUpResultsInCache(execEnv, importName, moduleDescriptor.importedSymbols, fromUserFile);
+            if (cachedResults) {
+                // In most cases, we can simply return a cached entry. However, there are cases
+                // where the cached entry refers to a previously-resolved namespace package
+                // that does not resolve the symbols specified in the module descriptor.
+                // In this case, we will ignore the cached value and run the full import
+                // resolution again to try to find a package that resolves the import.
+                const isUnresolvedNamespace = cachedResults.isImportFound &&
+                    cachedResults.isNamespacePackage &&
+                    !this._isNamespacePackageResolved(moduleDescriptor, cachedResults.implicitImports);
+                if (!isUnresolvedNamespace) {
+                    return cachedResults;
+                }
+            }
+            const bestImport = this._resolveBestAbsoluteImport(sourceFilePath, execEnv, moduleDescriptor, 
+            /* allowPyi */ true);
+            if (bestImport) {
+                if (bestImport.isStubFile) {
+                    bestImport.nonStubImportResult =
+                        this._resolveBestAbsoluteImport(sourceFilePath, execEnv, moduleDescriptor, 
+                        /* allowPyi */ false) || notFoundResult;
+                }
+                return this.addResultsToCache(execEnv, importName, bestImport, moduleDescriptor.importedSymbols, fromUserFile);
+            }
+        }
+        return this.addResultsToCache(execEnv, importName, notFoundResult, 
+        /* importedSymbols */ undefined, fromUserFile);
+    }
+    _getCompletionSuggestionsStrict(sourceFilePath, execEnv, moduleDescriptor) {
+        const importFailureInfo = [];
+        const suggestions = new Map();
+        // Is it a relative import?
+        if (moduleDescriptor.leadingDots > 0) {
+            this._getCompletionSuggestionsRelative(sourceFilePath, execEnv, moduleDescriptor, suggestions);
+        }
+        else {
+            // First check for a typeshed file.
+            if (moduleDescriptor.nameParts.length > 0) {
+                this._getCompletionSuggestionsTypeshedPath(sourceFilePath, execEnv, moduleDescriptor, true, suggestions);
+            }
+            // Look for it in the root directory of the execution environment.
+            if (execEnv.root) {
+                this._getCompletionSuggestionsAbsolute(sourceFilePath, execEnv, execEnv.root, moduleDescriptor, suggestions);
+            }
+            for (const extraPath of execEnv.extraPaths) {
+                this._getCompletionSuggestionsAbsolute(sourceFilePath, execEnv, extraPath, moduleDescriptor, suggestions);
+            }
+            // Check for a typings file.
+            if (this._configOptions.stubPath) {
+                this._getCompletionSuggestionsAbsolute(sourceFilePath, execEnv, this._configOptions.stubPath, moduleDescriptor, suggestions);
+            }
+            // Check for a typeshed file.
+            this._getCompletionSuggestionsTypeshedPath(sourceFilePath, execEnv, moduleDescriptor, false, suggestions);
+            // Look for the import in the list of third-party packages.
+            const pythonSearchPaths = this.getPythonSearchPaths(importFailureInfo);
+            for (const searchPath of pythonSearchPaths) {
+                this._getCompletionSuggestionsAbsolute(sourceFilePath, execEnv, searchPath, moduleDescriptor, suggestions);
+            }
+        }
+        return suggestions;
+    }
+    _getModuleNameForImport(filePath, execEnv, allowInvalidModuleName) {
+        let moduleName;
+        let importType = 0 /* BuiltIn */;
+        let isLocalTypingsFile = 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(execEnv, importFailureInfo);
+        if (stdLibTypeshedPath) {
+            moduleName = this.getModuleNameFromPath(stdLibTypeshedPath, filePath);
+            if (moduleName) {
+                const moduleDescriptor = {
+                    leadingDots: 0,
+                    nameParts: moduleName.split('.'),
+                    importedSymbols: undefined,
+                };
+                if (this._isStdlibTypeshedStubValidForVersion(moduleDescriptor, execEnv, [])) {
+                    return { moduleName, importType, isLocalTypingsFile };
+                }
+            }
+        }
+        // Look for it in the root directory of the execution environment.
+        if (execEnv.root) {
+            const candidateModuleNameInfo = this.getModuleNameInfoFromPath(execEnv.root, filePath);
+            if (candidateModuleNameInfo) {
+                if (candidateModuleNameInfo.containsInvalidCharacters) {
+                    moduleNameWithInvalidCharacters = candidateModuleNameInfo.moduleName;
+                }
+                else {
+                    moduleName = candidateModuleNameInfo.moduleName;
+                }
+            }
+            importType = 2 /* Local */;
         }
-        if (entry === null || entry === void 0 ? void 0 : entry.isSymbolicLink()) {
-            const realPath = (0, pathUtils_1.tryRealpath)(this.fileSystem, path);
-            if (realPath && this.fileSystem.existsSync(realPath) && (0, pathUtils_1.isDirectory)(this.fileSystem, realPath)) {
-                return true;
+        for (const extraPath of execEnv.extraPaths) {
+            const candidateModuleNameInfo = this.getModuleNameInfoFromPath(extraPath, filePath);
+            if (candidateModuleNameInfo) {
+                if (candidateModuleNameInfo.containsInvalidCharacters) {
+                    moduleNameWithInvalidCharacters = candidateModuleNameInfo.moduleName;
+                }
+                else {
+                    // Does this candidate look better than the previous best module name?
+                    // We'll always try to use the shortest version.
+                    const candidateModuleName = candidateModuleNameInfo.moduleName;
+                    if (!moduleName || (candidateModuleName && candidateModuleName.length < moduleName.length)) {
+                        moduleName = candidateModuleName;
+                        importType = 2 /* Local */;
+                    }
+                }
             }
         }
-        return false;
-    }
-    ensurePartialStubPackages(execEnv) {
-        if (!pyrightFileSystem_1.SupportPartialStubs.is(this.fileSystem)) {
-            return false;
+        // Check for a typings file.
+        if (this._configOptions.stubPath) {
+            const candidateModuleNameInfo = this.getModuleNameInfoFromPath(this._configOptions.stubPath, filePath);
+            if (candidateModuleNameInfo) {
+                if (candidateModuleNameInfo.containsInvalidCharacters) {
+                    moduleNameWithInvalidCharacters = candidateModuleNameInfo.moduleName;
+                }
+                else {
+                    // Does this candidate look better than the previous best module name?
+                    // We'll always try to use the shortest version.
+                    const candidateModuleName = candidateModuleNameInfo.moduleName;
+                    if (!moduleName || (candidateModuleName && candidateModuleName.length < moduleName.length)) {
+                        moduleName = candidateModuleName;
+                        // Treat the typings path as a local import so errors are reported for it.
+                        importType = 2 /* Local */;
+                        isLocalTypingsFile = true;
+                    }
+                }
+            }
         }
-        if (this.fileSystem.isPartialStubPackagesScanned(execEnv)) {
-            return false;
+        // Check for a typeshed file.
+        const thirdPartyTypeshedPath = this._getThirdPartyTypeshedPath(execEnv, importFailureInfo);
+        if (thirdPartyTypeshedPath) {
+            const candidateModuleName = this.getModuleNameFromPath(thirdPartyTypeshedPath, filePath, 
+            /* stripTopContainerDir */ true);
+            // Does this candidate look better than the previous best module name?
+            // We'll always try to use the shortest version.
+            if (!moduleName || (candidateModuleName && candidateModuleName.length < moduleName.length)) {
+                moduleName = candidateModuleName;
+                importType = 1 /* ThirdParty */;
+            }
         }
-        const fs = this.fileSystem;
-        const ignored = [];
-        const paths = [];
-        const typeshedPathEx = this.getTypeshedPathEx(execEnv, ignored);
-        // Add paths to search stub packages.
-        addPaths(this._configOptions.stubPath);
-        addPaths(execEnv.root);
-        execEnv.extraPaths.forEach((p) => addPaths(p));
-        addPaths(typeshedPathEx);
-        this.getPythonSearchPaths(ignored).forEach((p) => addPaths(p));
-        this.fileSystem.processPartialStubPackages(paths, this.getImportRoots(execEnv), typeshedPathEx);
-        this._invalidateFileSystemCache();
-        return true;
-        function addPaths(path) {
-            if (!path || fs.isPathScanned(path)) {
-                return;
+        const thirdPartyTypeshedPathEx = this.getTypeshedPathEx(execEnv, importFailureInfo);
+        if (thirdPartyTypeshedPathEx) {
+            const candidateModuleName = this.getModuleNameFromPath(thirdPartyTypeshedPathEx, filePath);
+            // Does this candidate look better than the previous best module name?
+            // We'll always try to use the shortest version.
+            if (!moduleName || (candidateModuleName && candidateModuleName.length < moduleName.length)) {
+                moduleName = candidateModuleName;
+                importType = 1 /* ThirdParty */;
             }
-            paths.push(path);
         }
-    }
-    addResultsToCache(execEnv, importName, importResult, importedSymbols, fromUserFile) {
-        (0, collectionUtils_1.getOrAdd)(this._cachedImportResults, execEnv.root, () => new Map()).set(this._getCacheKey(importName, fromUserFile), importResult);
-        return this.filterImplicitImports(importResult, importedSymbols);
-    }
-    // Follows import resolution algorithm defined in PEP-420:
-    // https://www.python.org/dev/peps/pep-0420/
-    resolveAbsoluteImport(sourceFilePath, rootPath, execEnv, moduleDescriptor, importName, importFailureInfo, allowPartial = false, allowNativeLib = false, useStubPackage = false, allowPyi = true, lookForPyTyped = false) {
-        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(sourceFilePath, rootPath, execEnv, moduleDescriptor, importName, importFailureInfo, allowPartial, 
-            /* allowNativeLib */ false, 
-            /* useStubPackage */ true, 
-            /* allowPyi */ true, 
-            /* lookForPyTyped */ true);
-            // We found fully typed stub packages.
-            if (importResult.packageDirectory) {
-                // If this is a namespace package that wasn't resolved, assume that
-                // it's a partial stub package and continue looking for a real package.
-                if (!importResult.isNamespacePackage || importResult.isImportFound) {
-                    return importResult;
+        // Look for the import in the list of third-party packages.
+        const pythonSearchPaths = this.getPythonSearchPaths(importFailureInfo);
+        for (const searchPath of pythonSearchPaths) {
+            const candidateModuleNameInfo = this.getModuleNameInfoFromPath(searchPath, filePath);
+            if (candidateModuleNameInfo) {
+                if (candidateModuleNameInfo.containsInvalidCharacters) {
+                    moduleNameWithInvalidCharacters = candidateModuleNameInfo.moduleName;
+                }
+                else {
+                    // Does this candidate look better than the previous best module name?
+                    // We'll always try to use the shortest version.
+                    const candidateModuleName = candidateModuleNameInfo.moduleName;
+                    if (!moduleName || (candidateModuleName && candidateModuleName.length < moduleName.length)) {
+                        moduleName = candidateModuleName;
+                        importType = 1 /* ThirdParty */;
+                    }
                 }
             }
         }
-        return this._resolveAbsoluteImport(sourceFilePath, rootPath, execEnv, moduleDescriptor, importName, importFailureInfo, allowPartial, allowNativeLib, 
-        /* useStubPackage */ false, allowPyi, lookForPyTyped);
+        if (moduleName) {
+            return { moduleName, importType, isLocalTypingsFile };
+        }
+        if (allowInvalidModuleName && moduleNameWithInvalidCharacters) {
+            return { moduleName: moduleNameWithInvalidCharacters, importType, isLocalTypingsFile };
+        }
+        // We didn't find any module name.
+        return { moduleName: '', importType: 2 /* Local */, isLocalTypingsFile };
     }
     _invalidateFileSystemCache() {
         this._cachedEntriesForPath.clear();
@@ -842,30 +957,6 @@ class ImportResolver {
             packageDirectory,
         };
     }
-    // Intended to be overridden by subclasses to provide additional stub
-    // path capabilities. Return undefined if no extra stub path were found.
-    getTypeshedPathEx(execEnv, importFailureInfo) {
-        return undefined;
-    }
-    // Intended to be overridden by subclasses to provide additional stub
-    // resolving capabilities. Return undefined if no stubs were found for
-    // this import.
-    resolveImportEx(sourceFilePath, execEnv, moduleDescriptor, importName, importFailureInfo = [], 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(libraryFilePath, importName, importFailureInfo = []) {
-        return undefined;
-    }
-    getNativeModuleName(fileName) {
-        const fileExtension = (0, pathUtils_1.getFileExtension)(fileName, /* multiDotExtension */ false).toLowerCase();
-        if (this._isNativeModuleFileExtension(fileExtension)) {
-            return (0, pathUtils_1.stripFileExtension)((0, pathUtils_1.stripFileExtension)(fileName));
-        }
-        return undefined;
-    }
     _getCacheKey(importName, fromUserFile) {
         return `${importName}-${fromUserFile}`;
     }
@@ -900,52 +991,6 @@ class ImportResolver {
         }
         return true;
     }
-    getModuleNameFromPath(containerPath, filePath, stripTopContainerDir = false) {
-        const moduleNameInfo = this.getModuleNameInfoFromPath(containerPath, filePath, stripTopContainerDir);
-        if (!moduleNameInfo || moduleNameInfo.containsInvalidCharacters) {
-            return undefined;
-        }
-        return moduleNameInfo.moduleName;
-    }
-    getModuleNameInfoFromPath(containerPath, filePath, stripTopContainerDir = false) {
-        containerPath = (0, pathUtils_1.ensureTrailingDirectorySeparator)(containerPath);
-        let filePathWithoutExtension = (0, pathUtils_1.stripFileExtension)(filePath);
-        // If module is native, strip platform part, such as 'cp36-win_amd64' in 'mtrand.cp36-win_amd64'.
-        if (this._isNativeModuleFileExtension((0, pathUtils_1.getFileExtension)(filePath))) {
-            filePathWithoutExtension = (0, pathUtils_1.stripFileExtension)(filePathWithoutExtension);
-        }
-        if (!filePathWithoutExtension.startsWith(containerPath)) {
-            return undefined;
-        }
-        // Strip off the '/__init__' if it's present.
-        if (filePathWithoutExtension.endsWith('__init__')) {
-            filePathWithoutExtension = filePathWithoutExtension.substr(0, filePathWithoutExtension.length - 9);
-        }
-        const relativeFilePath = filePathWithoutExtension.substr(containerPath.length);
-        const parts = (0, pathUtils_1.getPathComponents)(relativeFilePath);
-        parts.shift();
-        if (stripTopContainerDir) {
-            if (parts.length === 0) {
-                return undefined;
-            }
-            parts.shift();
-        }
-        if (parts.length === 0) {
-            return undefined;
-        }
-        // Handle the case where the symbol was resolved to a stubs package
-        // rather than the real package. We'll strip off the "-stubs" suffix
-        // in this case.
-        if (parts[0].endsWith(pathConsts_1.stubsSuffix)) {
-            parts[0] = parts[0].substr(0, parts[0].length - pathConsts_1.stubsSuffix.length);
-        }
-        // Check whether parts contains invalid characters.
-        const containsInvalidCharacters = parts.some((p) => !this._isIdentifier(p));
-        return {
-            moduleName: parts.join('.'),
-            containsInvalidCharacters,
-        };
-    }
     _resolveBestAbsoluteImport(sourceFilePath, execEnv, moduleDescriptor, allowPyi) {
         const importName = this.formatImportName(moduleDescriptor);
         const importFailureInfo = [];
@@ -1125,18 +1170,6 @@ class ImportResolver {
         }
         return true;
     }
-    getPythonSearchPaths(importFailureInfo) {
-        // 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));
-            // Remove duplicates (yes, it happens).
-            this._cachedPythonSearchPaths = { paths: [...new Set(paths)], failureInfo: info };
-        }
-        // 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;
-    }
     _findTypeshedPath(execEnv, moduleDescriptor, importName, isStdLib, importFailureInfo) {
         importFailureInfo.push(`Looking for typeshed ${isStdLib ? PythonPathUtils.stdLibFolderName : PythonPathUtils.thirdPartyFolderName} path`);
         let typeshedPaths;
@@ -1572,7 +1605,7 @@ class ImportResolver {
             return this._resolveImportStrict(importName, sourceFilePath, execEnv, moduleDescriptor, importFailureInfo)
                 .isImportFound;
         }
-        return this._resolveImport(sourceFilePath, execEnv, moduleDescriptor).isImportFound;
+        return this.resolveImportInternal(sourceFilePath, execEnv, moduleDescriptor).isImportFound;
     }
     _isUniqueValidSuggestion(suggestionToAdd, suggestions) {
         if (suggestions.has(suggestionToAdd)) {
@@ -1588,30 +1621,6 @@ class ImportResolver {
         }
         return true;
     }
-    // Potentially modifies the ImportResult by removing some or all of the
-    // implicit import entries. Only the imported symbols should be included.
-    filterImplicitImports(importResult, importedSymbols) {
-        if (importedSymbols === undefined) {
-            const newImportResult = Object.assign({}, importResult);
-            newImportResult.filteredImplicitImports = [];
-            return newImportResult;
-        }
-        if (importedSymbols.length === 0) {
-            return importResult;
-        }
-        if (importResult.implicitImports.length === 0) {
-            return importResult;
-        }
-        const filteredImplicitImports = importResult.implicitImports.filter((implicitImport) => {
-            return importedSymbols.some((sym) => sym === implicitImport.name);
-        });
-        if (filteredImplicitImports.length === importResult.implicitImports.length) {
-            return importResult;
-        }
-        const newImportResult = Object.assign({}, importResult);
-        newImportResult.filteredImplicitImports = filteredImplicitImports;
-        return newImportResult;
-    }
     _findImplicitImports(importingModuleName, dirPath, exclusions) {
         const implicitImportMap = new Map();
         // Enumerate all of the files and directories in the path, expanding links.
@@ -1686,9 +1695,6 @@ class ImportResolver {
         }
         return [...implicitImportMap.values()];
     }
-    formatImportName(moduleDescriptor) {
-        return '.'.repeat(moduleDescriptor.leadingDots) + moduleDescriptor.nameParts.join('.');
-    }
     _resolveNativeModuleStub(nativeLibPath, execEnv, importName, moduleDescriptor, importFailureInfo, resolvedPaths) {
         let moduleFullName = importName;
         if (moduleDescriptor.leadingDots > 0) {
@@ -1730,12 +1736,6 @@ class ImportResolver {
     _shouldWalkUp(current, root, execEnv) {
         return current.length > root.length || (current === root && !execEnv.root);
     }
-    getParentImportResolutionRoot(sourceFilePath, executionRoot) {
-        if (executionRoot) {
-            return (0, pathUtils_1.ensureTrailingDirectorySeparator)((0, pathUtils_1.normalizePathCase)(this.fileSystem, (0, pathUtils_1.normalizePath)(executionRoot)));
-        }
-        return (0, pathUtils_1.ensureTrailingDirectorySeparator)((0, pathUtils_1.getDirectoryPath)(sourceFilePath));
-    }
 }
 exports.ImportResolver = ImportResolver;
 //# sourceMappingURL=importResolver.js.map