Avoid operations on disposed workspace (#42768)

src/EditorFeatures/TestUtilities/LanguageServer/AbstractLanguageServerProtocolTests.cs

@@ -18,6 +18,7 @@
 using Microsoft.CodeAnalysis.LanguageServer.Handler.Commands;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.CodeAnalysis.Text;
+using Microsoft.CodeAnalysis.UnitTests;
 using Microsoft.VisualStudio.Composition;
 using Microsoft.VisualStudio.Text.Adornments;
 using Newtonsoft.Json;
@@ -178,8 +179,8 @@ private protected static RunCodeActionParams CreateRunCodeActionParams(string co
         /// Creates a solution with a document.
         /// </summary>
         /// <returns>the solution and the annotated ranges in the document.</returns>
-        protected (Solution solution, Dictionary<string, IList<LSP.Location>> locations) CreateTestSolution(string markup)
-            => CreateTestSolution(new string[] { markup });
+        protected Workspace CreateTestWorkspace(string markup, out Dictionary<string, IList<LSP.Location>> locations)
+            => CreateTestWorkspace(new string[] { markup }, out locations);
 
         /// <summary>
         /// Create a solution with multiple documents.
@@ -187,29 +188,29 @@ private protected static RunCodeActionParams CreateRunCodeActionParams(string co
         /// <returns>
         /// the solution with the documents plus a list for each document of all annotated ranges in the document.
         /// </returns>
-        protected (Solution solution, Dictionary<string, IList<LSP.Location>> locations) CreateTestSolution(string[] markups)
+        protected Workspace CreateTestWorkspace(string[] markups, out Dictionary<string, IList<LSP.Location>> locations)
         {
-            using var workspace = TestWorkspace.CreateCSharp(markups, exportProvider: GetExportProvider());
+            var workspace = TestWorkspace.CreateCSharp(markups, exportProvider: GetExportProvider());
             var solution = workspace.CurrentSolution;
-            var locations = new Dictionary<string, IList<LSP.Location>>();
+            locations = new Dictionary<string, IList<LSP.Location>>();
 
             foreach (var document in workspace.Documents)
             {
                 var text = solution.GetDocument(document.Id).GetTextSynchronously(CancellationToken.None);
-                foreach (var kvp in document.AnnotatedSpans)
+                foreach (var (name, spans) in document.AnnotatedSpans)
                 {
-                    locations.GetOrAdd(kvp.Key, CreateLocation)
-                        .AddRange(kvp.Value.Select(s => ProtocolConversions.TextSpanToLocation(s, text, new Uri(GetDocumentFilePathFromName(document.Name)))));
+                    locations
+                        .GetOrAdd(name, _ => new List<LSP.Location>())
+                        .AddRange(spans.Select(span => ProtocolConversions.TextSpanToLocation(span, text, new Uri(GetDocumentFilePathFromName(document.Name)))));
                 }
 
                 // Pass in the text without markup.
-                workspace.ChangeSolution(ChangeDocumentFilePathToValidURI(workspace.CurrentSolution, document, text));
+                solution = ChangeDocumentFilePathToValidURI(solution, document, text);
             }
 
-            return (workspace.CurrentSolution, locations);
+            workspace.ChangeSolution(solution);
 
-            // local functions
-            static List<LSP.Location> CreateLocation(string s) => new List<LSP.Location>();
+            return workspace;
         }
 
         // Private protected because LanguageServerProtocol is internal
@@ -227,15 +228,15 @@ private static string GetDocumentFilePathFromName(string documentName)
         /// Adds/Removes the document instead of updating file path due to
         /// https://github.com/dotnet/roslyn/issues/34837
         /// </summary>
-        private static Solution ChangeDocumentFilePathToValidURI(Solution originalSolution, TestHostDocument originalDocument, SourceText text)
+        private static Solution ChangeDocumentFilePathToValidURI(Solution solution, TestHostDocument document, SourceText text)
         {
-            var documentName = originalDocument.Name;
+            var documentId = document.Id;
+            var documentName = document.Name;
             var documentPath = GetDocumentFilePathFromName(documentName);
 
-            var solution = originalSolution.RemoveDocument(originalDocument.Id);
-
-            var newDocumentId = DocumentId.CreateNewId(originalDocument.Project.Id);
-            return solution.AddDocument(newDocumentId, documentName, text, filePath: documentPath);
+            return solution
+                .RemoveDocument(documentId)
+                .AddDocument(documentId, documentName, text, filePath: documentPath);
         }
     }
 }

src/Features/LanguageServer/ProtocolUnitTests/CodeActions/CodeActionsTests.cs

@@ -26,11 +26,11 @@ void M()
         {|caret:|}int i = 1;
     }
 }";
