@zzzen/pyright-internal 1.2.0-dev.20231126 → 1.2.0-dev.20231210

package/dist/analyzer/importResolver.js

@@ -41,6 +41,8 @@ const pythonVersion_1 = require("../common/pythonVersion");
 const serviceProviderExtensions_1 = require("../common/serviceProviderExtensions");
 const StringUtils = __importStar(require("../common/stringUtils"));
 const stringUtils_1 = require("../common/stringUtils");
+const uri_1 = require("../common/uri/uri");
+const uriUtils_1 = require("../common/uri/uriUtils");
 const characters_1 = require("../parser/characters");
 const importStatementUtils_1 = require("./importStatementUtils");
 const parentDirectoryCache_1 = require("./parentDirectoryCache");
@@ -84,20 +86,25 @@ class ImportResolver {
         this._cachedImportResults = new Map();
         this._cachedModuleNameResults = new Map();
         this._cachedEntriesForPath = new Map();
+        this._cachedFilesForPath = new Map();
+        this._cachedDirExistenceForRoot = new Map();
         this.cachedParentImportResults = new parentDirectoryCache_1.ParentDirectoryCache(() => this.getPythonSearchPaths([]));
     }
     get fileSystem() {
         return this.serviceProvider.fs();
     }
+    get tmp() {
+        return this.serviceProvider.tmp();
+    }
     get partialStubs() {
         return this.serviceProvider.tryGet(serviceProviderExtensions_1.ServiceKeys.partialStubs);
     }
