From b01e15c7dfd22bec2004365dd3330312ffc2f63a Mon Sep 17 00:00:00 2001
From: Mikayla Hutchinson <m.j.hutchinson@gmail.com>
Date: Tue, 21 May 2024 20:22:38 -0400
Subject: [PATCH] Use non-LSP Roslyn code via package ref instead of source

Some of the LSP code depends on Roslyn workspaces etc.
but importing these as source got messy fast due to the
web of dependencies. Instead, import them as package
references and hope we don't run into any issues with
lack of internals visibility.
---
 Directory.Packages.props                      |  10 +-
 .../Import/UseExportProviderAttribute.cs      | 263 ++++++++
 .../MSBuildLanguageServer.Tests.csproj        |   4 +-
 MSBuildLanguageServer/DocumentId.cs           |  26 -
 MSBuildLanguageServer/EditorDocument.cs       |  63 --
 MSBuildLanguageServer/EditorWorkspace.cs      |  75 ---
 MSBuildLanguageServer/GlobalSuppressions.cs   |   8 +
 .../Import/MefHostServices.cs                 | 147 -----
 .../Import/MefWorkspaceServices.cs            | 165 -----
 .../Import/StateChecksums.cs                  | 599 ------------------
 .../Import/TextDocumentState.cs               | 258 --------
 .../Import/VisualStudioMefHostServices.cs     | 101 +++
 .../Import/Workspace_Imported.cs              |  47 --
 .../MSBuildLanguageServer.csproj              |  48 +-
 MSBuildLanguageServer/Workspace.cs            |  44 --
 MSBuildLanguageServer/WorkspaceServices.cs    |  16 -
 16 files changed, 393 insertions(+), 1481 deletions(-)
 create mode 100644 MSBuildLanguageServer.Tests/Import/UseExportProviderAttribute.cs
 delete mode 100644 MSBuildLanguageServer/DocumentId.cs
 delete mode 100644 MSBuildLanguageServer/EditorDocument.cs
 delete mode 100644 MSBuildLanguageServer/EditorWorkspace.cs
 create mode 100644 MSBuildLanguageServer/GlobalSuppressions.cs
 delete mode 100644 MSBuildLanguageServer/Import/MefHostServices.cs
 delete mode 100644 MSBuildLanguageServer/Import/MefWorkspaceServices.cs
 delete mode 100644 MSBuildLanguageServer/Import/StateChecksums.cs
 delete mode 100644 MSBuildLanguageServer/Import/TextDocumentState.cs
 create mode 100644 MSBuildLanguageServer/Import/VisualStudioMefHostServices.cs
 delete mode 100644 MSBuildLanguageServer/Import/Workspace_Imported.cs
 delete mode 100644 MSBuildLanguageServer/Workspace.cs
 delete mode 100644 MSBuildLanguageServer/WorkspaceServices.cs

diff --git a/Directory.Packages.props b/Directory.Packages.props
index 6149f7ee..952953a0 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -1,5 +1,6 @@
 <Project>
   <PropertyGroup>
+    <RoslynVersion>4.5</RoslynVersion>
     <!--
     We cannot go higher than 17.5.
     IConnectedSpan gained a new Disconnect() method in 17.6, which MiniEditor cannot implement as it is internal.
@@ -14,9 +15,10 @@
     <PackageVersion Include="Microsoft.Build" Version="17.5.0" />
     <PackageVersion Include="Microsoft.Build.Framework" Version="17.5.0" />
     <PackageVersion Include="Microsoft.Build.Locator" Version="1.7.8" />
-    <PackageVersion Include="Microsoft.CodeAnalysis" Version="4.5.0" />
-    <PackageVersion Include="Microsoft.CodeAnalysis.Common" Version="4.5.0" />
-    <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="4.5.0" />
+    <PackageVersion Include="Microsoft.CodeAnalysis" Version="$(RoslynVersion)" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.Common" Version="$(RoslynVersion)" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.Workspaces.Common" Version="$(RoslynVersion)" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="$(RoslynVersion)" />
     <PackageVersion Include="Microsoft.NET.StringTools" Version="17.5.0" />
     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
     <PackageVersion Include="Microsoft.VisualStudio.CoreUtility" Version="$(VSEditorNugetVersion)" />
@@ -24,7 +26,7 @@
     <PackageVersion Include="Microsoft.VisualStudio.Imaging.Interop.14.0.DesignTime" Version="17.5.33428.366" />
     <PackageVersion Include="Microsoft.VisualStudio.Language.Intellisense" Version="$(VSEditorNugetVersion)" />
     <PackageVersion Include="Microsoft.VisualStudio.Language.StandardClassification" Version="$(VSEditorNugetVersion)" />
-    <PackageVersion Include="Microsoft.VisualStudio.LanguageServices" Version="4.5.0" />
+    <PackageVersion Include="Microsoft.VisualStudio.LanguageServices" Version="$(RoslynVersion)" />
     <PackageVersion Include="Microsoft.VisualStudio.SDK" Version="17.5.33428.388" />
     <PackageVersion Include="Microsoft.VisualStudio.TemplateWizardInterface" Version="17.5.33428.366" />
     <PackageVersion Include="Microsoft.VisualStudio.Text.Data" Version="$(VSEditorNugetVersion)" />
diff --git a/MSBuildLanguageServer.Tests/Import/UseExportProviderAttribute.cs b/MSBuildLanguageServer.Tests/Import/UseExportProviderAttribute.cs
new file mode 100644
index 00000000..6f35574c
--- /dev/null
+++ b/MSBuildLanguageServer.Tests/Import/UseExportProviderAttribute.cs
@@ -0,0 +1,263 @@
+// modified copy of
+// https://raw.githubusercontent.com/dotnet/roslyn/1d8582e04c5af87883eab0a5ba7d0788d19a3eb4/src/Workspaces/CoreTestUtilities/MEF/UseExportProviderAttribute.cs
+// portions commented out using /* */ comments
+// and other changes annotated inline with // MODIFICATION
+
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Composition.Hosting;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Remote;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
+using Microsoft.VisualStudio.Composition;
+using Roslyn.Test.Utilities;
+using Xunit.Sdk;
+
+namespace Microsoft.CodeAnalysis.Test.Utilities
+{
+    /// <summary>
+    /// This attribute supports tests that need to use a MEF container (<see cref="ExportProvider"/>) directly or
+    /// indirectly during the test sequence. It ensures production code uniformly handles the export provider created
+    /// during a test, and cleans up the state before the test completes.
+    /// </summary>
+    /// <remarks>
+    /// <para>This attribute serves several important functions for tests that use state variables which are otherwise
+    /// shared at runtime:</para>
+    /// <list type="bullet">
+    /// <item>Ensures <see cref="HostServices"/> implementations all use the same <see cref="ExportProvider"/>, which is
+    /// the one created by the test.</item>
+    /// <item>Clears static cached values in production code holding instances of <see cref="HostServices"/>, or any
+    /// object obtained from it or one of its related interfaces such as <see cref="HostLanguageServices"/>.</item>
+    /// <item>Isolates tests by waiting for asynchronous operations to complete before a test is considered
+    /// complete.</item>
+    /// <item>When required, provides a separate <see cref="ExportProvider"/> for the <see cref="RemoteWorkspace"/>
+    /// executing in the test process. If this provider is created during testing, it is cleaned up with the primary
+    /// export provider during test teardown.</item>
+    /// </list>
+    /// </remarks>
+    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
+    public class UseExportProviderAttribute : BeforeAfterTestAttribute
+    {
+        /// <summary>
+        /// Asynchronous operations are expected to be cancelled at the end of the test that started them. Operations
+        /// cancelled by the test are cleaned up immediately. The remaining operations are given an opportunity to run
+        /// to completion. If this timeout is exceeded by the asynchronous operations running after a test completes,
+        /// the test is failed.
+        /// </summary>
+        private static readonly TimeSpan CleanupTimeout = TimeSpan.FromMinutes(1);
+
+        private MefHostServices? _hostServices;
+
+        static UseExportProviderAttribute()
+        {
+            // Make sure we run the module initializer for Roslyn.Test.Utilities. C# projects do this via a
+            // build-injected module initializer, but VB projects can ensure initialization occurs by applying the
+            // UseExportProviderAttribute to test classes that rely on it.
+            RuntimeHelpers.RunModuleConstructor(typeof(TestBase).Module.ModuleHandle);
+
+            testHookMethod = typeof(MefHostServices)
+                .GetNestedType("TestAccessor", BindingFlags.NonPublic)
+                ?.GetMethod("TestAccessor", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static)
+                ?? throw new InvalidOperationException("Could not get test accessor method for MefHostServices.TestAccessor.HookServiceCreation");
+        }
+
+        static MethodInfo testHookMethod;
+
+        static void HookServiceCreationViaReflection(Func<IEnumerable<Assembly>, MefHostServices> hook)
+        {
+            testHookMethod.Invoke(null, [hook]);
+        }
+
+        public override void Before(MethodInfo? methodUnderTest)
+        {
+            // Need to clear cached MefHostServices between test runs.
+            // MODIFICATION: use reflection helper to access internal method
+            HookServiceCreationViaReflection(CreateMefHostServices);
+
+            // make sure we enable this for all unit tests
+            AsynchronousOperationListenerProvider.Enable(enable: true, diagnostics: true);
+            ExportProviderCache.SetEnabled_OnlyUseExportProviderAttributeCanCall(true);
+        }
+
+        /// <summary>
+        /// To the extent reasonably possible, this method resets the state of the test environment to the same state as
+        /// it started, ensuring that tests running in sequence cannot influence the outcome of later tests.
+        /// </summary>
+        /// <remarks>
+        /// <para>The test cleanup runs in two primary steps:</para>
+        /// <list type="number">
+        /// <item>Waiting for asynchronous operations started by the test to complete.</item>
+        /// <item>Disposing of mutable resources created by the test.</item>
+        /// <item>Clearing static state variables related to the use of MEF during a test.</item>
+        /// </list>
+        /// </remarks>
+        public override void After(MethodInfo? methodUnderTest)
+        {
+            try
+            {
+                DisposeExportProvider(ExportProviderCache.LocalExportProviderForCleanup);
+                DisposeExportProvider(ExportProviderCache.RemoteExportProviderForCleanup);
+            }
+            finally
+            {
+                // Replace hooks with ones that always throw exceptions. These hooks detect cases where code executing
+                // after the end of a test attempts to create an ExportProvider.
+                // MODIFICATION: use reflection helper to access internal method
+                HookServiceCreationViaReflection(DenyMefHostServicesCreationBetweenTests);
+
+                // Reset static state variables.
+                _hostServices = null;
+                ExportProviderCache.SetEnabled_OnlyUseExportProviderAttributeCanCall(false);
+            }
+        }
+
+        private static void DisposeExportProvider(ExportProvider? exportProvider)
+        {
+            if (exportProvider == null)
+            {
+                return;
+            }
+
+            // Dispose of the export provider, including calling Dispose for any IDisposable services created during the test.
+            using var _ = exportProvider;
+
+            if (exportProvider.GetExportedValues<IAsynchronousOperationListenerProvider>().SingleOrDefault() is { } listenerProvider)
+            {
+                // Verify the synchronization context was not used incorrectly
+                var testExportJoinableTaskContext = exportProvider.GetExportedValues<TestExportJoinableTaskContext>().SingleOrDefault();
+                var denyExecutionSynchronizationContext = testExportJoinableTaskContext?.SynchronizationContext as TestExportJoinableTaskContext.DenyExecutionSynchronizationContext;
+
+                // Join remaining operations with a timeout
+                using (var timeoutTokenSource = new CancellationTokenSource(CleanupTimeout))
+                {
+                    if (denyExecutionSynchronizationContext is object)
+                    {
+                        // Immediately cancel the test if the synchronization context is improperly used
+                        denyExecutionSynchronizationContext.InvalidSwitch += delegate { timeoutTokenSource.CancelAfter(0); };
+                        denyExecutionSynchronizationContext.ThrowIfSwitchOccurred();
+                    }
+
+                    try
+                    {
+                        // This attribute cleans up the in-process and out-of-process export providers separately, so we
+                        // don't need to provide a workspace when waiting for operations to complete.
+                        var waiter = ((AsynchronousOperationListenerProvider)listenerProvider).WaitAllDispatcherOperationAndTasksAsync(workspace: null);
+
+                        if (testExportJoinableTaskContext?.DispatcherTaskJoiner is { } taskJoiner)
+                        {
+                            taskJoiner.JoinUsingDispatcher(waiter, timeoutTokenSource.Token);
+                        }
+                        else
+                        {
+                            waiter.GetAwaiter().GetResult();
+                        }
+                    }
+                    catch (OperationCanceledException ex) when (timeoutTokenSource.IsCancellationRequested)
+                    {
+                        // If the failure was caused by an invalid thread change, throw that exception
+                        denyExecutionSynchronizationContext?.ThrowIfSwitchOccurred();
+
+                        var messageBuilder = new StringBuilder("Failed to clean up listeners in a timely manner.");
+                        foreach (var token in ((AsynchronousOperationListenerProvider)listenerProvider).GetTokens())
+                        {
+                            messageBuilder.AppendLine().Append($"  {token}");
+                        }
+
+                        throw new TimeoutException(messageBuilder.ToString(), ex);
+                    }
+                }
+
+                denyExecutionSynchronizationContext?.ThrowIfSwitchOccurred();
+
+                foreach (var testErrorHandler in exportProvider.GetExportedValues<ITestErrorHandler>())
+                {
+                    var exceptions = testErrorHandler.Exceptions;
+                    if (exceptions.Count > 0)
+                    {
+                        throw new AggregateException("Tests threw unexpected exceptions", exceptions);
+                    }
+                }
+            }
+        }
+
+        private MefHostServices CreateMefHostServices(IEnumerable<Assembly> assemblies)
+        {
+            ExportProvider exportProvider;
+
+            if (assemblies is ImmutableArray<Assembly> array &&
+                array == MefHostServices.DefaultAssemblies &&
+                ExportProviderCache.LocalExportProviderForCleanup != null)
+            {
+                if (_hostServices != null)
+                {
+                    return _hostServices;
+                }
+
+                exportProvider = ExportProviderCache.LocalExportProviderForCleanup;
+            }
+            else
+            {
+                exportProvider = ExportProviderCache.GetOrCreateExportProviderFactory(assemblies).CreateExportProvider();
+            }
+
+            Interlocked.CompareExchange(
+                    ref _hostServices,
+                    new ExportProviderMefHostServices(exportProvider),
+                    null);
+
+            return _hostServices;
+        }
+
+        private static MefHostServices DenyMefHostServicesCreationBetweenTests(IEnumerable<Assembly> assemblies)
+        {
+            // If you hit this, one of three situations occurred:
+            //
+            // 1. A test method that uses ExportProvider is not marked with UseExportProviderAttribute (can also be
+            //    applied to the containing type or a base type.
+            // 2. A test attempted to create an ExportProvider during the test cleanup operations after the
+            //    ExportProvider was already disposed.
+            // 3. A test attempted to use an ExportProvider in the constructor of the test, or during the initialization
+            //    of a field in the test class.
+            throw new InvalidOperationException("Cannot create host services after test tear down.");
+        }
+
+        private class ExportProviderMefHostServices : MefHostServices, IMefHostExportProvider
+        {
+            private readonly VisualStudioMefHostServices _vsHostServices;
+
+            public ExportProviderMefHostServices(ExportProvider exportProvider)
+                : base(new ContainerConfiguration().CreateContainer())
+            {
+                _vsHostServices = VisualStudioMefHostServices.Create(exportProvider);
+            }
+
+            // MODIFICATION: made protected instead of protected internal, use reflection to call internal method
+            protected override HostWorkspaceServices CreateWorkspaceServices(Workspace workspace)
+            {
+                //=> _vsHostServices.CreateWorkspaceServices(workspace);
+                return (HostWorkspaceServices?) _vsHostServices
+                    .GetType()
+                    .GetMethod("CreateWorkspaceServices", BindingFlags.NonPublic | BindingFlags.Instance)
+                    ?.Invoke(_vsHostServices, [workspace])
+                    ?? throw new InvalidOperationException();
+            }
+
+            IEnumerable<Lazy<TExtension, TMetadata>> IMefHostExportProvider.GetExports<TExtension, TMetadata>()
+                => _vsHostServices.GetExports<TExtension, TMetadata>();
+
+            IEnumerable<Lazy<TExtension>> IMefHostExportProvider.GetExports<TExtension>()
+                => _vsHostServices.GetExports<TExtension>();
+        }
+    }
+}
\ No newline at end of file
diff --git a/MSBuildLanguageServer.Tests/MSBuildLanguageServer.Tests.csproj b/MSBuildLanguageServer.Tests/MSBuildLanguageServer.Tests.csproj
index ac3287a9..dc01ea70 100644
--- a/MSBuildLanguageServer.Tests/MSBuildLanguageServer.Tests.csproj
+++ b/MSBuildLanguageServer.Tests/MSBuildLanguageServer.Tests.csproj
@@ -26,11 +26,9 @@
     <Compile Include="../external/roslyn/src/Features/LanguageServer/Protocol/NoOpLspLogger.cs" />
     <Compile Include="../external/roslyn/src/Workspaces/CoreTestUtilities/ITestErrorHandler.cs" />
     <Compile Include="../external/roslyn/src/Workspaces/CoreTestUtilities/MEF/ExportProviderCache.cs" />