-            var (solution, locations) = CreateTestSolution(markup);
+            using var workspace = CreateTestWorkspace(markup, out var locations);
             var expected = CreateCommand(CSharpAnalyzersResources.Use_implicit_type, locations["caret"].Single());
             var clientCapabilities = CreateClientCapabilitiesWithExperimentalValue("supportsWorkspaceEdits", JToken.FromObject(false));
 
-            var results = await RunGetCodeActionsAsync(solution, locations["caret"].Single(), clientCapabilities);
+            var results = await RunGetCodeActionsAsync(workspace.CurrentSolution, locations["caret"].Single(), clientCapabilities);
             var useImplicitTypeResult = results.Single(r => r.Title == CSharpAnalyzersResources.Use_implicit_type);
             AssertJsonEquals(expected, useImplicitTypeResult);
         }

src/Features/LanguageServer/ProtocolUnitTests/Completion/CompletionResolveTests.cs

@@ -25,7 +25,7 @@ void M()
         {|caret:|}
     }
 }";
-            var (solution, locations) = CreateTestSolution(markup);
+            using var workspace = CreateTestWorkspace(markup, out var locations);
             var tags = new string[] { "Class", "Internal" };
             var completionParams = CreateCompletionParams(locations["caret"].Single());
             var completionItem = CreateCompletionItem("A", LSP.CompletionItemKind.Class, tags, completionParams);
@@ -34,7 +34,7 @@ void M()
 
             var expected = CreateResolvedCompletionItem("A", LSP.CompletionItemKind.Class, null, completionParams, description, "class A", null);
 
-            var results = (LSP.VSCompletionItem)await RunResolveCompletionItemAsync(solution, completionItem, clientCapabilities);
+            var results = (LSP.VSCompletionItem)await RunResolveCompletionItemAsync(workspace.CurrentSolution, completionItem, clientCapabilities);
             AssertJsonEquals(expected, results);
         }
 

src/Features/LanguageServer/ProtocolUnitTests/Completion/CompletionTests.cs

@@ -25,11 +25,11 @@ void M()
         {|caret:|}
     }
 }";
-            var (solution, locations) = CreateTestSolution(markup);
+            using var workspace = CreateTestWorkspace(markup, out var locations);
             var expected = CreateCompletionItem("A", LSP.CompletionItemKind.Class, new string[] { "Class", "Internal" }, CreateCompletionParams(locations["caret"].Single()));
             var clientCapabilities = new LSP.VSClientCapabilities { SupportsVisualStudioExtensions = true };
 
-            var results = (LSP.CompletionItem[])await RunGetCompletionsAsync(solution, locations["caret"].Single(), clientCapabilities);
+            var results = (LSP.CompletionItem[])await RunGetCompletionsAsync(workspace.CurrentSolution, locations["caret"].Single(), clientCapabilities);
             AssertJsonEquals(expected, results.First());
         }
 
@@ -44,7 +44,8 @@ void M()
         {|caret:|}
     }
 }";
-            var (solution, locations) = CreateTestSolution(markup);
+            using var workspace = CreateTestWorkspace(markup, out var locations);
+            var solution = workspace.CurrentSolution;
 
             // Make sure the unimported types option is on by default.
             solution = solution.WithOptions(solution.Options

src/Features/LanguageServer/ProtocolUnitTests/Definitions/GoToDefinitionTests.cs

@@ -25,9 +25,9 @@ void M()
         var len = {|caret:|}aString.Length;
     }
 }";
-            var (solution, locations) = CreateTestSolution(markup);
+            using var workspace = CreateTestWorkspace(markup, out var locations);
 
-            var results = await RunGotoDefinitionAsync(solution, locations["caret"].Single());
+            var results = await RunGotoDefinitionAsync(workspace.CurrentSolution, locations["caret"].Single());
             AssertLocationsEqual(locations["definition"], results);
         }
 
@@ -51,9 +51,10 @@ class B
     }
 }"
             };
-            var (solution, locations) = CreateTestSolution(markups);
 
-            var results = await RunGotoDefinitionAsync(solution, locations["caret"].Single());
+            using var workspace = CreateTestWorkspace(markups, out var locations);
+
+            var results = await RunGotoDefinitionAsync(workspace.CurrentSolution, locations["caret"].Single());
             AssertLocationsEqual(locations["definition"], results);
         }
 
@@ -68,9 +69,9 @@ void M()
         var len = aString.Length;
     }
 }";
