Remove RoslynServiceExtensions.GetServiceAsync (#77799)

Fixes #73636

Remove the RoslynServiceExtensions.GetServiceAsync and instead encourage use of the standard IAsyncServiceProvider* methods. The VS implementation of these methods has been changed to better understand which interfaces require a main thread switch for the cast, as opposed to the roslyn implementations which blindly did a main thread switch.

Author: ToddGrun

eng/config/BannedSymbols.txt

@@ -26,8 +26,6 @@ M:Microsoft.CodeAnalysis.Document.GetOptionsAsync(System.Threading.CancellationT
 T:Microsoft.CodeAnalysis.Options.DocumentOptionSet; Use AnalyzerConfigOptions instead
 M:Microsoft.VisualStudio.Shell.ServiceExtensions.GetService``2(System.IServiceProvider); Use RoslynServiceExtensions instead. This extension internally relies on ThreadHelper, which is incompatible with testing.
 M:Microsoft.VisualStudio.Shell.ServiceExtensions.GetService``2(System.IServiceProvider,System.Boolean); Use RoslynServiceExtensions instead. This extension internally relies on ThreadHelper, which is incompatible with testing
-M:Microsoft.VisualStudio.Shell.ServiceExtensions.GetServiceAsync``2(Microsoft.VisualStudio.Shell.IAsyncServiceProvider); Use RoslynServiceExtensions instead. This extension internally relies on ThreadHelper, which is incompatible with testing
-M:Microsoft.VisualStudio.Shell.ServiceExtensions.GetServiceAsync``2(Microsoft.VisualStudio.Shell.IAsyncServiceProvider,System.Boolean); Use RoslynServiceExtensions instead. This extension internally relies on ThreadHelper, which is incompatible with testing
 P:Microsoft.VisualStudio.Shell.ThreadHelper.JoinableTaskFactory; Use IThreadingContext.JoinableTaskFactory instead.
 M:Microsoft.CodeAnalysis.Formatting.Formatter.FormatAsync(Microsoft.CodeAnalysis.Document,Microsoft.CodeAnalysis.Options.OptionSet,System.Threading.CancellationToken); Use internal overload instead
 M:Microsoft.CodeAnalysis.Formatting.Formatter.FormatAsync(Microsoft.CodeAnalysis.Document,Microsoft.CodeAnalysis.Text.TextSpan,Microsoft.CodeAnalysis.Options.OptionSet,System.Threading.CancellationToken); Use overload with SyntaxFormattingOptions instead

src/EditorFeatures/Core.Wpf/Utilities/RoslynServiceExtensions.cs

@@ -4,8 +4,6 @@
 
 using System;
 using System.Diagnostics.CodeAnalysis;
-using System.Threading.Tasks;
-using Microsoft.VisualStudio.Shell;
 using Microsoft.VisualStudio.Threading;
 
 namespace Microsoft.VisualStudio.Shell
@@ -25,12 +23,6 @@ public static TInterface GetServiceOnMainThread<TService, TInterface>(this IServ
             return @interface;
         }
 
-        /// <summary>
-        /// Returns the specified service type from the service.
-        /// </summary>
-        public static TServiceType GetServiceOnMainThread<TServiceType>(this IServiceProvider serviceProvider) where TServiceType : class
-            => serviceProvider.GetServiceOnMainThread<TServiceType, TServiceType>();
-
         /// <summary>
         /// Gets a service interface from a service provider.
         /// </summary>
@@ -99,88 +91,5 @@ public static TInterface GetService<TService, TInterface>(
                 return @interface;
             });
         }
