WIP: Support multi-root workspace

This time in the server.

Author: andyleejordan

src/PowerShellEditorServices/Extensions/EditorWorkspace.cs

@@ -19,6 +19,7 @@ public sealed class EditorWorkspace
 
         /// <summary>
         /// Gets the current workspace path if there is one or null otherwise.
+        /// TODO: This API needs to be deprecated for new `Paths` instead.
         /// </summary>
         public string Path => editorOperations.GetWorkspacePath();
 

src/PowerShellEditorServices/Extensions/FileContext.cs

@@ -58,8 +58,7 @@ public sealed class FileContext
         /// <summary>
         /// Gets the workspace-relative path of the file.
         /// </summary>
-        public string WorkspacePath => editorOperations.GetWorkspaceRelativePath(
-                        scriptFile.FilePath);
+        public string WorkspacePath => editorOperations.GetWorkspaceRelativePath(scriptFile);
 
         #endregion
 

src/PowerShellEditorServices/Extensions/IEditorOperations.cs

@@ -28,9 +28,8 @@ internal interface IEditorOperations
         /// <summary>
         /// Resolves the given file path relative to the current workspace path.
         /// </summary>
-        /// <param name="filePath">The file path to be resolved.</param>
         /// <returns>The resolved file path.</returns>
-        string GetWorkspaceRelativePath(string filePath);
+        string GetWorkspaceRelativePath(ScriptFile scriptFile);
 
         /// <summary>
         /// Causes a new untitled file to be created in the editor.

src/PowerShellEditorServices/Server/PsesLanguageServer.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 using System.IO;
+using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
@@ -13,7 +14,6 @@
 using Microsoft.PowerShell.EditorServices.Services.Template;
 using Newtonsoft.Json.Linq;
 using OmniSharp.Extensions.JsonRpc;
-using OmniSharp.Extensions.LanguageServer.Protocol.Models;
 using OmniSharp.Extensions.LanguageServer.Protocol.Server;
 using OmniSharp.Extensions.LanguageServer.Server;
 using Serilog;
@@ -130,12 +130,7 @@ public async Task StartAsync()
                             WorkspaceService workspaceService = languageServer.Services.GetService<WorkspaceService>();
                             if (initializeParams.WorkspaceFolders is not null)
                             {
-                                // TODO: Support multi-workspace.
-                                foreach (WorkspaceFolder workspaceFolder in initializeParams.WorkspaceFolders)
-                                {
-                                    workspaceService.WorkspacePath = workspaceFolder.Uri.GetFileSystemPath();
-                                    break;
-                                }
+                                workspaceService.WorkspaceFolders.AddRange(initializeParams.WorkspaceFolders);
                             }
 
                             // Parse initialization options.
@@ -149,13 +144,18 @@ public async Task StartAsync()
                                 //
                                 // NOTE: The keys start with a lowercase because OmniSharp's client
                                 // (used for testing) forces it to be that way.
-                                LoadProfiles = initializationOptions?.GetValue("enableProfileLoading")?.Value<bool>() ?? true,
-                                // TODO: Consider deprecating the setting which sets this and
-                                // instead use WorkspacePath exclusively.
-                                InitialWorkingDirectory = initializationOptions?.GetValue("initialWorkingDirectory")?.Value<string>() ?? workspaceService.WorkspacePath,
-                                ShellIntegrationEnabled = initializationOptions?.GetValue("shellIntegrationEnabled")?.Value<bool>() ?? false
+                                LoadProfiles = initializationOptions?.GetValue("enableProfileLoading")?.Value<bool>()
+                                    ?? true,
+                                InitialWorkingDirectory = initializationOptions?.GetValue("initialWorkingDirectory")?.Value<string>()
+                                    ?? workspaceService.WorkspaceFolders.FirstOrDefault()?.Uri.GetFileSystemPath(),
+                                ShellIntegrationEnabled = initializationOptions?.GetValue("shellIntegrationEnabled")?.Value<bool>()
+                                    ?? false
                             };
 