-            var (solution, locations) = CreateTestSolution(markup);
+            using var workspace = CreateTestWorkspace(markup, out var locations);
 
-            var results = await RunGotoDefinitionAsync(solution, locations["caret"].Single());
+            var results = await RunGotoDefinitionAsync(workspace.CurrentSolution, locations["caret"].Single());
             Assert.Empty(results);
         }
 

src/Features/LanguageServer/ProtocolUnitTests/Definitions/GoToTypeDefinitionTests.cs

@@ -24,9 +24,9 @@ class B
 {
     {|caret:|}A classA;
 }";
-            var (solution, locations) = CreateTestSolution(markup);
+            using var workspace = CreateTestWorkspace(markup, out var locations);
 
-            var results = await RunGotoTypeDefinitionAsync(solution, locations["caret"].Single());
+            var results = await RunGotoTypeDefinitionAsync(workspace.CurrentSolution, locations["caret"].Single());
             AssertLocationsEqual(locations["definition"], results);
         }
 
@@ -49,9 +49,10 @@ class B
     }
 }"
             };
-            var (solution, locations) = CreateTestSolution(markups);
 
-            var results = await RunGotoTypeDefinitionAsync(solution, locations["caret"].Single());
+            using var workspace = CreateTestWorkspace(markups, out var locations);
+
+            var results = await RunGotoTypeDefinitionAsync(workspace.CurrentSolution, locations["caret"].Single());
             AssertLocationsEqual(locations["definition"], results);
         }
 
@@ -67,9 +68,9 @@ class B
     A classA;
     {|caret:|}
 }";
-            var (solution, locations) = CreateTestSolution(markup);
+            using var workspace = CreateTestWorkspace(markup, out var locations);
 
-            var results = await RunGotoTypeDefinitionAsync(solution, locations["caret"].Single());
+            var results = await RunGotoTypeDefinitionAsync(workspace.CurrentSolution, locations["caret"].Single());
             Assert.Empty(results);
         }
 

src/Features/LanguageServer/ProtocolUnitTests/FoldingRanges/FoldingRangesTests.cs

@@ -20,12 +20,12 @@ public async Task TestGetFoldingRangeAsync_Imports()
             var markup =
 @"using {|foldingRange:System;
 using System.Linq;|}";
-            var (solution, locations) = CreateTestSolution(markup);
+            using var workspace = CreateTestWorkspace(markup, out var locations);
             var expected = locations["foldingRange"]
                 .Select(location => CreateFoldingRange(LSP.FoldingRangeKind.Imports, location.Range))
                 .ToArray();
 
-            var results = await RunGetFoldingRangeAsync(solution);
+            var results = await RunGetFoldingRangeAsync(workspace.CurrentSolution);
             AssertJsonEquals(expected, results);
         }
 
@@ -36,12 +36,12 @@ public async Task TestGetFoldingRangeAsync_Comments()
 @"{|foldingRange:// A comment|}
 {|foldingRange:/* A multiline
 comment */|}";
-            var (solution, locations) = CreateTestSolution(markup);
+            using var workspace = CreateTestWorkspace(markup, out var locations);
             var expected = locations["foldingRange"]
                 .Select(location => CreateFoldingRange(LSP.FoldingRangeKind.Comment, location.Range))
                 .ToArray();
 
-            var results = await RunGetFoldingRangeAsync(solution);
+            var results = await RunGetFoldingRangeAsync(workspace.CurrentSolution);
             AssertJsonEquals(expected, results);
         }
 
@@ -52,12 +52,12 @@ public async Task TestGetFoldingRangeAsync_Regions()
 @"{|foldingRange:#region ARegion
 #endregion|}
 }";
-            var (solution, locations) = CreateTestSolution(markup);
+            using var workspace = CreateTestWorkspace(markup, out var locations);
             var expected = locations["foldingRange"]
                 .Select(location => CreateFoldingRange(LSP.FoldingRangeKind.Region, location.Range))
                 .ToArray();
 
-            var results = await RunGetFoldingRangeAsync(solution);
+            var results = await RunGetFoldingRangeAsync(workspace.CurrentSolution);
             AssertJsonEquals(expected, results);
         }
 

src/Features/LanguageServer/ProtocolUnitTests/Formatting/FormatDocumentOnTypeTests.cs

@@ -34,12 +34,12 @@ void M()
         {
     }
 }";
-            var (solution, locations) = CreateTestSolution(markup);
+            using var workspace = CreateTestWorkspace(markup, out var locations);
             var characterTyped = ";";
             var locationTyped = locations["type"].Single();
