Make only typescript handlers and run code actions switch to main thread.

src/VisualStudio/LiveShare/Impl/Shims/AbstractLiveShareHandlerShim.cs

@@ -6,6 +6,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.LanguageServer.Handler;
 using Microsoft.VisualStudio.LanguageServer.Protocol;
 using Microsoft.VisualStudio.LiveShare.LanguageServices;
@@ -29,18 +30,34 @@ public virtual Task<ResponseType> HandleAsync(RequestType param, RequestContext<
             return ((IRequestHandler<RequestType, ResponseType>)LazyRequestHandler.Value).HandleRequestAsync(requestContext.Context, param, requestContext.ClientCapabilities?.ToObject<VSClientCapabilities>(), cancellationToken);
         }
 
+        protected Lazy<IRequestHandler, IRequestHandlerMetadata> GetRequestHandler(IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers, string methodName)
+        {
+            return requestHandlers.First(handler => handler.Metadata.MethodName == methodName);
+        }
+    }
+
+    internal abstract class AbstractLiveShareHandlerOnMainThreadShim<RequestType, ResponseType> : AbstractLiveShareHandlerShim<RequestType, ResponseType>
+    {
+        private readonly IThreadingContext _threadingContext;
+
+        public AbstractLiveShareHandlerOnMainThreadShim(IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers, string methodName, IThreadingContext threadingContext) : base(requestHandlers, methodName)
+        {
+            _threadingContext = threadingContext;
+        }
+
+        public override async Task<ResponseType> HandleAsync(RequestType param, RequestContext<Solution> requestContext, CancellationToken cancellationToken)
+        {
+            await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
+            return await HandleAsyncPreserveThreadContext(param, requestContext, cancellationToken).ConfigureAwait(false);
+        }
+
         /// <summary>
         /// Certain implementations require that the processing be done on the UI thread.
         /// So allow the handler to specifiy that the thread context should be preserved.
         /// </summary>
-        protected Task<ResponseType> HandleAsyncPreserveThreadContext(RequestType param, RequestContext<Solution> requestContext, CancellationToken cancellationToken)
+        private Task<ResponseType> HandleAsyncPreserveThreadContext(RequestType param, RequestContext<Solution> requestContext, CancellationToken cancellationToken)
         {
             return ((IRequestHandler<RequestType, ResponseType>)LazyRequestHandler.Value).HandleRequestAsync(requestContext.Context, param, requestContext.ClientCapabilities?.ToObject<ClientCapabilities>(), cancellationToken, keepThreadContext: true);
         }
-
-        protected Lazy<IRequestHandler, IRequestHandlerMetadata> GetRequestHandler(IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers, string methodName)
-        {
-            return requestHandlers.First(handler => handler.Metadata.MethodName == methodName);
-        }
     }
 }

src/VisualStudio/LiveShare/Impl/Shims/FindImplementationsHandlerShim.cs

@@ -3,9 +3,6 @@
 using System;
 using System.Collections.Generic;
 using System.ComponentModel.Composition;
-using System.Threading;
-using System.Threading.Tasks;
-using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.LanguageServer.Handler;
 using Microsoft.VisualStudio.LanguageServer.Protocol;
