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

package/dist/analyzer/program.js

@@ -41,12 +41,13 @@ const console_1 = require("../common/console");
 const debug = __importStar(require("../common/debug"));
 const debug_1 = require("../common/debug");
 const logTracker_1 = require("../common/logTracker");
-const pathUtils_1 = require("../common/pathUtils");
 const positionUtils_1 = require("../common/positionUtils");
 require("../common/serviceProviderExtensions");
 const serviceProviderExtensions_1 = require("../common/serviceProviderExtensions");
 const textRange_1 = require("../common/textRange");
 const timing_1 = require("../common/timing");
+const uri_1 = require("../common/uri/uri");
+const uriUtils_1 = require("../common/uri/uriUtils");
 const AnalyzerNodeInfo = __importStar(require("./analyzerNodeInfo"));
 const cacheManager_1 = require("./cacheManager");
 const circularDependency_1 = require("./circularDependency");
@@ -104,21 +105,21 @@ class Program {
         this._sourceFileMap = new Map();
         this._parsedFileCount = 0;
         this._editModeTracker = new EditModeTracker();
-        this._lookUpImport = (filePathOrModule, options) => {
+        this._lookUpImport = (fileUriOrModule, options) => {
             var _a;
             let sourceFileInfo;
-            if (typeof filePathOrModule === 'string') {
-                sourceFileInfo = this.getSourceFileInfo(filePathOrModule);
+            if (uri_1.Uri.isUri(fileUriOrModule)) {
+                sourceFileInfo = this.getSourceFileInfo(fileUriOrModule);
             }
             else {
                 // Resolve the import.
-                const importResult = this._importResolver.resolveImport(filePathOrModule.importingFilePath, this._configOptions.findExecEnvironment(filePathOrModule.importingFilePath), {
+                const importResult = this._importResolver.resolveImport(fileUriOrModule.importingFileUri, this._configOptions.findExecEnvironment(fileUriOrModule.importingFileUri), {
                     leadingDots: 0,
-                    nameParts: filePathOrModule.nameParts,
+                    nameParts: fileUriOrModule.nameParts,
                     importedSymbols: undefined,
                 });
-                if (importResult.isImportFound && !importResult.isNativeLib && importResult.resolvedPaths.length > 0) {
-                    const resolvedPath = importResult.resolvedPaths[importResult.resolvedPaths.length - 1];
+                if (importResult.isImportFound && !importResult.isNativeLib && importResult.resolvedUris.length > 0) {
+                    const resolvedPath = importResult.resolvedUris[importResult.resolvedUris.length - 1];
                     if (resolvedPath) {
                         // See if the source file already exists in the program.
                         sourceFileInfo = this.getSourceFileInfo(resolvedPath);
@@ -224,10 +225,10 @@ class Program {
             const newContents = fileInfo.restore();
             if (newContents) {
                 // Create a text document so we can compute the edits.
-                const textDocument = vscode_languageserver_textdocument_1.TextDocument.create(fileInfo.sourceFile.getFilePath(), 'python', 1, fileInfo.sourceFile.getFileContent() || '');
+                const textDocument = vscode_languageserver_textdocument_1.TextDocument.create(fileInfo.sourceFile.getUri().toString(), 'python', 1, fileInfo.sourceFile.getFileContent() || '');
                 // Add an edit action to the list.
                 edits.push({
-                    filePath: fileInfo.sourceFile.getFilePath(),
+                    fileUri: fileInfo.sourceFile.getUri(),
                     range: {
                         start: { line: 0, character: 0 },
                         end: { line: textDocument.lineCount, character: 0 },
@@ -245,7 +246,7 @@ class Program {
                     // We don't need to care about file diagnostics since in edit mode
                     // checker won't run.
                     v.sourceFile.prepareForClose();
-                    this._removeSourceFileFromListAndMap(v.sourceFile.getFilePath(), i);
+                    this._removeSourceFileFromListAndMap(v.sourceFile.getUri(), i);
                 }
             }
         }
@@ -269,24 +270,24 @@ class Program {
         this._createNewEvaluator();
     }
     // Sets the list of tracked files that make up the program.
-    setTrackedFiles(filePaths) {
+    setTrackedFiles(fileUris) {
         if (this._sourceFileList.length > 0) {
             // We need to determine which files to remove from the existing file list.
             const newFileMap = new Map();
-            filePaths.forEach((path) => {
-                newFileMap.set(path, path);
+            fileUris.forEach((path) => {
+                newFileMap.set(path.key, path);
             });
             // Files that are not in the tracked file list are
             // marked as no longer tracked.
             this._sourceFileList.forEach((oldFile) => {
-                const filePath = oldFile.sourceFile.getFilePath();
-                if (!newFileMap.has(filePath)) {
+                const fileUri = oldFile.sourceFile.getUri();
+                if (!newFileMap.has(fileUri.key)) {
                     oldFile.isTracked = false;
                 }
             });
         }
         // Add the new files. Only the new items will be added.
-        this.addTrackedFiles(filePaths);
+        this.addTrackedFiles(fileUris);
         return this._removeUnneededFiles();
     }
     // Allows a caller to set a callback that is called right before
@@ -302,23 +303,23 @@ class Program {
     setAllowedThirdPartyImports(importNames) {
         this._allowedThirdPartyImports = importNames;
     }
-    addTrackedFiles(filePaths, isThirdPartyImport = false, isInPyTypedPackage = false) {
-        filePaths.forEach((filePath) => {
-            this.addTrackedFile(filePath, isThirdPartyImport, isInPyTypedPackage);
+    addTrackedFiles(fileUris, isThirdPartyImport = false, isInPyTypedPackage = false) {
+        fileUris.forEach((fileUri) => {
+            this.addTrackedFile(fileUri, isThirdPartyImport, isInPyTypedPackage);
         });
     }
-    addInterimFile(filePath) {
+    addInterimFile(fileUri) {
         // Double check not already there.
-        let fileInfo = this.getSourceFileInfo(filePath);
+        let fileInfo = this.getSourceFileInfo(fileUri);
         if (!fileInfo) {
-            fileInfo = this._createInterimFileInfo(filePath);
+            fileInfo = this._createInterimFileInfo(fileUri);
             this._addToSourceFileListAndMap(fileInfo);
         }
         return fileInfo;
     }
-    addTrackedFile(filePath, isThirdPartyImport = false, isInPyTypedPackage = false) {
-        let sourceFileInfo = this.getSourceFileInfo(filePath);
-        const moduleImportInfo = this._getModuleImportInfoForFile(filePath);
+    addTrackedFile(fileUri, isThirdPartyImport = false, isInPyTypedPackage = false) {
+        let sourceFileInfo = this.getSourceFileInfo(fileUri);
+        const moduleImportInfo = this._getModuleImportInfoForFile(fileUri);
         const importName = moduleImportInfo.moduleName;
         if (sourceFileInfo) {
             // The module name may have changed based on updates to the
@@ -327,7 +328,7 @@ class Program {
             sourceFileInfo.isTracked = true;
             return sourceFileInfo.sourceFile;
         }
-        const sourceFile = this._sourceFileFactory.createSourceFile(this.serviceProvider, filePath, importName, isThirdPartyImport, isInPyTypedPackage, this._editModeTracker, this._console, this._logTracker);
+        const sourceFile = this._sourceFileFactory.createSourceFile(this.serviceProvider, fileUri, importName, isThirdPartyImport, isInPyTypedPackage, this._editModeTracker, this._console, this._logTracker);
         sourceFileInfo = new sourceFileInfo_1.SourceFileInfo(sourceFile, 
         /* isTypeshedFile */ false, isThirdPartyImport, isInPyTypedPackage, this._editModeTracker, {
             isTracked: true,
@@ -335,14 +336,14 @@ class Program {
         this._addToSourceFileListAndMap(sourceFileInfo);
         return sourceFile;
     }
-    setFileOpened(filePath, version, contents, options) {
+    setFileOpened(fileUri, version, contents, options) {
         var _a, _b;
-        let sourceFileInfo = this.getSourceFileInfo(filePath);
+        let sourceFileInfo = this.getSourceFileInfo(fileUri);
         if (!sourceFileInfo) {
-            const moduleImportInfo = this._getModuleImportInfoForFile(filePath);
-            const sourceFile = this._sourceFileFactory.createSourceFile(this.serviceProvider, filePath, moduleImportInfo.moduleName, 
-            /* isThirdPartyImport */ false, moduleImportInfo.isThirdPartyPyTypedPresent, this._editModeTracker, this._console, this._logTracker, options === null || options === void 0 ? void 0 : options.realFilePath, (_a = options === null || options === void 0 ? void 0 : options.ipythonMode) !== null && _a !== void 0 ? _a : sourceFile_1.IPythonMode.None);
-            const chainedFilePath = options === null || options === void 0 ? void 0 : options.chainedFilePath;
+            const moduleImportInfo = this._getModuleImportInfoForFile(fileUri);
+            const sourceFile = this._sourceFileFactory.createSourceFile(this.serviceProvider, fileUri, moduleImportInfo.moduleName, 
+            /* isThirdPartyImport */ false, moduleImportInfo.isThirdPartyPyTypedPresent, this._editModeTracker, this._console, this._logTracker, (_a = options === null || options === void 0 ? void 0 : options.ipythonMode) !== null && _a !== void 0 ? _a : sourceFile_1.IPythonMode.None);
+            const chainedFilePath = options === null || options === void 0 ? void 0 : options.chainedFileUri;
             sourceFileInfo = new sourceFileInfo_1.SourceFileInfo(sourceFile, 
             /* isTypeshedFile */ false, 
             /* isThirdPartyImport */ false, 
@@ -364,23 +365,23 @@ class Program {
         (0, sourceFileInfoUtils_1.verifyNoCyclesInChainedFiles)(this, sourceFileInfo);
         sourceFileInfo.sourceFile.setClientVersion(version, contents);
     }
-    getChainedFilePath(filePath) {
+    getChainedUri(fileUri) {
         var _a;
-        const sourceFileInfo = this.getSourceFileInfo(filePath);
-        return (_a = sourceFileInfo === null || sourceFileInfo === void 0 ? void 0 : sourceFileInfo.chainedSourceFile) === null || _a === void 0 ? void 0 : _a.sourceFile.getFilePath();
+        const sourceFileInfo = this.getSourceFileInfo(fileUri);
+        return (_a = sourceFileInfo === null || sourceFileInfo === void 0 ? void 0 : sourceFileInfo.chainedSourceFile) === null || _a === void 0 ? void 0 : _a.sourceFile.getUri();
     }
-    updateChainedFilePath(filePath, chainedFilePath) {
-        const sourceFileInfo = this.getSourceFileInfo(filePath);
+    updateChainedUri(fileUri, chainedFileUri) {
+        const sourceFileInfo = this.getSourceFileInfo(fileUri);
         if (!sourceFileInfo) {
             return;
         }
-        sourceFileInfo.chainedSourceFile = chainedFilePath ? this.getSourceFileInfo(chainedFilePath) : undefined;
+        sourceFileInfo.chainedSourceFile = chainedFileUri ? this.getSourceFileInfo(chainedFileUri) : undefined;
         sourceFileInfo.sourceFile.markDirty();
         this._markFileDirtyRecursive(sourceFileInfo, new Set());
         (0, sourceFileInfoUtils_1.verifyNoCyclesInChainedFiles)(this, sourceFileInfo);
     }
-    setFileClosed(filePath, isTracked) {
-        const sourceFileInfo = this.getSourceFileInfo(filePath);
+    setFileClosed(fileUri, isTracked) {
+        const sourceFileInfo = this.getSourceFileInfo(fileUri);
         if (sourceFileInfo) {
             sourceFileInfo.isOpenByClient = false;
             sourceFileInfo.isTracked = isTracked !== null && isTracked !== void 0 ? isTracked : sourceFileInfo.isTracked;
@@ -413,12 +414,12 @@ class Program {
             this._createNewEvaluator();
         }
     }
-    markFilesDirty(filePaths, evenIfContentsAreSame) {
+    markFilesDirty(fileUris, evenIfContentsAreSame) {
         const markDirtySet = new Set();
-        filePaths.forEach((filePath) => {
-            const sourceFileInfo = this.getSourceFileInfo(filePath);
+        fileUris.forEach((fileUri) => {
+            const sourceFileInfo = this.getSourceFileInfo(fileUri);
             if (sourceFileInfo) {
-                const fileName = (0, pathUtils_1.getFileName)(filePath);
+                const fileName = fileUri.fileName;
                 // Handle builtins and __builtins__ specially. They are implicitly
                 // included by all source files.
                 if (fileName === 'builtins.pyi' || fileName === '__builtins__.pyi') {
@@ -479,41 +480,44 @@ class Program {
         return this._configOptions.functionSignatureDisplay;
     }
     containsSourceFileIn(folder) {
-        for (const normalizedSourceFilePath of this._sourceFileMap.keys()) {
-            if (normalizedSourceFilePath.startsWith(folder)) {
+        for (const normalizedSourceFilePath of this._sourceFileMap.values()) {
+            if (normalizedSourceFilePath.sourceFile.getUri().startsWith(folder)) {
                 return true;
             }
         }
         return false;
     }
-    owns(filePath) {
-        const fileInfo = this.getSourceFileInfo(filePath);
+    owns(uri) {
+        const fileInfo = this.getSourceFileInfo(uri);
         if (fileInfo) {
             // If we already determined whether the file is tracked or not, don't do it again.
             // This will make sure we have consistent look at the state once it is loaded to the memory.
             return fileInfo.isTracked;
         }
-        return (0, configOptions_1.matchFileSpecs)(this._configOptions, filePath);
+        return (0, configOptions_1.matchFileSpecs)(this._configOptions, uri);
     }
-    getSourceFile(filePath) {
-        const sourceFileInfo = this.getSourceFileInfo(filePath);
+    getSourceFile(uri) {
+        const sourceFileInfo = this.getSourceFileInfo(uri);
         if (!sourceFileInfo) {
             return undefined;
         }
         return sourceFileInfo.sourceFile;
     }
-    getBoundSourceFile(filePath) {
+    getBoundSourceFile(uri) {
         var _a;
-        return (_a = this.getBoundSourceFileInfo(filePath)) === null || _a === void 0 ? void 0 : _a.sourceFile;
+        return (_a = this.getBoundSourceFileInfo(uri)) === null || _a === void 0 ? void 0 : _a.sourceFile;
     }
     getSourceFileInfoList() {
         return this._sourceFileList;
     }
-    getSourceFileInfo(filePath) {
-        return this._sourceFileMap.get(filePath);
+    getSourceFileInfo(uri) {
+        if (!uri.isEmpty()) {
+            return this._sourceFileMap.get(uri.key);
+        }
+        return undefined;
     }
-    getBoundSourceFileInfo(filePath, content, force) {
-        const sourceFileInfo = this.getSourceFileInfo(filePath);
+    getBoundSourceFileInfo(uri, content, force) {
+        const sourceFileInfo = this.getSourceFileInfo(uri);
         if (!sourceFileInfo) {
             return undefined;
         }
@@ -566,9 +570,9 @@ class Program {
     }
     // Performs parsing and analysis of a single file in the program. If the file is not part of
     // the program returns false to indicate analysis was not performed.
-    analyzeFile(filePath, token = vscode_languageserver_1.CancellationToken.None) {
+    analyzeFile(fileUri, token = vscode_languageserver_1.CancellationToken.None) {
         return this._runEvaluatorWithCancellationToken(token, () => {
-            const sourceFileInfo = this.getSourceFileInfo(filePath);
+            const sourceFileInfo = this.getSourceFileInfo(fileUri);
             if (sourceFileInfo && this._checkTypes(sourceFileInfo, token)) {
                 return true;
             }
@@ -587,14 +591,14 @@ class Program {
             return this._runEvaluatorWithCancellationToken(token, () => callback(this));
         }
     }
-    getSourceMapper(filePath, token, mapCompiled, preferStubs) {
-        const sourceFileInfo = this.getSourceFileInfo(filePath);
-        const execEnv = this._configOptions.findExecEnvironment(filePath);
+    getSourceMapper(fileUri, token, mapCompiled, preferStubs) {
+        const sourceFileInfo = this.getSourceFileInfo(fileUri);
+        const execEnv = this._configOptions.findExecEnvironment(fileUri);
         return this._createSourceMapper(execEnv, token, sourceFileInfo, mapCompiled, preferStubs);
     }
-    getParseResults(filePath) {
+    getParseResults(fileUri) {
         var _a;
-        return (_a = this.getBoundSourceFileInfo(filePath, 
+        return (_a = this.getBoundSourceFileInfo(fileUri, 
         /* content */ undefined, 
         /* force */ true)) === null || _a === void 0 ? void 0 : _a.sourceFile.getParseResults();
     }
@@ -613,7 +617,7 @@ class Program {
         this._console.info('Analysis time by file');
         sortedFiles.forEach((sfInfo) => {
             const checkTimeInMs = sfInfo.sourceFile.getCheckTime();
-            this._console.info(`${checkTimeInMs}ms: ${sfInfo.sourceFile.getFilePath()}`);
+            this._console.info(`${checkTimeInMs}ms: ${sfInfo.sourceFile.getUri()}`);
         });
     }
     // Prints import dependency information for each of the files in
@@ -623,30 +627,28 @@ class Program {
         const sortedFiles = this._sourceFileList
             .filter((s) => !s.isTypeshedFile)
             .sort((a, b) => {
-            return fs.getOriginalFilePath(a.sourceFile.getFilePath()) <
-                fs.getOriginalFilePath(b.sourceFile.getFilePath())
-                ? 1
-                : -1;
+            return fs.getOriginalUri(a.sourceFile.getUri()) < fs.getOriginalUri(b.sourceFile.getUri()) ? 1 : -1;
         });
         const zeroImportFiles = [];
         sortedFiles.forEach((sfInfo) => {
             this._console.info('');
-            let filePath = fs.getOriginalFilePath(sfInfo.sourceFile.getFilePath());
-            const relPath = (0, pathUtils_1.getRelativePath)(filePath, projectRootDir);
+            const fileUri = fs.getOriginalUri(sfInfo.sourceFile.getUri());
+            let fileString = fileUri.toString();
+            const relPath = projectRootDir.getRelativePathComponents(fileUri);
             if (relPath) {
-                filePath = relPath;
+                fileString = relPath.join('/');
             }
-            this._console.info(`${filePath}`);
+            this._console.info(`${fileString}`);
             this._console.info(` Imports     ${sfInfo.imports.length} ` + `file${sfInfo.imports.length === 1 ? '' : 's'}`);
             if (verbose) {
                 sfInfo.imports.forEach((importInfo) => {
-                    this._console.info(`    ${fs.getOriginalFilePath(importInfo.sourceFile.getFilePath())}`);
+                    this._console.info(`    ${fs.getOriginalUri(importInfo.sourceFile.getUri())}`);
                 });
             }
             this._console.info(` Imported by ${sfInfo.importedBy.length} ` + `file${sfInfo.importedBy.length === 1 ? '' : 's'}`);
             if (verbose) {
                 sfInfo.importedBy.forEach((importInfo) => {
-                    this._console.info(`    ${fs.getOriginalFilePath(importInfo.sourceFile.getFilePath())}`);
+                    this._console.info(`    ${fs.getOriginalUri(importInfo.sourceFile.getUri())}`);
                 });
             }
             if (sfInfo.importedBy.length === 0) {
@@ -657,31 +659,31 @@ class Program {
             this._console.info('');
             this._console.info(`${zeroImportFiles.length} file${zeroImportFiles.length === 1 ? '' : 's'}` + ` not explicitly imported`);
             zeroImportFiles.forEach((importFile) => {
-                this._console.info(`    ${fs.getOriginalFilePath(importFile.getFilePath())}`);
+                this._console.info(`    ${fs.getOriginalUri(importFile.getUri())}`);
             });
         }
     }
     writeTypeStub(targetImportPath, targetIsSingleFile, stubPath, token) {
         for (const sourceFileInfo of this._sourceFileList) {
             (0, cancellationUtils_1.throwIfCancellationRequested)(token);
-            const filePath = sourceFileInfo.sourceFile.getFilePath();
+            const fileUri = sourceFileInfo.sourceFile.getUri();
             // Generate type stubs only for the files within the target path,
             // not any files that the target module happened to import.
-            const relativePath = (0, pathUtils_1.getRelativePath)(filePath, targetImportPath);
+            const relativePath = targetImportPath.getRelativePath(fileUri);
             if (relativePath !== undefined) {
-                let typeStubPath = (0, pathUtils_1.normalizePath)((0, pathUtils_1.combinePaths)(stubPath, relativePath));
+                let typeStubPath = stubPath.combinePaths(relativePath);
                 // If the target is a single file implementation, as opposed to
                 // a package in a directory, transform the name of the type stub
                 // to __init__.pyi because we're placing it in a directory.
                 if (targetIsSingleFile) {
-                    typeStubPath = (0, pathUtils_1.combinePaths)((0, pathUtils_1.getDirectoryPath)(typeStubPath), '__init__.pyi');
+                    typeStubPath = typeStubPath.getDirectory().combinePaths('__init__.pyi');
                 }
                 else {
-                    typeStubPath = (0, pathUtils_1.stripFileExtension)(typeStubPath) + '.pyi';
+                    typeStubPath = typeStubPath.replaceExtension('.pyi');
                 }
-                const typeStubDir = (0, pathUtils_1.getDirectoryPath)(typeStubPath);
+                const typeStubDir = typeStubPath.getDirectory();
                 try {
-                    (0, pathUtils_1.makeDirectories)(this.fileSystem, typeStubDir, stubPath);
+                    (0, uriUtils_1.makeDirectories)(this.fileSystem, typeStubDir, stubPath);
                 }
                 catch (e) {
                     const errMsg = `Could not create directory for '${typeStubDir}'`;
@@ -708,8 +710,8 @@ class Program {
         const evaluator = this._evaluator || this._createNewEvaluator();
         return evaluator.printType(type, options);
     }
-    getTextOnRange(filePath, range, token) {
-        const sourceFileInfo = this.getSourceFileInfo(filePath);
+    getTextOnRange(fileUri, range, token) {
+        const sourceFileInfo = this.getSourceFileInfo(fileUri);
         if (!sourceFileInfo) {
             return undefined;
         }
@@ -736,7 +738,7 @@ class Program {
                 const diagnostics = sourceFileInfo.sourceFile.getDiagnostics(options, sourceFileInfo.diagnosticsVersion);
                 if (diagnostics !== undefined) {
                     fileDiagnostics.push({
-                        filePath: sourceFileInfo.sourceFile.getFilePath(),
+                        fileUri: sourceFileInfo.sourceFile.getUri(),
                         version: sourceFileInfo.sourceFile.getClientVersion(),
                         diagnostics,
                     });
@@ -751,7 +753,7 @@ class Program {
                 // This condition occurs when the user switches from workspace to
                 // "open files only" mode. Clear all diagnostics for this file.
                 fileDiagnostics.push({
-                    filePath: sourceFileInfo.sourceFile.getFilePath(),
+                    fileUri: sourceFileInfo.sourceFile.getUri(),
                     version: sourceFileInfo.sourceFile.getClientVersion(),
                     diagnostics: [],
                 });
@@ -760,8 +762,8 @@ class Program {
         });
         return fileDiagnostics;
     }
-    getDiagnosticsForRange(filePath, range) {
-        const sourceFile = this.getSourceFile(filePath);
+    getDiagnosticsForRange(fileUri, range) {
+        const sourceFile = this.getSourceFile(fileUri);
         if (!sourceFile) {
             return [];
         }
@@ -778,7 +780,7 @@ class Program {
         const program = new Program(this._importResolver, this._configOptions, this.serviceProvider, new logTracker_1.LogTracker(this._console, 'Cloned'));
         // Cloned program will use whatever user files the program currently has.
         const userFiles = this.getUserFiles();
-        program.setTrackedFiles(userFiles.map((i) => i.sourceFile.getFilePath()));
+        program.setTrackedFiles(userFiles.map((i) => i.sourceFile.getUri()));
         program.markAllFilesDirty(/* evenIfContentsAreSame */ true);
         // Make sure we keep editor content (open file) which could be different than one in the file system.
         for (const fileInfo of this.getOpened()) {
@@ -786,11 +788,10 @@ class Program {
             if (version === undefined) {
                 continue;
             }
-            program.setFileOpened(fileInfo.sourceFile.getFilePath(), version, (_a = fileInfo.sourceFile.getOpenFileContents()) !== null && _a !== void 0 ? _a : '', {
-                chainedFilePath: (_b = fileInfo.chainedSourceFile) === null || _b === void 0 ? void 0 : _b.sourceFile.getFilePath(),
+            program.setFileOpened(fileInfo.sourceFile.getUri(), version, (_a = fileInfo.sourceFile.getOpenFileContents()) !== null && _a !== void 0 ? _a : '', {
+                chainedFileUri: (_b = fileInfo.chainedSourceFile) === null || _b === void 0 ? void 0 : _b.sourceFile.getUri(),
                 ipythonMode: fileInfo.sourceFile.getIPythonMode(),
                 isTracked: fileInfo.isTracked,
-                realFilePath: fileInfo.sourceFile.getRealFilePath(),
             });
         }
         return program;
@@ -872,13 +873,13 @@ class Program {
                 // Clear only if there are any errors for this file.
                 if (fileInfo.diagnosticsVersion !== undefined) {
                     fileDiagnostics.push({
-                        filePath: fileInfo.sourceFile.getFilePath(),
+                        fileUri: fileInfo.sourceFile.getUri(),
                         version: fileInfo.sourceFile.getClientVersion(),
                         diagnostics: [],
                     });
                 }
                 fileInfo.sourceFile.prepareForClose();
-                this._removeSourceFileFromListAndMap(fileInfo.sourceFile.getFilePath(), i);
+                this._removeSourceFileFromListAndMap(fileInfo.sourceFile.getUri(), i);
                 // Unlink any imports and remove them from the list if
                 // they are no longer referenced.
                 fileInfo.imports.forEach((importedFile) => {
@@ -896,13 +897,13 @@ class Program {
                             // Clear if there are any errors for this import.
                             if (importedFile.diagnosticsVersion !== undefined) {
                                 fileDiagnostics.push({
-                                    filePath: importedFile.sourceFile.getFilePath(),
+                                    fileUri: importedFile.sourceFile.getUri(),
                                     version: importedFile.sourceFile.getClientVersion(),
                                     diagnostics: [],
                                 });
                             }
                             importedFile.sourceFile.prepareForClose();
-                            this._removeSourceFileFromListAndMap(importedFile.sourceFile.getFilePath(), indexToRemove);
+                            this._removeSourceFileFromListAndMap(importedFile.sourceFile.getUri(), indexToRemove);
                             i--;
                         }
                     }
@@ -918,7 +919,7 @@ class Program {
                 // out the errors for the now-closed file.
                 if (!this._shouldCheckFile(fileInfo) && fileInfo.diagnosticsVersion !== undefined) {
                     fileDiagnostics.push({
-                        filePath: fileInfo.sourceFile.getFilePath(),
+                        fileUri: fileInfo.sourceFile.getUri(),
                         version: fileInfo.sourceFile.getClientVersion(),
                         diagnostics: [],
                     });
@@ -952,12 +953,12 @@ class Program {
         if (fileInfo.isTracked || fileInfo.isOpenByClient || fileInfo.shadows.length > 0) {
             return true;
         }
-        const filePath = fileInfo.sourceFile.getFilePath();
+        const fileUri = fileInfo.sourceFile.getUri();
         // Avoid infinite recursion.
-        if (recursionSet.has(filePath)) {
+        if (recursionSet.has(fileUri.key)) {
             return false;
         }
-        recursionSet.add(filePath);
+        recursionSet.add(fileUri.key);
         for (const importerInfo of fileInfo.importedBy) {
             if (this._isImportNeededRecursive(importerInfo, recursionSet)) {
                 return true;
@@ -966,15 +967,15 @@ class Program {
         return false;
     }
     _createSourceMapper(execEnv, token, from, mapCompiled, preferStubs) {
-        const sourceMapper = new sourceMapper_1.SourceMapper(this._importResolver, execEnv, this._evaluator, (stubFilePath, implFilePath) => {
-            let stubFileInfo = this.getSourceFileInfo(stubFilePath);
+        const sourceMapper = new sourceMapper_1.SourceMapper(this._importResolver, execEnv, this._evaluator, (stubFileUri, implFileUri) => {
+            let stubFileInfo = this.getSourceFileInfo(stubFileUri);
             if (!stubFileInfo) {
                 // Special case for import statement like "import X.Y". The SourceFile
                 // for X might not be in memory since import `X.Y` only brings in Y.
-                stubFileInfo = this.addInterimFile(stubFilePath);
+                stubFileInfo = this.addInterimFile(stubFileUri);
             }
-            this._addShadowedFile(stubFileInfo, implFilePath);
-            return this.getBoundSourceFile(implFilePath);
+            this._addShadowedFile(stubFileInfo, implFileUri);
+            return this.getBoundSourceFile(implFileUri);
         }, (f) => {
             let fileInfo = this.getBoundSourceFileInfo(f);
             if (!fileInfo) {
@@ -1045,6 +1046,9 @@ class Program {
         }
         return true;
     }
+    _getSourceFileInfoFromKey(key) {
+        return this._sourceFileMap.get(key);
+    }
     _updateSourceFileImports(sourceFileInfo, options) {
         const filesAdded = [];
         // Get the new list of imports and see if it changed from the last
@@ -1083,9 +1087,9 @@ class Program {
                 sourceFileInfo.chainedSourceFile = undefined;
             }
             else {
-                const filePath = sourceFileInfo.chainedSourceFile.sourceFile.getFilePath();
-                newImportPathMap.set(filePath, {
-                    path: filePath,
+                const fileUri = sourceFileInfo.chainedSourceFile.sourceFile.getUri();
+                newImportPathMap.set(fileUri.key, {
+                    path: fileUri,
                     isTypeshedFile: false,
                     isThirdPartyImport: false,
                     isPyTypedPresent: false,
@@ -1095,12 +1099,12 @@ class Program {
         imports.forEach((importResult) => {
             if (importResult.isImportFound) {
                 if (this._isImportAllowed(sourceFileInfo, importResult, importResult.isStubFile)) {
-                    if (importResult.resolvedPaths.length > 0) {
-                        const filePath = importResult.resolvedPaths[importResult.resolvedPaths.length - 1];
-                        if (filePath) {
+                    if (importResult.resolvedUris.length > 0) {
+                        const fileUri = importResult.resolvedUris[importResult.resolvedUris.length - 1];
+                        if (!fileUri.isEmpty()) {
                             const thirdPartyTypeInfo = getThirdPartyImportInfo(importResult);
-                            newImportPathMap.set(filePath, {
-                                path: filePath,
+                            newImportPathMap.set(fileUri.key, {
+                                path: fileUri,
                                 isTypeshedFile: !!importResult.isStdlibTypeshedFile || !!importResult.isThirdPartyTypeshedFile,
                                 isThirdPartyImport: thirdPartyTypeInfo.isThirdPartyImport,
                                 isPyTypedPresent: thirdPartyTypeInfo.isPyTypedPresent,
@@ -1112,8 +1116,8 @@ class Program {
                     if (this._isImportAllowed(sourceFileInfo, importResult, implicitImport.isStubFile)) {
                         if (!implicitImport.isNativeLib) {
                             const thirdPartyTypeInfo = getThirdPartyImportInfo(importResult);
-                            newImportPathMap.set(implicitImport.path, {
-                                path: implicitImport.path,
+                            newImportPathMap.set(implicitImport.uri.key, {
+                                path: implicitImport.uri,
                                 isTypeshedFile: !!importResult.isStdlibTypeshedFile || !!importResult.isThirdPartyTypeshedFile,
                                 isThirdPartyImport: thirdPartyTypeInfo.isThirdPartyImport,
                                 isPyTypedPresent: thirdPartyTypeInfo.isPyTypedPresent,
@@ -1130,7 +1134,7 @@ class Program {
                     if (!sourceFileInfo.sourceFile.isStubFile() && !importResult.isStdlibTypeshedFile) {
                         if (options.verboseOutput) {
                             this._console.info(`Could not resolve source for '${importResult.importName}' ` +
-                                `in file '${sourceFileInfo.sourceFile.getFilePath()}'`);
+                                `in file '${sourceFileInfo.sourceFile.getUri().toUserVisibleString()}'`);
                             if (importResult.nonStubImportResult.importFailureInfo) {
                                 importResult.nonStubImportResult.importFailureInfo.forEach((diag) => {
                                     this._console.info(`  ${diag}`);
@@ -1142,7 +1146,7 @@ class Program {
             }
             else if (options.verboseOutput) {
                 this._console.info(`Could not import '${importResult.importName}' ` +
-                    `in file '${sourceFileInfo.sourceFile.getFilePath()}'`);
+                    `in file '${sourceFileInfo.sourceFile.getUri().toUserVisibleString()}'`);
                 if (importResult.importFailureInfo) {
                     importResult.importFailureInfo.forEach((diag) => {
                         this._console.info(`  ${diag}`);
@@ -1152,15 +1156,15 @@ class Program {
         });
         const updatedImportMap = new Map();
         sourceFileInfo.imports.forEach((importInfo) => {
-            const oldFilePath = importInfo.sourceFile.getFilePath();
+            const oldFilePath = importInfo.sourceFile.getUri();
             // A previous import was removed.
-            if (!newImportPathMap.has(oldFilePath)) {
+            if (!newImportPathMap.has(oldFilePath.key)) {
                 importInfo.mutate((s) => {
-                    s.importedBy = s.importedBy.filter((fi) => fi.sourceFile.getFilePath() !== sourceFileInfo.sourceFile.getFilePath());
+                    s.importedBy = s.importedBy.filter((fi) => !fi.sourceFile.getUri().equals(sourceFileInfo.sourceFile.getUri()));
                 });
             }
             else {
-                updatedImportMap.set(oldFilePath, importInfo);
+                updatedImportMap.set(oldFilePath.key, importInfo);
             }
         });
         // See if there are any new imports to be added.
@@ -1183,9 +1187,9 @@ class Program {
         // Update the imports list. It should now map the set of imports
         // specified by the source file.
         sourceFileInfo.mutate((s) => (s.imports = []));
-        newImportPathMap.forEach((_, path) => {
-            if (this.getSourceFileInfo(path)) {
-                sourceFileInfo.mutate((s) => s.imports.push(this.getSourceFileInfo(path)));
+        newImportPathMap.forEach((_, key) => {
+            if (this._getSourceFileInfoFromKey(key)) {
+                sourceFileInfo.mutate((s) => s.imports.push(this._getSourceFileInfoFromKey(key)));
             }
         });
         // Resolve the builtins import for the file. This needs to be
@@ -1193,21 +1197,23 @@ class Program {
         sourceFileInfo.builtinsImport = undefined;
         const builtinsImport = sourceFileInfo.sourceFile.getBuiltinsImport();
         if (builtinsImport && builtinsImport.isImportFound) {
-            const resolvedBuiltinsPath = builtinsImport.resolvedPaths[builtinsImport.resolvedPaths.length - 1];
+            const resolvedBuiltinsPath = builtinsImport.resolvedUris[builtinsImport.resolvedUris.length - 1];
             sourceFileInfo.builtinsImport = this.getSourceFileInfo(resolvedBuiltinsPath);
         }
         return filesAdded;
     }
-    _removeSourceFileFromListAndMap(filePath, indexToRemove) {
-        this._sourceFileMap.delete(filePath);
+    _removeSourceFileFromListAndMap(fileUri, indexToRemove) {
+        this._sourceFileMap.delete(fileUri.key);
         this._sourceFileList.splice(indexToRemove, 1);
     }
     _addToSourceFileListAndMap(fileInfo) {
-        const filePath = fileInfo.sourceFile.getFilePath();
+        const fileUri = fileInfo.sourceFile.getUri();
         // We should never add a file with the same path twice.
-        (0, debug_1.assert)(!this._sourceFileMap.has(filePath));
+        (0, debug_1.assert)(!this._sourceFileMap.has(fileUri.key));
+        // We should never have an empty URI for a source file.
+        (0, debug_1.assert)(!fileInfo.sourceFile.getUri().isEmpty());
         this._sourceFileList.push(fileInfo);
-        this._sourceFileMap.set(filePath, fileInfo);
+        this._sourceFileMap.set(fileUri.key, fileInfo);
     }
     static _getPrintTypeFlags(configOptions) {
         let flags = 0 /* PrintTypeFlags.None */;
@@ -1228,14 +1234,14 @@ class Program {
         }
         return flags;
     }
-    _getModuleImportInfoForFile(filePath) {
+    _getModuleImportInfoForFile(fileUri) {
         // We allow illegal module names (e.g. names that include "-" in them)
         // because we want a unique name for each module even if it cannot be
         // imported through an "import" statement. It's important to have a
         // unique name in case two modules declare types with the same local
         // name. The type checker uses the fully-qualified (unique) module name
         // to differentiate between such types.
-        const moduleNameAndType = this._importResolver.getModuleNameForImport(filePath, this._configOptions.getDefaultExecEnvironment(), 
+        const moduleNameAndType = this._importResolver.getModuleNameForImport(fileUri, this._configOptions.getDefaultExecEnvironment(), 
         /* allowIllegalModuleName */ true, 
         /* detectPyTyped */ true);
         return moduleNameAndType;
@@ -1257,9 +1263,9 @@ class Program {
         }
         return shadowFileInfo.sourceFile;
     }
-    _createInterimFileInfo(filePath) {
-        const moduleImportInfo = this._getModuleImportInfoForFile(filePath);
-        const sourceFile = this._sourceFileFactory.createSourceFile(this.serviceProvider, filePath, moduleImportInfo.moduleName, 
+    _createInterimFileInfo(fileUri) {
+        const moduleImportInfo = this._getModuleImportInfoForFile(fileUri);
+        const sourceFile = this._sourceFileFactory.createSourceFile(this.serviceProvider, fileUri, moduleImportInfo.moduleName, 
         /* isThirdPartyImport */ false, 
         /* isInPyTypedPackage */ false, this._editModeTracker, this._console, this._logTracker);
         const sourceFileInfo = new sourceFileInfo_1.SourceFileInfo(sourceFile, 
@@ -1331,13 +1337,13 @@ class Program {
         const implicitSet = new Set();
         let nextImplicitImport = this._getImplicitImports(fileToAnalyze);
         while (nextImplicitImport) {
-            const implicitPath = nextImplicitImport.sourceFile.getFilePath();
-            if (implicitSet.has(implicitPath)) {
+            const implicitPath = nextImplicitImport.sourceFile.getUri();
+            if (implicitSet.has(implicitPath.key)) {
                 // We've found a cycle. Break out of the loop.
                 debug.fail((_b = (_a = this.serviceProvider
                     .tryGet(serviceProviderExtensions_1.ServiceKeys.debugInfoInspector)) === null || _a === void 0 ? void 0 : _a.getCycleDetail(this, nextImplicitImport)) !== null && _b !== void 0 ? _b : `Found a cycle in implicit imports files`);
             }
-            implicitSet.add(implicitPath);
+            implicitSet.add(implicitPath.key);
             implicitImports.push(nextImplicitImport);
             this._parseFile(nextImplicitImport, /* content */ undefined, skipFileNeededCheck);
             nextImplicitImport = this._getImplicitImports(nextImplicitImport);
@@ -1418,7 +1424,7 @@ class Program {
         return false;
     }
     _checkTypes(fileToCheck, token, chainedByList) {
-        return this._logTracker.log(`analyzing: ${fileToCheck.sourceFile.getFilePath()}`, (logState) => {
+        return this._logTracker.log(`analyzing: ${fileToCheck.sourceFile.getUri()}`, (logState) => {
             // If the file isn't needed because it was eliminated from the
             // transitive closure or deleted, skip the file rather than wasting
             // time on it.
@@ -1449,7 +1455,7 @@ class Program {
                     }
                 }
                 if (boundFile) {
-                    const execEnv = this._configOptions.findExecEnvironment(fileToCheck.sourceFile.getFilePath());
+                    const execEnv = this._configOptions.findExecEnvironment(fileToCheck.sourceFile.getUri());
                     fileToCheck.sourceFile.check(this.configOptions, this._importResolver, this._evaluator, this._createSourceMapper(execEnv, token, fileToCheck), dependentFiles);
                 }
             }
@@ -1537,8 +1543,8 @@ class Program {
     _getImportsRecursive(file, closureMap, recursionCount) {
         // If the file is already in the closure map, we found a cyclical
         // dependency. Don't recur further.
-        const filePath = file.sourceFile.getFilePath();
-        if (closureMap.has(filePath)) {
+        const fileUri = file.sourceFile.getUri();
+        if (closureMap.has(fileUri.key)) {
             return;
         }
         // If the import chain is too long, emit an error. Otherwise we
@@ -1548,7 +1554,7 @@ class Program {
             return;
         }
         // Add the file to the closure map.
-        closureMap.set(filePath, file);
+        closureMap.set(fileUri.key, file);
         // If this file hasn't already been parsed, parse it now. This will
         // discover any files it imports. Skip this if the file is part
         // of a library. We'll assume that no cycles will be generated from
@@ -1571,10 +1577,10 @@ class Program {
         if (sourceFileInfo.sourceFile.isNoCircularDependencyConfirmed()) {
             return false;
         }
-        const filePath = sourceFileInfo.sourceFile.getFilePath();
-        filesVisited.set(filePath, sourceFileInfo);
+        const fileUri = sourceFileInfo.sourceFile.getUri();
+        filesVisited.set(fileUri.key, sourceFileInfo);
         let detectedCycle = false;
-        if (dependencyMap.has(filePath)) {
+        if (dependencyMap.has(fileUri.key)) {
             // We detect a cycle (partial or full). A full cycle is one that is
             // rooted in the file at the start of our dependency chain. A partial
             // cycle loops back on some other file in the dependency chain. We
@@ -1591,14 +1597,14 @@ class Program {
         else {
             // If we've already checked this dependency along
             // some other path, we can skip it.
-            if (dependencyMap.has(filePath)) {
+            if (dependencyMap.has(fileUri.key)) {
                 return false;
             }
             // We use both a map (for fast lookups) and a list
             // (for ordering information). Set the dependency map
             // entry to true to indicate that we're actively exploring
             // that dependency.
-            dependencyMap.set(filePath, true);
+            dependencyMap.set(fileUri.key, true);
             dependencyChain.push(sourceFileInfo);
             for (const imp of sourceFileInfo.imports) {
                 if (this._detectAndReportImportCycles(imp, filesVisited, dependencyChain, dependencyMap)) {
@@ -1607,7 +1613,7 @@ class Program {
             }
             // Set the dependencyMap entry to false to indicate that we have
             // already explored this file and don't need to explore it again.
-            dependencyMap.set(filePath, false);
+            dependencyMap.set(fileUri.key, false);
             dependencyChain.pop();
         }
         return detectedCycle;
@@ -1615,7 +1621,7 @@ class Program {
     _logImportCycle(dependencyChain) {
         const circDep = new circularDependency_1.CircularDependency();
         dependencyChain.forEach((sourceFileInfo) => {
-            circDep.appendPath(sourceFileInfo.sourceFile.getFilePath());
+            circDep.appendPath(sourceFileInfo.sourceFile.getUri());
         });
         circDep.normalizeOrder();
         const firstFilePath = circDep.getPaths()[0];
@@ -1624,13 +1630,13 @@ class Program {
         firstSourceFile.sourceFile.addCircularDependency(this.configOptions, circDep);
     }
     _markFileDirtyRecursive(sourceFileInfo, markSet, forceRebinding = false) {
-        const filePath = sourceFileInfo.sourceFile.getFilePath();
+        const fileUri = sourceFileInfo.sourceFile.getUri();
         // Don't mark it again if it's already been visited.
-        if (markSet.has(filePath)) {
+        if (markSet.has(fileUri.key)) {
             return;
         }
         sourceFileInfo.sourceFile.markReanalysisRequired(forceRebinding);
-        markSet.add(filePath);
+        markSet.add(fileUri.key);
         sourceFileInfo.importedBy.forEach((dep) => {
             // Changes on chained source file can change symbols in the symbol table and
             // dependencies on the dependent file. Force rebinding.
@@ -1650,7 +1656,7 @@ class Program {
             chainedSourceFile.sourceFile.markReanalysisRequired(/* forceRebinding */ false);
             chainedSourceFile = chainedSourceFile.chainedSourceFile;
         }
-        // If the checker is going to run again, we have to recreate the type evaulator so
+        // If the checker is going to run again, we have to recreate the type evaluator so
         // that it actually reevaluates all the nodes (instead of using the cache).
         // This is necessary because the original file change may not recreate the TypeEvaluator.
         // For example, it might be a file delete.