Merge branch 'main' into rename-function-customvisitor

Author: JustinGrote

src/PowerShellEditorServices.Hosting/Internal/EditorServicesRunner.cs

@@ -267,18 +267,12 @@ private HostStartupInfo CreateHostStartupInfo()
         {
             _logger.Log(PsesLogLevel.Debug, "Creating startup info object");
 
-            ProfilePathInfo profilePaths = null;
-            if (_config.ProfilePaths.AllUsersAllHosts != null
-                || _config.ProfilePaths.AllUsersCurrentHost != null
-                || _config.ProfilePaths.CurrentUserAllHosts != null
-                || _config.ProfilePaths.CurrentUserCurrentHost != null)
-            {
-                profilePaths = new ProfilePathInfo(
-                    _config.ProfilePaths.CurrentUserAllHosts,
-                    _config.ProfilePaths.CurrentUserCurrentHost,
-                    _config.ProfilePaths.AllUsersAllHosts,
-                    _config.ProfilePaths.AllUsersCurrentHost);
-            }
+            ProfilePathInfo profilePaths = new(
+                _config.ProfilePaths.CurrentUserAllHosts,
+                _config.ProfilePaths.CurrentUserCurrentHost,
+                _config.ProfilePaths.AllUsersAllHosts,
+                _config.ProfilePaths.AllUsersCurrentHost
+            );
 
             return new HostStartupInfo(
                 _config.HostInfo.Name,

src/PowerShellEditorServices/Extensions/EditorWorkspace.cs

@@ -28,6 +28,11 @@ public sealed class EditorWorkspace
         /// </summary>
         public string[] Paths => editorOperations.GetWorkspacePaths();
 
+        /// <summary>
+        /// Get all currently open documents in the workspace.
+        /// </summary>
+        public WorkspaceOpenDocument[] Documents => editorOperations.GetWorkspaceOpenDocuments();
+
         #endregion
 
         #region Constructors
@@ -76,13 +81,15 @@ public sealed class EditorWorkspace
         /// <param name="filePath">The path to the file to be closed.</param>
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "VSTHRD002:Avoid problematic synchronous waits", Justification = "Supporting synchronous API.")]
         public void CloseFile(string filePath) => editorOperations.CloseFileAsync(filePath).Wait();
+        public void CloseFile(WorkspaceOpenDocument document) => CloseFile(document.Path);
 
         /// <summary>
         /// Saves an open file in the workspace.
         /// </summary>
         /// <param name="filePath">The path to the file to be saved.</param>
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "VSTHRD002:Avoid problematic synchronous waits", Justification = "Supporting synchronous API.")]
         public void SaveFile(string filePath) => editorOperations.SaveFileAsync(filePath).Wait();
+        public void SaveFile(WorkspaceOpenDocument document) => SaveFile(document.Path);
 
         /// <summary>
         /// Saves a file with a new name AKA a copy.

src/PowerShellEditorServices/Extensions/IEditorOperations.cs

@@ -3,9 +3,34 @@
 
 using System.Threading.Tasks;
 using Microsoft.PowerShell.EditorServices.Services.TextDocument;
