@zzzen/pyright-internal 1.1.254

package/dist/analyzer/importResolver.js

@@ -0,0 +1,1617 @@
+"use strict";
+/*
+ * importResolver.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ * Author: Eric Traut
+ *
+ * Provides the logic for resolving imports according to the
+ * runtime rules of Python.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportResolver = exports.supportedFileExtensions = exports.createImportedModuleDescriptor = void 0;
+const collectionUtils_1 = require("../common/collectionUtils");
+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 characters_1 = require("../parser/characters");
+const pyrightFileSystem_1 = require("../pyrightFileSystem");
+const importStatementUtils_1 = require("./importStatementUtils");
+const parentDirectoryCache_1 = require("./parentDirectoryCache");
+const PythonPathUtils = __importStar(require("./pythonPathUtils"));
+const pyTypedUtils_1 = require("./pyTypedUtils");
+const symbolNameUtils_1 = require("./symbolNameUtils");
+function createImportedModuleDescriptor(moduleName) {
+    if (moduleName.length === 0) {
+        return { leadingDots: 0, nameParts: [], importedSymbols: [] };
+    }
+    let startIndex = 0;
+    let leadingDots = 0;
+    for (; startIndex < moduleName.length; startIndex++) {
+        if (moduleName[startIndex] !== '.') {
+            break;
+        }
+        leadingDots++;
+    }
+    return {
+        leadingDots,
+        nameParts: moduleName.slice(startIndex).split('.'),
+        importedSymbols: [],
+    };
+}
+exports.createImportedModuleDescriptor = createImportedModuleDescriptor;
+const supportedNativeLibExtensions = ['.pyd', '.so', '.dylib'];
+exports.supportedFileExtensions = ['.py', '.pyi', ...supportedNativeLibExtensions];
+// Should we allow partial resolution for third-party packages? Some use tricks
+// to populate their package namespaces, so we might be able to partially resolve
+// a multi - part import(e.g. "a.b.c") but not fully resolve it. If this is set to
+// false, we will have some false positives. If it is set to true, we won't report
+// errors when these partial-resolutions fail.
+const allowPartialResolutionForThirdPartyPackages = false;
+class ImportResolver {
+    constructor(fileSystem, _configOptions, host) {
+        this.fileSystem = fileSystem;
+        this._configOptions = _configOptions;
+        this.host = host;
+        this._cachedImportResults = new Map();
+        this._cachedModuleNameResults = new Map();
+        this._cachedEntriesForPath = new Map();
+        this.cachedParentImportResults = new parentDirectoryCache_1.ParentDirectoryCache(() => this.getPythonSearchPaths([]));
+    }
+    invalidateCache() {
+        this._cachedImportResults = new Map();
+        this._cachedModuleNameResults = new Map();
+        this.cachedParentImportResults.reset();
+        this._invalidateFileSystemCache();
+        if (this.fileSystem instanceof pyrightFileSystem_1.PyrightFileSystem) {
+            this.fileSystem.clearPartialStubs();
+        }
+    }
+    // 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
+        // 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(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 notFoundResult = {
+            importName,
+            isRelative: false,
+            isImportFound: false,
+            isPartlyResolved: false,
+            isNamespacePackage: 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);
+            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);
+            }
+        }
+        return this.addResultsToCache(execEnv, importName, notFoundResult, /* importedSymbols */ undefined);
+    }
+    getCompletionSuggestions(sourceFilePath, execEnv, moduleDescriptor) {
+        const suggestions = this._getCompletionSuggestionsStrict(sourceFilePath, execEnv, moduleDescriptor);
+        // We only do parent import resolution for absolute path.
+        if (moduleDescriptor.leadingDots > 0) {
+            return suggestions;
+        }
+        const root = this.getParentImportResolutionRoot(sourceFilePath, execEnv.root);
+        const origin = (0, pathUtils_1.ensureTrailingDirectorySeparator)((0, pathUtils_1.getDirectoryPath)((0, pathUtils_1.normalizePathCase)(this.fileSystem, (0, pathUtils_1.normalizePath)(sourceFilePath))));
+        let current = origin;
+        while (this._shouldWalkUp(current, root, execEnv)) {
+            this._getCompletionSuggestionsAbsolute(sourceFilePath, execEnv, current, moduleDescriptor, suggestions, 
+            /* strictOnly */ false);
+            let success;
+            [success, current] = this._tryWalkUp(current);
+            if (!success) {
+                break;
+            }
+        }
+        return suggestions;
+    }
+    getConfigOption() {
+        return this._configOptions;
+    }
+    _getCompletionSuggestionsStrict(sourceFilePath, execEnv, moduleDescriptor) {
+        const importFailureInfo = [];
+        const suggestions = new Set();
+        // 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 = [];
+        // When ImportResolver resolves an import to a stub file, a second resolve is done
+        // ignoring stub files, which gives us an approximation of where the implementation
+        // for that stub is located.
+        this._cachedImportResults.forEach((map) => {
+            map.forEach((result) => {
+                if (result.isStubFile && result.isImportFound && result.nonStubImportResult) {
+                    if (result.resolvedPaths[result.resolvedPaths.length - 1] === stubFilePath) {
+                        if (result.nonStubImportResult.isImportFound) {
+                            const nonEmptyPath = result.nonStubImportResult.resolvedPaths[result.nonStubImportResult.resolvedPaths.length - 1];
+                            if (nonEmptyPath.endsWith('.py') || nonEmptyPath.endsWith('.pyi')) {
+                                // We allow pyi in case there are multiple pyi for a compiled module such as
+                                // numpy.random.mtrand
+                                sourceFilePaths.push(nonEmptyPath);
+                            }
+                        }
+                    }
+                }
+            });
+        });
+        // We haven't seen an import of that stub, attempt to find the source
+        // in some other ways.
+        if (sourceFilePaths.length === 0) {
+            // Simple case where the stub and source files are next to each other.
+            const sourceFilePath = (0, pathUtils_1.changeAnyExtension)(stubFilePath, '.py');
+            if (this.dirExistsCached(sourceFilePath)) {
+                sourceFilePaths.push(sourceFilePath);
+            }
+        }
+        if (sourceFilePaths.length === 0) {
+            // The stub and the source file may have the same name, but be located
+            // in different folder hierarchies.
+            // Example:
+            // <stubPath>\package\module.pyi
+            // <site-packages>\package\module.py
+            // We get the relative path(s) of the stub to its import root(s),
+            // in theory there can be more than one, then look for source
+            // files in all the import roots using the same relative path(s).
+            const importRootPaths = this.getImportRoots(execEnv);
+            const relativeStubPaths = [];
+            for (const importRootPath of importRootPaths) {
+                if ((0, pathUtils_1.containsPath)(importRootPath, stubFilePath, true)) {
+                    const parts = (0, pathUtils_1.getRelativePathComponentsFromDirectory)(importRootPath, stubFilePath, true);
+                    // Note that relative paths have an empty parts[0]
+                    if (parts.length > 1) {
+                        // 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[1].endsWith(pathConsts_1.stubsSuffix)) {
+                            parts[1] = parts[1].substr(0, parts[1].length - pathConsts_1.stubsSuffix.length);
+                        }
+                        const relativeStubPath = (0, pathUtils_1.combinePathComponents)(parts);
+                        if (relativeStubPath) {
+                            relativeStubPaths.push(relativeStubPath);
+                        }
+                    }
+                }
+            }
+            for (const relativeStubPath of relativeStubPaths) {
+                for (const importRootPath of importRootPaths) {
+                    const absoluteStubPath = (0, pathUtils_1.resolvePaths)(importRootPath, relativeStubPath);
+                    let absoluteSourcePath = (0, pathUtils_1.changeAnyExtension)(absoluteStubPath, '.py');
+                    if (this.fileExistsCached(absoluteSourcePath)) {
+                        sourceFilePaths.push(absoluteSourcePath);
+                    }
+                    else {
+                        const filePathWithoutExtension = (0, pathUtils_1.stripFileExtension)(absoluteSourcePath);
+                        if (filePathWithoutExtension.endsWith('__init__')) {
+                            // Did not match: <root>/package/__init__.py
+                            // Try equivalent: <root>/package.py
+                            absoluteSourcePath =
+                                filePathWithoutExtension.substr(0, filePathWithoutExtension.length - 9) + '.py';
+                            if (this.fileExistsCached(absoluteSourcePath)) {
+                                sourceFilePaths.push(absoluteSourcePath);
+                            }
+                        }
+                        else {
+                            // Did not match: <root>/package.py
+                            // Try equivalent: <root>/package/__init__.py
+                            absoluteSourcePath = (0, pathUtils_1.combinePaths)(filePathWithoutExtension, '__init__.py');
+                            if (this.fileExistsCached(absoluteSourcePath)) {
+                                sourceFilePaths.push(absoluteSourcePath);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return sourceFilePaths;
+    }
+    // Returns the module name (of the form X.Y.Z) that needs to be imported
+    // from the current context to access the module with the specified file path.
+    // In a sense, it's performing the inverse of resolveImport.
+    getModuleNameForImport(filePath, execEnv) {
+        // Cache results of the reverse of resolveImport as we cache resolveImport.
+        const cache = (0, collectionUtils_1.getOrAdd)(this._cachedModuleNameResults, execEnv.root, () => new Map());
+        return (0, collectionUtils_1.getOrAdd)(cache, filePath, () => this._getModuleNameForImport(filePath, execEnv));
+    }
+    _getModuleNameForImport(filePath, execEnv) {
+        let moduleName;
+        let importType = 0 /* BuiltIn */;
+        let isLocalTypingsFile = false;
+        const importFailureInfo = [];
+        // 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) {
+            moduleName = this.getModuleNameFromPath(execEnv.root, filePath);
+            importType = 2 /* Local */;
+        }
+        for (const extraPath of execEnv.extraPaths) {
+            const candidateModuleName = this.getModuleNameFromPath(extraPath, 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 = 2 /* Local */;
+            }
+        }
+        // Check for a typings file.
+        if (this._configOptions.stubPath) {
+            const candidateModuleName = this.getModuleNameFromPath(this._configOptions.stubPath, 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;
+                // Treat the typings path as a local import so errors are reported for it.
+                importType = 2 /* Local */;
+                isLocalTypingsFile = true;
+            }
+        }
+        // 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 candidateModuleName = this.getModuleNameFromPath(searchPath, 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 */;
+            }
+        }
+        if (moduleName) {
+            return { moduleName, importType, isLocalTypingsFile };
+        }
+        // We didn't find any module name.
+        return { moduleName: '', importType: 2 /* Local */, isLocalTypingsFile };
+    }
+    getTypeshedStdLibPath(execEnv) {
+        const unused = [];
+        return this._getStdlibTypeshedPath(execEnv, unused);
+    }
+    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, '...'));
+            }
+        }
+        else {
+            const thirdPartyPaths = this._getThirdPartyTypeshedPackageRoots(execEnv, importFailureInfo);
+            (0, collectionUtils_1.appendArray)(roots, thirdPartyPaths);
+        }
+        const typeshedPathEx = this.getTypeshedPathEx(execEnv, importFailureInfo);
+        if (typeshedPathEx) {
+            roots.push(typeshedPathEx);
+        }
+        const pythonSearchPaths = this.getPythonSearchPaths(importFailureInfo);
+        if (pythonSearchPaths.length > 0) {
+            (0, collectionUtils_1.appendArray)(roots, pythonSearchPaths);
+        }
+        return roots;
+    }
+    readdirEntriesCached(path) {
+        const cachedValue = this._cachedEntriesForPath.get(path);
+        if (cachedValue) {
+            return cachedValue;
+        }
+        let newCacheValue;
+        try {
+            newCacheValue = this.fileSystem.readdirEntriesSync(path);
+        }
+        catch {
+            newCacheValue = [];
+        }
+        // Populate cache for next time.
+        this._cachedEntriesForPath.set(path, newCacheValue);
+        return newCacheValue;
+    }
+    fileExistsCached(path) {
+        var _a, _b;
+        const splitPath = this._splitPath(path);
+        if (!splitPath[0] || !splitPath[1]) {
+            if (!this.fileSystem.existsSync(path)) {
+                return false;
+            }
+            return (_b = (_a = (0, pathUtils_1.tryStat)(this.fileSystem, path)) === null || _a === void 0 ? void 0 : _a.isFile()) !== 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.isFile()) {
+            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.isFile)(this.fileSystem, realPath)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    dirExistsCached(path) {
+        var _a, _b;
+        const splitPath = this._splitPath(path);
+        if (!splitPath[0] || !splitPath[1]) {
+            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;
+        }
+        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;
+    }
+    ensurePartialStubPackages(execEnv) {
+        if (!(this.fileSystem instanceof pyrightFileSystem_1.PyrightFileSystem)) {
+            return false;
+        }
+        if (this.fileSystem.isPartialStubPackagesScanned(execEnv)) {
+            return false;
+        }
+        const fs = this.fileSystem;
+        const ignored = [];
+        const paths = [];
+        // Add paths to search stub packages.
+        addPaths(this._configOptions.stubPath);
+        addPaths(execEnv.root);
+        execEnv.extraPaths.forEach((p) => addPaths(p));
+        addPaths(this.getTypeshedPathEx(execEnv, ignored));
+        this.getPythonSearchPaths(ignored).forEach((p) => addPaths(p));
+        this.fileSystem.processPartialStubPackages(paths, this.getImportRoots(execEnv));
+        this._invalidateFileSystemCache();
+        return true;
+        function addPaths(path) {
+            if (!path || fs.isPathScanned(path)) {
+                return;
+            }
+            paths.push(path);
+        }
+    }
+    addResultsToCache(execEnv, importName, importResult, importedSymbols) {
+        (0, collectionUtils_1.getOrAdd)(this._cachedImportResults, execEnv.root, () => new Map()).set(importName, importResult);
+        return this.filterImplicitImports(importResult, importedSymbols);
+    }
+    // Follows import resolution algorithm defined in PEP-420:
+    // https://www.python.org/dev/peps/pep-0420/
+    resolveAbsoluteImport(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(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(rootPath, execEnv, moduleDescriptor, importName, importFailureInfo, allowPartial, allowNativeLib, 
+        /* useStubPackage */ false, allowPyi, lookForPyTyped);
+    }
+    _invalidateFileSystemCache() {
+        this._cachedEntriesForPath.clear();
+    }
+    // Splits a path into the name of the containing directory and
+    // a file or dir within that containing directory.
+    _splitPath(path) {
+        const pathComponents = (0, pathUtils_1.getPathComponents)(path);
+        if (pathComponents.length <= 1) {
+            return [path, ''];
+        }
+        const containingPath = (0, pathUtils_1.combinePathComponents)(pathComponents.slice(0, -1));
+        const fileOrDirName = pathComponents[pathComponents.length - 1];
+        return [containingPath, fileOrDirName];
+    }
+    _resolveAbsoluteImport(rootPath, execEnv, moduleDescriptor, importName, importFailureInfo, allowPartial, allowNativeLib, useStubPackage, allowPyi, lookForPyTyped) {
+        if (useStubPackage) {
+            importFailureInfo.push(`Attempting to resolve stub package using root path '${rootPath}'`);
+        }
+        else {
+            importFailureInfo.push(`Attempting to resolve using root path '${rootPath}'`);
+        }
+        // Starting at the specified path, walk the file system to find the
+        // specified module.
+        const resolvedPaths = [];
+        let dirPath = rootPath;
+        let isNamespacePackage = false;
+        let isStubPackage = false;
+        let isStubFile = false;
+        let isNativeLib = false;
+        let implicitImports = [];
+        let packageDirectory;
+        let pyTypedInfo;
+        // Handle the "from . import XXX" case.
+        if (moduleDescriptor.nameParts.length === 0) {
+            const fileNameWithoutExtension = '__init__';
+            const pyFilePath = (0, pathUtils_1.combinePaths)(dirPath, fileNameWithoutExtension + '.py');
+            const pyiFilePath = (0, pathUtils_1.combinePaths)(dirPath, fileNameWithoutExtension + '.pyi');
+            if (allowPyi && this.fileExistsCached(pyiFilePath)) {
+                importFailureInfo.push(`Resolved import with file '${pyiFilePath}'`);
+                resolvedPaths.push(pyiFilePath);
+                isStubFile = true;
+            }
+            else if (this.fileExistsCached(pyFilePath)) {
+                importFailureInfo.push(`Resolved import with file '${pyFilePath}'`);
+                resolvedPaths.push(pyFilePath);
+            }
+            else {
+                importFailureInfo.push(`Partially resolved import with directory '${dirPath}'`);
+                resolvedPaths.push('');
+                isNamespacePackage = true;
+            }
+            implicitImports = this._findImplicitImports(importName, dirPath, [pyFilePath, pyiFilePath]);
+        }
+        else {
+            for (let i = 0; i < moduleDescriptor.nameParts.length; i++) {
+                const isFirstPart = i === 0;
+                const isLastPart = i === moduleDescriptor.nameParts.length - 1;
+                dirPath = (0, pathUtils_1.combinePaths)(dirPath, moduleDescriptor.nameParts[i]);
+                if (useStubPackage && isFirstPart) {
+                    dirPath += pathConsts_1.stubsSuffix;
+                    isStubPackage = true;
+                }
+                const foundDirectory = this.dirExistsCached(dirPath);
+                if (foundDirectory) {
+                    if (isFirstPart) {
+                        packageDirectory = dirPath;
+                    }
+                    // See if we can find an __init__.py[i] in this directory.
+                    const fileNameWithoutExtension = '__init__';
+                    const pyFilePath = (0, pathUtils_1.combinePaths)(dirPath, fileNameWithoutExtension + '.py');
+                    const pyiFilePath = (0, pathUtils_1.combinePaths)(dirPath, fileNameWithoutExtension + '.pyi');
+                    let foundInit = false;
+                    if (allowPyi && this.fileExistsCached(pyiFilePath)) {
+                        importFailureInfo.push(`Resolved import with file '${pyiFilePath}'`);
+                        resolvedPaths.push(pyiFilePath);
+                        if (isLastPart) {
+                            isStubFile = true;
+                        }
+                        foundInit = true;
+                    }
+                    else if (this.fileExistsCached(pyFilePath)) {
+                        importFailureInfo.push(`Resolved import with file '${pyFilePath}'`);
+                        resolvedPaths.push(pyFilePath);
+                        foundInit = true;
+                    }
+                    if (!pyTypedInfo && lookForPyTyped) {
+                        if (this.fileExistsCached((0, pathUtils_1.combinePaths)(dirPath, 'py.typed'))) {
+                            pyTypedInfo = (0, pyTypedUtils_1.getPyTypedInfo)(this.fileSystem, dirPath);
+                        }
+                    }
+                    if (!isLastPart) {
+                        // We are not at the last part, and we found a directory,
+                        // so continue to look for the next part.
+                        if (!foundInit) {
+                            resolvedPaths.push('');
+                            isNamespacePackage = true;
+                            pyTypedInfo = undefined;
+                        }
+                        continue;
+                    }
+                    if (foundInit) {
+                        implicitImports = this._findImplicitImports(moduleDescriptor.nameParts.join('.'), dirPath, [
+                            pyFilePath,
+                            pyiFilePath,
+                        ]);
+                        break;
+                    }
+                }
+                // We weren't able to find a directory or we found a directory with
+                // no __init__.py[i] file. See if we can find a ".py" or ".pyi" file
+                // with this name.
+                let fileDirectory = (0, pathUtils_1.stripTrailingDirectorySeparator)(dirPath);
+                const fileNameWithoutExtension = (0, pathUtils_1.getFileName)(fileDirectory);
+                fileDirectory = (0, pathUtils_1.getDirectoryPath)(fileDirectory);
+                const pyFilePath = (0, pathUtils_1.combinePaths)(fileDirectory, fileNameWithoutExtension + '.py');
+                const pyiFilePath = (0, pathUtils_1.combinePaths)(fileDirectory, fileNameWithoutExtension + '.pyi');
+                if (allowPyi && this.fileExistsCached(pyiFilePath)) {
+                    importFailureInfo.push(`Resolved import with file '${pyiFilePath}'`);
+                    resolvedPaths.push(pyiFilePath);
+                    if (isLastPart) {
+                        isStubFile = true;
+                    }
+                }
+                else if (this.fileExistsCached(pyFilePath)) {
+                    importFailureInfo.push(`Resolved import with file '${pyFilePath}'`);
+                    resolvedPaths.push(pyFilePath);
+                }
+                else {
+                    if (allowNativeLib && this.dirExistsCached(fileDirectory)) {
+                        const filesInDir = this._getFilesInDirectory(fileDirectory);
+                        const nativeLibFileName = filesInDir.find((f) => this._isNativeModuleFileName(fileNameWithoutExtension, f));
+                        if (nativeLibFileName) {
+                            const nativeLibPath = (0, pathUtils_1.combinePaths)(fileDirectory, nativeLibFileName);
+                            // Try resolving native library to a custom stub.
+                            isNativeLib = this._resolveNativeModuleStub(nativeLibPath, execEnv, importName, moduleDescriptor, importFailureInfo, resolvedPaths);
+                        }
+                    }
+                    if (!isNativeLib && foundDirectory) {
+                        importFailureInfo.push(`Partially resolved import with directory '${dirPath}'`);
+                        resolvedPaths.push('');
+                        if (isLastPart) {
+                            implicitImports = this._findImplicitImports(importName, dirPath, [pyFilePath, pyiFilePath]);
+                            isNamespacePackage = true;
+                        }
+                    }
+                    else if (isNativeLib) {
+                        importFailureInfo.push(`Did not find file '${pyiFilePath}' or '${pyFilePath}'`);
+                    }
+                }
+                break;
+            }
+        }
+        let importFound;
+        const isPartlyResolved = resolvedPaths.length > 0 && resolvedPaths.length < moduleDescriptor.nameParts.length;
+        if (allowPartial) {
+            importFound = resolvedPaths.length > 0;
+        }
+        else {
+            importFound = resolvedPaths.length >= moduleDescriptor.nameParts.length;
+        }
+        return {
+            importName,
+            isRelative: false,
+            isNamespacePackage,
+            isStubPackage,
+            isImportFound: importFound,
+            isPartlyResolved,
+            importFailureInfo,
+            importType: 2 /* Local */,
+            resolvedPaths,
+            searchPath: rootPath,
+            isStubFile,
+            isNativeLib,
+            implicitImports,
+            pyTypedInfo,
+            filteredImplicitImports: implicitImports,
+            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;
+    }
+    _lookUpResultsInCache(execEnv, importName, importedSymbols) {
+        const cacheForExecEnv = this._cachedImportResults.get(execEnv.root);
+        if (!cacheForExecEnv) {
+            return undefined;
+        }
+        const cachedEntry = cacheForExecEnv.get(importName);
+        if (!cachedEntry) {
+            return undefined;
+        }
+        return this.filterImplicitImports(cachedEntry, importedSymbols);
+    }
+    // Determines whether a namespace package resolves all of the symbols
+    // requested in the module descriptor. Namespace packages have no "__init__.py"
+    // file, so the only way that symbols can be resolved is if submodules
+    // are present. If specific symbols were requested, make sure they
+    // are all satisfied by submodules (as listed in the implicit imports).
+    _isNamespacePackageResolved(moduleDescriptor, implicitImports) {
+        if (moduleDescriptor.importedSymbols) {
+            if (!moduleDescriptor.importedSymbols.some((symbol) => {
+                return implicitImports.some((implicitImport) => {
+                    return implicitImport.name === symbol;
+                });
+            })) {
+                return false;
+            }
+        }
+        else if (implicitImports.length === 0) {
+            return false;
+        }
+        return true;
+    }
+    getModuleNameFromPath(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.
+        if (parts.some((p) => !this._isIdentifier(p))) {
+            return undefined;
+        }
+        return parts.join('.');
+    }
+    _resolveBestAbsoluteImport(sourceFilePath, execEnv, moduleDescriptor, allowPyi) {
+        const importName = this.formatImportName(moduleDescriptor);
+        const importFailureInfo = [];
+        // 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(this._configOptions.stubPath, execEnv, moduleDescriptor, importName, importFailureInfo, 
+            /* allowPartial */ undefined, 
+            /* allowNativeLib */ false, 
+            /* useStubPackage */ true, allowPyi, 
+            /* lookForPyTyped */ false);
+            if (typingsImport.isImportFound) {
+                // We will treat typings files as "local" rather than "third party".
+                typingsImport.importType = 2 /* Local */;
+                typingsImport.isLocalTypingsFile = true;
+                // If it's a namespace package that didn't resolve to a file, make sure that
+                // the imported symbols are present in the implicit imports. If not, we'll
+                // skip the typings import and continue searching.
+                if (typingsImport.isNamespacePackage &&
+                    !typingsImport.resolvedPaths[typingsImport.resolvedPaths.length - 1]) {
+                    if (this._isNamespacePackageResolved(moduleDescriptor, typingsImport.implicitImports)) {
+                        return typingsImport;
+                    }
+                }
+                else {
+                    return typingsImport;
+                }
+            }
+        }
+        let bestResultSoFar;
+        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(execEnv.root, execEnv, moduleDescriptor, importName, importFailureInfo, 
+            /* allowPartial */ undefined, 
+            /* allowNativeLib */ true, 
+            /* useStubPackage */ true, allowPyi, 
+            /* lookForPyTyped */ false);
+            bestResultSoFar = localImport;
+        }
+        for (const extraPath of execEnv.extraPaths) {
+            importFailureInfo.push(`Looking in extraPath '${extraPath}'`);
+            localImport = this.resolveAbsoluteImport(extraPath, execEnv, moduleDescriptor, importName, importFailureInfo, 
+            /* allowPartial */ undefined, 
+            /* allowNativeLib */ true, 
+            /* useStubPackage */ true, allowPyi, 
+            /* lookForPyTyped */ false);
+            bestResultSoFar = this._pickBestImport(bestResultSoFar, localImport, moduleDescriptor);
+        }
+        // Look for the import in the list of third-party packages.
+        const pythonSearchPaths = this.getPythonSearchPaths(importFailureInfo);
+        if (pythonSearchPaths.length > 0) {
+            for (const searchPath of pythonSearchPaths) {
+                importFailureInfo.push(`Looking in python search path '${searchPath}'`);
+                const thirdPartyImport = this.resolveAbsoluteImport(searchPath, execEnv, moduleDescriptor, importName, importFailureInfo, 
+                /* allowPartial */ allowPartialResolutionForThirdPartyPackages, 
+                /* allowNativeLib */ true, 
+                /* useStubPackage */ true, allowPyi, 
+                /* lookForPyTyped */ true);
+                if (thirdPartyImport) {
+                    thirdPartyImport.importType = 1 /* ThirdParty */;
+                    bestResultSoFar = this._pickBestImport(bestResultSoFar, thirdPartyImport, moduleDescriptor);
+                }
+            }
+        }
+        else {
+            importFailureInfo.push('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(execEnv, importFailureInfo)) {
+            if ((bestResultSoFar === null || bestResultSoFar === void 0 ? void 0 : bestResultSoFar.pyTypedInfo) && !bestResultSoFar.isPartlyResolved) {
+                return bestResultSoFar;
+            }
+        }
+        // Call the extensibility hook for subclasses.
+        const extraResults = this.resolveImportEx(sourceFilePath, execEnv, moduleDescriptor, importName, importFailureInfo, allowPyi);
+        if (extraResults) {
+            return extraResults;
+        }
+        if (allowPyi && moduleDescriptor.nameParts.length > 0) {
+            // Check for a stdlib typeshed file.
+            importFailureInfo.push(`Looking for typeshed stdlib path`);
+            const typeshedStdlibImport = this._findTypeshedPath(execEnv, moduleDescriptor, importName, 
+            /* isStdLib */ true, importFailureInfo);
+            if (typeshedStdlibImport) {
+                typeshedStdlibImport.isTypeshedFile = true;
+                return typeshedStdlibImport;
+            }
+            // Check for a third-party typeshed file.
+            importFailureInfo.push(`Looking for typeshed third-party path`);
+            const typeshedImport = this._findTypeshedPath(execEnv, moduleDescriptor, importName, 
+            /* isStdLib */ false, importFailureInfo);
+            if (typeshedImport) {
+                typeshedImport.isTypeshedFile = true;
+                bestResultSoFar = this._pickBestImport(bestResultSoFar, typeshedImport, moduleDescriptor);
+            }
+        }
+        // We weren't able to find an exact match, so return the best
+        // partial match.
+        return bestResultSoFar;
+    }
+    _pickBestImport(bestImportSoFar, newImport, moduleDescriptor) {
+        if (!bestImportSoFar) {
+            return newImport;
+        }
+        if (!newImport) {
+            return bestImportSoFar;
+        }
+        if (newImport.isImportFound) {
+            // Prefer found over not found.
+            if (!bestImportSoFar.isImportFound) {
+                return newImport;
+            }
+            // Prefer traditional over namespace imports.
+            if (bestImportSoFar.isNamespacePackage && !newImport.isNamespacePackage) {
+                return newImport;
+            }
+            // Prefer local packages.
+            if (bestImportSoFar.importType === 2 /* Local */ && !bestImportSoFar.isNamespacePackage) {
+                return bestImportSoFar;
+            }
+            // If both are namespace imports, select the one that resolves the symbols.
+            if (bestImportSoFar.isNamespacePackage &&
+                newImport.isNamespacePackage &&
+                moduleDescriptor.importedSymbols) {
+                if (!this._isNamespacePackageResolved(moduleDescriptor, bestImportSoFar.implicitImports) &&
+                    this._isNamespacePackageResolved(moduleDescriptor, newImport.implicitImports)) {
+                    return newImport;
+                }
+            }
+            // Prefer py.typed over non-py.typed.
+            if (bestImportSoFar.pyTypedInfo && !newImport.pyTypedInfo) {
+                return bestImportSoFar;
+            }
+            else if (!bestImportSoFar.pyTypedInfo && newImport.pyTypedInfo) {
+                return newImport;
+            }
+            // Prefer pyi over py.
+            if (bestImportSoFar.isStubFile && !newImport.isStubFile) {
+                return bestImportSoFar;
+            }
+            else if (!bestImportSoFar.isStubFile && newImport.isStubFile) {
+                return newImport;
+            }
+            // All else equal, prefer shorter resolution paths.
+            if (bestImportSoFar.resolvedPaths.length > newImport.resolvedPaths.length) {
+                return newImport;
+            }
+        }
+        else if (newImport.isPartlyResolved && bestImportSoFar.isNamespacePackage && !newImport.isNamespacePackage) {
+            // Always prefer a traditional over namespace import even
+            // if the traditional import is only partly resolved.
+            return newImport;
+        }
+        return bestImportSoFar;
+    }
+    _isIdentifier(value) {
+        for (let i = 0; i < value.length; i++) {
+            if (i === 0 ? !(0, characters_1.isIdentifierStartChar)(value.charCodeAt(i)) : !(0, characters_1.isIdentifierChar)(value.charCodeAt(i))) {
+                return false;
+            }
+        }
+        return true;
+    }
+    getPythonSearchPaths(importFailureInfo) {
+        // Find the site packages for the configured virtual environment.
+        if (!this._cachedPythonSearchPaths) {
+            const paths = (PythonPathUtils.findPythonSearchPaths(this.fileSystem, this._configOptions, this.host, importFailureInfo) || []).map((p) => this.fileSystem.realCasePath(p));
+            // Remove duplicates (yes, it happens).
+            this._cachedPythonSearchPaths = [...new Set(paths)];
+        }
+        return this._cachedPythonSearchPaths;
+    }
+    _findTypeshedPath(execEnv, moduleDescriptor, importName, isStdLib, importFailureInfo) {
+        importFailureInfo.push(`Looking for typeshed ${isStdLib ? PythonPathUtils.stdLibFolderName : PythonPathUtils.thirdPartyFolderName} path`);
+        let typeshedPaths;
+        if (isStdLib) {
+            const path = this._getStdlibTypeshedPath(execEnv, importFailureInfo, moduleDescriptor);
+            if (path) {
+                typeshedPaths = [path];
+            }
+        }
+        else {
+            typeshedPaths = this._getThirdPartyTypeshedPackagePaths(moduleDescriptor, execEnv, importFailureInfo);
+        }
+        if (typeshedPaths) {
+            for (const typeshedPath of typeshedPaths) {
+                if (this.dirExistsCached(typeshedPath)) {
+                    const importInfo = this.resolveAbsoluteImport(typeshedPath, execEnv, moduleDescriptor, importName, importFailureInfo);
+                    if (importInfo.isImportFound) {
+                        importInfo.importType = isStdLib ? 0 /* BuiltIn */ : 1 /* ThirdParty */;
+                        return importInfo;
+                    }
+                }
+            }
+        }
+        importFailureInfo.push(`Typeshed path not found`);
+        return undefined;
+    }
+    // Populates a cache of third-party packages found within the typeshed
+    // directory. They are organized such that top-level directories contain
+    // the pypi-registered name of the package and an inner directory contains
+    // the name of the package as it is referenced by import statements. These
+    // don't always match.
+    _buildTypeshedThirdPartyPackageMap(thirdPartyDir) {
+        this._cachedTypeshedThirdPartyPackagePaths = new Map();
+        if (thirdPartyDir) {
+            this.readdirEntriesCached(thirdPartyDir).forEach((outerEntry) => {
+                if (outerEntry.isDirectory()) {
+                    const innerDirPath = (0, pathUtils_1.combinePaths)(thirdPartyDir, outerEntry.name);
+                    this.readdirEntriesCached(innerDirPath).forEach((innerEntry) => {
+                        if (innerEntry.name === '@python2') {
+                            return;
+                        }
+                        if (innerEntry.isDirectory()) {
+                            const pathList = this._cachedTypeshedThirdPartyPackagePaths.get(innerEntry.name);
+                            if (pathList) {
+                                pathList.push(innerDirPath);
+                            }
+                            else {
+                                this._cachedTypeshedThirdPartyPackagePaths.set(innerEntry.name, [innerDirPath]);
+                            }
+                        }
+                        else if (innerEntry.isFile()) {
+                            if (innerEntry.name.endsWith('.pyi')) {
+                                const strippedFileName = (0, pathUtils_1.stripFileExtension)(innerEntry.name);
+                                const pathList = this._cachedTypeshedThirdPartyPackagePaths.get(strippedFileName);
+                                if (pathList) {
+                                    pathList.push(innerDirPath);
+                                }
+                                else {
+                                    this._cachedTypeshedThirdPartyPackagePaths.set(strippedFileName, [innerDirPath]);
+                                }
+                            }
+                        }
+                    });
+                }
+            });
+        }
+        const flattenPaths = [...this._cachedTypeshedThirdPartyPackagePaths.values()].flatMap((v) => v);
+        this._cachedTypeshedThirdPartyPackageRoots = [...new Set(flattenPaths)].sort();
+    }
+    _getCompletionSuggestionsTypeshedPath(sourceFilePath, execEnv, moduleDescriptor, isStdLib, suggestions) {
+        const importFailureInfo = [];
+        let typeshedPaths;
+        if (isStdLib) {
+            const path = this._getStdlibTypeshedPath(execEnv, importFailureInfo, moduleDescriptor);
+            if (path) {
+                typeshedPaths = [path];
+            }
+        }
+        else {
+            typeshedPaths = this._getThirdPartyTypeshedPackagePaths(moduleDescriptor, execEnv, importFailureInfo, 
+            /* includeMatchOnly */ false);
+            const typeshedPathEx = this.getTypeshedPathEx(execEnv, importFailureInfo);
+            if (typeshedPathEx) {
+                typeshedPaths = typeshedPaths !== null && typeshedPaths !== void 0 ? typeshedPaths : [];
+                typeshedPaths.push(typeshedPathEx);
+            }
+        }
+        if (!typeshedPaths) {
+            return;
+        }
+        typeshedPaths.forEach((typeshedPath) => {
+            if (this.dirExistsCached(typeshedPath)) {
+                this._getCompletionSuggestionsAbsolute(sourceFilePath, execEnv, typeshedPath, moduleDescriptor, suggestions);
+            }
+        });
+    }
+    // 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(execEnv, importFailureInfo, moduleDescriptor) {
+        const subdirectory = this._getTypeshedSubdirectory(/* isStdLib */ true, execEnv, importFailureInfo);
+        if (subdirectory &&
+            moduleDescriptor &&
+            !this._isStdlibTypeshedStubValidForVersion(moduleDescriptor, execEnv, importFailureInfo)) {
+            return undefined;
+        }
+        return subdirectory;
+    }
+    _getThirdPartyTypeshedPath(execEnv, importFailureInfo) {
+        return this._getTypeshedSubdirectory(/* isStdLib */ false, execEnv, importFailureInfo);
+    }
+    _isStdlibTypeshedStubValidForVersion(moduleDescriptor, execEnv, importFailureInfo) {
+        if (!this._cachedTypeshedStdLibModuleVersions) {
+            this._cachedTypeshedStdLibModuleVersions = this._readTypeshedStdLibVersions(execEnv, importFailureInfo);
+        }
+        // Loop through the name parts to make sure the module and submodules
+        // referenced in the import statement are valid for this version of Python.
+        for (let namePartCount = 1; namePartCount <= moduleDescriptor.nameParts.length; namePartCount++) {
+            const namePartsToConsider = moduleDescriptor.nameParts.slice(0, namePartCount);
+            const versionRange = this._cachedTypeshedStdLibModuleVersions.get(namePartsToConsider.join('.'));
+            if (versionRange) {
+                if (execEnv.pythonVersion < versionRange.min) {
+                    return false;
+                }
+                if (versionRange.max !== undefined && execEnv.pythonVersion > versionRange.max) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    _readTypeshedStdLibVersions(execEnv, importFailureInfo) {
+        const versionRangeMap = new Map();
+        // Read the VERSIONS file from typeshed.
+        const typeshedStdLibPath = this._getTypeshedSubdirectory(/* isStdLib */ true, execEnv, importFailureInfo);
+        if (typeshedStdLibPath) {
+            const versionsFilePath = (0, pathUtils_1.combinePaths)(typeshedStdLibPath, 'VERSIONS');
+            try {
+                const fileStats = this.fileSystem.statSync(versionsFilePath);
+                if (fileStats.size > 0 && fileStats.size < 256 * 1024) {
+                    const fileContents = this.fileSystem.readFileSync(versionsFilePath, 'utf8');
+                    fileContents.split(/\r?\n/).forEach((line) => {
+                        const commentSplit = line.split('#');
+                        const colonSplit = commentSplit[0].split(':');
+                        if (colonSplit.length !== 2) {
+                            return;
+                        }
+                        const versionSplit = colonSplit[1].split('-');
+                        if (versionSplit.length > 2) {
+                            return;
+                        }
+                        const moduleName = colonSplit[0].trim();
+                        if (!moduleName) {
+                            return;
+                        }
+                        let minVersionString = versionSplit[0].trim();
+                        if (minVersionString.endsWith('+')) {
+                            // If the version ends in "+", strip it off.
+                            minVersionString = minVersionString.substr(0, minVersionString.length - 1);
+                        }
+                        let minVersion = (0, pythonVersion_1.versionFromString)(minVersionString);
+                        if (!minVersion) {
+                            minVersion = pythonVersion_1.PythonVersion.V3_0;
+                        }
+                        let maxVersion;
+                        if (versionSplit.length > 1) {
+                            maxVersion = (0, pythonVersion_1.versionFromString)(versionSplit[1].trim());
+                        }
+                        versionRangeMap.set(moduleName, { min: minVersion, max: maxVersion });
+                    });
+                }
+                else {
+                    importFailureInfo.push(`Typeshed stdlib VERSIONS file is unexpectedly large`);
+                }
+            }
+            catch (e) {
+                importFailureInfo.push(`Could not read typeshed stdlib VERSIONS file: '${JSON.stringify(e)}'`);
+            }
+        }
+        return versionRangeMap;
+    }
+    _getThirdPartyTypeshedPackagePaths(moduleDescriptor, execEnv, importFailureInfo, includeMatchOnly = true) {
+        const typeshedPath = this._getThirdPartyTypeshedPath(execEnv, importFailureInfo);
+        if (!this._cachedTypeshedThirdPartyPackagePaths) {
+            this._buildTypeshedThirdPartyPackageMap(typeshedPath);
+        }
+        const firstNamePart = moduleDescriptor.nameParts.length > 0 ? moduleDescriptor.nameParts[0] : '';
+        if (includeMatchOnly) {
+            return this._cachedTypeshedThirdPartyPackagePaths.get(firstNamePart);
+        }
+        if (firstNamePart) {
+            return (0, collectionUtils_1.flatten)((0, collectionUtils_1.getMapValues)(this._cachedTypeshedThirdPartyPackagePaths, (k) => k.startsWith(firstNamePart)));
+        }
+        return [];
+    }
+    _getThirdPartyTypeshedPackageRoots(execEnv, importFailureInfo) {
+        const typeshedPath = this._getThirdPartyTypeshedPath(execEnv, importFailureInfo);
+        if (!this._cachedTypeshedThirdPartyPackagePaths) {
+            this._buildTypeshedThirdPartyPackageMap(typeshedPath);
+        }
+        return this._cachedTypeshedThirdPartyPackageRoots;
+    }
+    _getTypeshedRoot(execEnv, importFailureInfo) {
+        if (this._cachedTypeshedRoot !== undefined) {
+            return this._cachedTypeshedRoot;
+        }
+        let typeshedPath = '';
+        // Did the user specify a typeshed path? If not, we'll look in the
+        // python search paths, then in the typeshed-fallback directory.
+        if (this._configOptions.typeshedPath) {
+            const possibleTypeshedPath = this._configOptions.typeshedPath;
+            if (this.dirExistsCached(possibleTypeshedPath)) {
+                typeshedPath = possibleTypeshedPath;
+            }
+        }
+        else {
+            const pythonSearchPaths = this.getPythonSearchPaths(importFailureInfo);
+            for (const searchPath of pythonSearchPaths) {
+                const possibleTypeshedPath = (0, pathUtils_1.combinePaths)(searchPath, 'typeshed');
+                if (this.dirExistsCached(possibleTypeshedPath)) {
+                    typeshedPath = possibleTypeshedPath;
+                    break;
+                }
+            }
+        }
+        // If typeshed directory wasn't found in other locations, use the fallback.
+        if (!typeshedPath) {
+            typeshedPath = PythonPathUtils.getTypeShedFallbackPath(this.fileSystem) || '';
+        }
+        this._cachedTypeshedRoot = typeshedPath;
+        return typeshedPath;
+    }
+    _getTypeshedSubdirectory(isStdLib, execEnv, importFailureInfo) {
+        // See if we have it cached.
+        if (isStdLib) {
+            if (this._cachedTypeshedStdLibPath !== undefined) {
+                return this._cachedTypeshedStdLibPath;
+            }
+        }
+        else {
+            if (this._cachedTypeshedThirdPartyPath !== undefined) {
+                return this._cachedTypeshedThirdPartyPath;
+            }
+        }
+        let typeshedPath = this._getTypeshedRoot(execEnv, importFailureInfo);
+        typeshedPath = PythonPathUtils.getTypeshedSubdirectory(typeshedPath, isStdLib);
+        if (!this.dirExistsCached(typeshedPath)) {
+            return undefined;
+        }
+        // Cache the results.
+        if (isStdLib) {
+            this._cachedTypeshedStdLibPath = typeshedPath;
+        }
+        else {
+            this._cachedTypeshedThirdPartyPath = typeshedPath;
+        }
+        return typeshedPath;
+    }
+    _resolveRelativeImport(sourceFilePath, execEnv, moduleDescriptor, importName, importFailureInfo) {
+        importFailureInfo.push('Attempting to resolve relative import');
+        // Determine which search path this file is part of.
+        const directory = (0, importStatementUtils_1.getDirectoryLeadingDotsPointsTo)((0, pathUtils_1.getDirectoryPath)(sourceFilePath), moduleDescriptor.leadingDots);
+        if (!directory) {
+            importFailureInfo.push(`Invalid relative path '${importName}'`);
+            return undefined;
+        }
+        // Now try to match the module parts from the current directory location.
+        const absImport = this.resolveAbsoluteImport(directory, execEnv, moduleDescriptor, importName, importFailureInfo, 
+        /* 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(directory, execEnv, moduleDescriptor, importName, importFailureInfo, 
+            /* allowPartial */ false, 
+            /* allowNativeLib */ true, 
+            /* useStubPackage */ false, 
+            /* allowPyi */ false) || {
+                importName,
+                isRelative: true,
+                isImportFound: false,
+                isPartlyResolved: false,
+                isNamespacePackage: false,
+                isStubPackage: false,
+                importFailureInfo,
+                resolvedPaths: [],
+                importType: 2 /* Local */,
+                isStubFile: false,
+                isNativeLib: false,
+                implicitImports: [],
+                filteredImplicitImports: [],
+                nonStubImportResult: undefined,
+            };
+        }
+        return this.filterImplicitImports(absImport, moduleDescriptor.importedSymbols);
+    }
+    _getCompletionSuggestionsRelative(sourceFilePath, execEnv, moduleDescriptor, suggestions) {
+        // Determine which search path this file is part of.
+        const directory = (0, importStatementUtils_1.getDirectoryLeadingDotsPointsTo)((0, pathUtils_1.getDirectoryPath)(sourceFilePath), moduleDescriptor.leadingDots);
+        if (!directory) {
+            return;
+        }
+        // Now try to match the module parts from the current directory location.
+        this._getCompletionSuggestionsAbsolute(sourceFilePath, execEnv, directory, moduleDescriptor, suggestions);
+    }
+    _getFilesInDirectory(dirPath) {
+        const entriesInDir = this.readdirEntriesCached(dirPath);
+        const filesInDir = entriesInDir.filter((f) => f.isFile()).map((f) => f.name);
+        // Add any symbolic links that point to files.
+        entriesInDir.forEach((f) => {
+            var _a;
+            const linkPath = (0, pathUtils_1.combinePaths)(dirPath, f.name);
+            if (f.isSymbolicLink() && ((_a = (0, pathUtils_1.tryStat)(this.fileSystem, linkPath)) === null || _a === void 0 ? void 0 : _a.isFile())) {
+                filesInDir.push(f.name);
+            }
+        });
+        return filesInDir;
+    }
+    _getCompletionSuggestionsAbsolute(sourceFilePath, execEnv, rootPath, moduleDescriptor, suggestions, strictOnly = true) {
+        // Starting at the specified path, walk the file system to find the
+        // specified module.
+        let dirPath = rootPath;
+        // Copy the nameParts into a new directory and add an extra empty
+        // part if there is a trailing dot.
+        const nameParts = moduleDescriptor.nameParts.map((name) => name);
+        if (moduleDescriptor.hasTrailingDot) {
+            nameParts.push('');
+        }
+        // We need to track this since a module might be resolvable using relative path
+        // but can't resolved by absolute path.
+        const leadingDots = moduleDescriptor.leadingDots;
+        const parentNameParts = nameParts.slice(0, -1);
+        // Handle the case where the user has typed the first
+        // dot (or multiple) in a relative path.
+        if (nameParts.length === 0) {
+            this._addFilteredSuggestionsAbsolute(sourceFilePath, execEnv, dirPath, '', suggestions, leadingDots, parentNameParts, strictOnly);
+        }
+        else {
+            for (let i = 0; i < nameParts.length; i++) {
+                // Provide completions only if we're on the last part
+                // of the name.
+                if (i === nameParts.length - 1) {
+                    this._addFilteredSuggestionsAbsolute(sourceFilePath, execEnv, dirPath, nameParts[i], suggestions, leadingDots, parentNameParts, strictOnly);
+                }
+                dirPath = (0, pathUtils_1.combinePaths)(dirPath, nameParts[i]);
+                if (!this.dirExistsCached(dirPath)) {
+                    break;
+                }
+            }
+        }
+    }
+    _addFilteredSuggestionsAbsolute(sourceFilePath, execEnv, currentPath, filter, suggestions, leadingDots, parentNameParts, strictOnly) {
+        // Enumerate all of the files and directories in the path, expanding links.
+        const entries = (0, pathUtils_1.getFileSystemEntriesFromDirEntries)(this.readdirEntriesCached(currentPath), 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.
+            const fileExtension = (0, pathUtils_1.getFileExtension)(file, /* multiDotExtension */ false).toLowerCase();
+            const fileWithoutExtension = (0, pathUtils_1.stripFileExtension)(file, /* multiDotExtension */ true);
+            if (exports.supportedFileExtensions.some((ext) => ext === fileExtension)) {
+                if (fileWithoutExtension === '__init__') {
+                    return;
+                }
+                if (filter && !StringUtils.isPatternInSymbol(filter, fileWithoutExtension)) {
+                    return;
+                }
+                if (!this._isUniqueValidSuggestion(fileWithoutExtension, suggestions) ||
+                    !this._isResolvableSuggestion(fileWithoutExtension, leadingDots, parentNameParts, sourceFilePath, execEnv, strictOnly)) {
+                    return;
+                }
+                suggestions.add(fileWithoutExtension);
+            }
+        });
+        entries.directories.forEach((dir) => {
+            if (filter && !dir.startsWith(filter)) {
+                return;
+            }
+            if (!this._isUniqueValidSuggestion(dir, suggestions) ||
+                !this._isResolvableSuggestion(dir, leadingDots, parentNameParts, sourceFilePath, execEnv, strictOnly)) {
+                return;
+            }
+            suggestions.add(dir);
+        });
+    }
+    // Fix for editable installed submodules where the suggested directory was a namespace directory that wouldn't resolve.
+    // only used for absolute imports
+    _isResolvableSuggestion(name, leadingDots, parentNameParts, sourceFilePath, execEnv, strictOnly) {
+        // We always resolve names based on sourceFilePath.
+        const moduleDescriptor = {
+            leadingDots: leadingDots,
+            nameParts: [...parentNameParts, name],
+            importedSymbols: [],
+        };
+        // Make sure we don't use parent folder resolution when checking whether the given name is resolvable.
+        if (strictOnly) {
+            const importName = this.formatImportName(moduleDescriptor);
+            const importFailureInfo = [];
+            return this._resolveImportStrict(importName, sourceFilePath, execEnv, moduleDescriptor, importFailureInfo)
+                .isImportFound;
+        }
+        return this._resolveImport(sourceFilePath, execEnv, moduleDescriptor).isImportFound;
+    }
+    _isUniqueValidSuggestion(suggestionToAdd, suggestions) {
+        if (suggestions.has(suggestionToAdd)) {
+            return false;
+        }
+        // Don't add directories with illegal module names.
+        if (/[.-]/.test(suggestionToAdd)) {
+            return false;
+        }
+        // Don't add directories with dunder names like "__pycache__".
+        if ((0, symbolNameUtils_1.isDunderName)(suggestionToAdd) && suggestionToAdd !== '__future__') {
+            return false;
+        }
+        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.
+        const entries = (0, pathUtils_1.getFileSystemEntriesFromDirEntries)(this.readdirEntriesCached(dirPath), this.fileSystem, dirPath);
+        // Add implicit file-based modules.
+        for (const fileName of entries.files) {
+            const fileExt = (0, pathUtils_1.getFileExtension)(fileName);
+            let strippedFileName;
+            let isNativeLib = false;
+            if (fileExt === '.py' || fileExt === '.pyi') {
+                strippedFileName = (0, pathUtils_1.stripFileExtension)(fileName);
+            }
+            else if (this._isNativeModuleFileExtension(fileExt) &&
+                !this.fileExistsCached(`${fileName}.py`) &&
+                !this.fileExistsCached(`${fileName}.pyi`)) {
+                // Native module.
+                strippedFileName = fileName.substr(0, fileName.indexOf('.'));
+                isNativeLib = true;
+            }
+            else {
+                continue;
+            }
+            const filePath = (0, pathUtils_1.combinePaths)(dirPath, fileName);
+            if (!exclusions.find((exclusion) => exclusion === filePath)) {
+                const implicitImport = {
+                    isStubFile: fileName.endsWith('.pyi'),
+                    isNativeLib,
+                    name: strippedFileName,
+                    path: filePath,
+                };
+                // Always prefer stub files over non-stub files.
+                const entry = implicitImportMap.get(implicitImport.name);
+                if (!entry || !entry.isStubFile) {
+                    // Try resolving resolving native lib to a custom stub.
+                    if (isNativeLib) {
+                        const nativeLibPath = (0, pathUtils_1.combinePaths)(dirPath, fileName);
+                        const nativeStubPath = this.resolveNativeImportEx(nativeLibPath, `${importingModuleName}.${strippedFileName}`, []);
+                        if (nativeStubPath) {
+                            implicitImport.path = nativeStubPath;
+                            implicitImport.isNativeLib = false;
+                        }
+                    }
+                    implicitImportMap.set(implicitImport.name, implicitImport);
+                }
+            }
+        }
+        // Add implicit directory-based modules.
+        for (const dirName of entries.directories) {
+            const pyFilePath = (0, pathUtils_1.combinePaths)(dirPath, dirName, '__init__.py');
+            const pyiFilePath = pyFilePath + 'i';
+            let isStubFile = false;
+            let path = '';
+            if (this.fileExistsCached(pyiFilePath)) {
+                isStubFile = true;
+                path = pyiFilePath;
+            }
+            else if (this.fileExistsCached(pyFilePath)) {
+                path = pyFilePath;
+            }
+            if (path) {
+                if (!exclusions.find((exclusion) => exclusion === path)) {
+                    const implicitImport = {
+                        isStubFile,
+                        isNativeLib: false,
+                        name: dirName,
+                        path,
+                    };
+                    implicitImportMap.set(implicitImport.name, implicitImport);
+                }
+            }
+        }
+        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) {
+            // 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);
+        if (compiledStubPath) {
+            importFailureInfo.push(`Resolved native import ${importName} with stub '${compiledStubPath}'`);
+            resolvedPaths.push(compiledStubPath);
+            return false; // Resolved to a stub.
+        }
+        importFailureInfo.push(`Resolved import with file '${nativeLibPath}'`);
+        resolvedPaths.push(nativeLibPath);
+        return true;
+    }
+    _isNativeModuleFileName(moduleName, fileName) {
+        // Strip off the final file extension and the part of the file name
+        // that excludes all (multi-part) file extensions. This allows us to
+        // handle file names like "foo.cpython-32m.so".
+        const fileExtension = (0, pathUtils_1.getFileExtension)(fileName, /* multiDotExtension */ false).toLowerCase();
+        const withoutExtension = (0, pathUtils_1.stripFileExtension)(fileName, /* multiDotExtension */ true);
+        return (this._isNativeModuleFileExtension(fileExtension) &&
+            (0, stringUtils_1.equateStringsCaseInsensitive)(moduleName, withoutExtension));
+    }
+    _isNativeModuleFileExtension(fileExtension) {
+        return supportedNativeLibExtensions.some((ext) => ext === fileExtension);
+    }
+    _tryWalkUp(current) {
+        if ((0, pathUtils_1.isDiskPathRoot)(current)) {
+            return [false, ''];
+        }
+        return [
+            true,
+            (0, pathUtils_1.ensureTrailingDirectorySeparator)((0, pathUtils_1.normalizePathCase)(this.fileSystem, (0, pathUtils_1.normalizePath)((0, pathUtils_1.combinePaths)(current, '..')))),
+        ];
+    }
+    _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