+                            // NOTE: We're still maintaining a root path while things transition to
+                            // support multi-root workspaces.
+                            workspaceService.WorkspacePath = hostStartOptions.InitialWorkingDirectory;
+
                             _psesHost = languageServer.Services.GetService<PsesInternalHost>();
                             return _psesHost.TryStartAsync(hostStartOptions, cancellationToken);
                         });

src/PowerShellEditorServices/Services/Extension/EditorOperationsService.cs

@@ -193,7 +193,7 @@ public async Task SaveFileAsync(string currentPath, string newSavePath)
 
         public string GetWorkspacePath() => _workspaceService.WorkspacePath;
 
-        public string GetWorkspaceRelativePath(string filePath) => _workspaceService.GetRelativePath(filePath);
+        public string GetWorkspaceRelativePath(ScriptFile scriptFile) => _workspaceService.GetRelativePath(scriptFile);
 
         public async Task ShowInformationMessageAsync(string message)
         {

src/PowerShellEditorServices/Services/Workspace/WorkspaceService.cs

@@ -13,6 +13,7 @@
 using Microsoft.PowerShell.EditorServices.Services.Workspace;
 using Microsoft.PowerShell.EditorServices.Utility;
 using OmniSharp.Extensions.LanguageServer.Protocol;
+using OmniSharp.Extensions.LanguageServer.Protocol.Models;
 
 namespace Microsoft.PowerShell.EditorServices.Services
 {
@@ -58,10 +59,15 @@ internal class WorkspaceService
         #region Properties
 
         /// <summary>
-        /// Gets or sets the root path of the workspace.
+        /// Deprecated! Multi-root workspace support requires multiple workspace paths.
         /// </summary>
         public string WorkspacePath { get; set; }
 
+        /// <summary>
+        /// Gets or sets the folders of the workspace.
+        /// </summary>
+        public List<WorkspaceFolder> WorkspaceFolders { get; set; }
+
         /// <summary>
         /// Gets or sets the default list of file globs to exclude during workspace searches.
         /// </summary>
@@ -83,6 +89,7 @@ public WorkspaceService(ILoggerFactory factory)
         {
             powerShellVersion = VersionUtils.PSVersion;
             logger = factory.CreateLogger<WorkspaceService>();
+            WorkspaceFolders = new List<WorkspaceFolder>();
             ExcludeFilesGlob = new List<string>();
             FollowSymlinks = true;
         }
@@ -293,18 +300,23 @@ public void CloseFile(ScriptFile scriptFile)
         /// <summary>
         /// Gets the workspace-relative path of the given file path.
         /// </summary>
-        /// <param name="filePath">The original full file path.</param>
         /// <returns>A relative file path</returns>
-        public string GetRelativePath(string filePath)
+        public string GetRelativePath(ScriptFile scriptFile)
         {
-            string resolvedPath = filePath;
+            string resolvedPath = scriptFile.FilePath;
 
-            if (!IsPathInMemory(filePath) && !string.IsNullOrEmpty(WorkspacePath))
+            if (!scriptFile.IsInMemory)
             {
-                Uri workspaceUri = new(WorkspacePath);
-                Uri fileUri = new(filePath);
-
-                resolvedPath = workspaceUri.MakeRelativeUri(fileUri).ToString();
+                Uri fileUri = scriptFile.DocumentUri.ToUri();
+                foreach (WorkspaceFolder workspaceFolder in WorkspaceFolders)
+                {
+                    Uri workspaceUri = workspaceFolder.Uri.ToUri();
+                    if (workspaceUri.IsBaseOf(fileUri))
+                    {
+                        resolvedPath = workspaceUri.MakeRelativeUri(fileUri).ToString();
+                        break;
+                    }
+                }
 
                 // Convert the directory separators if necessary
                 if (Path.DirectorySeparatorChar == '\\')
@@ -341,7 +353,7 @@ public IEnumerable<string> EnumeratePSFiles(
             bool ignoreReparsePoints
         )
         {
-            if (WorkspacePath is null || !Directory.Exists(WorkspacePath))
+            if (WorkspaceFolders.Count == 0)
             {
                 yield break;
             }
@@ -350,20 +362,29 @@ bool ignoreReparsePoints
             foreach (string pattern in includeGlobs) { matcher.AddInclude(pattern); }
             foreach (string pattern in excludeGlobs) { matcher.AddExclude(pattern); }
 
-            WorkspaceFileSystemWrapperFactory fsFactory = new(
-                WorkspacePath,
-                maxDepth,
-                VersionUtils.IsNetCore ? s_psFileExtensionsCoreFramework : s_psFileExtensionsFullFramework,
-                ignoreReparsePoints,
-                logger
-            );
-            PatternMatchingResult fileMatchResult = matcher.Execute(fsFactory.RootDirectory);
-            foreach (FilePatternMatch item in fileMatchResult.Files)
+            foreach (WorkspaceFolder workspaceFolder in WorkspaceFolders)
             {
-                // item.Path always contains forward slashes in paths when it should be backslashes on Windows.
-                // Since we're returning strings here, it's important to use the correct directory separator.
-                string path = VersionUtils.IsWindows ? item.Path.Replace('/', Path.DirectorySeparatorChar) : item.Path;
-                yield return Path.Combine(WorkspacePath, path);
+                string rootPath = workspaceFolder.Uri.GetFileSystemPath();
+                if (!Directory.Exists(rootPath))
+                {
+                    continue;
+                }
+
+                WorkspaceFileSystemWrapperFactory fsFactory = new(
+                    rootPath,
+                    maxDepth,
+                    VersionUtils.IsNetCore ? s_psFileExtensionsCoreFramework : s_psFileExtensionsFullFramework,
+                    ignoreReparsePoints,
+                    logger);
+
+                PatternMatchingResult fileMatchResult = matcher.Execute(fsFactory.RootDirectory);
+                foreach (FilePatternMatch item in fileMatchResult.Files)
+                {
+                    // item.Path always contains forward slashes in paths when it should be backslashes on Windows.
+                    // Since we're returning strings here, it's important to use the correct directory separator.
+                    string path = VersionUtils.IsWindows ? item.Path.Replace('/', Path.DirectorySeparatorChar) : item.Path;
+                    yield return Path.Combine(rootPath, path);
+                }
             }
         }
 

test/PowerShellEditorServices.Test/Language/SymbolsServiceTests.cs

@@ -23,6 +23,8 @@
 using Microsoft.PowerShell.EditorServices.Test.Shared.SymbolDetails;
 using Microsoft.PowerShell.EditorServices.Test.Shared.Symbols;
 using Microsoft.PowerShell.EditorServices.Utility;
+using OmniSharp.Extensions.LanguageServer.Protocol;
+using OmniSharp.Extensions.LanguageServer.Protocol.Models;
 using Xunit;
 
 namespace PowerShellEditorServices.Test.Language
@@ -38,10 +40,11 @@ public class SymbolsServiceTests : IDisposable
         public SymbolsServiceTests()
         {
             psesHost = PsesHostFactory.Create(NullLoggerFactory.Instance);
-            workspace = new WorkspaceService(NullLoggerFactory.Instance)
+            workspace = new WorkspaceService(NullLoggerFactory.Instance);
+            workspace.WorkspaceFolders.Add(new WorkspaceFolder()
             {
-                WorkspacePath = TestUtilities.GetSharedPath("References")
-            };
+                Uri = DocumentUri.FromFileSystemPath(TestUtilities.GetSharedPath("References"))
+            });
             symbolsService = new SymbolsService(
                 NullLoggerFactory.Instance,
                 psesHost,