-    <Compile Include="../external/roslyn/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Helpers/MefHostServicesHelpers.cs" />
     <Compile Include="../external/roslyn/src/Workspaces/CoreTestUtilities/TestExportJoinableTaskContext.cs" />
     <Compile Include="../external/roslyn/src/Workspaces/CoreTestUtilities/TestExportJoinableTaskContext+DenyExecutionSynchronizationContext.cs" />
     <Compile Include="../external/roslyn/src/Workspaces/Core/Portable/Shared/TestHooks/IAsynchronousOperationListenerProvider.cs" />
-    <Compile Include="../external/roslyn/src/Workspaces/CoreTestUtilities/MEF/UseExportProviderAttribute.cs" />
     <Compile Include="../external/roslyn/src/Workspaces/CoreTestUtilities/MEF/IDispatcherTaskJoiner.cs" />
     <Compile Include="../external/roslyn/src/EditorFeatures/Core/Shared/Utilities/IThreadingContext.cs" />
   </ItemGroup>
@@ -42,12 +40,12 @@
     <PackageReference Include="Microsoft.Build.Locator" />
     <PackageReference Include="Microsoft.VisualStudio.Composition" />
     <PackageReference Include="Microsoft.CodeAnalysis.Common" PrivateAssets="runtime" />
+    <PackageReference Include="Microsoft.CodeAnalysis.Workspaces.Common" PrivateAssets="runtime" />
   </ItemGroup>
 
   <ItemGroup>
     <Using Include="Xunit" />
     <Using Include="Microsoft.CodeAnalysis.LanguageServer.MSBuildLanguageServer" Alias="RoslynLanguageServer" />