-
-        /// <summary>
-        /// Gets a service interface from a service provider asynchronously.
-        /// </summary>
-        /// <typeparam name="TService">The service type</typeparam>
-        /// <typeparam name="TInterface">The interface type</typeparam>
-        /// <param name="asyncServiceProvider">The async service provider</param>
-        /// <returns>The requested service interface. Never <see langword="null"/>.</returns>
-        /// <exception cref="ServiceUnavailableException">
-        /// Either the service could not be acquired, or the service does not support
-        /// the requested interface.
-        /// </exception>
-        public static Task<TInterface> GetServiceAsync<TService, TInterface>(
-            this IAsyncServiceProvider asyncServiceProvider,
-            JoinableTaskFactory joinableTaskFactory)
-            where TInterface : class
-        {
-            return GetServiceAsync<TService, TInterface>(asyncServiceProvider, joinableTaskFactory, throwOnFailure: true)!;
-        }
-
-        /// <summary>
-        /// Gets a service interface from a service provider asynchronously.
-        /// </summary>
-        /// <typeparam name="TService">The service type</typeparam>
-        /// <typeparam name="TInterface">The interface type</typeparam>
-        /// <param name="asyncServiceProvider">The async service provider</param>
-        /// <param name="throwOnFailure">
-        /// Determines how a failure to get the requested service interface is handled. If <see langword="true"/>, an
-        /// exception is thrown; if <see langword="false"/>, <see langword="null"/> is returned.
-        /// </param>
-        /// <returns>The requested service interface, if it could be obtained; otherwise <see langword="null"/> if
-        /// <paramref name="throwOnFailure"/> is <see langword="false"/>.</returns>
-        /// <exception cref="ServiceUnavailableException">
-        /// Either the service could not be acquired, or the service does not support
-        /// the requested interface.
-        /// </exception>
-        public static async Task<TInterface?> GetServiceAsync<TService, TInterface>(
-            this IAsyncServiceProvider asyncServiceProvider,
-            JoinableTaskFactory joinableTaskFactory,
-            bool throwOnFailure)
-            where TInterface : class
-        {
-            Requires.NotNull(asyncServiceProvider, nameof(asyncServiceProvider));
-            object? service;
-
-            // Prefer IAsyncServiceProvider2 so that any original exceptions can be captured and included as an inner
-            // exception to the one that we throw.
-            if (throwOnFailure && asyncServiceProvider is IAsyncServiceProvider2 asyncServiceProvider2)
-            {
-                try
-                {
-                    service = await asyncServiceProvider2.GetServiceAsync(typeof(TService), swallowExceptions: false).ConfigureAwait(true);
-                }
-                catch (Exception ex)
-                {
-                    throw new ServiceUnavailableException(typeof(TService), ex);
-                }
-            }
-            else
-            {
-                service = await asyncServiceProvider.GetServiceAsync(typeof(TService)).ConfigureAwait(true);
-            }
-
-            if (service == null)
-            {
-                if (throwOnFailure)
-                    throw new ServiceUnavailableException(typeof(TService));
-
-                return null;
-            }
-
-            await joinableTaskFactory.SwitchToMainThreadAsync();
-
-            if (service is not TInterface @interface)
-            {
-                if (throwOnFailure)
-                    throw new ServiceUnavailableException(typeof(TInterface));
-
-                return null;
-            }
-
-            return @interface;
-        }
     }
 }

