Fix disco colors when modifying documents during project load (#10354)

Fixes an issue Andrew found in speedometer tests. When opening files and
modifying them, before we migrate the document to the "real" project,
things get out of sync.

Also matches some stacks on PRISM, but I think this bug was only
introduced in the last two weeks, so I don't think its the only cause
thats for sure.

Author: davidwengier

src/Razor/src/Microsoft.AspNetCore.Razor.LanguageServer/ProjectSystem/RazorProjectService.cs

@@ -391,10 +391,15 @@ private void UpdateProjectDocuments(
 
             _logger.LogTrace($"Updating document '{newHostDocument.FilePath}''s file kind to '{newHostDocument.FileKind}' and target path to '{newHostDocument.TargetPath}'.");
 
-            var remoteTextLoader = _remoteTextLoaderFactory.Create(newFilePath);
+            // If the physical file name hasn't changed, we use the current document snapshot as the source of truth for text, in case
+            // it has received text change info from LSP. eg, if someone changes the TargetPath of the file while its open in the editor
+            // with unsaved changes, we don't want to reload it from disk.
+            var textLoader = FilePathComparer.Instance.Equals(currentHostDocument.FilePath, newHostDocument.FilePath)
+                ? new DocumentSnapshotTextLoader(documentSnapshot)
+                : _remoteTextLoaderFactory.Create(newFilePath);
 
             updater.DocumentRemoved(currentProjectKey, currentHostDocument);
-            updater.DocumentAdded(currentProjectKey, newHostDocument, remoteTextLoader);
+            updater.DocumentAdded(currentProjectKey, newHostDocument, textLoader);
         }
 
         project = _projectManager.GetLoadedProject(project.Key);
@@ -493,18 +498,27 @@ private void TryMigrateMiscellaneousDocumentsToProject(ProjectSnapshotManager.Up
             }
 
             // Remove from miscellaneous project
-            var defaultMiscProject = miscellaneousProject;
-
-            updater.DocumentRemoved(defaultMiscProject.Key, documentSnapshot.State.HostDocument);
+            updater.DocumentRemoved(miscellaneousProject.Key, documentSnapshot.State.HostDocument);
 
             // Add to new project
 
             var textLoader = new DocumentSnapshotTextLoader(documentSnapshot);
-            var defaultProject = projectSnapshot;
-            var newHostDocument = new HostDocument(documentSnapshot.FilePath, documentSnapshot.TargetPath);
+
+            // If we're moving from the misc files project to a real project, then target path will be the full path to the file
+            // and the next update to the project will update it to be a relative path. To save a bunch of busy work if that is
+            // the only change necessary, we can proactively do that work here. This also means that when we later find out about
+            // this document the "real" way, it will be equal to the one we already know about, and we won't lose content
+            var projectDirectory = FilePathNormalizer.GetNormalizedDirectoryName(projectSnapshot.FilePath);
+            var newTargetPath = documentSnapshot.TargetPath;
+            if (FilePathNormalizer.Normalize(newTargetPath).StartsWith(projectDirectory))
+            {
+                newTargetPath = newTargetPath[projectDirectory.Length..];
+            }
+
+            var newHostDocument = new HostDocument(documentSnapshot.FilePath, newTargetPath, documentSnapshot.FileKind);
             _logger.LogInformation($"Migrating '{documentFilePath}' from the '{miscellaneousProject.Key}' project to '{projectSnapshot.Key}' project.");
 
-            updater.DocumentAdded(defaultProject.Key, newHostDocument, textLoader);
+            updater.DocumentAdded(projectSnapshot.Key, newHostDocument, textLoader);
         }
     }
 

src/Razor/test/Microsoft.AspNetCore.Razor.LanguageServer.Test/RazorProjectServiceTest.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT license. See License.txt in the project root for license information.
 
 using System;