+#nullable enable
 
 namespace Microsoft.PowerShell.EditorServices.Extensions
 {
+    public readonly struct WorkspaceOpenDocument(string path, bool saved)
+    {
+        /// <summary>
+        /// Gets the path or URI of the open document.
+        /// </summary>
+        public string Path { get; } = path;
+
+        /// <summary>
+        /// Gets whether the document is backed by a saved file path (not in-memory).
+        /// </summary>
+        public bool Saved { get; } = saved;
+
+        /// <summary>
+        /// Gets the display name of this document and unsaved status.
+        /// </summary>
+        /// <returns>The display name of this document.</returns>
+        public override string ToString()
+        {
+            string documentPath = Path ?? string.Empty;
+            string fileName = System.IO.Path.GetFileName(documentPath);
+            return Saved ? fileName : fileName + " [Unsaved]";
+        }
+    }
+
     /// <summary>
     /// Provides an interface that must be implemented by an editor
     /// host to perform operations invoked by extensions written in
@@ -32,6 +57,12 @@ internal interface IEditorOperations
         /// <returns></returns>
         string[] GetWorkspacePaths();
 
+        /// <summary>
+        /// Get all open documents in the current workspace session.
+        /// </summary>
+        /// <returns>All currently open documents.</returns>
+        WorkspaceOpenDocument[] GetWorkspaceOpenDocuments();
+
         /// <summary>
         /// Resolves the given file path relative to the current workspace path.
         /// </summary>

src/PowerShellEditorServices/Hosting/HostStartupInfo.cs

@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
+#nullable enable
 
 using System;
 using System.Collections.Generic;
@@ -190,32 +191,13 @@ public HostStartupInfo(
     }
 
     /// <summary>
-    /// This is a strange class that is generally <c>null</c> or otherwise just has a single path
-    /// set. It is eventually parsed one-by-one when setting up the PowerShell runspace.
+    /// Stores profile information passed from Start-EditorServices to be used for loading profiles if configured
+    /// and for the $PROFILE variable in the initial session state.
     /// </summary>
-    /// <remarks>
-    /// TODO: Simplify this as a <see langword="record"/>.
-    /// </remarks>
-    public sealed class ProfilePathInfo
-    {
-        public ProfilePathInfo(
-            string currentUserAllHosts,
-            string currentUserCurrentHost,
-            string allUsersAllHosts,
-            string allUsersCurrentHost)
-        {
-            CurrentUserAllHosts = currentUserAllHosts;
-            CurrentUserCurrentHost = currentUserCurrentHost;
-            AllUsersAllHosts = allUsersAllHosts;
-            AllUsersCurrentHost = allUsersCurrentHost;
-        }
-
-        public string CurrentUserAllHosts { get; }
-
-        public string CurrentUserCurrentHost { get; }
-
-        public string AllUsersAllHosts { get; }
-
-        public string AllUsersCurrentHost { get; }
-    }
+    public readonly record struct ProfilePathInfo(
+        string CurrentUserAllHosts,
+        string CurrentUserCurrentHost,
+        string AllUsersAllHosts,
+        string AllUsersCurrentHost
+    );
 }

src/PowerShellEditorServices/Services/Extension/EditorOperationsService.cs

@@ -198,6 +198,14 @@ public async Task SaveFileAsync(string currentPath, string newSavePath)
 
         public string[] GetWorkspacePaths() => _workspaceService.WorkspacePaths.ToArray();
 
+        public WorkspaceOpenDocument[] GetWorkspaceOpenDocuments()
+            => [..
+                    _workspaceService
+                    .GetOpenedFiles()
+                    .Where(static scriptFile => scriptFile.IsOpen)
+                    .Select(static scriptFile => new WorkspaceOpenDocument(scriptFile.FilePath, !scriptFile.IsInMemory))
+                ];
+
         public string GetWorkspaceRelativePath(ScriptFile scriptFile) => _workspaceService.GetRelativePath(scriptFile);
 
         public async Task ShowInformationMessageAsync(string message)

src/PowerShellEditorServices/Services/PowerShell/Host/PsesInternalHost.cs

@@ -306,12 +306,20 @@ public async Task<bool> TryStartAsync(HostStartOptions startOptions, Cancellatio
                 _logger.LogDebug("InitialWorkingDirectory set!");
             }
 
+            _logger.LogDebug("Setting profile variable...");
+            await SetProfileVariableAsync(cancellationToken).ConfigureAwait(false);
+            _logger.LogDebug("Profile variable set!");
+
             if (startOptions.LoadProfiles)
             {
                 _logger.LogDebug("Loading profiles...");
                 await LoadHostProfilesAsync(cancellationToken).ConfigureAwait(false);
                 _logger.LogDebug("Profiles loaded!");
             }
+            else
+            {
+                _logger.LogDebug("Profile loading skipped per configuration!");
+            }
 
             if (!string.IsNullOrEmpty(startOptions.ShellIntegrationScript))
             {
@@ -583,13 +591,35 @@ internal void DisableTranscribeOnly()
             }
         }
 