@@ -13,27 +10,27 @@
 
 namespace Microsoft.VisualStudio.LanguageServices.LiveShare
 {
-    internal class FindImplementationsHandlerShim : AbstractLiveShareHandlerShim<TextDocumentPositionParams, object>
+    /// <summary>
+    /// Typescript format expects to be called from the main thread.
+    /// </summary>
+    internal class FindImplementationsHandlerOnMainThreadShim : AbstractLiveShareHandlerOnMainThreadShim<TextDocumentPositionParams, object>
     {
-        private readonly IThreadingContext _threadingContext;
-
-        public FindImplementationsHandlerShim(IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers, IThreadingContext threadingContext)
-            : base(requestHandlers, Methods.TextDocumentImplementationName)
+        public FindImplementationsHandlerOnMainThreadShim(IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers, IThreadingContext threadingContext)
+            : base(requestHandlers, Methods.TextDocumentImplementationName, threadingContext)
         {
-            _threadingContext = threadingContext;
         }
+    }
 
-        public override async Task<object> HandleAsync(TextDocumentPositionParams param, RequestContext<Solution> requestContext, CancellationToken cancellationToken)
+    internal class FindImplementationsHandlerShim : AbstractLiveShareHandlerShim<TextDocumentPositionParams, object>
+    {
+        public FindImplementationsHandlerShim(IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers) : base(requestHandlers, Methods.TextDocumentImplementationName)
         {
-            // TypeScript requires this call to be on the UI thread.
-            await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
-            return await base.HandleAsyncPreserveThreadContext(param, requestContext, cancellationToken).ConfigureAwait(false);
         }
     }
 
     [ExportLspRequestHandler(LiveShareConstants.RoslynContractName, Methods.TextDocumentImplementationName)]
     [Obsolete("Used for backwards compatibility with old liveshare clients.")]
-    internal class RoslynFindImplementationsHandlerShim : FindImplementationsHandlerShim
+    internal class RoslynFindImplementationsHandlerShim : FindImplementationsHandlerOnMainThreadShim
     {
         [ImportingConstructor]
         public RoslynFindImplementationsHandlerShim([ImportMany] IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers, IThreadingContext threadingContext) : base(requestHandlers, threadingContext)
@@ -45,7 +42,7 @@ public RoslynFindImplementationsHandlerShim([ImportMany] IEnumerable<Lazy<IReque
     internal class CSharpFindImplementationsHandlerShim : FindImplementationsHandlerShim
     {
         [ImportingConstructor]
-        public CSharpFindImplementationsHandlerShim([ImportMany] IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers, IThreadingContext threadingContext) : base(requestHandlers, threadingContext)
+        public CSharpFindImplementationsHandlerShim([ImportMany] IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers) : base(requestHandlers)
         {
         }
     }
@@ -54,13 +51,13 @@ public CSharpFindImplementationsHandlerShim([ImportMany] IEnumerable<Lazy<IReque
     internal class VisualBasicFindImplementationsHandlerShim : FindImplementationsHandlerShim
     {
         [ImportingConstructor]
-        public VisualBasicFindImplementationsHandlerShim([ImportMany] IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers, IThreadingContext threadingContext) : base(requestHandlers, threadingContext)
+        public VisualBasicFindImplementationsHandlerShim([ImportMany] IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers) : base(requestHandlers)
         {
         }
     }
 
     [ExportLspRequestHandler(LiveShareConstants.TypeScriptContractName, Methods.TextDocumentImplementationName)]
-    internal class TypeScriptFindImplementationsHandlerShim : FindImplementationsHandlerShim
+    internal class TypeScriptFindImplementationsHandlerShim : FindImplementationsHandlerOnMainThreadShim
     {
         [ImportingConstructor]
         public TypeScriptFindImplementationsHandlerShim([ImportMany] IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers, IThreadingContext threadingContext) : base(requestHandlers, threadingContext)

src/VisualStudio/LiveShare/Impl/Shims/FormatDocumentHandlerShim.cs

@@ -3,9 +3,6 @@
 using System;
 using System.Collections.Generic;
 using System.ComponentModel.Composition;
-using System.Threading;
-using System.Threading.Tasks;
-using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.LanguageServer.Handler;
 using Microsoft.VisualStudio.LanguageServer.Protocol;
@@ -13,30 +10,34 @@
 
 namespace Microsoft.VisualStudio.LanguageServices.LiveShare
 {
-    internal class FormatDocumentHandlerShim : AbstractLiveShareHandlerShim<DocumentFormattingParams, TextEdit[]>
+    /// <summary>
+    /// Typescript format expects to be called from the main thread.
+    /// </summary>
+    internal class FormatDocumentHandlerOnMainThreadShim : AbstractLiveShareHandlerOnMainThreadShim<DocumentFormattingParams, TextEdit[]>
     {
-        private readonly IThreadingContext _threadingContext;
-
-        public FormatDocumentHandlerShim(IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers, IThreadingContext threadingContext)
-            : base(requestHandlers, Methods.TextDocumentFormattingName)
+        public FormatDocumentHandlerOnMainThreadShim(IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers, IThreadingContext threadingContext)
+            : base(requestHandlers, Methods.TextDocumentFormattingName, threadingContext)
         {
-            _threadingContext = threadingContext;
         }
+    }
 
-        public override async Task<TextEdit[]> HandleAsync(DocumentFormattingParams param, RequestContext<Solution> requestContext, CancellationToken cancellationToken)
+    internal class FormatDocumentHandlerShim : AbstractLiveShareHandlerShim<DocumentFormattingParams, TextEdit[]>
+    {
+
+        public FormatDocumentHandlerShim(IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers)
+            : base(requestHandlers, Methods.TextDocumentFormattingName)
         {
-            // To get the formatting options, TypeScript expects to be called on the UI thread.
-            await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
-            return await base.HandleAsyncPreserveThreadContext(param, requestContext, cancellationToken).ConfigureAwait(false);
         }
     }
 
+
     [ExportLspRequestHandler(LiveShareConstants.RoslynContractName, Methods.TextDocumentFormattingName)]
     [Obsolete("Used for backwards compatibility with old liveshare clients.")]
-    internal class RoslynFormatDocumentHandlerShim : FormatDocumentHandlerShim
+    internal class RoslynFormatDocumentHandlerShim : FormatDocumentHandlerOnMainThreadShim
     {
         [ImportingConstructor]
-        public RoslynFormatDocumentHandlerShim([ImportMany] IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers, IThreadingContext threadingContext) : base(requestHandlers, threadingContext)
+        public RoslynFormatDocumentHandlerShim([ImportMany] IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers, IThreadingContext threadingContext)
+            : base(requestHandlers, threadingContext)
         {
         }
     }
@@ -45,7 +46,7 @@ public RoslynFormatDocumentHandlerShim([ImportMany] IEnumerable<Lazy<IRequestHan
     internal class CSharpFormatDocumentHandlerShim : FormatDocumentHandlerShim
     {
         [ImportingConstructor]
-        public CSharpFormatDocumentHandlerShim([ImportMany] IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers, IThreadingContext threadingContext) : base(requestHandlers, threadingContext)
+        public CSharpFormatDocumentHandlerShim([ImportMany] IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers) : base(requestHandlers)
         {
         }
     }
@@ -54,16 +55,17 @@ public CSharpFormatDocumentHandlerShim([ImportMany] IEnumerable<Lazy<IRequestHan
     internal class VisualBasicFormatDocumentHandlerShim : FormatDocumentHandlerShim
     {
         [ImportingConstructor]
-        public VisualBasicFormatDocumentHandlerShim([ImportMany] IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers, IThreadingContext threadingContext) : base(requestHandlers, threadingContext)
+        public VisualBasicFormatDocumentHandlerShim([ImportMany] IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers) : base(requestHandlers)
         {
         }
     }
 
     [ExportLspRequestHandler(LiveShareConstants.TypeScriptContractName, Methods.TextDocumentFormattingName)]
-    internal class TypeScriptFormatDocumentHandlerShim : FormatDocumentHandlerShim
+    internal class TypeScriptFormatDocumentHandlerShim : FormatDocumentHandlerOnMainThreadShim
     {
         [ImportingConstructor]
-        public TypeScriptFormatDocumentHandlerShim([ImportMany] IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers, IThreadingContext threadingContext) : base(requestHandlers, threadingContext)
+        public TypeScriptFormatDocumentHandlerShim([ImportMany] IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers, IThreadingContext threadingContext)
+            : base(requestHandlers, threadingContext)
         {
         }
     }

src/VisualStudio/LiveShare/Impl/Shims/FormatDocumentOnTypeHandlerShim.cs

@@ -3,9 +3,6 @@
 using System;
 using System.Collections.Generic;
 using System.ComponentModel.Composition;
-using System.Threading;
-using System.Threading.Tasks;
-using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.LanguageServer.Handler;
 using Microsoft.VisualStudio.LanguageServer.Protocol;
@@ -13,27 +10,27 @@
 
 namespace Microsoft.VisualStudio.LanguageServices.LiveShare
 {
-    internal class FormatDocumentOnTypeHandlerShim : AbstractLiveShareHandlerShim<DocumentOnTypeFormattingParams, TextEdit[]>
+    /// <summary>
+    /// Typescript format expects to be called from the main thread.
+    /// </summary>
+    internal class FormatDocumentOnTypeHandlerOnMainThreadShim : AbstractLiveShareHandlerOnMainThreadShim<DocumentOnTypeFormattingParams, TextEdit[]>
     {
-        private readonly IThreadingContext _threadingContext;
-
-        public FormatDocumentOnTypeHandlerShim(IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers, IThreadingContext threadingContext)
-            : base(requestHandlers, Methods.TextDocumentOnTypeFormattingName)
+        public FormatDocumentOnTypeHandlerOnMainThreadShim(IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers, IThreadingContext threadingContext)
+            : base(requestHandlers, Methods.TextDocumentOnTypeFormattingName, threadingContext)
         {
-            _threadingContext = threadingContext;
         }
+    }
 
-        public override async Task<TextEdit[]> HandleAsync(DocumentOnTypeFormattingParams param, RequestContext<Solution> requestContext, CancellationToken cancellationToken)
+    internal class FormatDocumentOnTypeHandlerShim : AbstractLiveShareHandlerShim<DocumentOnTypeFormattingParams, TextEdit[]>
+    {
+        public FormatDocumentOnTypeHandlerShim(IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers) : base(requestHandlers, Methods.TextDocumentOnTypeFormattingName)
         {
-            // To get the formatting options, TypeScript expects to be called on the UI thread.
-            await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
-            return await base.HandleAsyncPreserveThreadContext(param, requestContext, cancellationToken).ConfigureAwait(false);
         }
     }
 
     [ExportLspRequestHandler(LiveShareConstants.RoslynContractName, Methods.TextDocumentOnTypeFormattingName)]
     [Obsolete("Used for backwards compatibility with old liveshare clients.")]
-    internal class RoslynFormatDocumentOnTypeHandlerShim : FormatDocumentOnTypeHandlerShim
+    internal class RoslynFormatDocumentOnTypeHandlerShim : FormatDocumentOnTypeHandlerOnMainThreadShim
     {
         [ImportingConstructor]
         public RoslynFormatDocumentOnTypeHandlerShim([ImportMany] IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers, IThreadingContext threadingContext) : base(requestHandlers, threadingContext)
@@ -45,7 +42,7 @@ public RoslynFormatDocumentOnTypeHandlerShim([ImportMany] IEnumerable<Lazy<IRequ
     internal class CSharpFormatDocumentOnTypeHandlerShim : FormatDocumentOnTypeHandlerShim
     {
         [ImportingConstructor]
-        public CSharpFormatDocumentOnTypeHandlerShim([ImportMany] IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers, IThreadingContext threadingContext) : base(requestHandlers, threadingContext)
+        public CSharpFormatDocumentOnTypeHandlerShim([ImportMany] IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers) : base(requestHandlers)
         {
         }
     }
@@ -54,13 +51,13 @@ public CSharpFormatDocumentOnTypeHandlerShim([ImportMany] IEnumerable<Lazy<IRequ
     internal class VisualBasicFormatDocumentOnTypeHandlerShim : FormatDocumentOnTypeHandlerShim
     {
         [ImportingConstructor]
-        public VisualBasicFormatDocumentOnTypeHandlerShim([ImportMany] IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers, IThreadingContext threadingContext) : base(requestHandlers, threadingContext)
+        public VisualBasicFormatDocumentOnTypeHandlerShim([ImportMany] IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers) : base(requestHandlers)
         {
         }
     }
 
     [ExportLspRequestHandler(LiveShareConstants.TypeScriptContractName, Methods.TextDocumentOnTypeFormattingName)]
-    internal class TypeScriptFormatDocumentOnTypeHandlerShim : FormatDocumentOnTypeHandlerShim
+    internal class TypeScriptFormatDocumentOnTypeHandlerShim : FormatDocumentOnTypeHandlerOnMainThreadShim
     {
         [ImportingConstructor]
         public TypeScriptFormatDocumentOnTypeHandlerShim([ImportMany] IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers, IThreadingContext threadingContext) : base(requestHandlers, threadingContext)

src/VisualStudio/LiveShare/Impl/Shims/FormatDocumentRangeHandlerShim.cs

@@ -3,9 +3,6 @@
 using System;
 using System.Collections.Generic;
 using System.ComponentModel.Composition;
-using System.Threading;
-using System.Threading.Tasks;
-using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.LanguageServer.Handler;
 using Microsoft.VisualStudio.LanguageServer.Protocol;
@@ -13,27 +10,27 @@
 
 namespace Microsoft.VisualStudio.LanguageServices.LiveShare
 {
-    internal class FormatDocumentRangeHandlerShim : AbstractLiveShareHandlerShim<DocumentRangeFormattingParams, TextEdit[]>
+    /// <summary>
+    /// Typescript format expects to be called from the main thread.
+    /// </summary>
+    internal class FormatDocumentRangeHandlerOnMainThreadShim : AbstractLiveShareHandlerOnMainThreadShim<DocumentRangeFormattingParams, TextEdit[]>
     {
-        private readonly IThreadingContext _threadingContext;
-
-        public FormatDocumentRangeHandlerShim(IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers, IThreadingContext threadingContext)
-            : base(requestHandlers, Methods.TextDocumentRangeFormattingName)
+        public FormatDocumentRangeHandlerOnMainThreadShim(IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers, IThreadingContext threadingContext)
+            : base(requestHandlers, Methods.TextDocumentRangeFormattingName, threadingContext)
         {
-            _threadingContext = threadingContext;
         }
+    }
 
-        public override async Task<TextEdit[]> HandleAsync(DocumentRangeFormattingParams param, RequestContext<Solution> requestContext, CancellationToken cancellationToken)
+    internal class FormatDocumentRangeHandlerShim : AbstractLiveShareHandlerShim<DocumentRangeFormattingParams, TextEdit[]>
+    {
+        public FormatDocumentRangeHandlerShim(IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers) : base(requestHandlers, Methods.TextDocumentRangeFormattingName)
         {
-            // To get the formatting options, TypeScript expects to be called on the UI thread.
-            await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
-            return await base.HandleAsyncPreserveThreadContext(param, requestContext, cancellationToken).ConfigureAwait(false);
         }
     }
 
     [ExportLspRequestHandler(LiveShareConstants.RoslynContractName, Methods.TextDocumentRangeFormattingName)]
     [Obsolete("Used for backwards compatibility with old liveshare clients.")]
-    internal class RoslynFormatDocumentRangeHandlerShim : FormatDocumentRangeHandlerShim
+    internal class RoslynFormatDocumentRangeHandlerShim : FormatDocumentRangeHandlerOnMainThreadShim
     {
         [ImportingConstructor]
         public RoslynFormatDocumentRangeHandlerShim([ImportMany] IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers, IThreadingContext threadingContext) : base(requestHandlers, threadingContext)
@@ -45,7 +42,7 @@ public RoslynFormatDocumentRangeHandlerShim([ImportMany] IEnumerable<Lazy<IReque
     internal class CSharpFormatDocumentRangeHandlerShim : FormatDocumentRangeHandlerShim
     {
         [ImportingConstructor]
-        public CSharpFormatDocumentRangeHandlerShim([ImportMany] IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers, IThreadingContext threadingContext) : base(requestHandlers, threadingContext)
+        public CSharpFormatDocumentRangeHandlerShim([ImportMany] IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers) : base(requestHandlers)
         {
         }
     }
@@ -54,13 +51,13 @@ public CSharpFormatDocumentRangeHandlerShim([ImportMany] IEnumerable<Lazy<IReque
     internal class VisualBasicFormatDocumentRangeHandlerShim : FormatDocumentRangeHandlerShim
     {
         [ImportingConstructor]
-        public VisualBasicFormatDocumentRangeHandlerShim([ImportMany] IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers, IThreadingContext threadingContext) : base(requestHandlers, threadingContext)
+        public VisualBasicFormatDocumentRangeHandlerShim([ImportMany] IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers) : base(requestHandlers)
         {
         }
     }
 
     [ExportLspRequestHandler(LiveShareConstants.TypeScriptContractName, Methods.TextDocumentRangeFormattingName)]
-    internal class TypeScriptFormatDocumentRangeHandlerShim : FormatDocumentRangeHandlerShim
+    internal class TypeScriptFormatDocumentRangeHandlerShim : FormatDocumentRangeHandlerOnMainThreadShim
     {
         [ImportingConstructor]
         public TypeScriptFormatDocumentRangeHandlerShim([ImportMany] IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers, IThreadingContext threadingContext) : base(requestHandlers, threadingContext)

src/VisualStudio/LiveShare/Impl/Shims/RunCodeActionsHandlerShim.cs

@@ -18,15 +18,13 @@ namespace Microsoft.VisualStudio.LanguageServices.LiveShare
 {
     /// <summary>
     /// Run code actions handler.  Called when lightbulb invoked.
+    /// Code actions must be applied from the UI thread in VS.
     /// </summary>
-    internal class RunCodeActionsHandlerShim : AbstractLiveShareHandlerShim<LSP.ExecuteCommandParams, object>
+    internal class RunCodeActionsHandlerShim : AbstractLiveShareHandlerOnMainThreadShim<LSP.ExecuteCommandParams, object>
     {
-        private readonly IThreadingContext _threadingContext;
-
         public RunCodeActionsHandlerShim(IEnumerable<Lazy<IRequestHandler, IRequestHandlerMetadata>> requestHandlers, IThreadingContext threadingContext)
-            : base(requestHandlers, LSP.Methods.WorkspaceExecuteCommandName)
+            : base(requestHandlers, LSP.Methods.WorkspaceExecuteCommandName, threadingContext)
         {
-            _threadingContext = threadingContext;
         }
 
         /// <summary>
@@ -47,9 +45,7 @@ public async override Task<object> HandleAsync(LSP.ExecuteCommandParams request,
 
             try
             {
-                // Code actions must be applied from the UI thread in the VS context.
-                await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
-                return await base.HandleAsyncPreserveThreadContext(request, requestContext, cancellationToken).ConfigureAwait(false);
+                return await base.HandleAsync(request, requestContext, cancellationToken).ConfigureAwait(false);
             }
             catch (ArgumentException ex)
             {