-    static isSupportedImportSourceFile(path) {
-        const fileExtension = (0, pathUtils_1.getFileExtension)(path).toLowerCase();
+    static isSupportedImportSourceFile(uri) {
+        const fileExtension = uri.lastExtension.toLowerCase();
         return supportedSourceFileExtensions.some((ext) => fileExtension === ext);
     }
-    static isSupportedImportFile(path) {
-        const fileExtension = (0, pathUtils_1.getFileExtension)(path).toLowerCase();
+    static isSupportedImportFile(uri) {
+        const fileExtension = uri.lastExtension.toLowerCase();
         return exports.supportedFileExtensions.some((ext) => fileExtension === ext);
     }
     invalidateCache() {
@@ -111,28 +118,24 @@ class ImportResolver {
     }
     // Resolves the import and returns the path if it exists, otherwise
     // returns undefined.
-    resolveImport(sourceFilePath, execEnv, moduleDescriptor) {
+    resolveImport(sourceFileUri, execEnv, moduleDescriptor) {
         // Wrap internal call to resolveImportInternal() to prevent calling any
         // child class version of resolveImport().
-        return this.resolveImportInternal(sourceFilePath, execEnv, moduleDescriptor);
+        return this.resolveImportInternal(sourceFileUri, execEnv, moduleDescriptor);
     }
-    getCompletionSuggestions(sourceFilePath, execEnv, moduleDescriptor) {
-        const suggestions = this._getCompletionSuggestionsStrict(sourceFilePath, execEnv, moduleDescriptor);
+    getCompletionSuggestions(sourceFileUri, execEnv, moduleDescriptor) {
+        const suggestions = this._getCompletionSuggestionsStrict(sourceFileUri, 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)(sourceFilePath));
+        const root = this.getParentImportResolutionRoot(sourceFileUri, execEnv.root);
+        const origin = sourceFileUri.getDirectory();
         let current = origin;
-        while (this._shouldWalkUp(current, root, execEnv)) {
-            this._getCompletionSuggestionsAbsolute(sourceFilePath, execEnv, current, moduleDescriptor, suggestions, 
+        while (this._shouldWalkUp(current, root, execEnv) && current) {
+            this._getCompletionSuggestionsAbsolute(sourceFileUri, execEnv, current, moduleDescriptor, suggestions, 
             /* strictOnly */ false);
-            let success;
-            [success, current] = this._tryWalkUp(current);
-            if (!success) {
-                break;
-            }
+            current = this._tryWalkUp(current);
         }
         return suggestions;
     }
@@ -144,21 +147,21 @@ class ImportResolver {
         this.invalidateCache();
     }
     // Returns the implementation file(s) for the given stub file.
-    getSourceFilesFromStub(stubFilePath, execEnv, _mapCompiled) {
-        const sourceFilePaths = [];
+    getSourceFilesFromStub(stubFileUri, execEnv, _mapCompiled) {
+        const sourceFileUris = [];
         // 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.resolvedUris[result.resolvedUris.length - 1].equals(stubFileUri)) {
                         if (result.nonStubImportResult.isImportFound) {
-                            const nonEmptyPath = result.nonStubImportResult.resolvedPaths[result.nonStubImportResult.resolvedPaths.length - 1];
-                            if (nonEmptyPath.endsWith('.py') || nonEmptyPath.endsWith('.pyi')) {
+                            const nonEmptyUri = result.nonStubImportResult.resolvedUris[result.nonStubImportResult.resolvedUris.length - 1];
+                            if (nonEmptyUri.pathEndsWith('.py') || nonEmptyUri.pathEndsWith('.pyi')) {
                                 // We allow pyi in case there are multiple pyi for a compiled module such as
                                 // numpy.random.mtrand
-                                sourceFilePaths.push(nonEmptyPath);
+                                sourceFileUris.push(nonEmptyUri);
                             }
                         }
                     }
@@ -167,14 +170,14 @@ class ImportResolver {
         });
         // We haven't seen an import of that stub, attempt to find the source
         // in some other ways.
-        if (sourceFilePaths.length === 0) {
+        if (sourceFileUris.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);
+            const sourceFileUri = stubFileUri.replaceExtension('.py');
+            if (this.dirExistsCached(sourceFileUri)) {
+                sourceFileUris.push(sourceFileUri);
             }
         }
-        if (sourceFilePaths.length === 0) {
+        if (sourceFileUris.length === 0) {
             // The stub and the source file may have the same name, but be located
             // in different folder hierarchies.
             // Example:
@@ -183,66 +186,62 @@ class ImportResolver {
             // 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 importRoots = 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) {
+            for (const importRootUri of importRoots) {
+                if (stubFileUri.isChild(importRootUri)) {
+                    const parts = Array.from(importRootUri.getRelativePathComponents(stubFileUri));
+                    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);
+                        if (parts[0].endsWith(pathConsts_1.stubsSuffix)) {
+                            parts[0] = parts[0].slice(0, parts[0].length - pathConsts_1.stubsSuffix.length);
                         }
+                        relativeStubPaths.push(parts.join('/'));
                     }
                 }
             }
             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');
+                for (const importRootUri of importRoots) {
+                    const absoluteStubPath = importRootUri.combinePaths(relativeStubPath);
+                    let absoluteSourcePath = absoluteStubPath.replaceExtension('.py');
                     if (this.fileExistsCached(absoluteSourcePath)) {
-                        sourceFilePaths.push(absoluteSourcePath);
+                        sourceFileUris.push(absoluteSourcePath);
                     }
                     else {
-                        const filePathWithoutExtension = (0, pathUtils_1.stripFileExtension)(absoluteSourcePath);
-                        if (filePathWithoutExtension.endsWith('__init__')) {
+                        const filePathWithoutExtension = absoluteSourcePath.stripExtension();
+                        if (filePathWithoutExtension.pathEndsWith('__init__')) {
                             // Did not match: <root>/package/__init__.py
                             // Try equivalent: <root>/package.py
-                            absoluteSourcePath =
-                                filePathWithoutExtension.substr(0, filePathWithoutExtension.length - 9) + '.py';
+                            absoluteSourcePath = filePathWithoutExtension.getDirectory().packageUri;
                             if (this.fileExistsCached(absoluteSourcePath)) {
-                                sourceFilePaths.push(absoluteSourcePath);
+                                sourceFileUris.push(absoluteSourcePath);
                             }
                         }
                         else {
                             // Did not match: <root>/package.py
                             // Try equivalent: <root>/package/__init__.py
-                            absoluteSourcePath = (0, pathUtils_1.combinePaths)(filePathWithoutExtension, '__init__.py');
+                            absoluteSourcePath = filePathWithoutExtension.initPyUri;
                             if (this.fileExistsCached(absoluteSourcePath)) {
-                                sourceFilePaths.push(absoluteSourcePath);
+                                sourceFileUris.push(absoluteSourcePath);
                             }
                         }
                     }
                 }
             }
         }
-        return sourceFilePaths;
+        return sourceFileUris;
     }
     // 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, allowInvalidModuleName = false, detectPyTyped = false) {
+    getModuleNameForImport(fileUri, execEnv, allowInvalidModuleName = false, detectPyTyped = false) {
+        var _a;
         // Cache results of the reverse of resolveImport as we cache resolveImport.
-        const cache = (0, collectionUtils_1.getOrAdd)(this._cachedModuleNameResults, execEnv.root, () => new Map());
-        const key = `${allowInvalidModuleName}.${detectPyTyped}.${filePath}`;
-        return (0, collectionUtils_1.getOrAdd)(cache, key, () => this._getModuleNameForImport(filePath, execEnv, allowInvalidModuleName, detectPyTyped));
+        const cache = (0, collectionUtils_1.getOrAdd)(this._cachedModuleNameResults, (_a = execEnv.root) === null || _a === void 0 ? void 0 : _a.key, () => new Map());
+        const key = `${allowInvalidModuleName}.${detectPyTyped}.${fileUri.key}`;
+        return (0, collectionUtils_1.getOrAdd)(cache, key, () => this._getModuleNameForImport(fileUri, execEnv, allowInvalidModuleName, detectPyTyped));
     }
     getTypeshedStdLibPath(execEnv) {
         const unused = [];
@@ -279,7 +278,7 @@ class ImportResolver {
             // is where the third party folder is in the roots.
             const thirdPartyRoot = this._getThirdPartyTypeshedPath(this._configOptions.typeshedPath, importFailureInfo);
             if (thirdPartyRoot) {
-                roots.push((0, pathUtils_1.combinePaths)(thirdPartyRoot, '...'));
+                roots.push(thirdPartyRoot.combinePaths('...'));
             }
         }
         else {
@@ -297,6 +296,7 @@ class ImportResolver {
         return roots;
     }
     ensurePartialStubPackages(execEnv) {
+        var _a;
         if (!this.partialStubs) {
             return false;
         }
@@ -309,7 +309,7 @@ class ImportResolver {
         const typeshedPathEx = this.getTypeshedPathEx(execEnv, ignored);
         // Add paths to search stub packages.
         addPaths(this._configOptions.stubPath);
-        addPaths(execEnv.root);
+        addPaths((_a = execEnv.root) !== null && _a !== void 0 ? _a : this._configOptions.projectRoot);
         execEnv.extraPaths.forEach((p) => addPaths(p));
         addPaths(typeshedPathEx);
         this.getPythonSearchPaths(ignored).forEach((p) => addPaths(p));
@@ -349,59 +349,58 @@ class ImportResolver {
             if (versionRange.max !== undefined && pythonVersion > versionRange.max) {
                 // Add excludes for both the ".pyi" file and the directory that contains it
                 // (in case it's using a "__init__.pyi" file).
-                const moduleDirPath = (0, pathUtils_1.combinePaths)(typeshedStdlibPath, ...moduleName.split('.'));
+                const moduleDirPath = typeshedStdlibPath.combinePaths(...moduleName.split('.'));
                 excludes.push(moduleDirPath);
-                const moduleFilePath = moduleDirPath + '.pyi';
+                const moduleFilePath = moduleDirPath.replaceExtension('.pyi');
                 excludes.push(moduleFilePath);
             }
         });
         return excludes;
     }
-    readdirEntriesCached(path) {
-        const cachedValue = this._cachedEntriesForPath.get(path);
+    readdirEntriesCached(uri) {
+        const cachedValue = this._cachedEntriesForPath.get(uri.key);
         if (cachedValue) {
             return cachedValue;
         }
         let newCacheValue;
         try {
-            newCacheValue = this.fileSystem.readdirEntriesSync(path);
+            newCacheValue = this.fileSystem.readdirEntriesSync(uri);
         }
         catch {
             newCacheValue = [];
         }
         // Populate cache for next time.
-        this._cachedEntriesForPath.set(path, newCacheValue);
+        this._cachedEntriesForPath.set(uri.key, newCacheValue);
         return newCacheValue;
     }
     // Resolves the import and returns the path if it exists, otherwise
     // returns undefined.
-    resolveImportInternal(sourceFilePath, execEnv, moduleDescriptor) {
+    resolveImportInternal(sourceFileUri, execEnv, moduleDescriptor) {
         const importName = this.formatImportName(moduleDescriptor);
         const importFailureInfo = [];
-        const importResult = this._resolveImportStrict(importName, sourceFilePath, execEnv, moduleDescriptor, importFailureInfo);
+        const importResult = this._resolveImportStrict(importName, sourceFileUri, 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.realCasePath)((0, pathUtils_1.normalizePath)(sourceFilePath), this.fileSystem);
-        const origin = (0, pathUtils_1.ensureTrailingDirectorySeparator)((0, pathUtils_1.getDirectoryPath)(sourceFilePath));
+        const origin = sourceFileUri.getDirectory();
         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)) {
+        const root = this.getParentImportResolutionRoot(sourceFileUri, execEnv.root);
+        if (!this.cachedParentImportResults.checkValidPath(this.fileSystem, sourceFileUri, 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, [], 
+        while (this._shouldWalkUp(current, root, execEnv) && current) {
+            const result = this.resolveAbsoluteImport(sourceFileUri, current, execEnv, moduleDescriptor, importName, [], 
             /* allowPartial */ undefined, 
             /* allowNativeLib */ undefined, 
             /* useStubPackage */ false, 
@@ -417,68 +416,72 @@ class ImportResolver {
                 });
                 return this.filterImplicitImports(result, moduleDescriptor.importedSymbols);
             }
-            let success;
-            [success, current] = this._tryWalkUp(current);
-            if (!success) {
-                break;
-            }
+            current = this._tryWalkUp(current);
+        }
+        if (current) {
+            this.cachedParentImportResults.checked(current, importName, importPath);
         }
-        this.cachedParentImportResults.checked(current, importName, importPath);
         return importResult;
     }
-    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;
+    fileExistsCached(uri) {
+        const directory = uri.getDirectory();
+        if (directory.equals(uri)) {
+            // Started at root, so this can't be a file.
+            return false;
         }
-        const entries = this.readdirEntriesCached(splitPath[0]);
-        const entry = entries.find((entry) => entry.name === splitPath[1]);
+        const fileName = uri.fileName;
+        const entries = this.readdirEntriesCached(directory);
+        const entry = entries.find((entry) => entry.name === fileName);
         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)) {
+            const realPath = (0, uriUtils_1.tryRealpath)(this.fileSystem, uri);
+            if (realPath && this.fileSystem.existsSync(realPath) && (0, uriUtils_1.isFile)(this.fileSystem, realPath)) {
                 return true;
             }
         }
         return false;
     }
-    dirExistsCached(path) {
+    dirExistsCached(uri) {
         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]);
+        const parent = uri.getDirectory();
+        if (parent.equals(uri)) {
+            // Started at root. No entries to read, so have to check ourselves.
+            let cachedExistence = this._cachedDirExistenceForRoot.get(uri.key);
+            // Check if the value was in the cache or not. Undefined means it wasn't.
+            if (cachedExistence === undefined) {
+                cachedExistence = (_b = (_a = (0, uriUtils_1.tryStat)(this.fileSystem, uri)) === null || _a === void 0 ? void 0 : _a.isDirectory()) !== null && _b !== void 0 ? _b : false;
+                this._cachedDirExistenceForRoot.set(uri.key, cachedExistence);
+            }
+            return cachedExistence;
+        }
+        // Otherwise not a root, so read the entries we have cached to see if
+        // the directory exists or not.
+        const directoryName = uri.fileName;
+        const entries = this.readdirEntriesCached(parent);
+        const entry = entries.find((entry) => entry.name === directoryName);
         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)) {
+            const realPath = (0, uriUtils_1.tryRealpath)(this.fileSystem, uri);
+            if (realPath && this.fileSystem.existsSync(realPath) && (0, uriUtils_1.isDirectory)(this.fileSystem, realPath)) {
                 return true;
             }
         }
         return false;
     }
-    addResultsToCache(sourceFilePath, execEnv, importName, importResult, moduleDescriptor, fromUserFile) {
+    addResultsToCache(sourceFileUri, execEnv, importName, importResult, moduleDescriptor, fromUserFile) {
+        var _a;
         // If the import is relative, include the source file path in the key.
-        const relativeSourceFilePath = moduleDescriptor && moduleDescriptor.leadingDots > 0 ? sourceFilePath : '';
-        (0, collectionUtils_1.getOrAdd)(this._cachedImportResults, execEnv.root, () => new Map()).set(this._getImportCacheKey(relativeSourceFilePath, importName, fromUserFile), importResult);
+        const relativeSourceFileUri = moduleDescriptor && moduleDescriptor.leadingDots > 0 ? sourceFileUri : undefined;
+        (0, collectionUtils_1.getOrAdd)(this._cachedImportResults, (_a = execEnv.root) === null || _a === void 0 ? void 0 : _a.key, () => new Map()).set(this._getImportCacheKey(relativeSourceFileUri, importName, fromUserFile), importResult);
         return this.filterImplicitImports(importResult, moduleDescriptor === null || moduleDescriptor === void 0 ? void 0 : moduleDescriptor.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) {
+    resolveAbsoluteImport(sourceFileUri, 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
@@ -508,46 +511,43 @@ class ImportResolver {
     // 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) {
+    resolveImportEx(sourceFileUri, 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 = []) {
+    resolveNativeImportEx(libraryFileUri, importName, importFailureInfo = []) {
         return undefined;
     }
-    getNativeModuleName(fileName) {
-        const fileExtension = (0, pathUtils_1.getFileExtension)(fileName, /* multiDotExtension */ false).toLowerCase();
+    getNativeModuleName(uri) {
+        const fileExtension = uri.lastExtension.toLowerCase();
         if (this._isNativeModuleFileExtension(fileExtension)) {
-            return (0, pathUtils_1.stripFileExtension)((0, pathUtils_1.stripFileExtension)(fileName));
+            return (0, pathUtils_1.stripFileExtension)(uri.fileName, /* multiDotExtension */ true);
         }
         return undefined;
     }
-    getModuleNameFromPath(containerPath, filePath, stripTopContainerDir = false) {
-        const moduleNameInfo = this.getModuleNameInfoFromPath(containerPath, filePath, stripTopContainerDir);
+    getModuleNameFromPath(containerPath, fileUri, stripTopContainerDir = false) {
+        const moduleNameInfo = this.getModuleNameInfoFromPath(containerPath, fileUri, 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);
+    getModuleNameInfoFromPath(containerPath, fileUri, stripTopContainerDir = false) {
+        let fileUriWithoutExtension = fileUri.stripExtension();
         // 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 (this._isNativeModuleFileExtension(fileUri.lastExtension)) {
+            fileUriWithoutExtension = fileUriWithoutExtension.stripExtension();
         }
-        if (!filePathWithoutExtension.startsWith(containerPath)) {
+        if (!fileUriWithoutExtension.startsWith(containerPath)) {
             return undefined;
         }
         // Strip off the '/__init__' if it's present.
-        if (filePathWithoutExtension.endsWith('__init__')) {
-            filePathWithoutExtension = filePathWithoutExtension.substr(0, filePathWithoutExtension.length - 9);
+        if (fileUriWithoutExtension.pathEndsWith('__init__')) {
+            fileUriWithoutExtension = fileUriWithoutExtension.getDirectory();
         }
-        const relativeFilePath = filePathWithoutExtension.substr(containerPath.length);
-        const parts = (0, pathUtils_1.getPathComponents)(relativeFilePath);
-        parts.shift();
+        const parts = Array.from(containerPath.getRelativePathComponents(fileUriWithoutExtension));
         if (stripTopContainerDir) {
             if (parts.length === 0) {
                 return undefined;
@@ -600,14 +600,14 @@ class ImportResolver {
     formatImportName(moduleDescriptor) {
         return '.'.repeat(moduleDescriptor.leadingDots) + moduleDescriptor.nameParts.join('.');
     }
-    getParentImportResolutionRoot(sourceFilePath, executionRoot) {
+    getParentImportResolutionRoot(sourceFileUri, executionRoot) {
         if (executionRoot) {
-            return (0, pathUtils_1.ensureTrailingDirectorySeparator)((0, pathUtils_1.realCasePath)((0, pathUtils_1.normalizePath)(executionRoot), this.fileSystem));
+            return this.fileSystem.realCasePath(executionRoot);
         }
-        return (0, pathUtils_1.ensureTrailingDirectorySeparator)((0, pathUtils_1.getDirectoryPath)(sourceFilePath));
+        return sourceFileUri.getDirectory();
     }
-    _resolveImportStrict(importName, sourceFilePath, execEnv, moduleDescriptor, importFailureInfo) {
-        const fromUserFile = (0, configOptions_1.matchFileSpecs)(this._configOptions, sourceFilePath);
+    _resolveImportStrict(importName, sourceFileUri, execEnv, moduleDescriptor, importFailureInfo) {
+        const fromUserFile = (0, configOptions_1.matchFileSpecs)(this._configOptions, sourceFileUri);
         const notFoundResult = {
             importName,
             isRelative: false,
@@ -617,7 +617,7 @@ class ImportResolver {
             isInitFilePresent: false,
             isStubPackage: false,
             importFailureInfo,
-            resolvedPaths: [],
+            resolvedUris: [],
             importType: 2 /* ImportType.Local */,
             isStubFile: false,
             isNativeLib: false,
@@ -628,18 +628,18 @@ class ImportResolver {
         this.ensurePartialStubPackages(execEnv);
         // Is it a relative import?
         if (moduleDescriptor.leadingDots > 0) {
-            const cachedResults = this._lookUpResultsInCache(sourceFilePath, execEnv, importName, moduleDescriptor, fromUserFile);
+            const cachedResults = this._lookUpResultsInCache(sourceFileUri, execEnv, importName, moduleDescriptor, fromUserFile);
             if (cachedResults) {
                 return cachedResults;
             }
-            const relativeImport = this._resolveRelativeImport(sourceFilePath, execEnv, moduleDescriptor, importName, importFailureInfo);
+            const relativeImport = this._resolveRelativeImport(sourceFileUri, execEnv, moduleDescriptor, importName, importFailureInfo);
             if (relativeImport) {
                 relativeImport.isRelative = true;
-                return this.addResultsToCache(sourceFilePath, execEnv, importName, relativeImport, moduleDescriptor, fromUserFile);
+                return this.addResultsToCache(sourceFileUri, execEnv, importName, relativeImport, moduleDescriptor, fromUserFile);
             }
         }
         else {
-            const cachedResults = this._lookUpResultsInCache(sourceFilePath, execEnv, importName, moduleDescriptor, fromUserFile);
+            const cachedResults = this._lookUpResultsInCache(sourceFileUri, execEnv, importName, moduleDescriptor, 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
@@ -653,54 +653,54 @@ class ImportResolver {
                     return cachedResults;
                 }
             }
-            const bestImport = this._resolveBestAbsoluteImport(sourceFilePath, execEnv, moduleDescriptor, 
+            const bestImport = this._resolveBestAbsoluteImport(sourceFileUri, execEnv, moduleDescriptor, 
             /* allowPyi */ true);
             if (bestImport) {
                 if (bestImport.isStubFile) {
                     bestImport.nonStubImportResult =
-                        this._resolveBestAbsoluteImport(sourceFilePath, execEnv, moduleDescriptor, 
+                        this._resolveBestAbsoluteImport(sourceFileUri, execEnv, moduleDescriptor, 
                         /* allowPyi */ false) || notFoundResult;
                 }
-                return this.addResultsToCache(sourceFilePath, execEnv, importName, bestImport, moduleDescriptor, fromUserFile);
+                return this.addResultsToCache(sourceFileUri, execEnv, importName, bestImport, moduleDescriptor, fromUserFile);
             }
         }
-        return this.addResultsToCache(sourceFilePath, execEnv, importName, notFoundResult, 
+        return this.addResultsToCache(sourceFileUri, execEnv, importName, notFoundResult, 
         /* moduleDescriptor */ undefined, fromUserFile);
     }
-    _getCompletionSuggestionsStrict(sourceFilePath, execEnv, moduleDescriptor) {
+    _getCompletionSuggestionsStrict(sourceFileUri, execEnv, moduleDescriptor) {
         const importFailureInfo = [];
         const suggestions = new Map();
         // Is it a relative import?
         if (moduleDescriptor.leadingDots > 0) {
-            this._getCompletionSuggestionsRelative(sourceFilePath, execEnv, moduleDescriptor, suggestions);
+            this._getCompletionSuggestionsRelative(sourceFileUri, execEnv, moduleDescriptor, suggestions);
         }
         else {
             // First check for a typeshed file.
             if (moduleDescriptor.nameParts.length > 0) {
-                this._getCompletionSuggestionsTypeshedPath(sourceFilePath, execEnv, moduleDescriptor, true, suggestions);
+                this._getCompletionSuggestionsTypeshedPath(sourceFileUri, 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);
+                this._getCompletionSuggestionsAbsolute(sourceFileUri, execEnv, execEnv.root, moduleDescriptor, suggestions);
             }
             for (const extraPath of execEnv.extraPaths) {
-                this._getCompletionSuggestionsAbsolute(sourceFilePath, execEnv, extraPath, moduleDescriptor, suggestions);
+                this._getCompletionSuggestionsAbsolute(sourceFileUri, execEnv, extraPath, moduleDescriptor, suggestions);
             }
             // Check for a typings file.
             if (this._configOptions.stubPath) {
-                this._getCompletionSuggestionsAbsolute(sourceFilePath, execEnv, this._configOptions.stubPath, moduleDescriptor, suggestions);
+                this._getCompletionSuggestionsAbsolute(sourceFileUri, execEnv, this._configOptions.stubPath, moduleDescriptor, suggestions);
             }
             // Check for a typeshed file.
-            this._getCompletionSuggestionsTypeshedPath(sourceFilePath, execEnv, moduleDescriptor, false, suggestions);
+            this._getCompletionSuggestionsTypeshedPath(sourceFileUri, 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);
+                this._getCompletionSuggestionsAbsolute(sourceFileUri, execEnv, searchPath, moduleDescriptor, suggestions);
             }
         }
         return suggestions;
     }
-    _getModuleNameForImport(filePath, execEnv, allowInvalidModuleName, detectPyTyped) {
+    _getModuleNameForImport(fileUri, execEnv, allowInvalidModuleName, detectPyTyped) {
         let moduleName;
         let importType = 0 /* ImportType.BuiltIn */;
         let isLocalTypingsFile = false;
@@ -715,7 +715,7 @@ class ImportResolver {
         // Is this a stdlib typeshed path?
         const stdLibTypeshedPath = this._getStdlibTypeshedPath(this._configOptions.typeshedPath, execEnv.pythonVersion, importFailureInfo);
         if (stdLibTypeshedPath) {
-            moduleName = this.getModuleNameFromPath(stdLibTypeshedPath, filePath);
+            moduleName = this.getModuleNameFromPath(stdLibTypeshedPath, fileUri);
             if (moduleName) {
                 const moduleDescriptor = {
                     leadingDots: 0,
@@ -735,7 +735,7 @@ class ImportResolver {
         }
         // Look for it in the root directory of the execution environment.
         if (execEnv.root) {
-            const candidateModuleNameInfo = this.getModuleNameInfoFromPath(execEnv.root, filePath);
+            const candidateModuleNameInfo = this.getModuleNameInfoFromPath(execEnv.root, fileUri);
             if (candidateModuleNameInfo) {
                 if (candidateModuleNameInfo.containsInvalidCharacters) {
                     moduleNameWithInvalidCharacters = candidateModuleNameInfo.moduleName;
@@ -747,7 +747,7 @@ class ImportResolver {
             importType = 2 /* ImportType.Local */;
         }
         for (const extraPath of execEnv.extraPaths) {
-            const candidateModuleNameInfo = this.getModuleNameInfoFromPath(extraPath, filePath);
+            const candidateModuleNameInfo = this.getModuleNameInfoFromPath(extraPath, fileUri);
             if (candidateModuleNameInfo) {
                 if (candidateModuleNameInfo.containsInvalidCharacters) {
                     moduleNameWithInvalidCharacters = candidateModuleNameInfo.moduleName;
@@ -765,7 +765,7 @@ class ImportResolver {
         }
         // Check for a typings file.
         if (this._configOptions.stubPath) {
-            const candidateModuleNameInfo = this.getModuleNameInfoFromPath(this._configOptions.stubPath, filePath);
+            const candidateModuleNameInfo = this.getModuleNameInfoFromPath(this._configOptions.stubPath, fileUri);
             if (candidateModuleNameInfo) {
                 if (candidateModuleNameInfo.containsInvalidCharacters) {
                     moduleNameWithInvalidCharacters = candidateModuleNameInfo.moduleName;
@@ -786,7 +786,7 @@ class ImportResolver {
         // Check for a typeshed file.
         const thirdPartyTypeshedPath = this._getThirdPartyTypeshedPath(this._configOptions.typeshedPath, importFailureInfo);
         if (thirdPartyTypeshedPath) {
-            const candidateModuleName = this.getModuleNameFromPath(thirdPartyTypeshedPath, filePath, 
+            const candidateModuleName = this.getModuleNameFromPath(thirdPartyTypeshedPath, fileUri, 
             /* stripTopContainerDir */ true);
             // Does this candidate look better than the previous best module name?
             // We'll always try to use the shortest version.
@@ -798,7 +798,7 @@ class ImportResolver {
         }
         const thirdPartyTypeshedPathEx = this.getTypeshedPathEx(execEnv, importFailureInfo);
         if (thirdPartyTypeshedPathEx) {
-            const candidateModuleName = this.getModuleNameFromPath(thirdPartyTypeshedPathEx, filePath);
+            const candidateModuleName = this.getModuleNameFromPath(thirdPartyTypeshedPathEx, fileUri);
             // 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)) {
@@ -810,7 +810,7 @@ class ImportResolver {
         // 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);
+            const candidateModuleNameInfo = this.getModuleNameInfoFromPath(searchPath, fileUri);
             if (candidateModuleNameInfo) {
                 if (candidateModuleNameInfo.containsInvalidCharacters) {
                     moduleNameWithInvalidCharacters = candidateModuleNameInfo.moduleName;
@@ -828,22 +828,16 @@ class ImportResolver {
             }
         }
         if (detectPyTyped && importType === 1 /* ImportType.ThirdParty */) {
-            const root = this.getParentImportResolutionRoot(filePath, execEnv.root);
+            const root = this.getParentImportResolutionRoot(fileUri, execEnv.root);
             // Go up directories one by one looking for a py.typed file.
-            let current = (0, pathUtils_1.ensureTrailingDirectorySeparator)((0, pathUtils_1.getDirectoryPath)(filePath));
+            let current = fileUri.getDirectory();
             while (this._shouldWalkUp(current, root, execEnv)) {
-                if (this.fileExistsCached((0, pathUtils_1.combinePaths)(current, 'py.typed'))) {
-                    const pyTypedInfo = (0, pyTypedUtils_1.getPyTypedInfo)(this.fileSystem, current);
-                    if (pyTypedInfo && !pyTypedInfo.isPartiallyTyped) {
-                        isThirdPartyPyTypedPresent = true;
-                    }
-                    break;
-                }
-                let success;
-                [success, current] = this._tryWalkUp(current);
-                if (!success) {
-                    break;
+                const pyTypedInfo = this._getPyTypedInfo(current);
+                if (pyTypedInfo && !pyTypedInfo.isPartiallyTyped) {
+                    isThirdPartyPyTypedPresent = true;
                 }
+                break;
+                current = this._tryWalkUp(current);
             }
         }
         if (moduleName) {
@@ -869,17 +863,8 @@ class ImportResolver {
     }
     _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];
+        this._cachedFilesForPath.clear();
+        this._cachedDirExistenceForRoot.clear();
     }
     _resolveAbsoluteImport(rootPath, execEnv, moduleDescriptor, importName, importFailureInfo, allowPartial, allowNativeLib, useStubPackage, allowPyi, lookForPyTyped) {
         if (useStubPackage) {
@@ -902,9 +887,8 @@ class ImportResolver {
         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');
+            const pyFilePath = dirPath.initPyUri;
+            const pyiFilePath = dirPath.initPyiUri;
             if (allowPyi && this.fileExistsCached(pyiFilePath)) {
                 importFailureInfo.push(`Resolved import with file '${pyiFilePath}'`);
                 resolvedPaths.push(pyiFilePath);
@@ -916,7 +900,7 @@ class ImportResolver {
             }
             else {
                 importFailureInfo.push(`Partially resolved import with directory '${dirPath}'`);
-                resolvedPaths.push('');
+                resolvedPaths.push(uri_1.Uri.empty());
                 isNamespacePackage = true;
             }
             implicitImports = this._findImplicitImports(importName, dirPath, [pyFilePath, pyiFilePath]);
@@ -925,9 +909,9 @@ class ImportResolver {
             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]);
+                dirPath = dirPath.combinePaths(moduleDescriptor.nameParts[i]);
                 if (useStubPackage && isFirstPart) {
-                    dirPath += pathConsts_1.stubsSuffix;
+                    dirPath = dirPath.addPath(pathConsts_1.stubsSuffix);
                     isStubPackage = true;
                 }
                 const foundDirectory = this.dirExistsCached(dirPath);
@@ -936,9 +920,8 @@ class ImportResolver {
                         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');
+                    const pyFilePath = dirPath.initPyUri;
+                    const pyiFilePath = dirPath.initPyiUri;
                     isInitFilePresent = false;
                     if (allowPyi && this.fileExistsCached(pyiFilePath)) {
                         importFailureInfo.push(`Resolved import with file '${pyiFilePath}'`);
@@ -954,15 +937,13 @@ class ImportResolver {
                         isInitFilePresent = true;
                     }
                     if (!pyTypedInfo && lookForPyTyped) {
-                        if (this.fileExistsCached((0, pathUtils_1.combinePaths)(dirPath, 'py.typed'))) {
-                            pyTypedInfo = (0, pyTypedUtils_1.getPyTypedInfo)(this.fileSystem, dirPath);
-                        }
+                        pyTypedInfo = this._getPyTypedInfo(dirPath);
                     }
                     if (!isLastPart) {
                         // We are not at the last part, and we found a directory,
                         // so continue to look for the next part.
                         if (!isInitFilePresent) {
-                            resolvedPaths.push('');
+                            resolvedPaths.push(uri_1.Uri.empty());
                             isNamespacePackage = true;
                             pyTypedInfo = undefined;
                         }
@@ -979,11 +960,9 @@ class ImportResolver {
                 // 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');
+                const pyFilePath = dirPath.packageUri;
+                const pyiFilePath = dirPath.packageStubUri;
+                const fileDirectory = dirPath.getDirectory();
                 if (allowPyi && this.fileExistsCached(pyiFilePath)) {
                     importFailureInfo.push(`Resolved import with file '${pyiFilePath}'`);
                     resolvedPaths.push(pyiFilePath);
@@ -998,16 +977,16 @@ class ImportResolver {
                 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);
+                        const dirName = dirPath.fileName;
+                        const nativeLibPath = filesInDir.find((f) => this._isNativeModuleFileName(dirName, f));
+                        if (nativeLibPath) {
                             // 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('');
+                        resolvedPaths.push(uri_1.Uri.empty());
                         if (isLastPart) {
                             implicitImports = this._findImplicitImports(importName, dirPath, [pyFilePath, pyiFilePath]);
                             isNamespacePackage = true;
@@ -1018,9 +997,7 @@ class ImportResolver {
                     }
                 }
                 if (!pyTypedInfo && lookForPyTyped) {
-                    if (this.fileExistsCached((0, pathUtils_1.combinePaths)(fileDirectory, 'py.typed'))) {
-                        pyTypedInfo = (0, pyTypedUtils_1.getPyTypedInfo)(this.fileSystem, fileDirectory);
-                    }
+                    pyTypedInfo = this._getPyTypedInfo(fileDirectory);
                 }
                 break;
             }
@@ -1043,7 +1020,7 @@ class ImportResolver {
             isPartlyResolved,
             importFailureInfo,
             importType: 2 /* ImportType.Local */,
-            resolvedPaths,
+            resolvedUris: resolvedPaths,
             searchPath: rootPath,
             isStubFile,
             isNativeLib,
@@ -1053,17 +1030,19 @@ class ImportResolver {
             packageDirectory,
         };
     }
-    _getImportCacheKey(sourceFilePath, importName, fromUserFile) {
-        return `${sourceFilePath}-${importName}-${fromUserFile}`;
+    _getImportCacheKey(sourceFileUri, importName, fromUserFile) {
+        var _a;
+        return `${(_a = sourceFileUri === null || sourceFileUri === void 0 ? void 0 : sourceFileUri.key) !== null && _a !== void 0 ? _a : ''}-${importName}-${fromUserFile}`;
     }
-    _lookUpResultsInCache(sourceFilePath, execEnv, importName, moduleDescriptor, fromUserFile) {
-        const cacheForExecEnv = this._cachedImportResults.get(execEnv.root);
+    _lookUpResultsInCache(sourceFileUri, execEnv, importName, moduleDescriptor, fromUserFile) {
+        var _a, _b;
+        const cacheForExecEnv = this._cachedImportResults.get((_b = (_a = execEnv.root) === null || _a === void 0 ? void 0 : _a.key) !== null && _b !== void 0 ? _b : '');
         if (!cacheForExecEnv) {
             return undefined;
         }
         // If the import is relative, include the source file path in the key.
-        const relativeSourceFilePath = moduleDescriptor.leadingDots > 0 ? sourceFilePath : '';
-        const cachedEntry = cacheForExecEnv.get(this._getImportCacheKey(relativeSourceFilePath, importName, fromUserFile));
+        const relativeSourceFileUri = moduleDescriptor.leadingDots > 0 ? sourceFileUri : undefined;
+        const cachedEntry = cacheForExecEnv.get(this._getImportCacheKey(relativeSourceFileUri, importName, fromUserFile));
         if (!cachedEntry) {
             return undefined;
         }
@@ -1085,13 +1064,13 @@ class ImportResolver {
         }
         return true;
     }
-    _resolveBestAbsoluteImport(sourceFilePath, execEnv, moduleDescriptor, allowPyi) {
+    _resolveBestAbsoluteImport(sourceFileUri, 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(sourceFilePath, this._configOptions.stubPath, execEnv, moduleDescriptor, importName, importFailureInfo, 
+            const typingsImport = this.resolveAbsoluteImport(sourceFileUri, this._configOptions.stubPath, execEnv, moduleDescriptor, importName, importFailureInfo, 
             /* allowPartial */ undefined, 
             /* allowNativeLib */ false, 
             /* useStubPackage */ true, allowPyi, 
@@ -1104,7 +1083,7 @@ class ImportResolver {
                 // 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]) {
+                    !typingsImport.resolvedUris[typingsImport.resolvedUris.length - 1]) {
                     if (this._isNamespacePackageResolved(moduleDescriptor, typingsImport.implicitImports)) {
                         return typingsImport;
                     }
@@ -1119,7 +1098,7 @@ class ImportResolver {
         // 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(sourceFilePath, execEnv.root, execEnv, moduleDescriptor, importName, importFailureInfo, 
+            localImport = this.resolveAbsoluteImport(sourceFileUri, execEnv.root, execEnv, moduleDescriptor, importName, importFailureInfo, 
             /* allowPartial */ undefined, 
             /* allowNativeLib */ true, 
             /* useStubPackage */ true, allowPyi, 
@@ -1128,7 +1107,7 @@ class ImportResolver {
         }
         for (const extraPath of execEnv.extraPaths) {
             importFailureInfo.push(`Looking in extraPath '${extraPath}'`);
-            localImport = this.resolveAbsoluteImport(sourceFilePath, extraPath, execEnv, moduleDescriptor, importName, importFailureInfo, 
+            localImport = this.resolveAbsoluteImport(sourceFileUri, extraPath, execEnv, moduleDescriptor, importName, importFailureInfo, 
             /* allowPartial */ undefined, 
             /* allowNativeLib */ true, 
             /* useStubPackage */ true, allowPyi, 
@@ -1140,7 +1119,7 @@ class ImportResolver {
         if (pythonSearchPaths.length > 0) {
             for (const searchPath of pythonSearchPaths) {
                 importFailureInfo.push(`Looking in python search path '${searchPath}'`);
-                const thirdPartyImport = this.resolveAbsoluteImport(sourceFilePath, searchPath, execEnv, moduleDescriptor, importName, importFailureInfo, 
+                const thirdPartyImport = this.resolveAbsoluteImport(sourceFileUri, searchPath, execEnv, moduleDescriptor, importName, importFailureInfo, 
                 /* allowPartial */ allowPartialResolutionForThirdPartyPackages, 
                 /* allowNativeLib */ true, 
                 /* useStubPackage */ true, allowPyi, 
@@ -1163,7 +1142,7 @@ class ImportResolver {
             }
         }
         // Call the extensibility hook for subclasses.
-        const extraResults = this.resolveImportEx(sourceFilePath, execEnv, moduleDescriptor, importName, importFailureInfo, allowPyi);
+        const extraResults = this.resolveImportEx(sourceFileUri, execEnv, moduleDescriptor, importName, importFailureInfo, allowPyi);
         if (extraResults) {
             return extraResults;
         }
@@ -1198,8 +1177,8 @@ class ImportResolver {
         }
         if (newImport.isImportFound) {
             // Prefer traditional packages over namespace packages.
-            const soFarIndex = bestImportSoFar.resolvedPaths.findIndex((path) => !!path);
-            const newIndex = newImport.resolvedPaths.findIndex((path) => !!path);
+            const soFarIndex = bestImportSoFar.resolvedUris.findIndex((path) => !path.isEmpty());
+            const newIndex = newImport.resolvedUris.findIndex((path) => !path.isEmpty());
             if (soFarIndex !== newIndex) {
                 if (soFarIndex < 0) {
                     return newImport;
@@ -1253,7 +1232,7 @@ class ImportResolver {
                 return newImport;
             }
             // All else equal, prefer shorter resolution paths.
-            if (bestImportSoFar.resolvedPaths.length > newImport.resolvedPaths.length) {
+            if (bestImportSoFar.resolvedUris.length > newImport.resolvedUris.length) {
                 return newImport;
             }
         }
@@ -1267,8 +1246,8 @@ class ImportResolver {
             //  bestSoFar: a/~b/~c/~d   new: a      Result: bestSoFar wins
             //  bestSoFar: ~a/~b/~c/~d  new: a      Result: new wins
             //  bestSoFar: a/~b/~c/~d   new: a/b    Result: new wins
-            const soFarIndex = bestImportSoFar.resolvedPaths.findIndex((path) => !!path);
-            const newIndex = newImport.resolvedPaths.findIndex((path) => !!path);
+            const soFarIndex = bestImportSoFar.resolvedUris.findIndex((path) => !path.isEmpty());
+            const newIndex = newImport.resolvedUris.findIndex((path) => !path.isEmpty());
             if (soFarIndex !== newIndex) {
                 if (soFarIndex < 0) {
                     return newImport;
@@ -1322,7 +1301,7 @@ class ImportResolver {
             const readDir = (root, prefix) => {
                 this.readdirEntriesCached(root).forEach((entry) => {
                     if (entry.isDirectory()) {
-                        const dirRoot = (0, pathUtils_1.combinePaths)(root, entry.name);
+                        const dirRoot = root.combinePaths(entry.name);
                         readDir(dirRoot, prefix ? `${prefix}.${entry.name}` : entry.name);
                     }
                     else if (entry.name.includes('.py')) {
@@ -1348,7 +1327,7 @@ class ImportResolver {
         if (thirdPartyDir) {
             this.readdirEntriesCached(thirdPartyDir).forEach((outerEntry) => {
                 if (outerEntry.isDirectory()) {
-                    const innerDirPath = (0, pathUtils_1.combinePaths)(thirdPartyDir, outerEntry.name);
+                    const innerDirPath = thirdPartyDir.combinePaths(outerEntry.name);
                     this.readdirEntriesCached(innerDirPath).forEach((innerEntry) => {
                         if (innerEntry.name === '@python2') {
                             return;
@@ -1381,7 +1360,7 @@ class ImportResolver {
         const flattenPaths = Array.from(this._cachedTypeshedThirdPartyPackagePaths.values()).flatMap((v) => v);
         this._cachedTypeshedThirdPartyPackageRoots = Array.from(new Set(flattenPaths)).sort();
     }
-    _getCompletionSuggestionsTypeshedPath(sourceFilePath, execEnv, moduleDescriptor, isStdLib, suggestions) {
+    _getCompletionSuggestionsTypeshedPath(sourceFileUri, execEnv, moduleDescriptor, isStdLib, suggestions) {
         const importFailureInfo = [];
         let typeshedPaths;
         if (isStdLib) {
@@ -1404,7 +1383,7 @@ class ImportResolver {
         }
         typeshedPaths.forEach((typeshedPath) => {
             if (this.dirExistsCached(typeshedPath)) {
-                this._getCompletionSuggestionsAbsolute(sourceFilePath, execEnv, typeshedPath, moduleDescriptor, suggestions);
+                this._getCompletionSuggestionsAbsolute(sourceFileUri, execEnv, typeshedPath, moduleDescriptor, suggestions);
             }
         });
     }
@@ -1449,7 +1428,7 @@ class ImportResolver {
         const typeshedStdLibPath = this._getTypeshedSubdirectory(
         /* isStdLib */ true, customTypeshedPath, importFailureInfo);
         if (typeshedStdLibPath) {
-            const versionsFilePath = (0, pathUtils_1.combinePaths)(typeshedStdLibPath, 'VERSIONS');
+            const versionsFilePath = typeshedStdLibPath.combinePaths('VERSIONS');
             try {
                 const fileStats = this.fileSystem.statSync(versionsFilePath);
                 if (fileStats.size > 0 && fileStats.size < 256 * 1024) {
@@ -1516,10 +1495,11 @@ class ImportResolver {
         return this._cachedTypeshedThirdPartyPackageRoots;
     }
     _getTypeshedRoot(customTypeshedPath, importFailureInfo) {
+        var _a;
         if (this._cachedTypeshedRoot !== undefined) {
             return this._cachedTypeshedRoot;
         }
-        let typeshedPath = '';
+        let typeshedPath = undefined;
         // Did the user specify a typeshed path? If not, we'll look in the
         // python search paths, then in the typeshed-fallback directory.
         if (customTypeshedPath) {
@@ -1529,7 +1509,7 @@ class ImportResolver {
         }
         // If typeshed directory wasn't found in other locations, use the fallback.
         if (!typeshedPath) {
-            typeshedPath = PythonPathUtils.getTypeShedFallbackPath(this.fileSystem) || '';
+            typeshedPath = (_a = PythonPathUtils.getTypeShedFallbackPath(this.fileSystem)) !== null && _a !== void 0 ? _a : uri_1.Uri.empty();
         }
         this._cachedTypeshedRoot = typeshedPath;
         return typeshedPath;
@@ -1560,23 +1540,23 @@ class ImportResolver {
         }
         return typeshedPath;
     }
-    _resolveRelativeImport(sourceFilePath, execEnv, moduleDescriptor, importName, importFailureInfo) {
+    _resolveRelativeImport(sourceFileUri, 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);
+        const directory = (0, importStatementUtils_1.getDirectoryLeadingDotsPointsTo)(sourceFileUri.getDirectory(), 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(sourceFilePath, directory, execEnv, moduleDescriptor, importName, importFailureInfo, 
+        const absImport = this.resolveAbsoluteImport(sourceFileUri, 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(sourceFilePath, directory, execEnv, moduleDescriptor, importName, importFailureInfo, 
+            absImport.nonStubImportResult = this.resolveAbsoluteImport(sourceFileUri, directory, execEnv, moduleDescriptor, importName, importFailureInfo, 
             /* allowPartial */ false, 
             /* allowNativeLib */ true, 
             /* useStubPackage */ false, 
@@ -1588,7 +1568,7 @@ class ImportResolver {
                 isNamespacePackage: false,
                 isStubPackage: false,
                 importFailureInfo,
-                resolvedPaths: [],
+                resolvedUris: [],
                 importType: 2 /* ImportType.Local */,
                 isStubFile: false,
                 isNativeLib: false,
@@ -1599,29 +1579,40 @@ class ImportResolver {
         }
         return absImport;
     }
-    _getCompletionSuggestionsRelative(sourceFilePath, execEnv, moduleDescriptor, suggestions) {
+    _getCompletionSuggestionsRelative(sourceFileUri, 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);
+        const directory = (0, importStatementUtils_1.getDirectoryLeadingDotsPointsTo)(sourceFileUri.getDirectory(), moduleDescriptor.leadingDots);
         if (!directory) {
             return;
         }
         // Now try to match the module parts from the current directory location.
-        this._getCompletionSuggestionsAbsolute(sourceFilePath, execEnv, directory, moduleDescriptor, suggestions);
+        this._getCompletionSuggestionsAbsolute(sourceFileUri, 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;
+        const cachedValue = this._cachedFilesForPath.get(dirPath.key);
+        if (cachedValue) {
+            return cachedValue;
+        }
+        let newCacheValue = [];
+        try {
+            const entriesInDir = this.readdirEntriesCached(dirPath);
+            const filesInDir = entriesInDir.filter((f) => f.isFile());
+            // Add any symbolic links that point to files.
+            entriesInDir.forEach((f) => {
+                var _a;
+                if (f.isSymbolicLink() && ((_a = (0, uriUtils_1.tryStat)(this.fileSystem, dirPath.combinePaths(f.name))) === null || _a === void 0 ? void 0 : _a.isFile())) {
+                    filesInDir.push(f);
+                }
+            });
+            newCacheValue = filesInDir.map((f) => dirPath.combinePaths(f.name));
+        }
+        catch {
+            newCacheValue = [];
+        }
+        this._cachedFilesForPath.set(dirPath.key, newCacheValue);
+        return newCacheValue;
     }
-    _getCompletionSuggestionsAbsolute(sourceFilePath, execEnv, rootPath, moduleDescriptor, suggestions, strictOnly = true) {
+    _getCompletionSuggestionsAbsolute(sourceFileUri, execEnv, rootPath, moduleDescriptor, suggestions, strictOnly = true) {
         // Starting at the specified path, walk the file system to find the
         // specified module.
         let dirPath = rootPath;
@@ -1638,29 +1629,29 @@ class ImportResolver {
         // 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);
+            this._addFilteredSuggestionsAbsolute(sourceFileUri, 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);
+                    this._addFilteredSuggestionsAbsolute(sourceFileUri, execEnv, dirPath, nameParts[i], suggestions, leadingDots, parentNameParts, strictOnly);
                 }
-                dirPath = (0, pathUtils_1.combinePaths)(dirPath, nameParts[i]);
+                dirPath = dirPath.combinePaths(nameParts[i]);
                 if (!this.dirExistsCached(dirPath)) {
                     break;
                 }
             }
         }
     }
-    _addFilteredSuggestionsAbsolute(sourceFilePath, execEnv, currentPath, filter, suggestions, leadingDots, parentNameParts, strictOnly) {
+    _addFilteredSuggestionsAbsolute(sourceFileUri, 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);
+        const entries = (0, uriUtils_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 fileWithoutExtension = (0, pathUtils_1.stripFileExtension)(file, /* multiDotExtension */ true);
+            const fileWithoutExtension = file.stripAllExtensions().fileName;
             if (ImportResolver.isSupportedImportFile(file)) {
                 if (fileWithoutExtension === '__init__') {
                     return;
@@ -1669,38 +1660,39 @@ class ImportResolver {
                     return;
                 }
                 if (!this._isUniqueValidSuggestion(fileWithoutExtension, suggestions) ||
-                    !this._isResolvableSuggestion(fileWithoutExtension, leadingDots, parentNameParts, sourceFilePath, execEnv, strictOnly)) {
+                    !this._isResolvableSuggestion(fileWithoutExtension, leadingDots, parentNameParts, sourceFileUri, execEnv, strictOnly)) {
                     return;
                 }
-                suggestions.set(fileWithoutExtension, (0, pathUtils_1.combinePaths)(currentPath, file));
+                suggestions.set(fileWithoutExtension, file);
             }
         });
         entries.directories.forEach((dir) => {
-            if (filter && !dir.startsWith(filter)) {
+            const dirSuggestion = dir.fileName;
+            if (filter && !dirSuggestion.startsWith(filter)) {
                 return;
             }
-            if (!this._isUniqueValidSuggestion(dir, suggestions) ||
-                !this._isResolvableSuggestion(dir, leadingDots, parentNameParts, sourceFilePath, execEnv, strictOnly)) {
+            if (!this._isUniqueValidSuggestion(dirSuggestion, suggestions) ||
+                !this._isResolvableSuggestion(dirSuggestion, leadingDots, parentNameParts, sourceFileUri, execEnv, strictOnly)) {
                 return;
             }
-            const initPyiPath = (0, pathUtils_1.combinePaths)(currentPath, dir, '__init__.pyi');
+            const initPyiPath = dir.initPyiUri;
             if (this.fileExistsCached(initPyiPath)) {
-                suggestions.set(dir, initPyiPath);
+                suggestions.set(dirSuggestion, initPyiPath);
                 return;
             }
-            const initPyPath = (0, pathUtils_1.combinePaths)(currentPath, dir, '__init__.py');
+            const initPyPath = dir.initPyUri;
             if (this.fileExistsCached(initPyPath)) {
-                suggestions.set(dir, initPyPath);
+                suggestions.set(dirSuggestion, initPyPath);
                 return;
             }
             // It is a namespace package. there is no corresponding module path.
-            suggestions.set(dir, '');
+            suggestions.set(dirSuggestion, uri_1.Uri.empty());
         });
     }
     // 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.
+    _isResolvableSuggestion(name, leadingDots, parentNameParts, sourceFileUri, execEnv, strictOnly) {
+        // We always resolve names based on sourceFileUri.
         const moduleDescriptor = {
             leadingDots: leadingDots,
             nameParts: [...parentNameParts, name],
@@ -1711,10 +1703,10 @@ class ImportResolver {
         if (strictOnly) {
             const importName = this.formatImportName(moduleDescriptor);
             const importFailureInfo = [];
-            importResult = this._resolveImportStrict(importName, sourceFilePath, execEnv, moduleDescriptor, importFailureInfo);
+            importResult = this._resolveImportStrict(importName, sourceFileUri, execEnv, moduleDescriptor, importFailureInfo);
         }
         else {
-            importResult = this.resolveImportInternal(sourceFilePath, execEnv, moduleDescriptor);
+            importResult = this.resolveImportInternal(sourceFileUri, execEnv, moduleDescriptor);
         }
         if (importResult && importResult.isImportFound) {
             // Check the import isn't for a private or protected module. If it is, then
@@ -1742,42 +1734,41 @@ class ImportResolver {
     _findImplicitImports(importingModuleName, dirPath, exclusions) {
         const implicitImportMap = new Map();
         // Enumerate all of the files and directories in the path, expanding links.
-        const entries = (0, pathUtils_1.getFileSystemEntriesFromDirEntries)(this.readdirEntriesCached(dirPath), this.fileSystem, dirPath);
+        const entries = (0, uriUtils_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);
+        for (const filePath of entries.files) {
+            const fileExt = filePath.lastExtension;
             let strippedFileName;
             let isNativeLib = false;
             if (fileExt === '.py' || fileExt === '.pyi') {
-                strippedFileName = (0, pathUtils_1.stripFileExtension)(fileName);
+                strippedFileName = (0, pathUtils_1.stripFileExtension)(filePath.fileName);
             }
             else if (this._isNativeModuleFileExtension(fileExt) &&
-                !this.fileExistsCached(`${fileName}.py`) &&
-                !this.fileExistsCached(`${fileName}.pyi`)) {
+                !this.fileExistsCached(filePath.packageUri) &&
+                !this.fileExistsCached(filePath.packageStubUri)) {
                 // Native module.
-                strippedFileName = fileName.substr(0, fileName.indexOf('.'));
+                strippedFileName = filePath.stripAllExtensions().fileName;
                 isNativeLib = true;
             }
             else {
                 continue;
             }
-            const filePath = (0, pathUtils_1.combinePaths)(dirPath, fileName);
-            if (!exclusions.find((exclusion) => exclusion === filePath)) {
+            if (!exclusions.find((exclusion) => exclusion.equals(filePath))) {
                 const implicitImport = {
-                    isStubFile: fileName.endsWith('.pyi'),
+                    isStubFile: filePath.hasExtension('.pyi'),
                     isNativeLib,
                     name: strippedFileName,
-                    path: filePath,
+                    uri: 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 nativeLibPath = filePath;
                         const nativeStubPath = this.resolveNativeImportEx(nativeLibPath, `${importingModuleName}.${strippedFileName}`, []);
                         if (nativeStubPath) {
-                            implicitImport.path = nativeStubPath;
+                            implicitImport.uri = nativeStubPath;
                             implicitImport.isNativeLib = false;
                         }
                     }
@@ -1786,11 +1777,11 @@ class ImportResolver {
             }
         }
         // 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';
+        for (const dirPath of entries.directories) {
+            const pyFilePath = dirPath.initPyUri;
+            const pyiFilePath = dirPath.initPyiUri;
             let isStubFile = false;
-            let path = '';
+            let path;
             if (this.fileExistsCached(pyiFilePath)) {
                 isStubFile = true;
                 path = pyiFilePath;
@@ -1799,13 +1790,13 @@ class ImportResolver {
                 path = pyFilePath;
             }
             if (path) {
-                if (!exclusions.find((exclusion) => exclusion === path)) {
+                if (!exclusions.find((exclusion) => exclusion.equals(path))) {
                     const implicitImport = {
                         isStubFile,
                         isNativeLib: false,
-                        name: dirName,
-                        path,
-                        pyTypedInfo: (0, pyTypedUtils_1.getPyTypedInfo)(this.fileSystem, (0, pathUtils_1.combinePaths)(dirPath, dirName)),
+                        name: dirPath.fileName,
+                        uri: path,
+                        pyTypedInfo: this._getPyTypedInfo(dirPath),
                     };
                     implicitImportMap.set(implicitImport.name, implicitImport);
                 }
@@ -1813,6 +1804,14 @@ class ImportResolver {
         }
         return implicitImportMap;
     }
+    // Retrieves the pytyped info for a directory if it exists. This is a small perf optimization
+    // that allows skipping the search when the pytyped file doesn't exist.
+    _getPyTypedInfo(filePath) {
+        if (!this.fileExistsCached(filePath.pytypedUri)) {
+            return undefined;
+        }
+        return (0, pyTypedUtils_1.getPyTypedInfo)(this.fileSystem, filePath);
+    }
     _resolveNativeModuleStub(nativeLibPath, execEnv, importName, moduleDescriptor, importFailureInfo, resolvedPaths) {
         let moduleFullName = importName;
         if (moduleDescriptor.leadingDots > 0) {
@@ -1830,12 +1829,12 @@ class ImportResolver {
         resolvedPaths.push(nativeLibPath);
         return true;
     }
-    _isNativeModuleFileName(moduleName, fileName) {
+    _isNativeModuleFileName(moduleName, fileUri) {
         // 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);
+        const fileExtension = fileUri.lastExtension.toLowerCase();
+        const withoutExtension = (0, pathUtils_1.stripFileExtension)(fileUri.fileName, /* multiDotExtension */ true);
         return (this._isNativeModuleFileExtension(fileExtension) &&
             (0, stringUtils_1.equateStringsCaseInsensitive)(moduleName, withoutExtension));
     }
@@ -1843,18 +1842,18 @@ class ImportResolver {
         return supportedNativeLibExtensions.some((ext) => ext === fileExtension);
     }
     _tryWalkUp(current) {
-        if ((0, pathUtils_1.isDiskPathRoot)(current)) {
-            return [false, ''];
+        if (!current || current.isEmpty() || current.isRoot()) {
+            return undefined;
         }
-        // Ensure we don't go around forever even if isDiskPathRoot returns false.
-        const next = (0, pathUtils_1.ensureTrailingDirectorySeparator)((0, pathUtils_1.normalizePath)((0, pathUtils_1.combinePaths)(current, '..')));
-        if (next === current) {
-            return [false, ''];
+        // Ensure we don't go around forever even if isRoot returns false.
+        const next = current.combinePaths('..');
+        if (next.equals(current)) {
+            return undefined;
         }
-        return [true, next];
+        return next;
     }
     _shouldWalkUp(current, root, execEnv) {
-        return current.length > root.length || (current === root && !execEnv.root);
+        return current && (current.isChild(root) || (current.equals(root) && !execEnv.root));
     }
 }
 exports.ImportResolver = ImportResolver;