+using System.Collections.Immutable;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -1137,13 +1138,77 @@ await _projectManager.UpdateAsync(updater =>
             x => x.DocumentRemoved(DocumentFilePath2, miscProject.Key));
     }
 
-    private static TextLoader CreateEmptyTextLoader()
+    [Fact]
+    public async Task AddProject_MigratesMiscellaneousDocumentsToNewOwnerProject_FixesTargetPath()
+    {
+        // Arrange
+        const string ProjectFilePath = "C:/path/to/project.csproj";
+        const string IntermediateOutputPath = "C:/path/to/obj";
+        const string DocumentFilePath1 = "C:/path/to/document1.cshtml";
+        const string DocumentFilePath2 = "C:/path/to/document2.cshtml";
+
+        var miscProject = _snapshotResolver.GetMiscellaneousProject();
+
+        await _projectManager.UpdateAsync(updater =>
+        {
+            updater.DocumentAdded(miscProject.Key,
+                new HostDocument(DocumentFilePath1, "C:/path/to/document1.cshtml"), CreateEmptyTextLoader());
+            updater.DocumentAdded(miscProject.Key,
+                new HostDocument(DocumentFilePath2, "C:/path/to/document2.cshtml"), CreateEmptyTextLoader());
+        });
+
+        // Act
+        var newProjectKey = await _projectService.AddProjectAsync(
+            ProjectFilePath, IntermediateOutputPath, RazorConfiguration.Default, rootNamespace: null, displayName: null, DisposalToken);
+
+        // Assert
+        var newProject = _projectManager.GetLoadedProject(newProjectKey);
+        Assert.Equal("document1.cshtml", newProject.GetDocument(DocumentFilePath1)!.TargetPath);
+        Assert.Equal("document2.cshtml", newProject.GetDocument(DocumentFilePath2)!.TargetPath);
+    }
+
+    [Fact]
+    public async Task AddOrUpdateProjectAsync_MigratesMiscellaneousDocumentsToNewOwnerProject_MaintainsTextState()
+    {
+        // Arrange
+        const string ProjectFilePath = "C:/path/to/project.csproj";
+        const string IntermediateOutputPath = "C:/path/to/obj";
+        const string DocumentFilePath1 = "C:/path/to/document1.cshtml";
+
+        var miscProject = _snapshotResolver.GetMiscellaneousProject();
+
+        await _projectManager.UpdateAsync(updater =>
+        {
+            updater.DocumentAdded(miscProject.Key,
+                new HostDocument(DocumentFilePath1, "other/document1.cshtml"), CreateTextLoader(SourceText.From("Hello")));
+        });
+
+        var projectKey = new ProjectKey(IntermediateOutputPath);
+
+        var documentHandles = ImmutableArray.Create(new DocumentSnapshotHandle(DocumentFilePath1, "document1.cshtml", "mvc"));
+
+        // Act
+        await _projectService.AddOrUpdateProjectAsync(
+            projectKey, ProjectFilePath, RazorConfiguration.Default, rootNamespace: null, displayName: null, ProjectWorkspaceState.Default, documentHandles, DisposalToken);
+
+        // Assert
+        var newProject = _projectManager.GetLoadedProject(projectKey);
+        var documentText = await newProject.GetDocument(DocumentFilePath1)!.GetTextAsync();
+        Assert.Equal("Hello", documentText.ToString());
+    }
+
+    private static TextLoader CreateTextLoader(SourceText text)
     {
         var textLoaderMock = new StrictMock<TextLoader>();
         textLoaderMock
             .Setup(x => x.LoadTextAndVersionAsync(It.IsAny<LoadTextOptions>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(TextAndVersion.Create(s_emptyText, VersionStamp.Create()));
+            .ReturnsAsync(TextAndVersion.Create(text, VersionStamp.Create()));
 
         return textLoaderMock.Object;
     }
+
+    private static TextLoader CreateEmptyTextLoader()
+    {
+        return CreateTextLoader(s_emptyText);
+    }
 }