src/EditorFeatures/TestUtilities/StubVsServiceExporter`2.cs

@@ -34,7 +34,7 @@ public StubVsServiceExporter(
         [Import(typeof(SAsyncServiceProvider))] IAsyncServiceProvider2 asyncServiceProvider,
         JoinableTaskContext joinableTaskContext)
     {
-        _serviceGetter = new AsyncLazy<TInterface>(() => asyncServiceProvider.GetServiceAsync<TService, TInterface>(joinableTaskContext.Factory, throwOnFailure: true)!, joinableTaskContext.Factory);
+        _serviceGetter = new AsyncLazy<TInterface>(() => asyncServiceProvider.GetServiceAsync<TService, TInterface>(throwOnFailure: true, CancellationToken.None)!, joinableTaskContext.Factory);
     }
 
     /// <inheritdoc />

src/VisualStudio/Core/Def/ColorSchemes/ColorSchemeApplier.cs

@@ -72,7 +72,7 @@ public void RegisterInitializationWork(PackageLoadTasks packageInitializationTas
 
     private async Task AfterPackageLoadedBackgroundThreadAsync(PackageLoadTasks afterPackageLoadedTasks, CancellationToken cancellationToken)
     {
-        var settingsManager = await _asyncServiceProvider.GetServiceAsync<SVsSettingsPersistenceManager, ISettingsManager>(_threadingContext.JoinableTaskFactory).ConfigureAwait(false);
+        var settingsManager = await _asyncServiceProvider.GetServiceAsync<SVsSettingsPersistenceManager, ISettingsManager>(cancellationToken).ConfigureAwait(false);
 
         // We need to update the theme whenever the Editor Color Scheme setting changes.
         settingsManager.GetSubset(ColorSchemeOptionsStorage.ColorSchemeSettingKey).SettingChangedAsync += ColorSchemeChangedAsync;

src/VisualStudio/Core/Def/Diagnostics/VisualStudioDiagnosticAnalyzerService.cs

@@ -62,7 +62,7 @@ public async Task InitializeAsync(IAsyncServiceProvider serviceProvider, Cancell
         _serviceProvider = (IServiceProvider)serviceProvider;
 
         // Hook up the "Run Code Analysis" menu command for CPS based managed projects.
-        var menuCommandService = await serviceProvider.GetServiceAsync<IMenuCommandService, IMenuCommandService>(_threadingContext.JoinableTaskFactory, throwOnFailure: false).ConfigureAwait(false);
+        var menuCommandService = await serviceProvider.GetServiceAsync<IMenuCommandService, IMenuCommandService>(throwOnFailure: false, cancellationToken).ConfigureAwait(false);
         if (menuCommandService != null)
         {
             await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);

src/VisualStudio/Core/Def/ProjectSystem/RuleSets/RuleSetEventHandler.cs

@@ -41,7 +41,7 @@ public async Task RegisterAsync(IAsyncServiceProvider serviceProvider, Cancellat
     {
         if (!_eventsHookedUp)
         {
-            var trackProjectDocuments = await serviceProvider.GetServiceAsync<SVsTrackProjectDocuments, IVsTrackProjectDocuments2>(_threadingContext.JoinableTaskFactory).ConfigureAwait(false);
+            var trackProjectDocuments = await serviceProvider.GetServiceAsync<SVsTrackProjectDocuments, IVsTrackProjectDocuments2>(cancellationToken).ConfigureAwait(false);
             await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
 
             if (!_eventsHookedUp)

src/VisualStudio/Core/Def/ProjectSystem/VisualStudioWorkspaceImpl.cs

@@ -924,7 +924,7 @@ private bool TryAddEditorConfigToSolutionItems(
             return false;
 
         // All checks pass, so let's treat this special.
-        var dte = _threadingContext.JoinableTaskFactory.Run(() => _asyncServiceProvider.GetServiceAsync<SDTE, EnvDTE.DTE>(_threadingContext.JoinableTaskFactory));
+        var dte = _threadingContext.JoinableTaskFactory.Run(() => _asyncServiceProvider.GetServiceAsync<SDTE, EnvDTE.DTE>(_threadingContext.DisposalToken));
 
         const string SolutionItemsFolderName = "Solution Items";
 

src/VisualStudio/Core/Def/RoslynPackage.cs

@@ -133,9 +133,9 @@ Task OnAfterPackageLoadedMainThreadAsync(PackageLoadTasks afterPackageLoadedTask
     private async Task ProfferServiceBrokerServicesAsync(CancellationToken cancellationToken)
     {
         // Proffer in-process service broker services
-        var serviceBrokerContainer = await this.GetServiceAsync<SVsBrokeredServiceContainer, IBrokeredServiceContainer>(throwOnFailure: true, cancellationToken).ConfigureAwait(false);
+        var serviceBrokerContainer = await this.GetServiceAsync<SVsBrokeredServiceContainer, IBrokeredServiceContainer>(cancellationToken).ConfigureAwait(false);
 
-        serviceBrokerContainer!.Proffer(
+        serviceBrokerContainer.Proffer(
             WorkspaceProjectFactoryServiceDescriptor.ServiceDescriptor,
             (_, _, _, _) => ValueTaskFactory.FromResult<object?>(new WorkspaceProjectFactoryService(this.ComponentModel.GetService<IWorkspaceProjectContextFactory>())));
 
@@ -172,7 +172,7 @@ protected override async Task LoadComponentsAsync(CancellationToken cancellation
 
         // we need to load it as early as possible since we can have errors from
         // package from each language very early
-        await this.ComponentModel.GetService<VisualStudioSuppressionFixService>().InitializeAsync(this).ConfigureAwait(false);
+        await this.ComponentModel.GetService<VisualStudioSuppressionFixService>().InitializeAsync(this, cancellationToken).ConfigureAwait(false);
         await this.ComponentModel.GetService<VisualStudioDiagnosticListSuppressionStateService>().InitializeAsync(this, cancellationToken).ConfigureAwait(false);
 
         await this.ComponentModel.GetService<IVisualStudioDiagnosticAnalyzerService>().InitializeAsync(this, cancellationToken).ConfigureAwait(false);

src/VisualStudio/Core/Def/SyncNamespaces/SyncNamespacesCommandHandler.cs

@@ -52,7 +52,7 @@ public async Task InitializeAsync(IAsyncServiceProvider serviceProvider, Cancell
         _serviceProvider = (IServiceProvider)serviceProvider;
 
         // Hook up the "Remove Unused References" menu command for CPS based managed projects.
-        var menuCommandService = await serviceProvider.GetServiceAsync<IMenuCommandService, IMenuCommandService>(_threadingContext.JoinableTaskFactory, throwOnFailure: false).ConfigureAwait(false);
+        var menuCommandService = await serviceProvider.GetServiceAsync<IMenuCommandService, IMenuCommandService>(throwOnFailure: false, cancellationToken).ConfigureAwait(false);
         if (menuCommandService != null)
         {
             await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);

src/VisualStudio/Core/Def/TableDataSource/Suppression/VisualStudioDiagnosticListSuppressionStateService.cs

@@ -58,8 +58,8 @@ public VisualStudioDiagnosticListSuppressionStateService(
 
     public async Task InitializeAsync(IAsyncServiceProvider serviceProvider, CancellationToken cancellationToken)
     {
-        _shellService = await serviceProvider.GetServiceAsync<SVsUIShell, IVsUIShell>(_threadingContext.JoinableTaskFactory).ConfigureAwait(false);
-        var errorList = await serviceProvider.GetServiceAsync<SVsErrorList, IErrorList>(_threadingContext.JoinableTaskFactory, throwOnFailure: false).ConfigureAwait(false);
+        _shellService = await serviceProvider.GetServiceAsync<SVsUIShell, IVsUIShell>(throwOnFailure: false, cancellationToken).ConfigureAwait(false);
+        var errorList = await serviceProvider.GetServiceAsync<SVsErrorList, IErrorList>(throwOnFailure: false, cancellationToken).ConfigureAwait(false);
         _tableControl = errorList?.TableControl;
 
         await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);