-            var documentText = await solution.GetDocumentFromURI(locationTyped.Uri).GetTextAsync();
+            var documentText = await workspace.CurrentSolution.GetDocumentFromURI(locationTyped.Uri).GetTextAsync();
 
-            var results = await RunFormatDocumentOnTypeAsync(solution, characterTyped, locationTyped);
+            var results = await RunFormatDocumentOnTypeAsync(workspace.CurrentSolution, characterTyped, locationTyped);
             var actualText = ApplyTextEdits(results, documentText);
             Assert.Equal(expected, actualText);
         }

src/Features/LanguageServer/ProtocolUnitTests/Formatting/FormatDocumentRangeTests.cs

@@ -32,11 +32,11 @@ void M()
             int i = 1;
     }
 }";
-            var (solution, locations) = CreateTestSolution(markup);
+            using var workspace = CreateTestWorkspace(markup, out var locations);
             var rangeToFormat = locations["format"].Single();
-            var documentText = await solution.GetDocumentFromURI(rangeToFormat.Uri).GetTextAsync();
+            var documentText = await workspace.CurrentSolution.GetDocumentFromURI(rangeToFormat.Uri).GetTextAsync();
 
-            var results = await RunFormatDocumentRangeAsync(solution, rangeToFormat);
+            var results = await RunFormatDocumentRangeAsync(workspace.CurrentSolution, rangeToFormat);
             var actualText = ApplyTextEdits(results, documentText);
             Assert.Equal(expected, actualText);
         }

src/Features/LanguageServer/ProtocolUnitTests/Formatting/FormatDocumentTests.cs

@@ -34,11 +34,11 @@ void M()
         int i = 1;
     }
 }";
-            var (solution, locations) = CreateTestSolution(markup);
+            using var workspace = CreateTestWorkspace(markup, out var locations);
             var documentURI = locations["caret"].Single().Uri;
-            var documentText = await solution.GetDocumentFromURI(documentURI).GetTextAsync();
+            var documentText = await workspace.CurrentSolution.GetDocumentFromURI(documentURI).GetTextAsync();
 
-            var results = await RunFormatDocumentAsync(solution, documentURI);
+            var results = await RunFormatDocumentAsync(workspace.CurrentSolution, documentURI);
             var actualText = ApplyTextEdits(results, documentText);
             Assert.Equal(expected, actualText);
         }

src/Features/LanguageServer/ProtocolUnitTests/Highlights/DocumentHighlightTests.cs

@@ -31,7 +31,7 @@ void M()
         {|caret:|}{|write:classB|} = new B();
     }
 }";
-            var (solution, locations) = CreateTestSolution(markup);
+            using var workspace = CreateTestWorkspace(markup, out var locations);
             var expected = new LSP.DocumentHighlight[]
             {
                 CreateDocumentHighlight(LSP.DocumentHighlightKind.Text, locations["text"].Single()),
@@ -39,7 +39,7 @@ void M()
                 CreateDocumentHighlight(LSP.DocumentHighlightKind.Write, locations["write"].Single())
             };
 
-            var results = await RunGetDocumentHighlightAsync(solution, locations["caret"].Single());
+            var results = await RunGetDocumentHighlightAsync(workspace.CurrentSolution, locations["caret"].Single());
             AssertJsonEquals(expected, results);
         }
 
@@ -54,9 +54,9 @@ void M()
         {|caret:|}
     }
 }";
-            var (solution, locations) = CreateTestSolution(markup);
+            using var workspace = CreateTestWorkspace(markup, out var locations);
 
-            var results = await RunGetDocumentHighlightAsync(solution, locations["caret"].Single());
+            var results = await RunGetDocumentHighlightAsync(workspace.CurrentSolution, locations["caret"].Single());
             Assert.Empty(results);
         }
 

src/Features/LanguageServer/ProtocolUnitTests/Hover/HoverTests.cs

@@ -28,11 +28,11 @@ public async Task TestGetHoverAsync()
     {
     }
 }";
-            var (solution, locations) = CreateTestSolution(markup);
+            using var workspace = CreateTestWorkspace(markup, out var locations);
             var expectedLocation = locations["caret"].Single();
             var expected = CreateHover(expectedLocation, "string A.Method(int i)\r\n> A great method");
 
-            var results = await RunGetHoverAsync(solution, expectedLocation).ConfigureAwait(false);
+            var results = await RunGetHoverAsync(workspace.CurrentSolution, expectedLocation).ConfigureAwait(false);
             AssertJsonEquals(expected, results);
         }
 
