Fixup Open/Unsaved file identification

Author: JustinGrote

src/PowerShellEditorServices/Services/Extension/EditorOperationsService.cs

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

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 = notification.TextDocument.Uri.ToUri().IsFile;
+                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);

src/PowerShellEditorServices/Services/TextDocument/ScriptFile.cs

@@ -51,9 +51,14 @@ internal sealed class ScriptFile
 
         /// <summary>
         /// Gets a boolean that determines whether this file is
-        /// in-memory or not (either unsaved or non-file content).
+        /// in-memory or not (either unsaved or non-file content) aka "dirty"
         /// </summary>
-        public bool IsInMemory { get; }
+        public bool IsInMemory { get; internal set; }
+
+        /// <summary>
+        /// Getter that returns if the document is not backed by a saved file path (not in-memory).
+        /// </summary>
+        public bool IsUntitled => !DocumentUri?.ToUri().IsFile ?? false;
 
         /// <summary>
         /// Gets a string containing the full contents of the file.
@@ -127,11 +132,15 @@ internal ScriptFile(
             // so that other operations know it's untitled/in-memory
             // and don't think that it's a relative path
             // on the file system.
-            IsInMemory = !docUri.ToUri().IsFile;
+            DocumentUri = docUri;
+
+            // Initial state of document. Untitled files are in memory by definition, otherwise files start non-dirty on a filesystem
+            IsInMemory = IsUntitled;
+
             FilePath = IsInMemory
                 ? docUri.ToString()
                 : docUri.GetFileSystemPath();
-            DocumentUri = docUri;
+
             IsAnalysisEnabled = true;
             this.powerShellVersion = powerShellVersion;
 
@@ -365,6 +374,9 @@ public void ApplyChange(FileChange fileChange)
             // Parse the script again to be up-to-date
             ParseFileContents();
             References.TagAsChanged();
+
+            // Flag the script as modified
+            IsInMemory = true;
         }
 
         /// <summary>

test/PowerShellEditorServices.Test/Extensions/EditorOperationsServiceTests.cs

@@ -0,0 +1,55 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System;
+using System.IO;
+using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.PowerShell.EditorServices.Extensions;
+using Microsoft.PowerShell.EditorServices.Services;
+using Microsoft.PowerShell.EditorServices.Services.Extension;
+using Microsoft.PowerShell.EditorServices.Services.TextDocument;
+using OmniSharp.Extensions.LanguageServer.Protocol;
+using Xunit;
+
+namespace PowerShellEditorServices.Test.Extensions
+{
+	[Trait("Category", "Extensions")]
+	public class EditorOperationsServiceTests
+	{
+		[Fact]
+		public void GetWorkspaceOpenDocumentsReturnsOnlyOpenDocumentsAndCurrentInMemoryState()
+		{
+			WorkspaceService workspaceService = new(NullLoggerFactory.Instance);
+
+			ScriptFile openSaved = CreateFileBuffer(workspaceService, "open-saved.ps1");
+			openSaved.IsOpen = true;
+			openSaved.IsInMemory = false;
+
+			ScriptFile openUnsaved = CreateFileBuffer(workspaceService, "open-unsaved.ps1");
+			openUnsaved.IsOpen = true;
+			openUnsaved.IsInMemory = true;
+
+			ScriptFile closed = CreateFileBuffer(workspaceService, "closed.ps1");
+			closed.IsOpen = false;
+			closed.IsInMemory = false;
+
+			EditorOperationsService editorOperationsService = new(
+					psesHost: null,
+					workspaceService,
+					languageServer: null);
+
+			WorkspaceOpenDocument[] documents = editorOperationsService.GetWorkspaceOpenDocuments();
+
+			Assert.Equal(2, documents.Length);
+			Assert.Contains(documents, static document => document.Path.EndsWith("open-saved.ps1") && document.Saved);
+			Assert.Contains(documents, static document => document.Path.EndsWith("open-unsaved.ps1") && !document.Saved);
+			Assert.DoesNotContain(documents, static document => document.Path.EndsWith("closed.ps1"));
+		}
+
+		private static ScriptFile CreateFileBuffer(WorkspaceService workspaceService, string fileName)
+		{
+			string filePath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString("N"), fileName);
+			return workspaceService.GetFileBuffer(DocumentUri.FromFileSystemPath(filePath), initialBuffer: string.Empty);
+		}
+	}
+}