-    <Using Include="MonoDevelop.MSBuild.Editor.LanguageServer.Workspace" Alias="Workspace" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/MSBuildLanguageServer/DocumentId.cs b/MSBuildLanguageServer/DocumentId.cs
deleted file mode 100644
index 6f406284..00000000
--- a/MSBuildLanguageServer/DocumentId.cs
+++ /dev/null
@@ -1,26 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-// Licensed under the MIT license. See LICENSE file in the project root for full license information.
-
-namespace MonoDevelop.MSBuild.Editor.LanguageServer;
-
-/// Unique persistent identifier for a document in a workspace.
-/// Dot not change when the document is renamed.
-/// The document may not be saved to disk, so may not have a file path.
-/// </summary>
-public class DocumentId : IEquatable<DocumentId>
-{
-    readonly Guid guid;
-
-    private DocumentId(Guid guid)
-    {
-        this.guid = guid;
-    }
-
-    public static DocumentId CreateNewId() => new (Guid.NewGuid());
-
-    public bool Equals(DocumentId? other) => other is not null && guid == other.guid;
-
-    public override bool Equals(object? obj) => obj is DocumentId id && guid.Equals(id.guid);
-
-    public override int GetHashCode() => guid.GetHashCode();
-}
\ No newline at end of file
diff --git a/MSBuildLanguageServer/EditorDocument.cs b/MSBuildLanguageServer/EditorDocument.cs
deleted file mode 100644
index 359bbe94..00000000
--- a/MSBuildLanguageServer/EditorDocument.cs
+++ /dev/null
@@ -1,63 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-// Licensed under the MIT license. See LICENSE file in the project root for full license information.
-
-using Microsoft.CodeAnalysis.Text;
-
-namespace MonoDevelop.MSBuild.Editor.LanguageServer;
-
-/// <summary>
-/// Represents a document that is open in the editor.
-/// </summary>
-public class EditorDocument
-{
-    readonly object lockObj = new();
-
-    VersionedSourceText? sourceText;
-
-    internal EditorDocument(EditorWorkspace workspace, DocumentId documentId, SourceText? sourceText)
-    {
-        Workspace = workspace;
-        DocumentId = documentId;
-        if (sourceText is not null) {
-            this.sourceText = new VersionedSourceText(sourceText, 0);
-        }
-    }
-
-    public EditorWorkspace Workspace { get; }
-    public DocumentId DocumentId { get; }
-    public SourceText SourceText => sourceText?.Text ?? throw new InvalidOperationException("Document has not yet been initialized");
-    public int Version => sourceText?.Version ?? -1;
-
-    internal void UpdateText(SourceText sourceText)
-    {
-        VersionedSourceText? newText = null, oldText = null;
-        lock(lockObj) {
-            oldText = this.sourceText;
-            this.sourceText = newText = new VersionedSourceText(sourceText, oldText?.Version + 1 ?? 0);
-        }
-
-        if (SourceTextUpdated is {} evt) {
-            evt?.Invoke(this, new DocumentSourceTextUpdated(DocumentId, oldText, newText));
-        }
-    }
-
-    public event EventHandler<DocumentSourceTextUpdated>? SourceTextUpdated;
-}
-
-public record class VersionedSourceText(SourceText Text, int Version);
-
-public class DocumentSourceTextUpdated : DocumentEventArgs
-{
-    readonly VersionedSourceText? oldText;
-    readonly VersionedSourceText newText;
-    public DocumentSourceTextUpdated(DocumentId documentId, VersionedSourceText? oldText, VersionedSourceText newText)
-        : base(documentId)
-    {
-        this.oldText = oldText;
-        this.newText = newText;
-    }
-    public SourceText? OldText => oldText?.Text;
-    public int OldVersion => oldText?.Version ?? -1;
-    public SourceText NewText => newText.Text;
-    public int NewVersion => newText.Version;
-}
\ No newline at end of file
diff --git a/MSBuildLanguageServer/EditorWorkspace.cs b/MSBuildLanguageServer/EditorWorkspace.cs
deleted file mode 100644
index bd432b34..00000000
--- a/MSBuildLanguageServer/EditorWorkspace.cs
+++ /dev/null
@@ -1,75 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-// Licensed under the MIT license. See LICENSE file in the project root for full license information.
-
-using Microsoft.CodeAnalysis.Text;
-
-namespace MonoDevelop.MSBuild.Editor.LanguageServer;
-
-/// <summary>
-/// Workspace that tracks documents that are open in the editor
-/// </summary>
-public class EditorWorkspace : Workspace
-{
-    readonly object openDocumentsLock = new ();
-    readonly Dictionary<DocumentId,EditorDocument> openDocuments = new();
-
-    public EditorWorkspace(HostServices services) : base(services)
-    {
-    }
-
-    public EditorDocument StartTrackingOpenDocument(string normalizedAbsoluteFilePath)
-    {
-        var id = GetOrCreateDocumentId(normalizedAbsoluteFilePath);
-        var document = new EditorDocument(this, id, null);
-        lock(openDocumentsLock) {
-            if (!openDocuments.TryAdd(id, document)) {
-                throw new ArgumentException("Document is already being tracked");
-            }
-        }
-
-        if (DocumentOpened is {} handlers) {
-            ScheduleTask(() => handlers.Invoke(this, new EditorDocumentEventArgs(document)));
-        }
-
-        return document;
-    }
-
-    public void StopTrackingOpenDocument(DocumentId id)
-    {
-        lock(openDocumentsLock) {
-            if (!openDocuments.Remove(id)) {
-                throw new ArgumentException("Document is not being tracked");
-            }
-        }
-        if (DocumentClosed is {} handlers) {
-            ScheduleTask(() => handlers.Invoke(this, new DocumentEventArgs(id)));
-        }
-    }
-
-    public EditorDocument GetOpenDocument(DocumentId id)
-    {
-        if (!openDocuments.TryGetValue(id, out var document)) {
-            throw new ArgumentException("Document is not being tracked");
-        }
-        return document;
-    }
-
-    public void UpdateOpenDocument(DocumentId id, SourceText text)
-    {
-        var document = GetOpenDocument(id);
-        document.UpdateText(text);
-    }
-
-    public event EventHandler<EditorDocumentEventArgs>? DocumentOpened;
-    public event EventHandler<DocumentEventArgs>? DocumentClosed;
-}
-
-public class DocumentEventArgs(DocumentId documentId) : EventArgs
-{
-    public DocumentId DocumentId { get; } = documentId;
-}
-
-public class EditorDocumentEventArgs(EditorDocument document) : DocumentEventArgs(document.DocumentId)
-{
-    public EditorDocument Document { get; } = document;
-}
diff --git a/MSBuildLanguageServer/GlobalSuppressions.cs b/MSBuildLanguageServer/GlobalSuppressions.cs
new file mode 100644
index 00000000..64a7b4ab
--- /dev/null
+++ b/MSBuildLanguageServer/GlobalSuppressions.cs
@@ -0,0 +1,8 @@
+// This file is used by Code Analysis to maintain SuppressMessage
+// attributes that are applied to this project.
+// Project-level suppressions either have no target or are given
+// a specific target and scoped to a namespace, type, member, etc.
+
+using System.Diagnostics.CodeAnalysis;
+
+[assembly: SuppressMessage("MicrosoftCodeAnalysisCorrectness", "RS1024:Symbols should be compared for equality", Justification = "<Pending>", Scope = "member", Target = "~M:Roslyn.Utilities.GeneratedCodeUtilities.IsGeneratedSymbolWithGeneratedCodeAttribute(Microsoft.CodeAnalysis.ISymbol,Microsoft.CodeAnalysis.INamedTypeSymbol)~System.Boolean")]
diff --git a/MSBuildLanguageServer/Import/MefHostServices.cs b/MSBuildLanguageServer/Import/MefHostServices.cs
deleted file mode 100644
index c0632080..00000000
--- a/MSBuildLanguageServer/Import/MefHostServices.cs
+++ /dev/null
@@ -1,147 +0,0 @@
-// modified version of
-// https://raw.githubusercontent.com/dotnet/roslyn/044acb4ec888bf080b707e3db6818107e018d80b/src/Workspaces/Core/Portable/Workspace/Host/Mef/MefHostServices.cs
-// changes annotated inline with // MODIFICATION
-
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-#nullable disable
-
-using System;
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Composition;
-using System.Composition.Hosting;
-using System.Linq;
-using System.Reflection;
-using System.Threading;
-
-namespace Microsoft.CodeAnalysis.Host.Mef;
-
-public class MefHostServices(CompositionContext compositionContext) : HostServices, IMefHostExportProvider
-{
-    internal delegate MefHostServices CreationHook(IEnumerable<Assembly> assemblies);
-
-    /// <summary>
-    /// This delegate allows test code to override the behavior of <see cref="Create(IEnumerable{Assembly})"/>.
-    /// </summary>
-    /// <seealso cref="TestAccessor.HookServiceCreation"/>
-    private static CreationHook s_creationHook;
-
-    public static MefHostServices Create(CompositionContext compositionContext)
-    {
-        if (compositionContext == null)
-        {
-            throw new ArgumentNullException(nameof(compositionContext));
-        }
-
-        return new MefHostServices(compositionContext);
-    }
-
-    public static MefHostServices Create(IEnumerable<System.Reflection.Assembly> assemblies)
-    {
-        if (assemblies == null)
-        {
-            throw new ArgumentNullException(nameof(assemblies));
-        }
-
-        if (s_creationHook != null)
-        {
-            return s_creationHook(assemblies);
-        }
-
-        var compositionConfiguration = new ContainerConfiguration().WithAssemblies(assemblies.Distinct());
-        var container = compositionConfiguration.CreateContainer();
-        return new MefHostServices(container);
-    }
-
-    protected internal override HostWorkspaceServices CreateWorkspaceServices(Workspace workspace)
-        => new MefWorkspaceServices(this, workspace);
-
-    IEnumerable<Lazy<TExtension>> IMefHostExportProvider.GetExports<TExtension>()
-        => compositionContext.GetExports<TExtension>().Select(e => new Lazy<TExtension>(() => e));
-
-    IEnumerable<Lazy<TExtension, TMetadata>> IMefHostExportProvider.GetExports<TExtension, TMetadata>()
-    {
-        var importer = new WithMetadataImporter<TExtension, TMetadata>();
-        compositionContext.SatisfyImports(importer);
-        return importer.Exports;
-    }
-
-    private class WithMetadataImporter<TExtension, TMetadata>
-    {
-        [ImportMany]
-        public IEnumerable<Lazy<TExtension, TMetadata>> Exports { get; set; }
-    }
-
-    #region Defaults
-
-    private static MefHostServices s_defaultHost;
-    public static MefHostServices DefaultHost
-    {
-        get
-        {
-            if (s_defaultHost == null)
-            {
-                var host = Create(DefaultAssemblies);
-                Interlocked.CompareExchange(ref s_defaultHost, host, null);
-            }
-
-            return s_defaultHost;
-        }
-    }
-
-    private static ImmutableArray<Assembly> s_defaultAssemblies;
-    public static ImmutableArray<Assembly> DefaultAssemblies
-    {
-        get
-        {
-            if (s_defaultAssemblies.IsDefault)
-            {
-                ImmutableInterlocked.InterlockedInitialize(ref s_defaultAssemblies, LoadDefaultAssemblies());
-            }
-
-            return s_defaultAssemblies;
-        }
-    }
-
-    // Used to build a MEF composition using the main workspaces assemblies and the known VisualBasic/CSharp workspace assemblies.
-    // updated: includes feature assemblies since they now have public API's.
-    private static readonly string[] s_defaultAssemblyNames =
-        [
-        /*
-            "Microsoft.CodeAnalysis.Workspaces",
-            "Microsoft.CodeAnalysis.CSharp.Workspaces",
-            "Microsoft.CodeAnalysis.VisualBasic.Workspaces",
-            "Microsoft.CodeAnalysis.Features",
-            "Microsoft.CodeAnalysis.CSharp.Features",
-            "Microsoft.CodeAnalysis.VisualBasic.Features"
-        */
-        ];
-
-    internal static bool IsDefaultAssembly(Assembly assembly)
-    {
-        var name = assembly.GetName().Name;
-        return s_defaultAssemblyNames.Contains(name);
-    }
-
-    private static ImmutableArray<Assembly> LoadDefaultAssemblies()
-        => MefHostServicesHelpers.LoadNearbyAssemblies(s_defaultAssemblyNames);
-
-    #endregion
-
-    internal readonly struct TestAccessor
-    {
-        /// <summary>
-        /// Injects replacement behavior for the <see cref="Create(IEnumerable{Assembly})"/> method.
-        /// </summary>
-        internal static void HookServiceCreation(CreationHook hook)
-        {
-            s_creationHook = hook;
-
-            // The existing host, if any, is not retained past this call.
-            s_defaultHost = null;
-        }
-    }
-}
\ No newline at end of file
diff --git a/MSBuildLanguageServer/Import/MefWorkspaceServices.cs b/MSBuildLanguageServer/Import/MefWorkspaceServices.cs
deleted file mode 100644
index a2f7c402..00000000
--- a/MSBuildLanguageServer/Import/MefWorkspaceServices.cs
+++ /dev/null
@@ -1,165 +0,0 @@
-//
-// https://raw.githubusercontent.com/dotnet/roslyn/dd3795a49875bef2728f01e0284406f33ea1e2e1/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Workspace/Mef/MefWorkspaceServices.cs
-//
-
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using System;
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Threading;
-using Microsoft.CodeAnalysis.Host;
-using Microsoft.CodeAnalysis.Host.Mef;
-using Roslyn.Utilities;
-
-[assembly: DebuggerTypeProxy(typeof(MefWorkspaceServices.LazyServiceMetadataDebuggerProxy), Target = typeof(ImmutableArray<Lazy<IWorkspaceService, WorkspaceServiceMetadata>>))]
-
-namespace Microsoft.CodeAnalysis.Host.Mef
-{
-    internal sealed class MefWorkspaceServices : HostWorkspaceServices
-    {
-        private readonly IMefHostExportProvider _exportProvider;
-        private readonly Workspace _workspace;
-
-        private readonly ImmutableArray<Lazy<IWorkspaceService, WorkspaceServiceMetadata>> _services;
-
-        // map of type name to workspace service
-        private ImmutableDictionary<Type, Lazy<IWorkspaceService, WorkspaceServiceMetadata>?> _serviceMap
-            = ImmutableDictionary<Type, Lazy<IWorkspaceService, WorkspaceServiceMetadata>?>.Empty;
-        /*
-        // accumulated cache for language services
-        private ImmutableDictionary<string, MefLanguageServices> _languageServicesMap
-            = ImmutableDictionary<string, MefLanguageServices>.Empty;
-        */
-
-        public MefWorkspaceServices(IMefHostExportProvider host, Workspace workspace)
-        {
-            _exportProvider = host;
-            _workspace = workspace;
-
-            var services = host.GetExports<IWorkspaceService, WorkspaceServiceMetadata>();
-            var factories = host.GetExports<IWorkspaceServiceFactory, WorkspaceServiceMetadata>()
-                .Select(lz => new Lazy<IWorkspaceService, WorkspaceServiceMetadata>(() => lz.Value.CreateService(this), lz.Metadata));
-
-            _services = services.Concat(factories).ToImmutableArray();
-        }
-
-        public override HostServices HostServices
-        {
-            get { return (HostServices)_exportProvider; }
-        }
-
-        internal IMefHostExportProvider HostExportProvider => _exportProvider;
-
-/*
-        internal string? WorkspaceKind => _workspace.Kind;
-        public override Workspace Workspace
-        {
-            get
-            {
-                //#if !CODE_STYLE
-                //                Contract.ThrowIfTrue(_workspace.Kind == CodeAnalysis.WorkspaceKind.RemoteWorkspace, "Access .Workspace off of a RemoteWorkspace MefWorkspaceServices is not supported.");
-                //#endif
-                return _workspace;
-            }
-        }
-*/
-        public override TWorkspaceService GetService<TWorkspaceService>()
-        {
-            if (TryGetService(typeof(TWorkspaceService), out var service))
-            {
-                return (TWorkspaceService)service.Value;
-            }
-            else
-            {
-                return default!;
-            }
-        }
-
-        private bool TryGetService(Type serviceType, [NotNullWhen(true)] out Lazy<IWorkspaceService, WorkspaceServiceMetadata>? service)
-        {
-            if (!_serviceMap.TryGetValue(serviceType, out service))
-            {
-                service = ImmutableInterlocked.GetOrAdd(ref _serviceMap, serviceType, serviceType => LayeredServiceUtilities.PickService(serviceType, _workspace.Kind, _services));
-            }
-
-            return service != null;
-        }
-
-        private IEnumerable<string>? _languages;
-
-        private IEnumerable<string> GetSupportedLanguages()
-        {
-            if (_languages == null)
-            {
-                var list = _exportProvider.GetExports<ILanguageService, LanguageServiceMetadata>().Select(lz => lz.Metadata.Language).Concat(
-                           _exportProvider.GetExports<ILanguageServiceFactory, LanguageServiceMetadata>().Select(lz => lz.Metadata.Language))
-                           .Distinct();
-
-                Interlocked.CompareExchange(ref _languages, list, null);
-            }
-
-            return _languages;
-        }
-
-        public override IEnumerable<string> SupportedLanguages
-        {
-            get { return this.GetSupportedLanguages(); }
-        }
-
-        public override bool IsSupported(string languageName)
-            => this.GetSupportedLanguages().Contains(languageName);
-
-        public override HostLanguageServices GetLanguageServices(string languageName)
-        {
-            var currentServicesMap = _languageServicesMap;
-            if (!currentServicesMap.TryGetValue(languageName, out var languageServices))
-            {
-                languageServices = ImmutableInterlocked.GetOrAdd(ref _languageServicesMap, languageName, static (languageName, self) => new MefLanguageServices(self, languageName), this);
-            }
-
-            if (languageServices.HasServices)
-            {
-                return languageServices;
-            }
-            else
-            {
-                // throws exception
-#pragma warning disable RS0030 // Do not used banned API 'GetLanguageServices', use 'GetExtendedLanguageServices' instead - allowed in this context.
-                return base.GetLanguageServices(languageName);
-#pragma warning restore RS0030 // Do not used banned APIs
-            }
-        }
-
-        public override IEnumerable<TLanguageService> FindLanguageServices<TLanguageService>(MetadataFilter filter)
-        {
-            foreach (var language in this.SupportedLanguages)
-            {
-#pragma warning disable RS0030 // Do not used banned API 'GetLanguageServices', use 'GetExtendedLanguageServices' instead - allowed in this context.
-                var services = (MefLanguageServices)this.GetLanguageServices(language);
-#pragma warning restore RS0030 // Do not used banned APIs
-                if (services.TryGetService(typeof(TLanguageService), out var service))
-                {
-                    if (filter(service.Metadata.Data))
-                    {
-                        yield return (TLanguageService)service.Value;
-                    }
-                }
-            }
-        }
-
-        internal bool TryGetLanguageServices(string languageName, [NotNullWhen(true)] out MefLanguageServices? languageServices)
-            => _languageServicesMap.TryGetValue(languageName, out languageServices);
-
-        internal sealed class LazyServiceMetadataDebuggerProxy(ImmutableArray<Lazy<IWorkspaceService, WorkspaceServiceMetadata>> services)
-        {
-            public (string type, string layer)[] Metadata
-                => services.Select(s => (s.Metadata.ServiceType, s.Metadata.Layer)).ToArray();
-        }
-    }
-}
\ No newline at end of file
diff --git a/MSBuildLanguageServer/Import/StateChecksums.cs b/MSBuildLanguageServer/Import/StateChecksums.cs
deleted file mode 100644
index 887e5458..00000000
--- a/MSBuildLanguageServer/Import/StateChecksums.cs
+++ /dev/null
@@ -1,599 +0,0 @@
-// modified copy of
-// https://raw.githubusercontent.com/dotnet/roslyn/dd3795a49875bef2728f01e0284406f33ea1e2e1/src/Workspaces/Core/Portable/Workspace/Solution/StateChecksums.cs
-// with portions commented out using /* */ comments
-// and other changes annotated inline with // MODIFICATION
-
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using System;
-using System.Collections.Frozen;
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Threading;
-using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.Shared.Extensions;
-using Roslyn.Utilities;
-
-namespace Microsoft.CodeAnalysis.Serialization;
-/*
-internal sealed class SolutionCompilationStateChecksums
-{
-    public SolutionCompilationStateChecksums(
-        Checksum solutionState,
-        Checksum sourceGeneratorExecutionVersionMap,
-        // These arrays are all the same length if present, and reference the same documents in the same order.
-        DocumentChecksumsAndIds? frozenSourceGeneratedDocuments,
-        ChecksumCollection? frozenSourceGeneratedDocumentIdentities,
-        ImmutableArray<DateTime> frozenSourceGeneratedDocumentGenerationDateTimes)
-    {
-        // For the frozen source generated document info, we expect two either have both checksum collections or neither, and they
-        // should both be the same length as there is a 1:1 correspondence between them.
-        Contract.ThrowIfFalse(frozenSourceGeneratedDocumentIdentities.HasValue == frozenSourceGeneratedDocuments.HasValue);
-        Contract.ThrowIfFalse(frozenSourceGeneratedDocumentIdentities?.Count == frozenSourceGeneratedDocuments?.Length);
-
-        SolutionState = solutionState;
-        SourceGeneratorExecutionVersionMap = sourceGeneratorExecutionVersionMap;
-        FrozenSourceGeneratedDocuments = frozenSourceGeneratedDocuments;
-        FrozenSourceGeneratedDocumentIdentities = frozenSourceGeneratedDocumentIdentities;
-        FrozenSourceGeneratedDocumentGenerationDateTimes = frozenSourceGeneratedDocumentGenerationDateTimes;
-
-        // note: intentionally not mixing in FrozenSourceGeneratedDocumentGenerationDateTimes as that is not part of the
-        // identity contract of this type.
-        Checksum = Checksum.Create(
-            SolutionState,
-            SourceGeneratorExecutionVersionMap,
-            FrozenSourceGeneratedDocumentIdentities?.Checksum ?? Checksum.Null,
-            frozenSourceGeneratedDocuments?.Checksum ?? Checksum.Null);
-    }
-
-    public Checksum Checksum { get; }
-    public Checksum SolutionState { get; }
-    public Checksum SourceGeneratorExecutionVersionMap { get; }
-
-    /// <summary>
-    /// Checksums of the SourceTexts of the frozen documents directly.  Not checksums of their DocumentStates.
-    /// </summary>
-    public DocumentChecksumsAndIds? FrozenSourceGeneratedDocuments { get; }
-    public ChecksumCollection? FrozenSourceGeneratedDocumentIdentities { get; }
-
-    // note: intentionally not part of the identity contract of this type.
-    public ImmutableArray<DateTime> FrozenSourceGeneratedDocumentGenerationDateTimes { get; }
-
-    public void AddAllTo(HashSet<Checksum> checksums)
-    {
-        checksums.AddIfNotNullChecksum(this.Checksum);
-        checksums.AddIfNotNullChecksum(this.SolutionState);
-        checksums.AddIfNotNullChecksum(this.SourceGeneratorExecutionVersionMap);
-        this.FrozenSourceGeneratedDocumentIdentities?.AddAllTo(checksums);
-        this.FrozenSourceGeneratedDocuments?.AddAllTo(checksums);
-    }
-
-    public void Serialize(ObjectWriter writer)
-    {
-        // Writing this is optional, but helps ensure checksums are being computed properly on both the host and oop side.
-        this.Checksum.WriteTo(writer);
-        this.SolutionState.WriteTo(writer);
-        this.SourceGeneratorExecutionVersionMap.WriteTo(writer);
-
-        // Write out a boolean to know whether we'll have this extra information
-        writer.WriteBoolean(this.FrozenSourceGeneratedDocumentIdentities.HasValue);
-        if (FrozenSourceGeneratedDocumentIdentities.HasValue)
-        {
-            this.FrozenSourceGeneratedDocuments!.Value.WriteTo(writer);
-            this.FrozenSourceGeneratedDocumentIdentities.Value.WriteTo(writer);
-            writer.WriteArray(this.FrozenSourceGeneratedDocumentGenerationDateTimes, static (w, d) => w.WriteInt64(d.Ticks));
-        }
-    }
-
-    public static SolutionCompilationStateChecksums Deserialize(ObjectReader reader)
-    {
-        var checksum = Checksum.ReadFrom(reader);
-        var solutionState = Checksum.ReadFrom(reader);
-        var sourceGeneratorExecutionVersionMap = Checksum.ReadFrom(reader);
-
-        var hasFrozenSourceGeneratedDocuments = reader.ReadBoolean();
-        DocumentChecksumsAndIds? frozenSourceGeneratedDocumentTexts = null;
-        ChecksumCollection? frozenSourceGeneratedDocumentIdentities = null;
-        ImmutableArray<DateTime> frozenSourceGeneratedDocumentGenerationDateTimes = default;
-
-        if (hasFrozenSourceGeneratedDocuments)
-        {
-            frozenSourceGeneratedDocumentTexts = DocumentChecksumsAndIds.ReadFrom(reader);
-            frozenSourceGeneratedDocumentIdentities = ChecksumCollection.ReadFrom(reader);
-            frozenSourceGeneratedDocumentGenerationDateTimes = reader.ReadArray(r => new DateTime(r.ReadInt64()));
-        }
-
-        var result = new SolutionCompilationStateChecksums(
-            solutionState: solutionState,
-            sourceGeneratorExecutionVersionMap: sourceGeneratorExecutionVersionMap,
-            frozenSourceGeneratedDocumentTexts,
-            frozenSourceGeneratedDocumentIdentities,
-            frozenSourceGeneratedDocumentGenerationDateTimes);
-        Contract.ThrowIfFalse(result.Checksum == checksum);
-        return result;
-    }
-
-    public async Task FindAsync<TArg>(
-        SolutionCompilationState compilationState,
-        ProjectCone? projectCone,
-        AssetPath assetPath,
-        HashSet<Checksum> searchingChecksumsLeft,
-        Action<Checksum, object, TArg> onAssetFound,
-        TArg arg,
-        CancellationToken cancellationToken)
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        if (searchingChecksumsLeft.Count == 0)
-            return;
-
-        if (assetPath.IncludeSolutionCompilationState)
-        {
-            if (assetPath.IncludeSolutionCompilationStateChecksums && searchingChecksumsLeft.Remove(this.Checksum))
-                onAssetFound(this.Checksum, this, arg);
-
-            if (assetPath.IncludeSolutionSourceGeneratorExecutionVersionMap && searchingChecksumsLeft.Remove(this.SourceGeneratorExecutionVersionMap))
-                onAssetFound(this.SourceGeneratorExecutionVersionMap, compilationState.SourceGeneratorExecutionVersionMap, arg);
-
-            if (compilationState.FrozenSourceGeneratedDocumentStates != null)
-            {
-                Contract.ThrowIfFalse(FrozenSourceGeneratedDocumentIdentities.HasValue);
-                Contract.ThrowIfFalse(FrozenSourceGeneratedDocuments.HasValue);
-
-                // This could either be the checksum for the text (which we'll use our regular helper for first)...
-                if (assetPath.IncludeSolutionFrozenSourceGeneratedDocumentText)
-                {
-                    await ChecksumCollection.FindAsync(
-                        new AssetPath(AssetPathKind.DocumentText, assetPath.ProjectId, assetPath.DocumentId),
-                        compilationState.FrozenSourceGeneratedDocumentStates, searchingChecksumsLeft, onAssetFound, arg, cancellationToken).ConfigureAwait(false);
-                }
-
-                // ... or one of the identities. In this case, we'll use the fact that there's a 1:1 correspondence between the
-                // two collections we hold onto.
-                if (assetPath.IncludeSolutionFrozenSourceGeneratedDocumentIdentities)
-                {
-                    var documentId = assetPath.DocumentId;
-                    if (documentId != null)
-                    {
-                        // If the caller is asking for a specific document, we can just look it up directly.
-                        var index = FrozenSourceGeneratedDocuments.Value.Ids.IndexOf(documentId);
-                        if (index >= 0)
-                        {
-                            var identityChecksum = FrozenSourceGeneratedDocumentIdentities.Value.Children[index];
-                            if (searchingChecksumsLeft.Remove(identityChecksum))
-                            {
-                                Contract.ThrowIfFalse(compilationState.FrozenSourceGeneratedDocumentStates.TryGetState(documentId, out var state));
-                                onAssetFound(identityChecksum, state.Identity, arg);
-                            }
-                        }
-                    }
-                    else
-                    {
-                        // Otherwise, we'll have to search through all of them.
-                        for (var i = 0; i < FrozenSourceGeneratedDocumentIdentities.Value.Count; i++)
-                        {
-                            var identityChecksum = FrozenSourceGeneratedDocumentIdentities.Value[0];
-                            if (searchingChecksumsLeft.Remove(identityChecksum))
-                            {
-                                var id = FrozenSourceGeneratedDocuments.Value.Ids[i];
-                                Contract.ThrowIfFalse(compilationState.FrozenSourceGeneratedDocumentStates.TryGetState(id, out var state));
-                                onAssetFound(identityChecksum, state.Identity, arg);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        var solutionState = compilationState.SolutionState;
-        if (projectCone is null)
-        {
-            // If we're not in a project cone, start the search at the top most state-checksum corresponding to the
-            // entire solution.
-            Contract.ThrowIfFalse(solutionState.TryGetStateChecksums(out var solutionChecksums));
-            await solutionChecksums.FindAsync(solutionState, projectCone, assetPath, searchingChecksumsLeft, onAssetFound, arg, cancellationToken).ConfigureAwait(false);
-        }
-        else
-        {
-            // Otherwise, grab the top-most state checksum for this cone and search within that.
-            Contract.ThrowIfFalse(solutionState.TryGetStateChecksums(projectCone.RootProjectId, out var solutionChecksums));
-            await solutionChecksums.FindAsync(solutionState, projectCone, assetPath, searchingChecksumsLeft, onAssetFound, arg, cancellationToken).ConfigureAwait(false);
-        }
-    }
-}
-
-/// <param name="projectConeId">The particular <see cref="ProjectId"/> if this was a checksum tree made for a particular
-/// project cone.</param>
-internal sealed class SolutionStateChecksums(
-    ProjectId? projectConeId,
-    Checksum attributes,
-    ProjectChecksumsAndIds projects,
-    ChecksumCollection analyzerReferences)
-{
-    private ProjectCone? _projectCone;
-
-    public Checksum Checksum { get; } = Checksum.Create(stackalloc[]
-    {
-        projectConeId == null ? Checksum.Null : projectConeId.Checksum,
-        attributes,
-        projects.Checksum,
-        analyzerReferences.Checksum,
-    });
-
-    public ProjectId? ProjectConeId { get; } = projectConeId;
-    public Checksum Attributes { get; } = attributes;
-    public ProjectChecksumsAndIds Projects { get; } = projects;
-    public ChecksumCollection AnalyzerReferences { get; } = analyzerReferences;
-
-    // Acceptably not threadsafe.  ProjectCone is a class, and the runtime guarantees anyone will see this field fully
-    // initialized.  It's acceptable to have multiple instances of this in a race condition as the data will be same
-    // (and our asserts don't check for reference equality, only value equality).
-    public ProjectCone? ProjectCone => _projectCone ??= ComputeProjectCone();
-
-    private ProjectCone? ComputeProjectCone()
-        => ProjectConeId == null ? null : new ProjectCone(ProjectConeId, Projects.Ids.ToFrozenSet());
-
-    public void AddAllTo(HashSet<Checksum> checksums)
-    {
-        checksums.AddIfNotNullChecksum(this.Checksum);
-        checksums.AddIfNotNullChecksum(this.Attributes);
-        this.Projects.Checksums.AddAllTo(checksums);
-        this.AnalyzerReferences.AddAllTo(checksums);
-    }
-
-    public void Serialize(ObjectWriter writer)
-    {
-        // Writing this is optional, but helps ensure checksums are being computed properly on both the host and oop side.
-        this.Checksum.WriteTo(writer);
-        writer.WriteBoolean(this.ProjectConeId != null);
-        this.ProjectConeId?.WriteTo(writer);
-
-        this.Attributes.WriteTo(writer);
-        this.Projects.WriteTo(writer);
-        this.AnalyzerReferences.WriteTo(writer);
-    }
-
-    public static SolutionStateChecksums Deserialize(ObjectReader reader)
-    {
-        var checksum = Checksum.ReadFrom(reader);
-
-        var result = new SolutionStateChecksums(
-            projectConeId: reader.ReadBoolean() ? ProjectId.ReadFrom(reader) : null,
-            attributes: Checksum.ReadFrom(reader),
-            projects: ProjectChecksumsAndIds.ReadFrom(reader),
-            analyzerReferences: ChecksumCollection.ReadFrom(reader));
-        Contract.ThrowIfFalse(result.Checksum == checksum);
-        return result;
-    }
-
-    public async Task FindAsync<TArg>(
-        SolutionState solution,
-        ProjectCone? projectCone,
-        AssetPath assetPath,
-        HashSet<Checksum> searchingChecksumsLeft,
-        Action<Checksum, object, TArg> onAssetFound,
-        TArg arg,
-        CancellationToken cancellationToken)
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        if (searchingChecksumsLeft.Count == 0)
-            return;
-
-        if (assetPath.IncludeSolutionState)
-        {
-            if (assetPath.IncludeSolutionStateChecksums && searchingChecksumsLeft.Remove(Checksum))
-                onAssetFound(Checksum, this, arg);
-
-            if (assetPath.IncludeSolutionAttributes && searchingChecksumsLeft.Remove(Attributes))
-                onAssetFound(Attributes, solution.SolutionAttributes, arg);
-
-            if (assetPath.IncludeSolutionAnalyzerReferences)
-                ChecksumCollection.Find(solution.AnalyzerReferences, AnalyzerReferences, searchingChecksumsLeft, onAssetFound, arg, cancellationToken);
-        }
-
-        if (searchingChecksumsLeft.Count == 0)
-            return;
-
-        if (assetPath.IncludeProjects || assetPath.IncludeDocuments)
-        {
-            if (assetPath.ProjectId is not null)
-            {
-                // Dive into this project to search for the remaining checksums.
-                Contract.ThrowIfTrue(
-                    projectCone != null && !projectCone.Contains(assetPath.ProjectId),
-                    "Requesting an asset outside of the cone explicitly being asked for!");
-
-                var projectState = solution.GetProjectState(assetPath.ProjectId);
-                if (projectState != null &&
-                    projectState.TryGetStateChecksums(out var projectStateChecksums))
-                {
-                    await projectStateChecksums.FindAsync(projectState, assetPath, searchingChecksumsLeft, onAssetFound, arg, cancellationToken).ConfigureAwait(false);
-                }
-            }
-            else
-            {
-                // Check all projects for the remaining checksums.
-
-                foreach (var (projectId, projectState) in solution.ProjectStates)
-                {
-                    cancellationToken.ThrowIfCancellationRequested();
-
-                    // If we have no more checksums, can immediately bail out.
-                    if (searchingChecksumsLeft.Count == 0)
-                        break;
-
-                    if (projectCone != null && !projectCone.Contains(projectId))
-                        continue;
-
-                    // It's possible not all all our projects have checksums.  Specifically, we may have only been asked to
-                    // compute the checksum tree for a subset of projects that were all that a feature needed.
-                    if (!projectState.TryGetStateChecksums(out var projectStateChecksums))
-                        continue;
-
-                    await projectStateChecksums.FindAsync(projectState, assetPath, searchingChecksumsLeft, onAssetFound, arg, cancellationToken).ConfigureAwait(false);
-                }
-            }
-        }
-    }
-}
-
-internal sealed class ProjectStateChecksums(
-    ProjectId projectId,
-    Checksum infoChecksum,
-    Checksum compilationOptionsChecksum,
-    Checksum parseOptionsChecksum,
-    ChecksumCollection projectReferenceChecksums,
-    ChecksumCollection metadataReferenceChecksums,
-    ChecksumCollection analyzerReferenceChecksums,
-    DocumentChecksumsAndIds documentChecksums,
-    DocumentChecksumsAndIds additionalDocumentChecksums,
-    DocumentChecksumsAndIds analyzerConfigDocumentChecksums) : IEquatable<ProjectStateChecksums>
-{
-    public Checksum Checksum { get; } = Checksum.Create(stackalloc[]
-    {
-        infoChecksum,
-        compilationOptionsChecksum,
-        parseOptionsChecksum,
-        documentChecksums.Checksum,
-        projectReferenceChecksums.Checksum,
-        metadataReferenceChecksums.Checksum,
-        analyzerReferenceChecksums.Checksum,
-        additionalDocumentChecksums.Checksum,
-        analyzerConfigDocumentChecksums.Checksum,
-    });
-
-    public ProjectId ProjectId => projectId;
-
-    public Checksum Info => infoChecksum;
-    public Checksum CompilationOptions => compilationOptionsChecksum;
-    public Checksum ParseOptions => parseOptionsChecksum;
-
-    public ChecksumCollection ProjectReferences => projectReferenceChecksums;
-    public ChecksumCollection MetadataReferences => metadataReferenceChecksums;
-    public ChecksumCollection AnalyzerReferences => analyzerReferenceChecksums;
-
-    public DocumentChecksumsAndIds Documents => documentChecksums;
-    public DocumentChecksumsAndIds AdditionalDocuments => additionalDocumentChecksums;
-    public DocumentChecksumsAndIds AnalyzerConfigDocuments => analyzerConfigDocumentChecksums;
-
-    public override bool Equals(object? obj)
-        => Equals(obj as ProjectStateChecksums);
-
-    public bool Equals(ProjectStateChecksums? obj)
-        => this.Checksum == obj?.Checksum;
-
-    public override int GetHashCode()
-        => this.Checksum.GetHashCode();
-
-    public void AddAllTo(HashSet<Checksum> checksums)
-    {
-        checksums.AddIfNotNullChecksum(this.Checksum);
-        checksums.AddIfNotNullChecksum(this.Info);
-        checksums.AddIfNotNullChecksum(this.CompilationOptions);
-        checksums.AddIfNotNullChecksum(this.ParseOptions);
-        this.ProjectReferences.AddAllTo(checksums);
-        this.MetadataReferences.AddAllTo(checksums);
-        this.AnalyzerReferences.AddAllTo(checksums);
-        this.Documents.AddAllTo(checksums);
-        this.AdditionalDocuments.AddAllTo(checksums);
-        this.AnalyzerConfigDocuments.AddAllTo(checksums);
-    }
-
-    public void Serialize(ObjectWriter writer)
-    {
-        // Writing this is optional, but helps ensure checksums are being computed properly on both the host and oop side.
-        this.Checksum.WriteTo(writer);
-
-        this.ProjectId.WriteTo(writer);
-        this.Info.WriteTo(writer);
-        this.CompilationOptions.WriteTo(writer);
-        this.ParseOptions.WriteTo(writer);
-        this.ProjectReferences.WriteTo(writer);
-        this.MetadataReferences.WriteTo(writer);
-        this.AnalyzerReferences.WriteTo(writer);
-        this.Documents.WriteTo(writer);
-        this.AdditionalDocuments.WriteTo(writer);
-        this.AnalyzerConfigDocuments.WriteTo(writer);
-    }
-
-    public static ProjectStateChecksums Deserialize(ObjectReader reader)
-    {
-        var checksum = Checksum.ReadFrom(reader);
-        var result = new ProjectStateChecksums(
-            projectId: ProjectId.ReadFrom(reader),
-            infoChecksum: Checksum.ReadFrom(reader),
-            compilationOptionsChecksum: Checksum.ReadFrom(reader),
-            parseOptionsChecksum: Checksum.ReadFrom(reader),
-            projectReferenceChecksums: ChecksumCollection.ReadFrom(reader),
-            metadataReferenceChecksums: ChecksumCollection.ReadFrom(reader),
-            analyzerReferenceChecksums: ChecksumCollection.ReadFrom(reader),
-            documentChecksums: DocumentChecksumsAndIds.ReadFrom(reader),
-            additionalDocumentChecksums: DocumentChecksumsAndIds.ReadFrom(reader),
-            analyzerConfigDocumentChecksums: DocumentChecksumsAndIds.ReadFrom(reader));
-        Contract.ThrowIfFalse(result.Checksum == checksum);
-        return result;
-    }
-
-    public async Task FindAsync<TArg>(
-        ProjectState state,
-        AssetPath assetPath,
-        HashSet<Checksum> searchingChecksumsLeft,
-        Action<Checksum, object, TArg> onAssetFound,
-        TArg arg,
-        CancellationToken cancellationToken)
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        // verify input
-        Contract.ThrowIfFalse(state.TryGetStateChecksums(out var stateChecksum));
-        Contract.ThrowIfFalse(this == stateChecksum);
-
-        if (searchingChecksumsLeft.Count == 0)
-            return;
-
-        if (assetPath.IncludeProjects)
-        {
-            if (assetPath.IncludeProjectStateChecksums && searchingChecksumsLeft.Remove(Checksum))
-                onAssetFound(Checksum, this, arg);
-
-            if (assetPath.IncludeProjectAttributes && searchingChecksumsLeft.Remove(Info))
-                onAssetFound(Info, state.ProjectInfo.Attributes, arg);
-
-            if (assetPath.IncludeProjectCompilationOptions && searchingChecksumsLeft.Remove(CompilationOptions))
-            {
-                var compilationOptions = state.CompilationOptions ?? throw new InvalidOperationException("We should not be trying to serialize a project with no compilation options; RemoteSupportedLanguages.IsSupported should have filtered it out.");
-                onAssetFound(CompilationOptions, compilationOptions, arg);
-            }
-
-            if (assetPath.IncludeProjectParseOptions && searchingChecksumsLeft.Remove(ParseOptions))
-            {
-                var parseOptions = state.ParseOptions ?? throw new InvalidOperationException("We should not be trying to serialize a project with no parse options; RemoteSupportedLanguages.IsSupported should have filtered it out.");
-                onAssetFound(ParseOptions, parseOptions, arg);
-            }
-
-            if (assetPath.IncludeProjectProjectReferences)
-                ChecksumCollection.Find(state.ProjectReferences, ProjectReferences, searchingChecksumsLeft, onAssetFound, arg, cancellationToken);
-
-            if (assetPath.IncludeProjectMetadataReferences)
-                ChecksumCollection.Find(state.MetadataReferences, MetadataReferences, searchingChecksumsLeft, onAssetFound, arg, cancellationToken);
-
-            if (assetPath.IncludeProjectAnalyzerReferences)
-                ChecksumCollection.Find(state.AnalyzerReferences, AnalyzerReferences, searchingChecksumsLeft, onAssetFound, arg, cancellationToken);
-        }
-
-        if (assetPath.IncludeDocuments)
-        {
-            await ChecksumCollection.FindAsync(assetPath, state.DocumentStates, searchingChecksumsLeft, onAssetFound, arg, cancellationToken).ConfigureAwait(false);
-            await ChecksumCollection.FindAsync(assetPath, state.AdditionalDocumentStates, searchingChecksumsLeft, onAssetFound, arg, cancellationToken).ConfigureAwait(false);
-            await ChecksumCollection.FindAsync(assetPath, state.AnalyzerConfigDocumentStates, searchingChecksumsLeft, onAssetFound, arg, cancellationToken).ConfigureAwait(false);
-        }
-    }
-
-    public override string ToString()
-        => $"""
-            ProjectStateChecksums({ProjectId})
-                Info={Info}
-                CompilationOptions={CompilationOptions}
-                ParseOptions={ParseOptions}
-                ProjectReferences={ProjectReferences.Checksum}
-                MetadataReferences={MetadataReferences.Checksum}
-                AnalyzerReferences={AnalyzerReferences.Checksum}
-                Documents={Documents.Checksum}
-                AdditionalDocuments={AdditionalDocuments.Checksum}
-                AnalyzerConfigDocuments={AnalyzerConfigDocuments.Checksum}
-            """;
-}
-*/
-internal sealed class DocumentStateChecksums(
-    DocumentId documentId,
-    Checksum infoChecksum,
-    Checksum textChecksum)
-{
-    public Checksum Checksum { get; } = Checksum.Create(infoChecksum, textChecksum);
-
-    public DocumentId DocumentId => documentId;
-    public Checksum Info => infoChecksum;
-    public Checksum Text => textChecksum;
-
-    public void AddAllTo(HashSet<Checksum> checksums)
-    {
-        checksums.AddIfNotNullChecksum(this.Info);
-        checksums.AddIfNotNullChecksum(this.Text);
-    }
-
-    public async Task FindAsync<TArg>(
-        AssetPath assetPath,
-        TextDocumentState state,
-        HashSet<Checksum> searchingChecksumsLeft,
-        Action<Checksum, object, TArg> onAssetFound,
-        TArg arg,
-        CancellationToken cancellationToken)
-    {
-        Debug.Assert(state.TryGetStateChecksums(out var stateChecksum) && this == stateChecksum);
-
-        cancellationToken.ThrowIfCancellationRequested();
-
-        if (assetPath.IncludeDocumentAttributes && searchingChecksumsLeft.Remove(Info))
-            onAssetFound(Info, state.Attributes, arg);
-
-        if (assetPath.IncludeDocumentText && searchingChecksumsLeft.Remove(Text))
-        {
-            var text = await SerializableSourceText.FromTextDocumentStateAsync(state, cancellationToken).ConfigureAwait(false);
-            onAssetFound(Text, text, arg);
-        }
-    }
-
-    public override string ToString()
-        => $"DocumentStateChecksums({DocumentId})";
-}
-
-/*
-/// <summary>
-/// hold onto object checksum that currently doesn't have a place to hold onto checksum
-/// </summary>
-internal static class ChecksumCache
-{
-    public static Checksum GetOrCreate<TValue, TArg>(TValue value, Func<TValue, TArg, Checksum> checksumCreator, TArg arg)
-        where TValue : class
-    {
-        return StronglyTypedChecksumCache<TValue, Checksum>.GetOrCreate(value, checksumCreator, arg);
-    }
-
-    public static ChecksumCollection GetOrCreateChecksumCollection<TReference>(
-        IReadOnlyList<TReference> references, ISerializerService serializer, CancellationToken cancellationToken) where TReference : class
-    {
-        return StronglyTypedChecksumCache<IReadOnlyList<TReference>, ChecksumCollection>.GetOrCreate(
-            references,
-            static (references, tuple) =>
-            {
-                var checksums = new FixedSizeArrayBuilder<Checksum>(references.Count);
-                foreach (var reference in references)
-                    checksums.Add(tuple.serializer.CreateChecksum(reference, tuple.cancellationToken));
-
-                return new ChecksumCollection(checksums.MoveToImmutable());
-            },
-            (serializer, cancellationToken));
-    }
-
-    private static class StronglyTypedChecksumCache<TValue, TResult>
-        where TValue : class
-        where TResult : struct
-    {
-        private static readonly ConditionalWeakTable<TValue, StrongBox<TResult>> s_objectToChecksumCollectionCache = new();
-
-        public static TResult GetOrCreate<TArg>(TValue value, Func<TValue, TArg, TResult> checksumCreator, TArg arg)
-        {
-            if (s_objectToChecksumCollectionCache.TryGetValue(value, out var checksumCollection))
-                return checksumCollection.Value;
-
-            return GetOrCreateSlow(value, checksumCreator, arg);
-
-            static TResult GetOrCreateSlow(TValue value, Func<TValue, TArg, TResult> checksumCreator, TArg arg)
-                => s_objectToChecksumCollectionCache.GetValue(value, _ => new StrongBox<TResult>(checksumCreator(value, arg))).Value;
-        }
-    }
-}
-*/
\ No newline at end of file
diff --git a/MSBuildLanguageServer/Import/TextDocumentState.cs b/MSBuildLanguageServer/Import/TextDocumentState.cs
deleted file mode 100644
index fcddff26..00000000
--- a/MSBuildLanguageServer/Import/TextDocumentState.cs
+++ /dev/null
@@ -1,258 +0,0 @@
-// modified copy of
-// https://raw.githubusercontent.com/dotnet/roslyn/dd3795a49875bef2728f01e0284406f33ea1e2e1/src/Workspaces/Core/Portable/Workspace/Solution/TextDocumentState.cs
-// with portions commented out using /* */ comments
-// and other changes annotated inline with // MODIFICATION
-
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-// changes annotated inline with // MODIFICATION
-// with portions commented out using /* */ comments
-
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.Threading;
-using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.Host;
-using Microsoft.CodeAnalysis.Serialization;
-using Microsoft.CodeAnalysis.Text;
-using Roslyn.Utilities;
-
-namespace Microsoft.CodeAnalysis;
-
-internal partial class TextDocumentState
-{
-    protected readonly SolutionServices solutionServices;
-    internal ITextAndVersionSource TextAndVersionSource { get; }
-    public readonly LoadTextOptions LoadTextOptions;
-
-    // Checksums for this solution state
-    private readonly AsyncLazy<DocumentStateChecksums> _lazyChecksums;
-/*
-    public DocumentInfo.DocumentAttributes Attributes { get; }
-
-    /// <summary>
-    /// A <see cref="IDocumentServiceProvider"/> associated with this document
-    /// </summary>
-    public IDocumentServiceProvider Services { get; }
-*/
-    protected TextDocumentState(
-        SolutionServices solutionServices,
-        /*
-        IDocumentServiceProvider? documentServiceProvider,
-        DocumentInfo.DocumentAttributes attributes,*/
-        ITextAndVersionSource textAndVersionSource,
-        LoadTextOptions loadTextOptions)
-    {
-        this.solutionServices = solutionServices;
-
-        this.LoadTextOptions = loadTextOptions;
-        TextAndVersionSource = textAndVersionSource;
-/*
-        Attributes = attributes;
-        Services = documentServiceProvider ?? DefaultTextDocumentServiceProvider.Instance;
-*/
-        // This constructor is called whenever we're creating a new TextDocumentState from another
-        // TextDocumentState, and so we populate all the fields from the inputs. We will always create
-        // a new AsyncLazy to compute the checksum though, and that's because there's no practical way for
-        // the newly created TextDocumentState to have the same checksum as a previous TextDocumentState:
-        // if we're creating a new state, it's because something changed, and we'll have to create a new checksum.
-        _lazyChecksums = AsyncLazy.Create(static (self, cancellationToken) => self.ComputeChecksumsAsync(cancellationToken), arg: this);
-    }
-
-    public TextDocumentState(SolutionServices solutionServices, DocumentInfo info, LoadTextOptions loadTextOptions)
-        : this(solutionServices,
-               info.DocumentServiceProvider,
-               info.Attributes,
-               textAndVersionSource: info.TextLoader != null
-                ? CreateTextFromLoader(info.TextLoader, PreservationMode.PreserveValue, solutionServices)
-                : CreateStrongText(TextAndVersion.Create(SourceText.From(string.Empty, encoding: null, loadTextOptions.ChecksumAlgorithm), VersionStamp.Default, info.FilePath)),
-               loadTextOptions)
-    {
-    }
-
-    public DocumentId Id => Attributes.Id;
-    public string? FilePath => Attributes.FilePath;
-    public IReadOnlyList<string> Folders => Attributes.Folders;
-    public string Name => Attributes.Name;
-
-    private static ITextAndVersionSource CreateStrongText(TextAndVersion text)
-        => new ConstantTextAndVersionSource(text);
-
-    private static ITextAndVersionSource CreateRecoverableText(TextAndVersion text, SolutionServices services)
-    {
-        /*
-        var service = services.GetRequiredService<IWorkspaceConfigurationService>();
-        var options = service.Options;
-        */
-
-        return /*options.DisableRecoverableText
-            ? CreateStrongText(text)
-            : */new RecoverableTextAndVersion(new ConstantTextAndVersionSource(text), services);
-    }
-
-    public ITemporaryStorageTextHandle? StorageHandle
-        => (TextAndVersionSource as RecoverableTextAndVersion)?.StorageHandle;
-
-    public bool TryGetText([NotNullWhen(returnValue: true)] out SourceText? text)
-    {
-        if (this.TextAndVersionSource.TryGetValue(LoadTextOptions, out var textAndVersion))
-        {
-            text = textAndVersion.Text;
-            return true;
-        }
-        else
-        {
-            text = null;
-            return false;
-        }
-    }
-
-    public bool TryGetTextVersion(out VersionStamp version)
-        => TextAndVersionSource.TryGetVersion(LoadTextOptions, out version);
-
-    public bool TryGetTextAndVersion([NotNullWhen(true)] out TextAndVersion? textAndVersion)
-        => TextAndVersionSource.TryGetValue(LoadTextOptions, out textAndVersion);
-
-    public ValueTask<SourceText> GetTextAsync(CancellationToken cancellationToken)
-    {
-        if (TryGetText(out var text))
-        {
-            return new ValueTask<SourceText>(text);
-        }
-
-        return SpecializedTasks.TransformWithoutIntermediateCancellationExceptionAsync(
-            static (self, cancellationToken) => self.GetTextAndVersionAsync(cancellationToken),
-            static (textAndVersion, _) => textAndVersion.Text,
-            this,
-            cancellationToken);
-    }
-
-    public SourceText GetTextSynchronously(CancellationToken cancellationToken)
-    {
-        var textAndVersion = this.TextAndVersionSource.GetValue(LoadTextOptions, cancellationToken);
-        return textAndVersion.Text;
-    }
-
-    public VersionStamp GetTextVersionSynchronously(CancellationToken cancellationToken)
-    {
-        var textAndVersion = this.TextAndVersionSource.GetValue(LoadTextOptions, cancellationToken);
-        return textAndVersion.Version;
-    }
-
-    public async Task<VersionStamp> GetTextVersionAsync(CancellationToken cancellationToken)
-    {
-        // try fast path first
-        if (TryGetTextVersion(out var version))
-        {
-            return version;
-        }
-
-        var textAndVersion = await GetTextAndVersionAsync(cancellationToken).ConfigureAwait(false);
-        return textAndVersion.Version;
-    }
-
-    public TextDocumentState UpdateText(TextAndVersion newTextAndVersion, PreservationMode mode)
-    {
-        var newTextSource = mode == PreservationMode.PreserveIdentity
-            ? CreateStrongText(newTextAndVersion)
-            : CreateRecoverableText(newTextAndVersion, solutionServices);
-
-        return UpdateText(newTextSource, mode, incremental: true);
-    }
-
-    public TextDocumentState UpdateText(SourceText newText, PreservationMode mode)
-    {
-        var newVersion = GetNewerVersion();
-        var newTextAndVersion = TextAndVersion.Create(newText, newVersion, FilePath);
-
-        return UpdateText(newTextAndVersion, mode);
-    }
-
-    public TextDocumentState UpdateText(TextLoader loader, PreservationMode mode)
-    {
-        // don't blow up on non-text documents.
-        var newTextSource = CreateTextFromLoader(loader, mode, this.solutionServices);
-
-        return UpdateText(newTextSource, mode, incremental: false);
-    }
-
-    private static ITextAndVersionSource CreateTextFromLoader(TextLoader loader, PreservationMode mode, SolutionServices solutionServices)
-    {
-        /*
-        var service = solutionServices.GetRequiredService<IWorkspaceConfigurationService>();
-        var options = service.Options;
-
-        // If the caller is explicitly stating that identity must be preserved, then we created a source that will load
-        // from the loader the first time, but then cache that result so that hte same result is *always* returned.
-        if (mode == PreservationMode.PreserveIdentity || options.DisableRecoverableText)
-            return new LoadableTextAndVersionSource(loader, cacheResult: true);
-        */
-
-        // If the loader asks us to always hold onto it strongly, then we do not want to create a recoverable text
-        // source here.  Instead, we'll go back to the loader each time to get the text.  This is useful for when the
-        // loader knows it can always reconstitute the snapshot exactly as it was before.  For example, if the loader
-        // points at the contents of a memory mapped file in another process.
-        if (loader.AlwaysHoldStrongly)
-            return new LoadableTextAndVersionSource(loader, cacheResult: false);
-
-        // Otherwise, we just want to hold onto this loader by value.  So we create a loader that will load the
-        // contents, but not hold onto them strongly, and we wrap it in a recoverable-text that will then take those
-        // contents and dump it into a memory-mapped-file in this process so that snapshot semantics can be preserved.
-        return new RecoverableTextAndVersion(new LoadableTextAndVersionSource(loader, cacheResult: false), solutionServices);
-    }
-
-    protected virtual TextDocumentState UpdateText(ITextAndVersionSource newTextSource, PreservationMode mode, bool incremental)
-    {
-        return new TextDocumentState(
-            solutionServices,
-            this.Services,
-            this.Attributes,
-            textAndVersionSource: newTextSource,
-            LoadTextOptions);
-    }
-
-    private ValueTask<TextAndVersion> GetTextAndVersionAsync(CancellationToken cancellationToken)
-    {
-        if (this.TextAndVersionSource.TryGetValue(LoadTextOptions, out var textAndVersion))
-        {
-            return new ValueTask<TextAndVersion>(textAndVersion);
-        }
-        else
-        {
-            return new ValueTask<TextAndVersion>(TextAndVersionSource.GetValueAsync(LoadTextOptions, cancellationToken));
-        }
-    }
-
-    internal virtual async Task<Diagnostic?> GetLoadDiagnosticAsync(CancellationToken cancellationToken)
-        => (await GetTextAndVersionAsync(cancellationToken).ConfigureAwait(false)).LoadDiagnostic;
-
-    private VersionStamp GetNewerVersion()
-    {
-        if (this.TextAndVersionSource.TryGetValue(LoadTextOptions, out var textAndVersion))
-        {
-            return textAndVersion.Version.GetNewerVersion();
-        }
-
-        return VersionStamp.Create();
-    }
-
-    public virtual ValueTask<VersionStamp> GetTopLevelChangeTextVersionAsync(CancellationToken cancellationToken)
-        => this.TextAndVersionSource.GetVersionAsync(LoadTextOptions, cancellationToken);
-
-    /// <summary>
-    /// Only checks if the source of the text has changed, no content check is done.
-    /// </summary>
-    public bool HasTextChanged(TextDocumentState oldState, bool ignoreUnchangeableDocument)
-    {
-        if (ignoreUnchangeableDocument && !oldState.CanApplyChange())
-        {
-            return false;
-        }
-
-        return oldState.TextAndVersionSource != TextAndVersionSource;
-    }
-
-    public bool HasInfoChanged(TextDocumentState oldState)
-        => oldState.Attributes != Attributes;
-}
\ No newline at end of file
diff --git a/MSBuildLanguageServer/Import/VisualStudioMefHostServices.cs b/MSBuildLanguageServer/Import/VisualStudioMefHostServices.cs
new file mode 100644
index 00000000..7854eb27
--- /dev/null
+++ b/MSBuildLanguageServer/Import/VisualStudioMefHostServices.cs
@@ -0,0 +1,101 @@
+// modified copy of
+// https://raw.githubusercontent.com/dotnet/roslyn/dd3795a49875bef2728f01e0284406f33ea1e2e1/src/Workspaces/Remote/Core/VisualStudioMefHostServices.cs
+// portions commented out using /* */ comments
+// and other changes annotated inline with // MODIFICATION
+
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using Microsoft.VisualStudio.Composition;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.Host.Mef
+{
+    /// <summary>
+    /// Provides host services imported via VS MEF.
+    /// </summary>
+    internal sealed class VisualStudioMefHostServices : HostServices, IMefHostExportProvider
+    {
+        // the export provider for the MEF composition
+        private readonly ExportProvider _exportProvider;
+
+        // accumulated cache for exports
+        private ImmutableDictionary<ExportKey, IEnumerable> _exportsMap
+            = ImmutableDictionary<ExportKey, IEnumerable>.Empty;
+
+        private VisualStudioMefHostServices(ExportProvider exportProvider)
+        {
+            Contract.ThrowIfNull(exportProvider);
+            _exportProvider = exportProvider;
+        }
+
+        public static VisualStudioMefHostServices Create(ExportProvider exportProvider)
+            => new(exportProvider);
+
+        /// <summary>
+        /// Creates a new <see cref="HostWorkspaceServices"/> associated with the specified workspace.
+        /// </summary>
+        // MODIFICATION: changed "protected internal" to "protected" as we don't have IVT for HostServices
+        protected override HostWorkspaceServices CreateWorkspaceServices(Workspace workspace)
+            => new MefWorkspaceServices(this, workspace);
+
+        /// <summary>
+        /// Gets all the MEF exports of the specified type with the specified metadata.
+        /// </summary>
+        public IEnumerable<Lazy<TExtension, TMetadata>> GetExports<TExtension, TMetadata>()
+        {
+            var key = new ExportKey(typeof(TExtension).AssemblyQualifiedName!, typeof(TMetadata).AssemblyQualifiedName!);
+            if (!_exportsMap.TryGetValue(key, out var exports))
+            {
+                exports = ImmutableInterlocked.GetOrAdd(ref _exportsMap, key, _ =>
+                {
+                    return _exportProvider.GetExports<TExtension, TMetadata>().ToImmutableArray();
+                });
+            }
+
+            return (IEnumerable<Lazy<TExtension, TMetadata>>)exports;
+        }
+
+        /// <summary>
+        /// Gets all the MEF exports of the specified type.
+        /// </summary>
+        public IEnumerable<Lazy<TExtension>> GetExports<TExtension>()
+        {
+            var key = new ExportKey(typeof(TExtension).AssemblyQualifiedName!, "");
+            if (!_exportsMap.TryGetValue(key, out var exports))
+            {
+                exports = ImmutableInterlocked.GetOrAdd(ref _exportsMap, key, _ =>
+                    _exportProvider.GetExports<TExtension>().ToImmutableArray());
+            }
+
+            return (IEnumerable<Lazy<TExtension>>)exports;
+        }
+
+        private readonly struct ExportKey : IEquatable<ExportKey>
+        {
+            internal readonly string ExtensionTypeName;
+            internal readonly string MetadataTypeName;
+
+            public ExportKey(string extensionTypeName, string metadataTypeName)
+            {
+                ExtensionTypeName = extensionTypeName;
+                MetadataTypeName = metadataTypeName;
+            }
+
+            public bool Equals(ExportKey other)
+                => string.Compare(ExtensionTypeName, other.ExtensionTypeName, StringComparison.OrdinalIgnoreCase) == 0 &&
+                   string.Compare(MetadataTypeName, other.MetadataTypeName, StringComparison.OrdinalIgnoreCase) == 0;
+
+            public override bool Equals(object? obj)
+                => obj is ExportKey key && Equals(key);
+
+            public override int GetHashCode()
+                => Hash.Combine(MetadataTypeName.GetHashCode(), ExtensionTypeName.GetHashCode());
+        }
+    }
+}
\ No newline at end of file
diff --git a/MSBuildLanguageServer/Import/Workspace_Imported.cs b/MSBuildLanguageServer/Import/Workspace_Imported.cs
deleted file mode 100644
index ee4da997..00000000
--- a/MSBuildLanguageServer/Import/Workspace_Imported.cs
+++ /dev/null
@@ -1,47 +0,0 @@
-// code fragments from
-// https://github.com/dotnet/roslyn/blob/dd3795a49875bef2728f01e0284406f33ea1e2e1/src/Workspaces/Core/Portable/Workspace/Workspace.cs
-// and
-// https://github.com/dotnet/roslyn/blob/dd3795a49875bef2728f01e0284406f33ea1e2e1/src/Workspaces/Core/Portable/Workspace/Workspace_Events.cs
-
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using System.Diagnostics.CodeAnalysis;
-using Microsoft.CodeAnalysis.Host;
-using Roslyn.Utilities;
-
-namespace MonoDevelop.MSBuild.Editor.LanguageServer;
-
-partial class Workspace
-{
-    readonly HostWorkspaceServices _services;
-    readonly TaskQueue _taskQueue;
-
-    internal string? Kind => "Host";
-
-    protected Workspace(HostServices host)
-    {
-        _services = host.CreateWorkspaceServices(this);
-
-        var schedulerProvider = _services.GetRequiredService<ITaskSchedulerProvider>();
-        var listenerProvider = _services.GetRequiredService<IWorkspaceAsynchronousOperationListenerProvider>();
-        _taskQueue = new TaskQueue(listenerProvider.GetListener(), schedulerProvider.CurrentContextScheduler);
-    }
-
-    public HostWorkspaceServices Services => _services;
-
-    /// <summary>
-    /// Executes an action as a background task, as part of a sequential queue of tasks.
-    /// </summary>
-    [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
-    protected internal Task ScheduleTask(Action action, string? taskName = "Workspace.Task")
-        => _taskQueue.ScheduleTask(taskName ?? "Workspace.Task", action, CancellationToken.None);
-
-    /// <summary>
-    /// Execute a function as a background task, as part of a sequential queue of tasks.
-    /// </summary>
-    [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
-    protected internal Task<T> ScheduleTask<T>(Func<T> func, string? taskName = "Workspace.Task")
-        => _taskQueue.ScheduleTask(taskName ?? "Workspace.Task", func, CancellationToken.None);
-}
diff --git a/MSBuildLanguageServer/MSBuildLanguageServer.csproj b/MSBuildLanguageServer/MSBuildLanguageServer.csproj
index 5f56ad2e..9f90629f 100644
--- a/MSBuildLanguageServer/MSBuildLanguageServer.csproj
+++ b/MSBuildLanguageServer/MSBuildLanguageServer.csproj
@@ -7,6 +7,11 @@
     <RootNamespace>MonoDevelop.MSBuild.Editor.LanguageServer</RootNamespace>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <OutputType>Exe</OutputType>
+    <!--
+    Makes some of the imported roslyn code compile unmodified.
+    May have other implications but none found so far.
+    -->
+    <DefineConstants>$(DefineConstants);CODE_STYLE</DefineConstants>
     <NoWarn>
       $(NoWarn);
       <!--
@@ -101,7 +106,6 @@
     <Compile Remove="../external/roslyn/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/NewtonsoftLanguageServer.cs" />
     <Compile Include="../external/roslyn/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Workspace/Mef/IMefHostExportProvider.cs" />
     <Compile Include="../external/roslyn/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostServicesProvider.cs" />
-    <Compile Include="../external/roslyn/src/Workspaces/Remote/Core/VisualStudioMefHostServices.cs" />
     <Compile Include="../external/roslyn/src/Features/LanguageServer/Protocol/Handler/DocumentChanges/DidOpenHandler.cs" />
     <Compile Include="../external/roslyn/src/Features/LanguageServer/Protocol/Handler/DocumentChanges/DidChangeHandler.cs" />
     <Compile Include="../external/roslyn/src/Features/LanguageServer/Protocol/Handler/DocumentChanges/DidCloseHandler.cs" />
@@ -109,34 +113,14 @@
     <Compile Include="../external/roslyn/src/Features/LanguageServer/Protocol/Handler/IDocumentChangeTracker.cs" />
     <Compile Include="../external/roslyn/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/SpecializedTasks.cs" />
     <Compile Include="../external/roslyn/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/FixedSizeArrayBuilder.cs" />
-    <Compile Include="../external/roslyn/src/Workspaces/Core/Portable/Workspace/Host/TaskScheduler/ITaskSchedulerProvider.cs" />
-    <Compile Include="../external/roslyn/src/Workspaces/Core/Portable/Workspace/Host/IWorkspaceService.cs" />
-    <Compile Include="../external/roslyn/src/Workspaces/Core/Portable/Workspace/Host/TaskScheduler/IWorkspaceAsynchronousOperationListenerProvider.cs" />
-    <Compile Include="../external/roslyn/src/Workspaces/Core/Portable/Utilities/TaskQueue.cs" />
-    <Compile Include="../external/roslyn/src/Workspaces/Core/Portable/Workspace/Solution/TextLoader.cs" />
-    <Compile Include="../external/roslyn/src/Workspaces/Core/Portable/Workspace/Solution/TextAndVersion.cs" />
-    <Compile Include="../external/roslyn/src/Workspaces/Core/Portable/Workspace/Solution/TextDocumentState_Checksum.cs" />
-    <Compile Include="../external/roslyn/src/Workspaces/Core/Portable/Workspace/Solution/TextDocumentStates.cs" />
-    <Compile Include="../external/roslyn/src/Workspaces/Core/Portable/Workspace/Solution/VersionSource/ITextAndVersionSource.cs" />
-    <Compile Include="../external/roslyn/src/Workspaces/Core/Portable/Workspace/Solution/ConstantTextAndVersionSource.cs" />
-    <Compile Include="../external/roslyn/src/Workspaces/Core/Portable/Workspace/Solution/LoadTextOptions.cs" />
-    <Compile Include="../external/roslyn/src/Workspaces/Core/Portable/Workspace/Solution/PreservationMode.cs" />
-    <Compile Include="../external/roslyn/src/Workspaces/Core/Portable/Workspace/Host/TemporaryStorage/ITemporaryStorageTextHandle.cs" />
-    <Compile Include="../external/roslyn/src/Workspaces/Core/Portable/Workspace/Solution/VersionSource/RecoverableTextAndVersion.cs" />
-    <Compile Include="../external/roslyn/src/Workspaces/Core/Portable/Workspace/Solution/VersionStamp.cs" />
-    <Compile Include="../external/roslyn/src/Workspaces/Core/Portable/Workspace/Solution/Checksum.cs" />
-    <Compile Include="../external/roslyn/src/Workspaces/Core/Portable/Workspace/Solution/Checksum_Factory.cs" />
-    <Compile Include="../external/roslyn/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/AsyncLazy.cs" />
-    <Compile Include="../external/roslyn/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/AsyncLazy`1.cs" />
-    <Compile Include="../external/roslyn/src/Workspaces/Core/Portable/Serialization/SerializableSourceText.cs" />
-    <Compile Include="../external/roslyn/src/Workspaces/Core/Portable/Workspace/Solution/VersionSource/LoadableTextAndVersionSource.cs" />
-    <Compile Include="../external/roslyn/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Helpers/MefHostServicesHelpers.cs" />
-    <Compile Include="../external/roslyn/src/Workspaces/Core/Portable/Workspace/Host/HostServices.cs" />
-    <Compile Include="../external/roslyn/src/Workspaces/Core/Portable/Workspace/Host/Mef/ExportWorkspaceServiceAttribute.cs" />
     <Compile Include="../external/roslyn/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Workspace/Mef/WorkspaceServiceMetadata.cs" />
-    <Compile Include="../external/roslyn/src/Workspaces/Core/Portable/Workspace/Host/Mef/IWorkspaceServiceFactory.cs" />
+    <Compile Include="../external/roslyn/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Workspace/Mef/LanguageServiceMetadata.cs" />
+    <Compile Include="../external/roslyn/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Workspace/Mef/MefLanguageServices.cs" />
     <Compile Include="../external/roslyn/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Workspace/Mef/LayeredServiceUtilities.cs" />
+    <Compile Include="../external/roslyn/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Workspace/Mef/MefWorkspaceServices.cs" />
     <Compile Include="../external/roslyn/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Workspace/Mef/ILayeredServiceMetadata.cs" />
+    <Compile Include="../external/roslyn/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Workspace/Mef/ILanguageMetadata.cs" />
+    <Compile Include="../external/roslyn/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/IDictionaryExtensions.cs" />
   </ItemGroup>
 
   <Import Project="../external/roslyn/src/Dependencies/PooledObjects/Microsoft.CodeAnalysis.PooledObjects.projitems" Label="Shared" />
@@ -149,6 +133,8 @@
       LogicalName="Microsoft.CodeAnalysis.LanguageServer.LanguageServerProtocolResources" />
     <EmbeddedResource Include="../external/roslyn/src/Compilers/Core/Portable/CodeAnalysisResources.resx"
       GenerateSource="true" ClassName="Microsoft.CodeAnalysis.CodeAnalysisResources" />
+    <EmbeddedResource Include="../external/roslyn/src/CodeStyle/Core/Analyzers/CodeStyleResources.resx"
+      GenerateSource="true" ClassName="Microsoft.CodeAnalysis.CodeStyleResources" />
   </ItemGroup>
 
   <ItemGroup>
@@ -173,14 +159,8 @@
     <PackageReference Include="System.CommandLine" />
     <PackageReference Include="System.Text.Json" />
     <PackageReference Include="StreamJsonRpc" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <Using Include="MonoDevelop.MSBuild.Editor.LanguageServer.Workspace" Alias="Workspace" />
-    <Using Include="MonoDevelop.MSBuild.Editor.LanguageServer.DocumentId" Alias="DocumentId" />
-    <!-- we don't have solutions or projects, so merge the solution and workspace services -->
-    <Using Include="MonoDevelop.MSBuild.Editor.LanguageServer.WorkspaceServices" Alias="SolutionServices" />
-    <Using Include="MonoDevelop.MSBuild.Editor.LanguageServer.WorkspaceServices" Alias="HostWorkspaceServices" />
+    <PackageReference Include="Microsoft.CodeAnalysis.Common" PrivateAssets="runtime" />
+    <PackageReference Include="Microsoft.CodeAnalysis.Workspaces.Common" PrivateAssets="runtime" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/MSBuildLanguageServer/Workspace.cs b/MSBuildLanguageServer/Workspace.cs
deleted file mode 100644
index 51e559a1..00000000
--- a/MSBuildLanguageServer/Workspace.cs
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-// Licensed under the MIT license. See LICENSE file in the project root for full license information.
-
-using System.Diagnostics.CodeAnalysis;
-
-namespace MonoDevelop.MSBuild.Editor.LanguageServer;
-
-/// <summary>
-/// Tracks files of interest to the editor, including files that are open
-/// and files that are imported by open files.
-/// </summary>
-public abstract partial class Workspace
-{
-    // Maps of files are keyed on document ID, which is a unique identifier for a document in the workspace.
-    // The document ID is generated on demand and is stable for the lifetime of the document,
-    // which reduces the need to propagate document renames through the system.
-    // The ID is not derived from the path of the document, but is internally a GUID. Although this
-    // means it is not deterministic, it also means we can track documents that don't have a name.
-    // We do not currently check for GUID collisions but could do so fairly easily if needed.
-    // TODO: need to ensure that the path is absolute and fully normalized, and take a account of case sensitivity
-    readonly object documentIdLock = new ();
-    readonly Dictionary<string,DocumentId> filePathToDocumentId = new();
-
-    public bool TryGetDocumentId(string normalizedAbsoluteFilePath, [NotNullWhen(true)] out DocumentId? id)
-        => filePathToDocumentId.TryGetValue(normalizedAbsoluteFilePath, out id);
-
-    protected DocumentId GetOrCreateDocumentId(string normalizedAbsoluteFilePath)
-    {
-        if (filePathToDocumentId.TryGetValue(normalizedAbsoluteFilePath, out var id))
-        {
-            return id;
-        }
-
-        lock (documentIdLock)
-        {
-            id = DocumentId.CreateNewId();
-            if (!filePathToDocumentId.TryAdd(normalizedAbsoluteFilePath, id)) {
-                id = filePathToDocumentId[normalizedAbsoluteFilePath];
-            }
-        }
-
-        return id;
-    }
-}
diff --git a/MSBuildLanguageServer/WorkspaceServices.cs b/MSBuildLanguageServer/WorkspaceServices.cs
deleted file mode 100644
index 12c94901..00000000
--- a/MSBuildLanguageServer/WorkspaceServices.cs
+++ /dev/null
@@ -1,16 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-// Licensed under the MIT license. See LICENSE file in the project root for full license information.
-
-using Microsoft.CodeAnalysis.Host;
-
-namespace MonoDevelop.MSBuild.Editor.LanguageServer;
-
-public abstract class WorkspaceServices
-{
-    public abstract HostServices HostServices { get; }
-
-    public abstract T? GetService<T>() where T : IWorkspaceService;
-
-    public T GetRequiredService<T>() where T : IWorkspaceService
-        => GetService<T>() ?? throw new InvalidOperationException($"Workspace does not provide service {typeof(T).FullName}.");
-}
\ No newline at end of file