@@ -52,9 +52,9 @@ private string Method(int i)
         {|caret:|}
     }
 }";
-            var (solution, locations) = CreateTestSolution(markup);
+            using var workspace = CreateTestWorkspace(markup, out var locations);
 
-            var results = await RunGetHoverAsync(solution, locations["caret"].Single()).ConfigureAwait(false);
+            var results = await RunGetHoverAsync(workspace.CurrentSolution, locations["caret"].Single()).ConfigureAwait(false);
             Assert.Null(results);
         }
 

src/Features/LanguageServer/ProtocolUnitTests/Initialize/InitializeTests.cs

@@ -16,8 +16,8 @@ public class InitializeTests : AbstractLanguageServerProtocolTests
         [Fact]
         public async Task TestInitializeAsync()
         {
-            var (solution, _) = CreateTestSolution(string.Empty);
-            var results = await RunInitializeAsync(solution, new LSP.InitializeParams());
+            using var worksapce = CreateTestWorkspace(string.Empty, out var _);
+            var results = await RunInitializeAsync(worksapce.CurrentSolution, new LSP.InitializeParams());
 
             AssertServerCapabilities(results.Capabilities);
         }

src/Features/LanguageServer/ProtocolUnitTests/References/FindImplementationsTests.cs

@@ -27,9 +27,9 @@ class A : IA
     {
     }
 }";
-            var (solution, locations) = CreateTestSolution(markup);
+            using var workspace = CreateTestWorkspace(markup, out var locations);
 
-            var results = await RunFindImplementationAsync(solution, locations["caret"].Single());
+            var results = await RunFindImplementationAsync(workspace.CurrentSolution, locations["caret"].Single());
             AssertLocationsEqual(locations["implementation"], results);
         }
 
@@ -55,9 +55,10 @@ class A : IA
     }
 }"
             };
-            var (solution, locations) = CreateTestSolution(markups);
 
-            var results = await RunFindImplementationAsync(solution, locations["caret"].Single());
+            using var workspace = CreateTestWorkspace(markups, out var locations);
+
+            var results = await RunFindImplementationAsync(workspace.CurrentSolution, locations["caret"].Single());
             AssertLocationsEqual(locations["implementation"], results);
         }
 
@@ -72,9 +73,9 @@ void M()
         {|caret:|}
     }
 }";
-            var (solution, locations) = CreateTestSolution(markup);
+            using var workspace = CreateTestWorkspace(markup, out var locations);
 
-            var results = await RunFindImplementationAsync(solution, locations["caret"].Single());
+            var results = await RunFindImplementationAsync(workspace.CurrentSolution, locations["caret"].Single());
             Assert.Empty(results);
         }
 

src/Features/LanguageServer/ProtocolUnitTests/Rename/RenameTests.cs

@@ -27,12 +27,12 @@ void M2()
         {|renamed:M|}()
     }
 }";
-            var (solution, ranges) = CreateTestSolution(markup);
-            var renameLocation = ranges["caret"].First();
+            using var workspace = CreateTestWorkspace(markup, out var locations);
+            var renameLocation = locations["caret"].First();
             var renameValue = "RENAME";
-            var expectedEdits = ranges["renamed"].Select(location => new LSP.TextEdit() { NewText = renameValue, Range = location.Range });
+            var expectedEdits = locations["renamed"].Select(location => new LSP.TextEdit() { NewText = renameValue, Range = location.Range });
 
-            var results = await RunRenameAsync(solution, renameLocation, renameValue);
+            var results = await RunRenameAsync(workspace.CurrentSolution, renameLocation, renameValue);
             AssertJsonEquals(expectedEdits, results.DocumentChanges.First().Edits);
         }
 

src/Features/LanguageServer/ProtocolUnitTests/SignatureHelp/SignatureHelpTests.cs

@@ -32,7 +32,7 @@ int M2(string a)
     }
 
 }";
-            var (solution, locations) = CreateTestSolution(markup);
+            using var workspace = CreateTestWorkspace(markup, out var locations);
             var expected = new LSP.SignatureHelp()
             {
                 ActiveParameter = 0,
@@ -40,7 +40,7 @@ int M2(string a)
                 Signatures = new LSP.SignatureInformation[] { CreateSignatureInformation("int A.M2(string a)", "M2 is a method.", "a", "") }
             };
 
-            var results = await RunGetSignatureHelpAsync(solution, locations["caret"].Single());
+            var results = await RunGetSignatureHelpAsync(workspace.CurrentSolution, locations["caret"].Single());
             AssertJsonEquals(expected, results);
         }
 

