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