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

package/dist/analyzer/service.js

@@ -44,6 +44,8 @@ const pathConsts_1 = require("../common/pathConsts");
 const pathUtils_1 = require("../common/pathUtils");
 const serviceProviderExtensions_1 = require("../common/serviceProviderExtensions");
 const timing_1 = require("../common/timing");
+const uri_1 = require("../common/uri/uri");
+const uriUtils_1 = require("../common/uri/uriUtils");
 const backgroundAnalysisProgram_1 = require("./backgroundAnalysisProgram");
 const importResolver_1 = require("./importResolver");
 const pythonPathUtils_1 = require("./pythonPathUtils");
@@ -53,7 +55,7 @@ exports.pyprojectTomlName = 'pyproject.toml';
 // How long since the last user activity should we wait until running
 // the analyzer on any files that have not yet been analyzed?
 const _userActivityBackoffTimeInMs = 250;
-const _gitDirectory = (0, pathUtils_1.normalizeSlashes)('/.git/');
+const _gitDirectory = '/.git/';
 // Hold uniqueId for this service. It can be used to distinguish each service later.
 let _nextServiceId = 1;
 function getNextServiceId(name) {
@@ -69,7 +71,7 @@ class AnalyzerService {
         this._disposed = false;
         this._pendingLibraryChanges = { changesOnly: true };
         this._instanceName = instanceName;
-        this._executionRootPath = '';
+        this._executionRootUri = uri_1.Uri.empty();
         this._options = options;
         this._options.serviceId = (_a = this._options.serviceId) !== null && _a !== void 0 ? _a : getNextServiceId(instanceName);
         this._options.console = options.console || new console_1.StandardConsole();
@@ -85,7 +87,8 @@ class AnalyzerService {
         this._options.importResolverFactory = (_b = options.importResolverFactory) !== null && _b !== void 0 ? _b : AnalyzerService.createImportResolver;
         this._options.cancellationProvider = (_c = options.cancellationProvider) !== null && _c !== void 0 ? _c : new cancellationUtils_1.DefaultCancellationProvider();
         this._options.hostFactory = (_d = options.hostFactory) !== null && _d !== void 0 ? _d : (() => new host_1.NoAccessHost());
-        this._options.configOptions = (_e = options.configOptions) !== null && _e !== void 0 ? _e : new configOptions_1.ConfigOptions(process.cwd());
+        this._options.configOptions =
+            (_e = options.configOptions) !== null && _e !== void 0 ? _e : new configOptions_1.ConfigOptions(uri_1.Uri.file(process.cwd(), this._serviceProvider.fs().isCaseSensitive));
         const importResolver = this._options.importResolverFactory(this._serviceProvider, this._options.configOptions, this._options.hostFactory());
         this._backgroundAnalysisProgram =
             this._options.backgroundAnalysisProgramFactory !== undefined
@@ -102,8 +105,8 @@ class AnalyzerService {
     get cancellationProvider() {
         return this._options.cancellationProvider;
     }
-    get librarySearchPathsToWatch() {
-        return this._librarySearchPathsToWatch;
+    get librarySearchUrisToWatch() {
+        return this._librarySearchUrisToWatch;
     }
     get backgroundAnalysisProgram() {
         return this._backgroundAnalysisProgram;
@@ -131,7 +134,7 @@ class AnalyzerService {
         for (const fileInfo of this.backgroundAnalysisProgram.program.getOpened()) {
             const version = fileInfo.sourceFile.getClientVersion();
             if (version !== undefined) {
-                service.setFileOpened(fileInfo.sourceFile.getFilePath(), version, fileInfo.sourceFile.getOpenFileContents(), fileInfo.sourceFile.getIPythonMode(), (_a = fileInfo.chainedSourceFile) === null || _a === void 0 ? void 0 : _a.sourceFile.getFilePath(), fileInfo.sourceFile.getRealFilePath());
+                service.setFileOpened(fileInfo.sourceFile.getUri(), version, fileInfo.sourceFile.getOpenFileContents(), fileInfo.sourceFile.getIPythonMode(), (_a = fileInfo.chainedSourceFile) === null || _a === void 0 ? void 0 : _a.sourceFile.getUri());
             }
         }
         return service;
@@ -178,64 +181,62 @@ class AnalyzerService {
         }
         configOptions.ensureDefaultPythonPlatform(host, this._console);
         this._backgroundAnalysisProgram.setConfigOptions(configOptions);
-        this._executionRootPath = (0, pathUtils_1.realCasePath)((0, pathUtils_1.combinePaths)(commandLineOptions.executionRoot, configOptions.projectRoot), this.fs);
+        this._executionRootUri = configOptions.projectRoot;
         this._applyConfigOptions(host);
     }
-    hasSourceFile(filePath) {
-        return this.backgroundAnalysisProgram.hasSourceFile(filePath);
+    hasSourceFile(uri) {
+        return this.backgroundAnalysisProgram.hasSourceFile(uri);
     }
-    isTracked(filePath) {
-        return this._program.owns(filePath);
+    isTracked(uri) {
+        return this._program.owns(uri);
     }
     getUserFiles() {
-        return this._program.getUserFiles().map((i) => i.sourceFile.getFilePath());
+        return this._program.getUserFiles().map((i) => i.sourceFile.getUri());
     }
     getOpenFiles() {
-        return this._program.getOpened().map((i) => i.sourceFile.getFilePath());
+        return this._program.getOpened().map((i) => i.sourceFile.getUri());
     }
-    setFileOpened(path, version, contents, ipythonMode = sourceFile_1.IPythonMode.None, chainedFilePath, realFilePath) {
+    setFileOpened(uri, version, contents, ipythonMode = sourceFile_1.IPythonMode.None, chainedFileUri) {
         // Open the file. Notebook cells are always tracked as they aren't 3rd party library files.
         // This is how it's worked in the past since each notebook used to have its own
         // workspace and the workspace include setting marked all cells as tracked.
-        this._backgroundAnalysisProgram.setFileOpened(path, version, contents, {
-            isTracked: this.isTracked(path) || ipythonMode !== sourceFile_1.IPythonMode.None,
+        this._backgroundAnalysisProgram.setFileOpened(uri, version, contents, {
+            isTracked: this.isTracked(uri) || ipythonMode !== sourceFile_1.IPythonMode.None,
             ipythonMode,
-            chainedFilePath,
-            realFilePath,
+            chainedFileUri: chainedFileUri,
         });
         this._scheduleReanalysis(/* requireTrackedFileUpdate */ false);
     }
-    getChainedFilePath(path) {
-        return this._backgroundAnalysisProgram.getChainedFilePath(path);
+    getChainedUri(uri) {
+        return this._backgroundAnalysisProgram.getChainedUri(uri);
     }
-    updateChainedFilePath(path, chainedFilePath) {
-        this._backgroundAnalysisProgram.updateChainedFilePath(path, chainedFilePath);
+    updateChainedUri(uri, chainedFileUri) {
+        this._backgroundAnalysisProgram.updateChainedUri(uri, chainedFileUri);
         this._scheduleReanalysis(/* requireTrackedFileUpdate */ false);
     }
-    updateOpenFileContents(path, version, contents, ipythonMode = sourceFile_1.IPythonMode.None, realFilePath) {
-        this._backgroundAnalysisProgram.updateOpenFileContents(path, version, contents, {
-            isTracked: this.isTracked(path),
+    updateOpenFileContents(uri, version, contents, ipythonMode = sourceFile_1.IPythonMode.None) {
+        this._backgroundAnalysisProgram.updateOpenFileContents(uri, version, contents, {
+            isTracked: this.isTracked(uri),
             ipythonMode,
-            chainedFilePath: undefined,
-            realFilePath,
+            chainedFileUri: undefined,
         });
         this._scheduleReanalysis(/* requireTrackedFileUpdate */ false);
     }
-    setFileClosed(path, isTracked) {
-        this._backgroundAnalysisProgram.setFileClosed(path, isTracked);
+    setFileClosed(uri, isTracked) {
+        this._backgroundAnalysisProgram.setFileClosed(uri, isTracked);
         this._scheduleReanalysis(/* requireTrackedFileUpdate */ false);
     }
-    addInterimFile(path) {
-        this._backgroundAnalysisProgram.addInterimFile(path);
+    addInterimFile(uri) {
+        this._backgroundAnalysisProgram.addInterimFile(uri);
     }
-    getParseResult(path) {
-        return this._program.getParseResults(path);
+    getParseResult(uri) {
+        return this._program.getParseResults(uri);
     }
-    getSourceFile(path) {
-        return this._program.getBoundSourceFile(path);
+    getSourceFile(uri) {
+        return this._program.getBoundSourceFile(uri);
     }
-    getTextOnRange(filePath, range, token) {
-        return this._program.getTextOnRange(filePath, range, token);
+    getTextOnRange(fileUri, range, token) {
+        return this._program.getTextOnRange(fileUri, range, token);
     }
     getEvaluator() {
         return this._program.evaluator;
@@ -255,13 +256,13 @@ class AnalyzerService {
         this._program.printDetailedAnalysisTimes();
     }
     printDependencies(verbose) {
-        this._program.printDependencies(this._executionRootPath, verbose);
+        this._program.printDependencies(this._executionRootUri, verbose);
     }
-    analyzeFile(filePath, token) {
-        return this._backgroundAnalysisProgram.analyzeFile(filePath, token);
+    analyzeFile(fileUri, token) {
+        return this._backgroundAnalysisProgram.analyzeFile(fileUri, token);
     }
-    getDiagnosticsForRange(filePath, range, token) {
-        return this._backgroundAnalysisProgram.getDiagnosticsForRange(filePath, range, token);
+    getDiagnosticsForRange(fileUri, range, token) {
+        return this._backgroundAnalysisProgram.getDiagnosticsForRange(fileUri, range, token);
     }
     getConfigOptions() {
         return this._configOptions;
@@ -283,21 +284,21 @@ class AnalyzerService {
     test_getFileNamesFromFileSpecs() {
         return this._getFileNamesFromFileSpecs();
     }
-    test_shouldHandleSourceFileWatchChanges(path, isFile) {
-        return this._shouldHandleSourceFileWatchChanges(path, isFile);
+    test_shouldHandleSourceFileWatchChanges(uri, isFile) {
+        return this._shouldHandleSourceFileWatchChanges(uri, isFile);
     }
-    test_shouldHandleLibraryFileWatchChanges(path, libSearchPaths) {
-        return this._shouldHandleLibraryFileWatchChanges(path, libSearchPaths);
+    test_shouldHandleLibraryFileWatchChanges(uri, libSearchUris) {
+        return this._shouldHandleLibraryFileWatchChanges(uri, libSearchUris);
     }
     writeTypeStub(token) {
         var _a;
-        const typingsSubdirPath = this._getTypeStubFolder();
-        this._program.writeTypeStub((_a = this._typeStubTargetPath) !== null && _a !== void 0 ? _a : '', this._typeStubTargetIsSingleFile, typingsSubdirPath, token);
+        const typingsSubdirUri = this._getTypeStubFolder();
+        this._program.writeTypeStub((_a = this._typeStubTargetUri) !== null && _a !== void 0 ? _a : uri_1.Uri.empty(), this._typeStubTargetIsSingleFile, typingsSubdirUri, token);
     }
     writeTypeStubInBackground(token) {
         var _a;
-        const typingsSubdirPath = this._getTypeStubFolder();
-        return this._backgroundAnalysisProgram.writeTypeStub((_a = this._typeStubTargetPath) !== null && _a !== void 0 ? _a : '', this._typeStubTargetIsSingleFile, typingsSubdirPath, token);
+        const typingsSubdirUri = this._getTypeStubFolder();
+        return this._backgroundAnalysisProgram.writeTypeStub((_a = this._typeStubTargetUri) !== null && _a !== void 0 ? _a : uri_1.Uri.empty(), this._typeStubTargetIsSingleFile, typingsSubdirUri, token);
     }
     invalidateAndForceReanalysis(reason) {
         this._backgroundAnalysisProgram.invalidateAndForceReanalysis(reason);
@@ -350,32 +351,35 @@ class AnalyzerService {
     // an optional config file, and default values.
     _getConfigOptions(host, commandLineOptions) {
         var _a, _b, _c;
-        let projectRoot = (0, pathUtils_1.realCasePath)(commandLineOptions.executionRoot, this.fs);
+        let projectRoot = this.fs.realCasePath(uri_1.Uri.file(commandLineOptions.executionRoot, this.fs.isCaseSensitive, /* checkRelative */ true));
+        const executionRoot = this.fs.realCasePath(uri_1.Uri.file(commandLineOptions.executionRoot, this.fs.isCaseSensitive, /* checkRelative */ true));
         let configFilePath;
         let pyprojectFilePath;
         if (commandLineOptions.configFilePath) {
             // If the config file path was specified, determine whether it's
             // a directory (in which case the default config file name is assumed)
             // or a file.
-            configFilePath = (0, pathUtils_1.realCasePath)((0, pathUtils_1.combinePaths)(commandLineOptions.executionRoot, (0, pathUtils_1.normalizePath)(commandLineOptions.configFilePath)), this.fs);
+            configFilePath = this.fs.realCasePath((0, pathUtils_1.isRootedDiskPath)(commandLineOptions.configFilePath)
+                ? uri_1.Uri.file(commandLineOptions.configFilePath, this.fs.isCaseSensitive, /* checkRelative */ true)
+                : projectRoot.combinePaths(commandLineOptions.configFilePath));
             if (!this.fs.existsSync(configFilePath)) {
-                this._console.info(`Configuration file not found at ${configFilePath}.`);
-                configFilePath = (0, pathUtils_1.realCasePath)(commandLineOptions.executionRoot, this.fs);
+                this._console.info(`Configuration file not found at ${configFilePath.toUserVisibleString()}.`);
+                configFilePath = projectRoot;
             }
             else {
-                if (configFilePath.toLowerCase().endsWith('.json')) {
-                    projectRoot = (0, pathUtils_1.realCasePath)((0, pathUtils_1.getDirectoryPath)(configFilePath), this.fs);
+                if (configFilePath.lastExtension.endsWith('.json')) {
+                    projectRoot = configFilePath.getDirectory();
                 }
                 else {
                     projectRoot = configFilePath;
                     configFilePath = this._findConfigFile(configFilePath);
                     if (!configFilePath) {
-                        this._console.info(`Configuration file not found at ${projectRoot}.`);
+                        this._console.info(`Configuration file not found at ${projectRoot.toUserVisibleString()}.`);
                     }
                 }
             }
         }
-        else if (projectRoot) {
+        else if (commandLineOptions.executionRoot) {
             // In a project-based IDE like VS Code, we should assume that the
             // project root directory contains the config file.
             configFilePath = this._findConfigFile(projectRoot);
@@ -386,7 +390,7 @@ class AnalyzerService {
                 configFilePath = this._findConfigFileHereOrUp(projectRoot);
             }
             if (configFilePath) {
-                projectRoot = (0, pathUtils_1.getDirectoryPath)(configFilePath);
+                projectRoot = configFilePath.getDirectory();
             }
             else {
                 this._console.log(`No configuration file found.`);
@@ -400,8 +404,8 @@ class AnalyzerService {
                 pyprojectFilePath = this._findPyprojectTomlFileHereOrUp(projectRoot);
             }
             if (pyprojectFilePath) {
-                projectRoot = (0, pathUtils_1.getDirectoryPath)(pyprojectFilePath);
-                this._console.log(`pyproject.toml file found at ${projectRoot}.`);
+                projectRoot = pyprojectFilePath.getDirectory();
+                this._console.log(`pyproject.toml file found at ${projectRoot.toUserVisibleString()}.`);
             }
             else {
                 this._console.log(`No pyproject.toml file found.`);
@@ -411,7 +415,7 @@ class AnalyzerService {
         const defaultExcludes = ['**/node_modules', '**/__pycache__', '**/.*'];
         if (commandLineOptions.pythonPath) {
             this._console.info(`Setting pythonPath for service "${this._instanceName}": ` + `"${commandLineOptions.pythonPath}"`);
-            (configOptions.pythonPath = commandLineOptions.pythonPath), this.fs;
+            configOptions.pythonPath = this.fs.realCasePath(uri_1.Uri.file(commandLineOptions.pythonPath, this.fs.isCaseSensitive, /* checkRelative */ true));
         }
         if (commandLineOptions.pythonEnvironmentName) {
             this._console.info(`Setting environmentName for service "${this._instanceName}": ` +
@@ -425,17 +429,17 @@ class AnalyzerService {
         configOptions.ensureDefaultExtraPaths(this.fs, (_a = commandLineOptions.autoSearchPaths) !== null && _a !== void 0 ? _a : false, commandLineOptions.extraPaths);
         if (commandLineOptions.includeFileSpecs.length > 0) {
             commandLineOptions.includeFileSpecs.forEach((fileSpec) => {
-                configOptions.include.push((0, pathUtils_1.getFileSpec)(this.serviceProvider, projectRoot, fileSpec));
+                configOptions.include.push((0, uriUtils_1.getFileSpec)(projectRoot, fileSpec));
             });
         }
         if (commandLineOptions.excludeFileSpecs.length > 0) {
             commandLineOptions.excludeFileSpecs.forEach((fileSpec) => {
-                configOptions.exclude.push((0, pathUtils_1.getFileSpec)(this.serviceProvider, projectRoot, fileSpec));
+                configOptions.exclude.push((0, uriUtils_1.getFileSpec)(projectRoot, fileSpec));
             });
         }
         if (commandLineOptions.ignoreFileSpecs.length > 0) {
             commandLineOptions.ignoreFileSpecs.forEach((fileSpec) => {
-                configOptions.ignore.push((0, pathUtils_1.getFileSpec)(this.serviceProvider, projectRoot, fileSpec));
+                configOptions.ignore.push((0, uriUtils_1.getFileSpec)(projectRoot, fileSpec));
             });
         }
         if (!configFilePath && commandLineOptions.executionRoot) {
@@ -443,40 +447,40 @@ class AnalyzerService {
                 // If no config file was found and there are no explicit include
                 // paths specified, assume the caller wants to include all source
                 // files under the execution root path.
-                configOptions.include.push((0, pathUtils_1.getFileSpec)(this.serviceProvider, commandLineOptions.executionRoot, '.'));
+                configOptions.include.push((0, uriUtils_1.getFileSpec)(executionRoot, '.'));
             }
             if (commandLineOptions.excludeFileSpecs.length === 0) {
                 // Add a few common excludes to avoid long scan times.
                 defaultExcludes.forEach((exclude) => {
-                    configOptions.exclude.push((0, pathUtils_1.getFileSpec)(this.serviceProvider, commandLineOptions.executionRoot, exclude));
+                    configOptions.exclude.push((0, uriUtils_1.getFileSpec)(executionRoot, exclude));
                 });
             }
         }
-        this._configFilePath = configFilePath || pyprojectFilePath;
+        this._configFileUri = configFilePath || pyprojectFilePath;
         // If we found a config file, parse it to compute the effective options.
         let configJsonObj;
         if (configFilePath) {
-            this._console.info(`Loading configuration file at ${configFilePath}`);
+            this._console.info(`Loading configuration file at ${configFilePath.toUserVisibleString()}`);
             configJsonObj = this._parseJsonConfigFile(configFilePath);
         }
         else if (pyprojectFilePath) {
-            this._console.info(`Loading pyproject.toml file at ${pyprojectFilePath}`);
+            this._console.info(`Loading pyproject.toml file at ${pyprojectFilePath.toUserVisibleString()}`);
             configJsonObj = this._parsePyprojectTomlFile(pyprojectFilePath);
         }
         if (configJsonObj) {
             configOptions.initializeFromJson(configJsonObj, this._typeCheckingMode, this.serviceProvider, host, commandLineOptions.diagnosticSeverityOverrides);
-            const configFileDir = (0, pathUtils_1.getDirectoryPath)(this._configFilePath);
+            const configFileDir = this._configFileUri.getDirectory();
             // If no include paths were provided, assume that all files within
             // the project should be included.
             if (configOptions.include.length === 0) {
-                this._console.info(`No include entries specified; assuming ${configFileDir}`);
-                configOptions.include.push((0, pathUtils_1.getFileSpec)(this.serviceProvider, configFileDir, '.'));
+                this._console.info(`No include entries specified; assuming ${configFileDir.toUserVisibleString()}`);
+                configOptions.include.push((0, uriUtils_1.getFileSpec)(configFileDir, '.'));
             }
             // If there was no explicit set of excludes, add a few common ones to avoid long scan times.
             if (configOptions.exclude.length === 0) {
                 defaultExcludes.forEach((exclude) => {
                     this._console.info(`Auto-excluding ${exclude}`);
-                    configOptions.exclude.push((0, pathUtils_1.getFileSpec)(this.serviceProvider, configFileDir, exclude));
+                    configOptions.exclude.push((0, uriUtils_1.getFileSpec)(configFileDir, exclude));
                 });
                 if (configOptions.autoExcludeVenv === undefined) {
                     configOptions.autoExcludeVenv = true;
@@ -496,7 +500,7 @@ class AnalyzerService {
         if (commandLineOptions.includeFileSpecsOverride) {
             configOptions.include = [];
             commandLineOptions.includeFileSpecsOverride.forEach((include) => {
-                configOptions.include.push((0, pathUtils_1.getFileSpec)(this.serviceProvider, include, '.'));
+                configOptions.include.push((0, uriUtils_1.getFileSpec)(uri_1.Uri.file(include, this.fs.isCaseSensitive, /* checkRelative */ true), '.'));
             });
         }
         const reportDuplicateSetting = (settingName, configValue) => {
@@ -512,18 +516,18 @@ class AnalyzerService {
         // duplicates.
         if (commandLineOptions.venvPath) {
             if (!configOptions.venvPath) {
-                configOptions.venvPath = commandLineOptions.venvPath;
+                configOptions.venvPath = projectRoot.combinePaths(commandLineOptions.venvPath);
             }
             else {
-                reportDuplicateSetting('venvPath', configOptions.venvPath);
+                reportDuplicateSetting('venvPath', configOptions.venvPath.toUserVisibleString());
             }
         }
         if (commandLineOptions.typeshedPath) {
             if (!configOptions.typeshedPath) {
-                configOptions.typeshedPath = (0, pathUtils_1.realCasePath)(commandLineOptions.typeshedPath, this.fs);
+                configOptions.typeshedPath = projectRoot.combinePaths(commandLineOptions.typeshedPath);
             }
             else {
-                reportDuplicateSetting('typeshedPath', configOptions.typeshedPath);
+                reportDuplicateSetting('typeshedPath', configOptions.typeshedPath.toUserVisibleString());
             }
         }
         // If the caller specified that "typeshedPath" is the root of the project,
@@ -536,7 +540,7 @@ class AnalyzerService {
             this._console.info(`Excluding typeshed stdlib stubs according to VERSIONS file:`);
             excludeList.forEach((exclude) => {
                 this._console.info(`    ${exclude}`);
-                configOptions.exclude.push((0, pathUtils_1.getFileSpec)(this.serviceProvider, commandLineOptions.executionRoot, exclude));
+                configOptions.exclude.push((0, uriUtils_1.getFileSpec)(executionRoot, exclude.getFilePath()));
             });
         }
         configOptions.verboseOutput = (_b = commandLineOptions.verboseOutput) !== null && _b !== void 0 ? _b : configOptions.verboseOutput;
@@ -560,42 +564,42 @@ class AnalyzerService {
         }
         if (commandLineOptions.stubPath) {
             if (!configOptions.stubPath) {
-                configOptions.stubPath = (0, pathUtils_1.realCasePath)(commandLineOptions.stubPath, this.fs);
+                configOptions.stubPath = this.fs.realCasePath(projectRoot.combinePaths(commandLineOptions.stubPath));
             }
             else {
-                reportDuplicateSetting('stubPath', configOptions.stubPath);
+                reportDuplicateSetting('stubPath', configOptions.stubPath.toUserVisibleString());
             }
         }
         if (configOptions.stubPath) {
             // If there was a stub path specified, validate it.
-            if (!this.fs.existsSync(configOptions.stubPath) || !(0, pathUtils_1.isDirectory)(this.fs, configOptions.stubPath)) {
+            if (!this.fs.existsSync(configOptions.stubPath) || !(0, uriUtils_1.isDirectory)(this.fs, configOptions.stubPath)) {
                 this._console.warn(`stubPath ${configOptions.stubPath} is not a valid directory.`);
             }
         }
         else {
             // If no stub path was specified, use a default path.
-            configOptions.stubPath = (0, pathUtils_1.normalizePath)((0, pathUtils_1.combinePaths)(configOptions.projectRoot, pathConsts_1.defaultStubsDirectory));
+            configOptions.stubPath = configOptions.projectRoot.combinePaths(pathConsts_1.defaultStubsDirectory);
         }
         // Do some sanity checks on the specified settings and report missing
         // or inconsistent information.
         if (configOptions.venvPath) {
-            if (!this.fs.existsSync(configOptions.venvPath) || !(0, pathUtils_1.isDirectory)(this.fs, configOptions.venvPath)) {
-                this._console.error(`venvPath ${configOptions.venvPath} is not a valid directory.`);
+            if (!this.fs.existsSync(configOptions.venvPath) || !(0, uriUtils_1.isDirectory)(this.fs, configOptions.venvPath)) {
+                this._console.error(`venvPath ${configOptions.venvPath.toUserVisibleString()} is not a valid directory.`);
             }
             // venvPath without venv means it won't do anything while resolveImport.
             // so first, try to set venv from existing configOption if it is null. if both are null,
             // then, resolveImport won't consider venv
             configOptions.venv = (_c = configOptions.venv) !== null && _c !== void 0 ? _c : this._configOptions.venv;
-            if (configOptions.venv) {
-                const fullVenvPath = (0, pathUtils_1.combinePaths)(configOptions.venvPath, configOptions.venv);
-                if (!this.fs.existsSync(fullVenvPath) || !(0, pathUtils_1.isDirectory)(this.fs, fullVenvPath)) {
-                    this._console.error(`venv ${configOptions.venv} subdirectory not found in venv path ${configOptions.venvPath}.`);
+            if (configOptions.venv && configOptions.venvPath) {
+                const fullVenvPath = configOptions.venvPath.combinePaths(configOptions.venv);
+                if (!this.fs.existsSync(fullVenvPath) || !(0, uriUtils_1.isDirectory)(this.fs, fullVenvPath)) {
+                    this._console.error(`venv ${configOptions.venv} subdirectory not found in venv path ${configOptions.venvPath.toUserVisibleString()}.`);
                 }
                 else {
                     const importFailureInfo = [];
                     if ((0, pythonPathUtils_1.findPythonSearchPaths)(this.fs, configOptions, host, importFailureInfo) === undefined) {
                         this._console.error(`site-packages directory cannot be located for venvPath ` +
-                            `${configOptions.venvPath} and venv ${configOptions.venv}.`);
+                            `${configOptions.venvPath.toUserVisibleString()} and venv ${configOptions.venv}.`);
                         if (configOptions.verboseOutput) {
                             importFailureInfo.forEach((diag) => {
                                 this._console.error(`  ${diag}`);
@@ -612,16 +616,16 @@ class AnalyzerService {
             }
         }
         if (configOptions.typeshedPath) {
-            if (!this.fs.existsSync(configOptions.typeshedPath) || !(0, pathUtils_1.isDirectory)(this.fs, configOptions.typeshedPath)) {
-                this._console.error(`typeshedPath ${configOptions.typeshedPath} is not a valid directory.`);
+            if (!this.fs.existsSync(configOptions.typeshedPath) || !(0, uriUtils_1.isDirectory)(this.fs, configOptions.typeshedPath)) {
+                this._console.error(`typeshedPath ${configOptions.typeshedPath.toUserVisibleString()} is not a valid directory.`);
             }
         }
         return configOptions;
     }
     _getTypeStubFolder() {
         var _a;
-        const stubPath = (_a = this._configOptions.stubPath) !== null && _a !== void 0 ? _a : (0, pathUtils_1.realCasePath)((0, pathUtils_1.combinePaths)(this._configOptions.projectRoot, pathConsts_1.defaultStubsDirectory), this.fs);
-        if (!this._typeStubTargetPath || !this._typeStubTargetImportName) {
+        const stubPath = (_a = this._configOptions.stubPath) !== null && _a !== void 0 ? _a : this.fs.realCasePath(this._configOptions.projectRoot.combinePaths(pathConsts_1.defaultStubsDirectory));
+        if (!this._typeStubTargetUri || !this._typeStubTargetImportName) {
             const errMsg = `Import '${this._typeStubTargetImportName}'` + ` could not be resolved`;
             this._console.error(errMsg);
             throw new Error(errMsg);
@@ -641,45 +645,45 @@ class AnalyzerService {
             }
         }
         catch (e) {
-            const errMsg = `Could not create typings directory '${stubPath}'`;
+            const errMsg = `Could not create typings directory '${stubPath.toUserVisibleString()}'`;
             this._console.error(errMsg);
             throw new Error(errMsg);
         }
         // Generate a typings subdirectory hierarchy.
-        const typingsSubdirPath = (0, pathUtils_1.combinePaths)(stubPath, typeStubInputTargetParts[0]);
-        const typingsSubdirHierarchy = (0, pathUtils_1.combinePaths)(stubPath, ...typeStubInputTargetParts);
+        const typingsSubdirPath = stubPath.combinePaths(typeStubInputTargetParts[0]);
+        const typingsSubdirHierarchy = stubPath.combinePaths(...typeStubInputTargetParts);
         try {
             // Generate a new typings subdirectory if necessary.
             if (!this.fs.existsSync(typingsSubdirHierarchy)) {
-                (0, pathUtils_1.makeDirectories)(this.fs, typingsSubdirHierarchy, stubPath);
+                (0, uriUtils_1.makeDirectories)(this.fs, typingsSubdirHierarchy, stubPath);
             }
         }
         catch (e) {
-            const errMsg = `Could not create typings subdirectory '${typingsSubdirHierarchy}'`;
+            const errMsg = `Could not create typings subdirectory '${typingsSubdirHierarchy.toUserVisibleString()}'`;
             this._console.error(errMsg);
             throw new Error(errMsg);
         }
         return typingsSubdirPath;
     }
     _findConfigFileHereOrUp(searchPath) {
-        return (0, pathUtils_1.forEachAncestorDirectory)(searchPath, (ancestor) => this._findConfigFile(ancestor));
+        return (0, uriUtils_1.forEachAncestorDirectory)(searchPath, (ancestor) => this._findConfigFile(ancestor));
     }
     _findConfigFile(searchPath) {
         for (const name of exports.configFileNames) {
-            const fileName = (0, pathUtils_1.combinePaths)(searchPath, name);
+            const fileName = searchPath.combinePaths(name);
             if (this.fs.existsSync(fileName)) {
-                return (0, pathUtils_1.realCasePath)(fileName, this.fs);
+                return this.fs.realCasePath(fileName);
             }
         }
         return undefined;
     }
     _findPyprojectTomlFileHereOrUp(searchPath) {
-        return (0, pathUtils_1.forEachAncestorDirectory)(searchPath, (ancestor) => this._findPyprojectTomlFile(ancestor));
+        return (0, uriUtils_1.forEachAncestorDirectory)(searchPath, (ancestor) => this._findPyprojectTomlFile(ancestor));
     }
     _findPyprojectTomlFile(searchPath) {
-        const fileName = (0, pathUtils_1.combinePaths)(searchPath, exports.pyprojectTomlName);
+        const fileName = searchPath.combinePaths(exports.pyprojectTomlName);
         if (this.fs.existsSync(fileName)) {
-            return (0, pathUtils_1.realCasePath)(fileName, this.fs);
+            return this.fs.realCasePath(fileName);
         }
         return undefined;
     }
@@ -705,20 +709,20 @@ class AnalyzerService {
                 this._console.error(`Pyproject file parse attempt ${attemptCount} error: ${JSON.stringify(e)}`);
                 throw e;
             }
-            this._console.info(`Pyproject file "${pyprojectPath}" has no "[tool.pyright]" section.`);
+            this._console.info(`Pyproject file "${pyprojectPath.toUserVisibleString()}" has no "[tool.pyright]" section.`);
             return undefined;
         });
     }
-    _attemptParseFile(filePath, parseCallback) {
+    _attemptParseFile(fileUri, parseCallback) {
         let fileContents = '';
         let parseAttemptCount = 0;
         while (true) {
             // Attempt to read the file contents.
             try {
-                fileContents = this.fs.readFileSync(filePath, 'utf8');
+                fileContents = this.fs.readFileSync(fileUri, 'utf8');
             }
             catch {
-                this._console.error(`Config file "${filePath}" could not be read.`);
+                this._console.error(`Config file "${fileUri.toUserVisibleString()}" could not be read.`);
                 this._reportConfigParseError();
                 return undefined;
             }
@@ -737,7 +741,7 @@ class AnalyzerService {
             // may have been partially written when we read it, resulting in parse
             // errors. We'll give it a little more time and try again.
             if (parseAttemptCount++ >= 5) {
-                this._console.error(`Config file "${filePath}" could not be parsed. Verify that format is correct.`);
+                this._console.error(`Config file "${fileUri.toUserVisibleString()}" could not be parsed. Verify that format is correct.`);
                 this._reportConfigParseError();
                 return undefined;
             }
@@ -751,16 +755,16 @@ class AnalyzerService {
         timing_1.timingStats.findFilesTime.timeOperation(() => {
             const matchedFiles = this._matchFiles(this._configOptions.include, this._configOptions.exclude);
             for (const file of matchedFiles) {
-                fileMap.set(file, file);
+                fileMap.set(file.key, file);
             }
         });
         // And scan all matching open files. We need to do this since some of files are not backed by
         // files in file system but only exist in memory (ex, virtual workspace)
         this._backgroundAnalysisProgram.program
             .getOpened()
-            .map((o) => o.sourceFile.getFilePath())
+            .map((o) => o.sourceFile.getUri())
             .filter((f) => (0, configOptions_1.matchFileSpecs)(this._program.configOptions, f))
-            .forEach((f) => fileMap.set(f, f));
+            .forEach((f) => fileMap.set(f.key, f));
         return Array.from(fileMap.values());
     }
     // If markFilesDirtyUnconditionally is true, we need to reparse
@@ -772,50 +776,50 @@ class AnalyzerService {
         // Are we in type stub generation mode? If so, we need to search
         // for a different set of files.
         if (this._typeStubTargetImportName) {
-            const execEnv = this._configOptions.findExecEnvironment(this._executionRootPath);
+            const execEnv = this._configOptions.findExecEnvironment(this._executionRootUri);
             const moduleDescriptor = (0, importResolver_1.createImportedModuleDescriptor)(this._typeStubTargetImportName);
-            const importResult = this._backgroundAnalysisProgram.importResolver.resolveImport('', execEnv, moduleDescriptor);
+            const importResult = this._backgroundAnalysisProgram.importResolver.resolveImport(uri_1.Uri.empty(), execEnv, moduleDescriptor);
             if (importResult.isImportFound) {
                 const filesToImport = [];
                 // Determine the directory that contains the root package.
-                const finalResolvedPath = importResult.resolvedPaths[importResult.resolvedPaths.length - 1];
-                const isFinalPathFile = (0, pathUtils_1.isFile)(this.fs, finalResolvedPath);
-                const isFinalPathInitFile = isFinalPathFile && (0, pathUtils_1.stripFileExtension)((0, pathUtils_1.getFileName)(finalResolvedPath)) === '__init__';
+                const finalResolvedPath = importResult.resolvedUris[importResult.resolvedUris.length - 1];
+                const isFinalPathFile = (0, uriUtils_1.isFile)(this.fs, finalResolvedPath);
+                const isFinalPathInitFile = isFinalPathFile && finalResolvedPath.stripAllExtensions().fileName === '__init__';
                 let rootPackagePath = finalResolvedPath;
                 if (isFinalPathFile) {
                     // If the module is a __init__.pyi? file, use its parent directory instead.
-                    rootPackagePath = (0, pathUtils_1.getDirectoryPath)(rootPackagePath);
+                    rootPackagePath = rootPackagePath.getDirectory();
                 }
-                for (let i = importResult.resolvedPaths.length - 2; i >= 0; i--) {
-                    if (importResult.resolvedPaths[i]) {
-                        rootPackagePath = importResult.resolvedPaths[i];
+                for (let i = importResult.resolvedUris.length - 2; i >= 0; i--) {
+                    if (!importResult.resolvedUris[i].isEmpty()) {
+                        rootPackagePath = importResult.resolvedUris[i];
                     }
                     else {
                         // If there was no file corresponding to this portion
                         // of the name path, assume that it's contained
                         // within its parent directory.
-                        rootPackagePath = (0, pathUtils_1.getDirectoryPath)(rootPackagePath);
+                        rootPackagePath = rootPackagePath.getDirectory();
                     }
                 }
-                if ((0, pathUtils_1.isDirectory)(this.fs, rootPackagePath)) {
-                    this._typeStubTargetPath = rootPackagePath;
+                if ((0, uriUtils_1.isDirectory)(this.fs, rootPackagePath)) {
+                    this._typeStubTargetUri = rootPackagePath;
                 }
-                else if ((0, pathUtils_1.isFile)(this.fs, rootPackagePath)) {
+                else if ((0, uriUtils_1.isFile)(this.fs, rootPackagePath)) {
                     // This can occur if there is a "dir/__init__.py" at the same level as a
                     // module "dir/module.py" that is specifically targeted for stub generation.
-                    this._typeStubTargetPath = (0, pathUtils_1.getDirectoryPath)(rootPackagePath);
+                    this._typeStubTargetUri = rootPackagePath.getDirectory();
                 }
                 if (!finalResolvedPath) {
                     this._typeStubTargetIsSingleFile = false;
                 }
                 else {
                     filesToImport.push(finalResolvedPath);
-                    this._typeStubTargetIsSingleFile = importResult.resolvedPaths.length === 1 && !isFinalPathInitFile;
+                    this._typeStubTargetIsSingleFile = importResult.resolvedUris.length === 1 && !isFinalPathInitFile;
                 }
                 // Add the implicit import paths.
                 importResult.filteredImplicitImports.forEach((implicitImport) => {
-                    if (importResolver_1.ImportResolver.isSupportedImportSourceFile(implicitImport.path)) {
-                        filesToImport.push(implicitImport.path);
+                    if (importResolver_1.ImportResolver.isSupportedImportSourceFile(implicitImport.uri)) {
+                        filesToImport.push(implicitImport.uri);
                     }
                 });
                 this._backgroundAnalysisProgram.setAllowedThirdPartyImports([this._typeStubTargetImportName]);
@@ -868,26 +872,24 @@ class AnalyzerService {
                 }
             }
             if (this._configOptions.autoExcludeVenv) {
-                if (envMarkers.some((f) => this.fs.existsSync((0, pathUtils_1.combinePaths)(absolutePath, ...f)))) {
+                if (envMarkers.some((f) => this.fs.existsSync(absolutePath.combinePaths(...f)))) {
                     // Save auto exclude paths in the configOptions once we found them.
-                    if (!pathUtils_1.FileSpec.isInPath(absolutePath, exclude)) {
-                        exclude.push((0, pathUtils_1.getFileSpec)(this.serviceProvider, this._configOptions.projectRoot, `${absolutePath}/**`));
+                    if (!uriUtils_1.FileSpec.isInPath(absolutePath, exclude)) {
+                        exclude.push((0, uriUtils_1.getFileSpec)(this._configOptions.projectRoot, `${absolutePath}/**`));
                     }
-                    this._console.info(`Auto-excluding ${absolutePath}`);
+                    this._console.info(`Auto-excluding ${absolutePath.toUserVisibleString()}`);
                     return;
                 }
             }
-            const { files, directories } = (0, pathUtils_1.getFileSystemEntries)(this.fs, absolutePath);
-            for (const file of files) {
-                const filePath = (0, pathUtils_1.combinePaths)(absolutePath, file);
-                if (pathUtils_1.FileSpec.matchIncludeFileSpec(includeRegExp, exclude, filePath)) {
+            const { files, directories } = (0, uriUtils_1.getFileSystemEntries)(this.fs, absolutePath);
+            for (const filePath of files) {
+                if (uriUtils_1.FileSpec.matchIncludeFileSpec(includeRegExp, exclude, filePath)) {
                     results.push(filePath);
                 }
             }
-            for (const directory of directories) {
-                const dirPath = (0, pathUtils_1.combinePaths)(absolutePath, directory);
-                if (includeRegExp.test(dirPath) || hasDirectoryWildcard) {
-                    if (!pathUtils_1.FileSpec.isInPath(dirPath, exclude)) {
+            for (const dirPath of directories) {
+                if (dirPath.matchesRegex(includeRegExp) || hasDirectoryWildcard) {
+                    if (!uriUtils_1.FileSpec.isInPath(dirPath, exclude)) {
                         visitDirectory(dirPath, includeRegExp, hasDirectoryWildcard);
                     }
                 }
@@ -895,27 +897,27 @@ class AnalyzerService {
         };
         const seenDirs = new Set();
         const visitDirectory = (absolutePath, includeRegExp, hasDirectoryWildcard) => {
-            const realDirPath = (0, pathUtils_1.tryRealpath)(this.fs, absolutePath);
+            const realDirPath = (0, uriUtils_1.tryRealpath)(this.fs, absolutePath);
             if (!realDirPath) {
                 this._console.warn(`Skipping broken link "${absolutePath}"`);
                 return;
             }
-            if (seenDirs.has(realDirPath)) {
+            if (seenDirs.has(realDirPath.key)) {
                 this._console.warn(`Skipping recursive symlink "${absolutePath}" -> "${realDirPath}"`);
                 return;
             }
-            seenDirs.add(realDirPath);
+            seenDirs.add(realDirPath.key);
             try {
                 visitDirectoryUnchecked(absolutePath, includeRegExp, hasDirectoryWildcard);
             }
             finally {
-                seenDirs.delete(realDirPath);
+                seenDirs.delete(realDirPath.key);
             }
         };
         include.forEach((includeSpec) => {
-            if (!pathUtils_1.FileSpec.isInPath(includeSpec.wildcardRoot, exclude)) {
+            if (!uriUtils_1.FileSpec.isInPath(includeSpec.wildcardRoot, exclude)) {
                 let foundFileSpec = false;
-                const stat = (0, pathUtils_1.tryStat)(this.fs, includeSpec.wildcardRoot);
+                const stat = (0, uriUtils_1.tryStat)(this.fs, includeSpec.wildcardRoot);
                 if (stat === null || stat === void 0 ? void 0 : stat.isFile()) {
                     results.push(includeSpec.wildcardRoot);
                     foundFileSpec = true;
@@ -925,7 +927,7 @@ class AnalyzerService {
                     foundFileSpec = true;
                 }
                 if (!foundFileSpec) {
-                    this._console.error(`File or directory "${includeSpec.wildcardRoot}" does not exist.`);
+                    this._console.error(`File or directory "${includeSpec.wildcardRoot.toUserVisibleString()}" does not exist.`);
                 }
             }
         });
@@ -944,13 +946,13 @@ class AnalyzerService {
         }
         if (this._configOptions.include.length > 0) {
             const fileList = this._configOptions.include.map((spec) => {
-                return (0, pathUtils_1.combinePaths)(this._executionRootPath, spec.wildcardRoot);
+                return spec.wildcardRoot;
             });
             try {
                 if (this._verboseOutput) {
                     this._console.info(`Adding fs watcher for directories:\n ${fileList.join('\n')}`);
                 }
-                const isIgnored = (0, fileWatcher_1.ignoredWatchEventFunction)(fileList);
+                const isIgnored = (0, fileWatcher_1.ignoredWatchEventFunction)(fileList.map((f) => f.getFilePath()));
                 this._sourceFileWatcher = this.fs.createFileSystemWatcher(fileList, (event, path) => {
                     if (!path) {
                         return;
@@ -965,21 +967,22 @@ class AnalyzerService {
                     if (path.endsWith('.tmp') || path.endsWith('.git') || path.includes(_gitDirectory)) {
                         return;
                     }
+                    let uri = uri_1.Uri.file(path, this.fs.isCaseSensitive, /* checkRelative */ true);
                     // Make sure path is the true case.
-                    path = (0, pathUtils_1.realCasePath)(path, this.fs);
-                    const eventInfo = getEventInfo(this.fs, this._console, this._program, event, path);
+                    uri = this.fs.realCasePath(uri);
+                    const eventInfo = getEventInfo(this.fs, this._console, this._program, event, uri);
                     if (!eventInfo) {
                         // no-op event, return.
                         return;
                     }
-                    if (!this._shouldHandleSourceFileWatchChanges(path, eventInfo.isFile)) {
+                    if (!this._shouldHandleSourceFileWatchChanges(uri, eventInfo.isFile)) {
                         return;
                     }
                     // This is for performance optimization. If the change only pertains to the content of one file,
                     // then it can't affect the 'import resolution' result. All we need to do is reanalyze the related files
                     // (those that have a transitive dependency on this file).
                     if (eventInfo.isFile && eventInfo.event === 'change') {
-                        this._backgroundAnalysisProgram.markFilesDirty([path], /* evenIfContentsAreSame */ false);
+                        this._backgroundAnalysisProgram.markFilesDirty([uri], /* evenIfContentsAreSame */ false);
                         this._scheduleReanalysis(/* requireTrackedFileUpdate */ false);
                         return;
                     }
@@ -995,13 +998,15 @@ class AnalyzerService {
                 });
             }
             catch {
-                this._console.error(`Exception caught when installing fs watcher for:\n ${fileList.join('\n')}`);
+                this._console.error(`Exception caught when installing fs watcher for:\n ${fileList
+                    .map((f) => f.toUserVisibleString())
+                    .join('\n')}`);
             }
         }
         function getEventInfo(fs, console, program, event, path) {
             // Due to the way we implemented file watcher, we will only get 2 events; 'add' and 'change'.
             // Here, we will convert those 2 to 3 events. 'add', 'change' and 'unlink';
-            const stats = (0, pathUtils_1.tryStat)(fs, path);
+            const stats = (0, uriUtils_1.tryStat)(fs, path);
             if (event === 'add') {
                 if (!stats) {
                     // If we are told that the path is added, but if we can't access it, then consider it as already deleted.
@@ -1031,7 +1036,7 @@ class AnalyzerService {
     }
     _shouldHandleSourceFileWatchChanges(path, isFile) {
         if (isFile) {
-            if (!(0, pathUtils_1.hasPythonExtension)(path) || isTemporaryFile(path)) {
+            if (!(0, uriUtils_1.hasPythonExtension)(path) || isTemporaryFile(path)) {
                 return false;
             }
             // Check whether the file change can affect semantics. If the file changed is not a user file or already a part of
@@ -1047,10 +1052,10 @@ class AnalyzerService {
             // First, make sure the folder is included. By default, we exclude any folder whose name starts with '.'
             return false;
         }
-        const parentPath = (0, pathUtils_1.getDirectoryPath)(path);
+        const parentPath = path.getDirectory();
         const hasInit = parentPath.startsWith(this._configOptions.projectRoot) &&
-            (this.fs.existsSync((0, pathUtils_1.combinePaths)(parentPath, '__init__.py')) ||
-                this.fs.existsSync((0, pathUtils_1.combinePaths)(parentPath, '__init__.pyi')));
+            (this.fs.existsSync(parentPath.combinePaths('__init__.py')) ||
+                this.fs.existsSync(parentPath.combinePaths('__init__.pyi')));
         // We don't have any file under the given path and its parent folder doesn't have __init__ then this folder change
         // doesn't have any meaning to us.
         if (!hasInit && !this._program.containsSourceFileIn(path)) {
@@ -1063,7 +1068,7 @@ class AnalyzerService {
             // alongside the original file and name them "x.py.<temp-id>.py" where
             // <temp-id> is a 32-character random string of hex digits. We don't
             // want these events to trigger a full reanalysis.
-            const fileName = (0, pathUtils_1.getFileName)(path);
+            const fileName = path.fileName;
             const fileNameSplit = fileName.split('.');
             if (fileNameSplit.length === 4) {
                 if (fileNameSplit[3] === fileNameSplit[1] && fileNameSplit[2].length === 32) {
@@ -1082,20 +1087,20 @@ class AnalyzerService {
     _updateLibraryFileWatcher() {
         this._removeLibraryFileWatcher();
         if (!this._watchForLibraryChanges) {
-            this._librarySearchPathsToWatch = undefined;
+            this._librarySearchUrisToWatch = undefined;
             return;
         }
         // Watch the library paths for package install/uninstall.
         const importFailureInfo = [];
-        this._librarySearchPathsToWatch = (0, pythonPathUtils_1.findPythonSearchPaths)(this.fs, this._backgroundAnalysisProgram.configOptions, this._backgroundAnalysisProgram.host, importFailureInfo, 
-        /* includeWatchPathsOnly */ true, this._executionRootPath);
-        const watchList = this._librarySearchPathsToWatch;
+        this._librarySearchUrisToWatch = (0, pythonPathUtils_1.findPythonSearchPaths)(this.fs, this._backgroundAnalysisProgram.configOptions, this._backgroundAnalysisProgram.host, importFailureInfo, 
+        /* includeWatchPathsOnly */ true, this._executionRootUri);
+        const watchList = this._librarySearchUrisToWatch;
         if (watchList && watchList.length > 0) {
             try {
                 if (this._verboseOutput) {
                     this._console.info(`Adding fs watcher for library directories:\n ${watchList.join('\n')}`);
                 }
-                const isIgnored = (0, fileWatcher_1.ignoredWatchEventFunction)(watchList);
+                const isIgnored = (0, fileWatcher_1.ignoredWatchEventFunction)(watchList.map((f) => f.getFilePath()));
                 this._libraryFileWatcher = this.fs.createFileSystemWatcher(watchList, (event, path) => {
                     if (!path) {
                         return;
@@ -1106,16 +1111,19 @@ class AnalyzerService {
                     if (isIgnored(path)) {
                         return;
                     }
-                    if (!this._shouldHandleLibraryFileWatchChanges(path, watchList)) {
+                    const uri = uri_1.Uri.file(path, this.fs.isCaseSensitive, /* checkRelative */ true);
+                    if (!this._shouldHandleLibraryFileWatchChanges(uri, watchList)) {
                         return;
                     }
                     // If file doesn't exist, it is delete.
-                    const isChange = event === 'change' && this.fs.existsSync(path);
+                    const isChange = event === 'change' && this.fs.existsSync(uri);
                     this._scheduleLibraryAnalysis(isChange);
                 });
             }
             catch {
-                this._console.error(`Exception caught when installing fs watcher for:\n ${watchList.join('\n')}`);
+                this._console.error(`Exception caught when installing fs watcher for:\n ${watchList
+                    .map((w) => w.toUserVisibleString())
+                    .join('\n')}`);
             }
         }
     }
@@ -1125,19 +1133,17 @@ class AnalyzerService {
         }
         // find the innermost matching search path
         let matchingSearchPath;
-        const tempFile = this.serviceProvider.tryGet(serviceProviderExtensions_1.ServiceKeys.tempFile);
-        const ignoreCase = !(0, pathUtils_1.isFileSystemCaseSensitive)(this.fs, tempFile);
         for (const libSearchPath of libSearchPaths) {
-            if ((0, pathUtils_1.containsPath)(libSearchPath, path, ignoreCase) &&
-                (!matchingSearchPath || matchingSearchPath.length < libSearchPath.length)) {
+            if (path.isChild(libSearchPath) &&
+                (!matchingSearchPath || matchingSearchPath.getPathLength() < libSearchPath.getPathLength())) {
                 matchingSearchPath = libSearchPath;
             }
         }
         if (!matchingSearchPath) {
             return true;
         }
-        const parentComponents = (0, pathUtils_1.getPathComponents)(matchingSearchPath);
-        const childComponents = (0, pathUtils_1.getPathComponents)(path);
+        const parentComponents = matchingSearchPath.getPathComponents();
+        const childComponents = path.getPathComponents();
         for (let i = parentComponents.length; i < childComponents.length; i++) {
             if (childComponents[i].startsWith('.')) {
                 return false;
@@ -1193,16 +1199,16 @@ class AnalyzerService {
         if (!this._watchForConfigChanges) {
             return;
         }
-        if (this._configFilePath) {
-            this._configFileWatcher = this.fs.createFileSystemWatcher([this._configFilePath], (event) => {
+        if (this._configFileUri) {
+            this._configFileWatcher = this.fs.createFileSystemWatcher([this._configFileUri], (event) => {
                 if (this._verboseOutput) {
                     this._console.info(`Received fs event '${event}' for config file`);
                 }
                 this._scheduleReloadConfigFile();
             });
         }
-        else if (this._executionRootPath) {
-            this._configFileWatcher = this.fs.createFileSystemWatcher([this._executionRootPath], (event, path) => {
+        else if (this._executionRootUri) {
+            this._configFileWatcher = this.fs.createFileSystemWatcher([this._executionRootUri], (event, path) => {
                 if (!path) {
                     return;
                 }
@@ -1239,8 +1245,8 @@ class AnalyzerService {
     }
     _reloadConfigFile() {
         this._updateConfigFileWatcher();
-        if (this._configFilePath) {
-            this._console.info(`Reloading configuration file at ${this._configFilePath}`);
+        if (this._configFileUri) {
+            this._console.info(`Reloading configuration file at ${this._configFileUri.toUserVisibleString()}`);
             const host = this._backgroundAnalysisProgram.host;
             // We can't just reload config file when it is changed; we need to consider
             // command line options as well to construct new config Options.
@@ -1261,7 +1267,7 @@ class AnalyzerService {
                 (0, console_1.log)(this._console, logLevel, `Search paths for ${execEnv.root || '<default>'}`);
                 const roots = importResolver.getImportRoots(execEnv, /* forLogging */ true);
                 roots.forEach((path) => {
-                    (0, console_1.log)(this._console, logLevel, `  ${path}`);
+                    (0, console_1.log)(this._console, logLevel, `  ${path.toUserVisibleString()}`);
                 });
             }
         }