src/Features/LanguageServer/ProtocolUnitTests/Symbols/DocumentSymbolsTests.cs

@@ -24,14 +24,14 @@ public async Task TestGetDocumentSymbolsAsync()
     {
     }|}
 }|}";
-            var (solution, locations) = CreateTestSolution(markup);
+            using var workspace = CreateTestWorkspace(markup, out var locations);
             var expected = new LSP.DocumentSymbol[]
             {
                 CreateDocumentSymbol(LSP.SymbolKind.Class, "A", "A", locations["class"].Single(), locations["classSelection"].Single())
             };
             CreateDocumentSymbol(LSP.SymbolKind.Method, "M", "M()", locations["method"].Single(), locations["methodSelection"].Single(), expected.First());
 
-            var results = await RunGetDocumentSymbolsAsync(solution, true);
+            var results = await RunGetDocumentSymbolsAsync(workspace.CurrentSolution, true);
             AssertJsonEquals(expected, results);
         }
 
@@ -45,14 +45,14 @@ public async Task TestGetDocumentSymbolsAsync__WithoutHierarchicalSupport()
     {
     }
 }";
-            var (solution, locations) = CreateTestSolution(markup);
+            using var workspace = CreateTestWorkspace(markup, out var locations);
             var expected = new LSP.SymbolInformation[]
             {
                 CreateSymbolInformation(LSP.SymbolKind.Class, "A", locations["class"].Single()),
                 CreateSymbolInformation(LSP.SymbolKind.Method, "M()", locations["method"].Single(), "A")
             };
 
-            var results = await RunGetDocumentSymbolsAsync(solution, false);
+            var results = await RunGetDocumentSymbolsAsync(workspace.CurrentSolution, false);
             AssertJsonEquals(expected, results);
         }
 
@@ -69,17 +69,17 @@ void Method()
         int i = 1;
     }
 }";
-            var (solution, _) = CreateTestSolution(markup);
-            var results = await RunGetDocumentSymbolsAsync(solution, false).ConfigureAwait(false);
+            using var workspace = CreateTestWorkspace(markup, out var _);
+            var results = await RunGetDocumentSymbolsAsync(workspace.CurrentSolution, false).ConfigureAwait(false);
             Assert.Equal(3, results.Length);
         }
 
         [Fact]
         public async Task TestGetDocumentSymbolsAsync__NoSymbols()
         {
-            var (solution, _) = CreateTestSolution(string.Empty);
+            using var workspace = CreateTestWorkspace(string.Empty, out var _);
 
-            var results = await RunGetDocumentSymbolsAsync(solution, true);
+            var results = await RunGetDocumentSymbolsAsync(workspace.CurrentSolution, true);
             Assert.Empty(results);
         }
 

src/Features/LanguageServer/ProtocolUnitTests/Symbols/WorkspaceSymbolsTests.cs

@@ -23,13 +23,13 @@ void M()
     {
     }
 }";
-            var (solution, locations) = CreateTestSolution(markup);
+            using var workspace = CreateTestWorkspace(markup, out var locations);
             var expected = new LSP.SymbolInformation[]
             {
                 CreateSymbolInformation(LSP.SymbolKind.Class, "A", locations["class"].Single())
             };
 
-            var results = await RunGetWorkspaceSymbolsAsync(solution, "A").ConfigureAwait(false);
+            var results = await RunGetWorkspaceSymbolsAsync(workspace.CurrentSolution, "A").ConfigureAwait(false);
             AssertJsonEquals(expected, results);
         }
 
@@ -43,13 +43,13 @@ public async Task TestGetWorkspaceSymbolsAsync_Method()
     {
     }
 }";
-            var (solution, locations) = CreateTestSolution(markup);
+            using var workspace = CreateTestWorkspace(markup, out var locations);
             var expected = new LSP.SymbolInformation[]
             {
                 CreateSymbolInformation(LSP.SymbolKind.Method, "M", locations["method"].Single())
             };
 
-            var results = await RunGetWorkspaceSymbolsAsync(solution, "M").ConfigureAwait(false);
+            var results = await RunGetWorkspaceSymbolsAsync(workspace.CurrentSolution, "M").ConfigureAwait(false);
             AssertJsonEquals(expected, results);
         }
 
@@ -66,13 +66,13 @@ void M()
         int {|local:i|} = 1;
     }
 }";
-            var (solution, locations) = CreateTestSolution(markup);
+            using var workspace = CreateTestWorkspace(markup, out var locations);
             var expected = new LSP.SymbolInformation[]
             {
                 CreateSymbolInformation(LSP.SymbolKind.Variable, "i", locations["local"].Single())
             };
 
