Remove RoslynServiceExtensions.GetServiceAsync

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,10 +72,10 @@ 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>(throwOnFailure: true, cancellationToken).ConfigureAwait(false);
 
         // We need to update the theme whenever the Editor Color Scheme setting changes.
-        settingsManager.GetSubset(ColorSchemeOptionsStorage.ColorSchemeSettingKey).SettingChangedAsync += ColorSchemeChangedAsync;
+        settingsManager!.GetSubset(ColorSchemeOptionsStorage.ColorSchemeSettingKey).SettingChangedAsync += ColorSchemeChangedAsync;
 
         // Try to migrate the `useEnhancedColorsSetting` to the new `ColorSchemeName` setting.
         _settings.MigrateToColorSchemeSetting();

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>(throwOnFailure: true, cancellationToken).ConfigureAwait(false);
             await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
 
             if (!_eventsHookedUp)

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

@@ -924,11 +924,11 @@ 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>(throwOnFailure: true, _threadingContext.DisposalToken));
 
         const string SolutionItemsFolderName = "Solution Items";
 
-        var projects = dte.Solution.Projects.OfType<EnvDTE.Project>();
+        var projects = dte!.Solution.Projects.OfType<EnvDTE.Project>();
         var solutionItemsFolder = projects.FirstOrDefault(static p => p.Kind == EnvDTE.Constants.vsProjectKindSolutionItems && p.Name == SolutionItemsFolderName);
 
         if (solutionItemsFolder != null)

src/VisualStudio/Core/Def/RoslynPackage.cs

@@ -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);

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

@@ -64,9 +64,9 @@ internal sealed class VisualStudioSuppressionFixService(
 
     private IWpfTableControl? _tableControl;
 
-    public async Task InitializeAsync(IAsyncServiceProvider serviceProvider)
+    public async Task InitializeAsync(IAsyncServiceProvider serviceProvider, CancellationToken cancellationToken)
     {
-        var errorList = await serviceProvider.GetServiceAsync<SVsErrorList, IErrorList>(_threadingContext.JoinableTaskFactory, throwOnFailure: false).ConfigureAwait(false);
+        var errorList = await serviceProvider.GetServiceAsync<SVsErrorList, IErrorList>(throwOnFailure: false, cancellationToken).ConfigureAwait(false);
         _tableControl = errorList?.TableControl;
     }
 

src/VisualStudio/Core/Def/UnusedReferences/RemoveUnusedReferencesCommandHandler.cs

@@ -65,7 +65,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/Workspace/VisualStudioSourceGeneratorTelemetryCollectorWorkspaceServiceFactory.cs

@@ -73,9 +73,9 @@ private void EnsureSubscribedToSolutionEvents()
         {
             Task.Run(async () =>
             {
-                var shellService = await _serviceProvider.GetServiceAsync<SVsSolution, IVsSolution>(_threadingContext.JoinableTaskFactory).ConfigureAwait(true);
+                var shellService = await _serviceProvider.GetServiceAsync<SVsSolution, IVsSolution>(throwOnFailure: true, _threadingContext.DisposalToken).ConfigureAwait(true);
                 await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(_threadingContext.DisposalToken);
-                shellService.AdviseSolutionEvents(this, out _);
+                shellService!.AdviseSolutionEvents(this, out _);
             }, _threadingContext.DisposalToken);
         }
     }

src/VisualStudio/Core/Def/Workspace/VisualStudioWorkspaceStatusServiceFactory.cs

@@ -77,7 +77,7 @@ public Service(IAsyncServiceProvider2 serviceProvider, IThreadingContext threadi
                 await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(alwaysYield: true, _threadingContext.DisposalToken);
 
                 // Make sure the HubClient package is loaded, since we rely on it for proffered OOP services
-                var shell = await _serviceProvider.GetServiceAsync<SVsShell, IVsShell7>(_threadingContext.JoinableTaskFactory).ConfigureAwait(true);
+                var shell = await _serviceProvider.GetServiceAsync<SVsShell, IVsShell7>(throwOnFailure: true, _threadingContext.DisposalToken).ConfigureAwait(true);
                 Assumes.Present(shell);
 
                 await shell.LoadPackageAsync(Guids.GlobalHubClientPackageGuid);
@@ -90,7 +90,7 @@ public Service(IAsyncServiceProvider2 serviceProvider, IThreadingContext threadi
                 using var asyncToken = listener.BeginAsyncOperation("StatusChanged_EventSubscription");
 
                 await threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(alwaysYield: true, _threadingContext.DisposalToken);
-                var service = await serviceProvider.GetServiceAsync<SVsOperationProgress, IVsOperationProgressStatusService>(_threadingContext.JoinableTaskFactory, throwOnFailure: false).ConfigureAwait(true);
+                var service = await serviceProvider.GetServiceAsync<SVsOperationProgress, IVsOperationProgressStatusService>(throwOnFailure: false, _threadingContext.DisposalToken).ConfigureAwait(true);
                 if (service is null)
                     return null;
 

src/VisualStudio/Core/Impl/ProjectSystem/CPS/CPSProjectFactory.cs

@@ -165,13 +165,13 @@ public async Task<IWorkspaceProjectContext> CreateProjectContextAsync(Guid id, s
             {
                 await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
 
-                var shell = await _serviceProvider.GetServiceAsync<SVsShell, IVsShell7>(_threadingContext.JoinableTaskFactory).ConfigureAwait(true);
+                var shell = await _serviceProvider.GetServiceAsync<SVsShell, IVsShell7>(throwOnFailure: true, cancellationToken).ConfigureAwait(true);
 
                 // Force the F# package to load; this is necessary because the F# package listens to WorkspaceChanged to 
                 // set up some items, and the F# project system doesn't guarantee that the F# package has been loaded itself
                 // so we're caught in the middle doing this.
                 var packageId = Guids.FSharpPackageId;
-                await shell.LoadPackageAsync(ref packageId);
+                await shell!.LoadPackageAsync(ref packageId);
 
                 await TaskScheduler.Default;
             }

src/VisualStudio/Core/Impl/SolutionExplorer/AnalyzerItemTracker.cs

@@ -34,7 +34,7 @@ internal sealed class AnalyzerItemsTracker(IThreadingContext threadingContext) :
 
     public async Task RegisterAsync(IAsyncServiceProvider serviceProvider, CancellationToken cancellationToken)
     {
-        _vsMonitorSelection ??= await serviceProvider.GetServiceAsync<SVsShellMonitorSelection, IVsMonitorSelection>(_threadingContext.JoinableTaskFactory, throwOnFailure: false).ConfigureAwait(false);
+        _vsMonitorSelection ??= await serviceProvider.GetServiceAsync<SVsShellMonitorSelection, IVsMonitorSelection>(throwOnFailure: false, cancellationToken).ConfigureAwait(false);
         await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
         _vsMonitorSelection?.AdviseSelectionEvents(this, out _selectionEventsCookie);
     }