+        internal Task SetProfileVariableAsync(CancellationToken cancellationToken)
+        {
+            // If the CurrentUserCurrentHost profile is null then we cannot create the profile variable
+            if (_hostInfo.ProfilePaths.CurrentUserCurrentHost is null)
+            {
+                return Task.CompletedTask;
+            }
+
+            // NOTE: This is a special task run on startup!
+            return ExecuteDelegateAsync(
+            "SetProfileVariable",
+            executionOptions: null,
+            (pwsh, _) => pwsh.SetProfileVariable(_hostInfo.ProfilePaths),
+            cancellationToken);
+        }
+
         internal Task LoadHostProfilesAsync(CancellationToken cancellationToken)
         {
+            // If the CurrentUserCurrentHost profile is null then we cannot instantiate
+            if (_hostInfo.ProfilePaths.CurrentUserCurrentHost is null)
+            {
+                return Task.CompletedTask;
+            }
+
             // NOTE: This is a special task run on startup!
             return ExecuteDelegateAsync(
                 "LoadProfiles",
                 executionOptions: null,
-                (pwsh, _) => pwsh.LoadProfiles(_hostInfo.ProfilePaths),
+            (pwsh, _) => pwsh.LoadProfileScripts(_hostInfo.ProfilePaths),
                 cancellationToken);
         }
 