-            var results = await RunGetWorkspaceSymbolsAsync(solution, "i").ConfigureAwait(false);
+            var results = await RunGetWorkspaceSymbolsAsync(workspace.CurrentSolution, "i").ConfigureAwait(false);
             AssertJsonEquals(expected, results);
         }
 
@@ -91,7 +91,7 @@ class {|class:F|}
         int {|field:F|};
     }
 }";
-            var (solution, locations) = CreateTestSolution(markup);
+            using var workspace = CreateTestWorkspace(markup, out var locations);
             var expected = new LSP.SymbolInformation[]
             {
                 CreateSymbolInformation(LSP.SymbolKind.Field, "F", locations["field"][0]),
@@ -99,7 +99,7 @@ class {|class:F|}
                 CreateSymbolInformation(LSP.SymbolKind.Field, "F", locations["field"][1])
             };
 
-            var results = await RunGetWorkspaceSymbolsAsync(solution, "F").ConfigureAwait(false);
+            var results = await RunGetWorkspaceSymbolsAsync(workspace.CurrentSolution, "F").ConfigureAwait(false);
             AssertJsonEquals(expected, results);
         }
 
@@ -122,14 +122,14 @@ public async Task TestGetWorkspaceSymbolsAsync_MultipleDocuments()
 }"
             };
 
-            var (solution, locations) = CreateTestSolution(markups);
+            using var workspace = CreateTestWorkspace(markups, out var locations);
             var expected = new LSP.SymbolInformation[]
             {
                 CreateSymbolInformation(LSP.SymbolKind.Method, "M", locations["method"][0]),
                 CreateSymbolInformation(LSP.SymbolKind.Method, "M", locations["method"][1])
             };
 
-            var results = await RunGetWorkspaceSymbolsAsync(solution, "M").ConfigureAwait(false);
+            var results = await RunGetWorkspaceSymbolsAsync(workspace.CurrentSolution, "M").ConfigureAwait(false);
             AssertJsonEquals(expected, results);
         }
 
@@ -143,9 +143,9 @@ void M()
     {
     }
 }";
-            var (solution, _) = CreateTestSolution(markup);
+            using var workspace = CreateTestWorkspace(markup, out var _);
 
-            var results = await RunGetWorkspaceSymbolsAsync(solution, "NonExistingSymbol").ConfigureAwait(false);
+            var results = await RunGetWorkspaceSymbolsAsync(workspace.CurrentSolution, "NonExistingSymbol").ConfigureAwait(false);
             Assert.Empty(results);
         }
 

src/VisualStudio/LiveShare/Test/ClassificationsHandlerTests.cs

@@ -24,10 +24,10 @@ void M()
         {|classify:var|} i = 1;
     }
 }";
-            var (solution, ranges) = CreateTestSolution(markup);
-            var classifyLocation = ranges["classify"].First();
+            using var workspace = CreateTestWorkspace(markup, out var locations);
+            var classifyLocation = locations["classify"].First();
 
-            var results = await TestHandleAsync<ClassificationParams, object[]>(solution, CreateClassificationParams(classifyLocation));
+            var results = await TestHandleAsync<ClassificationParams, object[]>(workspace.CurrentSolution, CreateClassificationParams(classifyLocation));
             AssertJsonEquals(new ClassificationSpan[] { CreateClassificationSpan("keyword", classifyLocation.Range) }, results);
         }
 

src/VisualStudio/LiveShare/Test/DiagnosticsHandlerTests.cs

@@ -25,12 +25,11 @@ void M()
         {|diagnostic:var|} i = 1;
     }
 }";
-            var (solution, ranges) = CreateTestSolution(markup);
-            var workspace = (TestWorkspace)solution.Workspace;
+            using var workspace = CreateTestWorkspace(markup, out var locations);
 
-            var diagnosticLocation = ranges["diagnostic"].First();
+            var diagnosticLocation = locations["diagnostic"].First();
 
-            var _ = await TestHandleAsync<TextDocumentParams, LSP.Diagnostic[]>(solution, CreateTestDocumentParams(diagnosticLocation.Uri));
+            var _ = await TestHandleAsync<TextDocumentParams, LSP.Diagnostic[]>(workspace.CurrentSolution, CreateTestDocumentParams(diagnosticLocation.Uri));
         }
 
         private static TextDocumentParams CreateTestDocumentParams(Uri uri)

src/VisualStudio/LiveShare/Test/FindAllReferencesHandlerTests.cs

@@ -33,9 +33,9 @@ void M2()
         var j = someInt + A.{|caret:|}{|reference:someInt|};
     }
 }";
