Add WorkspaceFolders and use it when enumerating files

Author: andyleejordan

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.InitialWorkingDirectory = workspaceFolder.Uri.GetFileSystemPath();
-                                    break;
-                                }
+                                workspaceService.WorkspaceFolders.AddRange(initializeParams.WorkspaceFolders);
                             }
 
                             // Parse initialization options.
@@ -149,13 +144,19 @@ 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.InitialWorkingDirectory,
-                                ShellIntegrationEnabled = initializationOptions?.GetValue("shellIntegrationEnabled")?.Value<bool>() ?? false
+                                LoadProfiles = initializationOptions?.GetValue("enableProfileLoading")?.Value<bool>()
+                                    ?? true,
+                                // First check the setting, then use the first workspace folder,
+                                // finally fall back to CWD.
+                                InitialWorkingDirectory = initializationOptions?.GetValue("initialWorkingDirectory")?.Value<string>()
+                                    ?? workspaceService.WorkspaceFolders.FirstOrDefault()?.Uri.GetFileSystemPath()
+                                    ?? Directory.GetCurrentDirectory(),
+                                ShellIntegrationEnabled = initializationOptions?.GetValue("shellIntegrationEnabled")?.Value<bool>()
+                                    ?? false
                             };
 
+                            workspaceService.InitialWorkingDirectory = hostStartOptions.InitialWorkingDirectory;
+
                             _psesHost = languageServer.Services.GetService<PsesInternalHost>();
                             return _psesHost.TryStartAsync(hostStartOptions, cancellationToken);
                         });

src/PowerShellEditorServices/Services/Workspace/WorkspaceService.cs

@@ -1,10 +1,11 @@
-// Copyright (c) Microsoft Corporation.
+// Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Security;
 using System.Text;
 using Microsoft.Extensions.FileSystemGlobbing;
@@ -13,6 +14,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
 {
@@ -67,6 +69,11 @@ internal class WorkspaceService
         /// </summary>
         public string InitialWorkingDirectory { 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>
@@ -88,6 +95,7 @@ public WorkspaceService(ILoggerFactory factory)
         {
             powerShellVersion = VersionUtils.PSVersion;
             logger = factory.CreateLogger<WorkspaceService>();
+            WorkspaceFolders = new List<WorkspaceFolder>();
             ExcludeFilesGlob = new List<string>();
             FollowSymlinks = true;
         }
@@ -336,39 +344,46 @@ public IEnumerable<string> EnumeratePSFiles()
         }
 
         /// <summary>
-        /// Enumerate all the PowerShell (ps1, psm1, psd1) files in the workspace in a recursive manner.
+        /// Enumerate all the PowerShell (ps1, psm1, psd1) files in the workspace folders in a
+        /// recursive manner. Falls back to initial working directory if there are no workspace folders.
         /// </summary>
         /// <returns>An enumerator over the PowerShell files found in the workspace.</returns>
         public IEnumerable<string> EnumeratePSFiles(
             string[] excludeGlobs,
             string[] includeGlobs,
             int maxDepth,
-            bool ignoreReparsePoints
-        )
+            bool ignoreReparsePoints)
         {
-            if (InitialWorkingDirectory is null || !Directory.Exists(InitialWorkingDirectory))
-            {
-                yield break;
-            }
+            IEnumerable<string> rootPaths = WorkspaceFolders.Count == 0
+                ? new List<string> { InitialWorkingDirectory }
+                : WorkspaceFolders.Select(i => i.Uri.GetFileSystemPath());
 
             Matcher matcher = new();
             foreach (string pattern in includeGlobs) { matcher.AddInclude(pattern); }
             foreach (string pattern in excludeGlobs) { matcher.AddExclude(pattern); }
 
-            WorkspaceFileSystemWrapperFactory fsFactory = new(
-                InitialWorkingDirectory,
-                maxDepth,
-                VersionUtils.IsNetCore ? s_psFileExtensionsCoreFramework : s_psFileExtensionsFullFramework,
-                ignoreReparsePoints,
-                logger
-            );
-            PatternMatchingResult fileMatchResult = matcher.Execute(fsFactory.RootDirectory);
-            foreach (FilePatternMatch item in fileMatchResult.Files)
+            foreach (string rootPath in rootPaths)
             {
-                // 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(InitialWorkingDirectory, path);
+                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
             {
-                InitialWorkingDirectory = TestUtilities.GetSharedPath("References")
-            };
+                Uri = DocumentUri.FromFileSystemPath(TestUtilities.GetSharedPath("References"))
+            });
             symbolsService = new SymbolsService(
                 NullLoggerFactory.Instance,
                 psesHost,