@@ -812,8 +842,9 @@ private void RunTopLevelExecutionLoop()
             {
                 // Make sure we execute any startup tasks first. These should be, in order:
                 // 1. Delegate to register psEditor variable
-                // 2. LoadProfiles delegate
-                // 3. Delegate to import PSEditModule
+                // 2. SetProfileVariable delegate
+                // 3. Optional LoadProfiles delegate
+                // 4. Delegate to import PSEditModule
                 while (_taskQueue.TryTake(out ISynchronousTask task))
                 {
                     task.ExecuteSynchronously(CancellationToken.None);

src/PowerShellEditorServices/Services/PowerShell/Utility/PowerShellExtensions.cs

@@ -1,6 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-
+#nullable enable
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
@@ -69,7 +69,7 @@ and not PSInvocationState.Failed
             pwsh.InvocationStateChanged += handler;
         }
 
-        public static Collection<TResult> InvokeAndClear<TResult>(this PowerShell pwsh, PSInvocationSettings invocationSettings = null)
+        public static Collection<TResult> InvokeAndClear<TResult>(this PowerShell pwsh, PSInvocationSettings? invocationSettings = null)
         {
             try
             {
@@ -81,7 +81,7 @@ public static Collection<TResult> InvokeAndClear<TResult>(this PowerShell pwsh,
             }
         }
 
-        public static void InvokeAndClear(this PowerShell pwsh, PSInvocationSettings invocationSettings = null)
+        public static void InvokeAndClear(this PowerShell pwsh, PSInvocationSettings? invocationSettings = null)
         {
             try
             {
@@ -93,13 +93,13 @@ public static void InvokeAndClear(this PowerShell pwsh, PSInvocationSettings inv
             }
         }
 
-        public static Collection<TResult> InvokeCommand<TResult>(this PowerShell pwsh, PSCommand psCommand, PSInvocationSettings invocationSettings = null)
+        public static Collection<TResult> InvokeCommand<TResult>(this PowerShell pwsh, PSCommand psCommand, PSInvocationSettings? invocationSettings = null)
         {
             pwsh.Commands = psCommand;
             return pwsh.InvokeAndClear<TResult>(invocationSettings);
         }
 
-        public static void InvokeCommand(this PowerShell pwsh, PSCommand psCommand, PSInvocationSettings invocationSettings = null)
+        public static void InvokeCommand(this PowerShell pwsh, PSCommand psCommand, PSInvocationSettings? invocationSettings = null)
         {
             pwsh.Commands = psCommand;
             pwsh.InvokeAndClear(invocationSettings);
@@ -193,7 +193,7 @@ public static void SetCorrectExecutionPolicy(this PowerShell pwsh, ILogger logge
             }
         }
 
-        public static void LoadProfiles(this PowerShell pwsh, ProfilePathInfo profilePaths)
+        public static void SetProfileVariable(this PowerShell pwsh, ProfilePathInfo profilePaths)
         {
             // Per the documentation, "the `$PROFILE` variable stores the path to the 'Current User,
             // Current Host' profile. The other profiles are saved in note properties of the
@@ -202,15 +202,24 @@ public static void LoadProfiles(this PowerShell pwsh, ProfilePathInfo profilePat
             // https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_profiles?view=powershell-7.1#the-profile-variable
             PSObject profileVariable = PSObject.AsPSObject(profilePaths.CurrentUserCurrentHost);
 
+            profileVariable.Members.Add(new PSNoteProperty(nameof(profilePaths.AllUsersAllHosts), profilePaths.AllUsersAllHosts));
+            profileVariable.Members.Add(new PSNoteProperty(nameof(profilePaths.AllUsersCurrentHost), profilePaths.AllUsersCurrentHost));
+            profileVariable.Members.Add(new PSNoteProperty(nameof(profilePaths.CurrentUserAllHosts), profilePaths.CurrentUserAllHosts));
+            profileVariable.Members.Add(new PSNoteProperty(nameof(profilePaths.CurrentUserCurrentHost), profilePaths.CurrentUserCurrentHost));
+
+            pwsh.Runspace.SessionStateProxy.SetVariable("PROFILE", profileVariable);
+        }
+
+        public static void LoadProfileScripts(this PowerShell pwsh, ProfilePathInfo profilePaths)
+        {
+            PSObject profileVariable = PSObject.AsPSObject(profilePaths.CurrentUserCurrentHost);
+
             PSCommand psCommand = new PSCommand()
                 .AddProfileLoadIfExists(profileVariable, nameof(profilePaths.AllUsersAllHosts), profilePaths.AllUsersAllHosts)
                 .AddProfileLoadIfExists(profileVariable, nameof(profilePaths.AllUsersCurrentHost), profilePaths.AllUsersCurrentHost)
                 .AddProfileLoadIfExists(profileVariable, nameof(profilePaths.CurrentUserAllHosts), profilePaths.CurrentUserAllHosts)
                 .AddProfileLoadIfExists(profileVariable, nameof(profilePaths.CurrentUserCurrentHost), profilePaths.CurrentUserCurrentHost);
 
-            // NOTE: This must be set before the profiles are loaded.
-            pwsh.Runspace.SessionStateProxy.SetVariable("PROFILE", profileVariable);
-
             // NOTE: Because it's possible there are no profiles defined, we might have an empty
             // command. Since this is being executed directly, we can't rely on `ThrowOnError =
             // false` to avoid an exception here. Instead, we must just not execute it.
@@ -253,7 +262,7 @@ private static StringBuilder AddErrorString(this StringBuilder sb, ErrorRecord e
                 .AppendLine("Exception:")
                 .Append("    ").Append(error.Exception.ToString() ?? "<null>");
 
-            Exception innerException = error.Exception?.InnerException;
+            Exception? innerException = error.Exception?.InnerException;
             while (innerException != null)
             {
                 sb.AppendLine("InnerException:")

src/PowerShellEditorServices/Services/TextDocument/Handlers/CompletionHandler.cs

@@ -366,7 +366,7 @@ private CompletionItem CreateProviderItemCompletion(
             if (textToBeReplaced.IndexOf(PSScriptRootVariable, StringComparison.OrdinalIgnoreCase) is int variableIndex and not -1
                 && System.IO.Path.GetDirectoryName(scriptFile.FilePath) is string scriptFolder and not ""
                 && completionText.IndexOf(scriptFolder, StringComparison.OrdinalIgnoreCase) is int pathIndex and not -1
-                && !scriptFile.IsInMemory)
+                && !scriptFile.IsUntitled)
             {
                 completionText = completionText
                     .Remove(pathIndex, scriptFolder.Length)

src/PowerShellEditorServices/Services/TextDocument/Handlers/TextDocumentHandler.cs

@@ -111,10 +111,11 @@ public override Task<Unit> Handle(DidCloseTextDocumentParams notification, Cance
             {
                 fileToClose.IsOpen = false;
 
-                // If the file watcher is supported, only close in-memory files when this
+                // If the file watcher is supported, only close non-file-backed documents when this
                 // notification is triggered. This lets us keep workspace files open so we can scan
                 // for references. When a file is deleted, the file watcher will close the file.
-                if (!_isFileWatcherSupported || fileToClose.IsInMemory)
+                bool isBackedByFile = !fileToClose.IsUntitled;
+                if (!_isFileWatcherSupported || !isBackedByFile)
                 {
                     _workspaceService.CloseFile(fileToClose);
                 }
@@ -132,6 +133,9 @@ public override async Task<Unit> Handle(DidSaveTextDocumentParams notification,
 
             if (savedFile != null)
             {
+                // On a save, untitled files will remain in memory, so this won't change for those
+                savedFile.IsInMemory = savedFile.IsUntitled;
+
                 if (_remoteFileManagerService.IsUnderRemoteTempPath(savedFile.FilePath))
                 {
                     await _remoteFileManagerService.SaveRemoteFileAsync(savedFile.FilePath).ConfigureAwait(false);