-            var (solution, locations) = CreateTestSolution(markup);
+            using var workspace = CreateTestWorkspace(markup, out var locations);
 
-            var results = await RunFindAllReferencesAsync(solution, locations["caret"].First(), true);
+            var results = await RunFindAllReferencesAsync(workspace.CurrentSolution, locations["caret"].First(), true);
             AssertLocationsEqual(locations["reference"], results);
         }
 
@@ -59,9 +59,9 @@ void M2()
         var j = someInt + A.{|caret:|}{|reference:someInt|};
     }
 }";
-            var (solution, locations) = CreateTestSolution(markup);
+            using var workspace = CreateTestWorkspace(markup, out var locations);
 
-            var results = await RunFindAllReferencesAsync(solution, locations["caret"].First(), false);
+            var results = await RunFindAllReferencesAsync(workspace.CurrentSolution, locations["caret"].First(), false);
             AssertLocationsEqual(locations["reference"], results);
         }
 
@@ -86,9 +86,10 @@ void M2()
     }
 }"
             };
-            var (solution, locations) = CreateTestSolution(markups);
 
-            var results = await RunFindAllReferencesAsync(solution, locations["caret"].First(), true);
+            using var workspace = CreateTestWorkspace(markups, out var locations);
+
+            var results = await RunFindAllReferencesAsync(workspace.CurrentSolution, locations["caret"].First(), true);
             AssertLocationsEqual(locations["reference"], results);
         }
 
@@ -100,9 +101,9 @@ public async Task TestFindAllReferencesAsync_InvalidLocation()
 {
     {|caret:|}
 }";
-            var (solution, ranges) = CreateTestSolution(markup);
+            using var workspace = CreateTestWorkspace(markup, out var locations);
 
-            var results = await RunFindAllReferencesAsync(solution, ranges["caret"].First(), true);
+            var results = await RunFindAllReferencesAsync(workspace.CurrentSolution, locations["caret"].First(), true);
             Assert.Empty(results);
         }
 

src/VisualStudio/LiveShare/Test/PreviewCodeActionsTests.cs

@@ -24,10 +24,10 @@ void M()
         {|caret:|}{|edit:int|} i = 1;
     }
 }";
-            var (solution, locations) = CreateTestSolution(markup);
+            using var workspace = CreateTestWorkspace(markup, out var locations);
             var expected = CreateTextEdit("var", locations["edit"].First().Range);
 
-            var results = await TestHandleAsync<RunCodeActionParams, LSP.TextEdit[]>(solution, CreateRunCodeActionParams(CSharpAnalyzersResources.Use_implicit_type, locations["caret"].First()));
+            var results = await TestHandleAsync<RunCodeActionParams, LSP.TextEdit[]>(workspace.CurrentSolution, CreateRunCodeActionParams(CSharpAnalyzersResources.Use_implicit_type, locations["caret"].First()));
             AssertJsonEquals(new LSP.TextEdit[] { expected }, results);
         }
 

src/VisualStudio/LiveShare/Test/ProjectsHandlerTests.cs

@@ -15,7 +15,8 @@ public class ProjectsHandlerTests : AbstractLiveShareRequestHandlerTests
         [Fact]
         public async Task TestProjectsAsync()
         {
-            var (solution, ranges) = CreateTestSolution(string.Empty);
+            using var workspace = CreateTestWorkspace(string.Empty, out var _);
+            var solution = workspace.CurrentSolution;
             var expected = solution.Projects.Select(p => CreateLspProject(p)).ToArray();
 
             var results = (CustomProtocol.Project[])await TestHandleAsync<object, object[]>(solution, null);

src/VisualStudio/LiveShare/Test/RunCodeActionsHandlerTests.cs

@@ -26,10 +26,10 @@ void M()
         {|caret:|}int i = 1;
     }
 }";
-            var (solution, ranges) = CreateTestSolution(markup);
-            var codeActionLocation = ranges["caret"].First();
+            using var workspace = CreateTestWorkspace(markup, out var locations);
+            var codeActionLocation = locations["caret"].First();
 
-            var results = await TestHandleAsync<LSP.ExecuteCommandParams, object>(solution, CreateExecuteCommandParams(codeActionLocation, CSharpAnalyzersResources.Use_implicit_type));
+            var results = await TestHandleAsync<LSP.ExecuteCommandParams, object>(workspace.CurrentSolution, CreateExecuteCommandParams(codeActionLocation, CSharpAnalyzersResources.Use_implicit_type));
             Assert.True((bool)results);
         }