Make IDiagnosticAnalyzerService into an IWorkspaceService (#78359)

Followup to #78356.

Needed so we can access IDiagAnalyzerService in OOP. Currently one
cannot as it attempts to access the Workspace of a document passed into
it. We block WOrkspace access like for safety/clarity concerns (we don't
want a stateless OOP api call to have access to the mutable workspace
API).

This also cleans up some ugly initialization code IDiagAnalyzerService
had.

Author: CyrusNajmabadi

src/EditorFeatures/CSharp/CodeCleanup/CSharpCodeCleanupService.cs

@@ -16,7 +16,8 @@ namespace Microsoft.CodeAnalysis.CSharp.CodeCleanup;
 [ExportLanguageService(typeof(ICodeCleanupService), LanguageNames.CSharp), Shared]
 [method: ImportingConstructor]
 [method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-internal sealed class CSharpCodeCleanupService(ICodeFixService codeFixService, IDiagnosticAnalyzerService diagnosticAnalyzerService) : AbstractCodeCleanupService(codeFixService, diagnosticAnalyzerService)
+internal sealed class CSharpCodeCleanupService(ICodeFixService codeFixService)
+    : AbstractCodeCleanupService(codeFixService)
 {
     /// <summary>
     /// Maps format document code cleanup options to DiagnosticId[]

src/EditorFeatures/Core.Wpf/InlineDiagnostics/AbstractDiagnosticsTaggerProvider.SingleDiagnosticKindPullTaggerProvider.cs

@@ -35,14 +35,12 @@ internal abstract partial class AbstractDiagnosticsTaggerProvider<TTag>
     /// </summary>
     private sealed class SingleDiagnosticKindPullTaggerProvider(
         AbstractDiagnosticsTaggerProvider<TTag> callback,
-        IDiagnosticAnalyzerService analyzerService,
         DiagnosticKind diagnosticKind,
         TaggerHost taggerHost,
         string featureName)
         : AsynchronousTaggerProvider<TTag>(taggerHost, featureName)
     {
         private readonly DiagnosticKind _diagnosticKind = diagnosticKind;
-        private readonly IDiagnosticAnalyzerService _analyzerService = analyzerService;
 
         // The following three fields are used to help calculate diagnostic performance for syntax errors upon file open.
         // During TagsChanged notification for syntax errors, VSPlatform will check the buffer's property bag for a 
@@ -104,7 +102,8 @@ private async Task ProduceTagsAsync(
             var snapshot = documentSpanToTag.SnapshotSpan.Snapshot;
 
             var project = document.Project;
-            var workspace = project.Solution.Workspace;
+            var solution = project.Solution;
+            var workspace = solution.Workspace;
 
             // See if we've marked any spans as those we want to suppress diagnostics for.
             // This can happen for buffers used in the preview workspace where some feature
@@ -124,7 +123,8 @@ private async Task ProduceTagsAsync(
                 // NOTE: We pass 'includeSuppressedDiagnostics: true' to ensure that IDE0079 (unnecessary suppressions)
                 // are flagged and faded in the editor. IDE0079 analyzer requires all source suppressed diagnostics to
                 // be provided to it to function correctly.
-                var diagnostics = await _analyzerService.GetDiagnosticsForSpanAsync(
+                var analyzerService = solution.Services.GetRequiredService<IDiagnosticAnalyzerService>();
+                var diagnostics = await analyzerService.GetDiagnosticsForSpanAsync(
                     document,
                     requestedSpan.Span.ToTextSpan(),
                     diagnosticKind: _diagnosticKind,

src/EditorFeatures/Core.Wpf/InlineDiagnostics/AbstractDiagnosticsTaggerProvider.cs

@@ -31,7 +31,6 @@ internal abstract partial class AbstractDiagnosticsTaggerProvider<TTag> : ITagge
     private readonly ImmutableArray<SingleDiagnosticKindPullTaggerProvider> _diagnosticsTaggerProviders;
 
     public AbstractDiagnosticsTaggerProvider(
-        IDiagnosticAnalyzerService analyzerService,
         TaggerHost taggerHost,
         string featureName)
     {
@@ -48,7 +47,7 @@ public AbstractDiagnosticsTaggerProvider(
         return;
 
         SingleDiagnosticKindPullTaggerProvider CreateDiagnosticsTaggerProvider(DiagnosticKind diagnosticKind)
-            => new(this, analyzerService, diagnosticKind, taggerHost, featureName);
+            => new(this, diagnosticKind, taggerHost, featureName);
     }
 
     // Functionality for subclasses to control how this diagnostic tagging operates.  All the individual

src/EditorFeatures/Core.Wpf/InlineDiagnostics/InlineDiagnosticsTaggerProvider.cs

@@ -25,15 +25,12 @@ namespace Microsoft.CodeAnalysis.Editor.InlineDiagnostics;
 [method: ImportingConstructor]
 [method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
 internal sealed class InlineDiagnosticsTaggerProvider(
-    IDiagnosticAnalyzerService analyzerService,
     TaggerHost taggerHost,
     IEditorFormatMapService editorFormatMapService,
     IClassificationFormatMapService classificationFormatMapService,
     IClassificationTypeRegistryService classificationTypeRegistryService)
     : AbstractDiagnosticsTaggerProvider<InlineDiagnosticsTag>(
-        analyzerService,
-        taggerHost,
-        FeatureAttribute.ErrorSquiggles)
+        taggerHost, FeatureAttribute.ErrorSquiggles)
 {
     private readonly IEditorFormatMap _editorFormatMap = editorFormatMapService.GetEditorFormatMap("text");
     private readonly IClassificationFormatMapService _classificationFormatMapService = classificationFormatMapService;

src/EditorFeatures/Core/EditorConfigSettings/DataProvider/Analyzer/AnalyzerSettingsProvider.cs

@@ -24,11 +24,10 @@ public AnalyzerSettingsProvider(
         string fileName,
         AnalyzerSettingsUpdater settingsUpdater,
         Workspace workspace,
-        IDiagnosticAnalyzerService analyzerService,
         IGlobalOptionService optionService)
         : base(fileName, settingsUpdater, workspace, optionService)
     {
-        _analyzerService = analyzerService;
+        _analyzerService = workspace.Services.GetRequiredService<IDiagnosticAnalyzerService>();
         Update();
     }
 

src/EditorFeatures/Core/EditorConfigSettings/DataProvider/Analyzer/AnalyzerSettingsProviderFactory.cs

@@ -11,12 +11,11 @@ namespace Microsoft.CodeAnalysis.Editor.EditorConfigSettings.DataProvider.Analyz
 
 internal sealed class AnalyzerSettingsProviderFactory(
     Workspace workspace,
-    IDiagnosticAnalyzerService analyzerService,
     IGlobalOptionService globalOptionService) : IWorkspaceSettingsProviderFactory<AnalyzerSetting>
 {
     public ISettingsProvider<AnalyzerSetting> GetForFile(string filePath)
     {
         var updater = new AnalyzerSettingsUpdater(workspace, filePath);
-        return new AnalyzerSettingsProvider(filePath, updater, workspace, analyzerService, globalOptionService);
+        return new AnalyzerSettingsProvider(filePath, updater, workspace, globalOptionService);
     }
 }

src/EditorFeatures/Core/EditorConfigSettings/DataProvider/Analyzer/AnalyzerSettingsWorkspaceServiceFactory.cs

@@ -16,9 +16,8 @@ namespace Microsoft.CodeAnalysis.Editor.EditorConfigSettings.DataProvider.Analyz
 [method: ImportingConstructor]
 [method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
 internal sealed class AnalyzerSettingsWorkspaceServiceFactory(
-    IDiagnosticAnalyzerService analyzerService,
     IGlobalOptionService globalOptionService) : IWorkspaceServiceFactory
 {
     public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
-        => new AnalyzerSettingsProviderFactory(workspaceServices.Workspace, analyzerService, globalOptionService);
+        => new AnalyzerSettingsProviderFactory(workspaceServices.Workspace, globalOptionService);
 }

src/EditorFeatures/Core/RenameTracking/RenameTrackingTaggerProvider.StateMachine.cs

@@ -38,7 +38,6 @@ private sealed class StateMachine
 
         private readonly IInlineRenameService _inlineRenameService;
         private readonly IAsynchronousOperationListener _asyncListener;
-        private readonly IDiagnosticAnalyzerService _diagnosticAnalyzerService;
 
         // Store committed sessions so they can be restored on undo/redo. The undo transactions
         // may live beyond the lifetime of the buffer tracked by this StateMachine, so storing
@@ -58,7 +57,6 @@ public StateMachine(
             IThreadingContext threadingContext,
             ITextBuffer buffer,
             IInlineRenameService inlineRenameService,
-            IDiagnosticAnalyzerService diagnosticAnalyzerService,
             IGlobalOptionService globalOptions,
             IAsynchronousOperationListener asyncListener)
         {
@@ -67,7 +65,6 @@ public StateMachine(
             Buffer.Changed += Buffer_Changed;
             _inlineRenameService = inlineRenameService;
             _asyncListener = asyncListener;
-            _diagnosticAnalyzerService = diagnosticAnalyzerService;
             GlobalOptions = globalOptions;
         }
 
@@ -238,8 +235,8 @@ public bool ClearVisibleTrackingSession()
                     // provide a diagnostic/codefix, but nothing has changed in the workspace
                     // to trigger the diagnostic system to reanalyze, so we trigger it 
                     // manually.
-
-                    _diagnosticAnalyzerService?.RequestDiagnosticRefresh();
+                    var service = document.Project.Solution.Services.GetRequiredService<IDiagnosticAnalyzerService>();
+                    service.RequestDiagnosticRefresh();
                 }
 
                 // Disallow the existing TrackingSession from triggering IdentifierFound.

src/EditorFeatures/Core/RenameTracking/RenameTrackingTaggerProvider.cs

@@ -40,19 +40,17 @@ namespace Microsoft.CodeAnalysis.Editor.Implementation.RenameTracking;
 internal sealed partial class RenameTrackingTaggerProvider(
     IThreadingContext threadingContext,
     IInlineRenameService inlineRenameService,
-    IDiagnosticAnalyzerService diagnosticAnalyzerService,
     IGlobalOptionService globalOptions,
     IAsynchronousOperationListenerProvider listenerProvider) : ITaggerProvider
 {
     private readonly IThreadingContext _threadingContext = threadingContext;
     private readonly IAsynchronousOperationListener _asyncListener = listenerProvider.GetListener(FeatureAttribute.RenameTracking);
     private readonly IInlineRenameService _inlineRenameService = inlineRenameService;
-    private readonly IDiagnosticAnalyzerService _diagnosticAnalyzerService = diagnosticAnalyzerService;
     private readonly IGlobalOptionService _globalOptions = globalOptions;
 
     public ITagger<T> CreateTagger<T>(ITextBuffer buffer) where T : ITag
     {
-        var stateMachine = buffer.Properties.GetOrCreateSingletonProperty(() => new StateMachine(_threadingContext, buffer, _inlineRenameService, _diagnosticAnalyzerService, _globalOptions, _asyncListener));
+        var stateMachine = buffer.Properties.GetOrCreateSingletonProperty(() => new StateMachine(_threadingContext, buffer, _inlineRenameService, _globalOptions, _asyncListener));
         return new Tagger(stateMachine) as ITagger<T>;
     }
 

src/EditorFeatures/Test/CodeFixes/CodeFixServiceTests.cs

@@ -43,14 +43,14 @@ public async Task TestGetFirstDiagnosticWithFixAsync()
 ";
         using var workspace = TestWorkspace.CreateCSharp(code, composition: s_compositionWithMockDiagnosticUpdateSourceRegistrationService, openDocuments: true);
 
-        var diagnosticService = workspace.GetService<IDiagnosticAnalyzerService>();
+        var diagnosticService = workspace.Services.GetRequiredService<IDiagnosticAnalyzerService>();
 
         var analyzerReference = new TestAnalyzerReferenceByLanguage(DiagnosticExtensions.GetCompilerDiagnosticAnalyzersMap());
         workspace.TryApplyChanges(workspace.CurrentSolution.WithAnalyzerReferences([analyzerReference]));
 
         var logger = SpecializedCollections.SingletonEnumerable(new Lazy<IErrorLoggerService>(() => workspace.Services.GetRequiredService<IErrorLoggerService>()));
         var fixService = new CodeFixService(
-            diagnosticService, logger, fixers, configurationProviders: []);
+            logger, fixers, configurationProviders: []);
 
         var reference = new MockAnalyzerReference();
         var project = workspace.CurrentSolution.Projects.Single().AddAnalyzerReference(reference);
@@ -323,15 +323,15 @@ private static async Task GetFirstDiagnosticWithFixWithExceptionValidationAsync(
         Assert.True(errorReported);
     }
 
-    private static (EditorTestWorkspace workspace, IDiagnosticAnalyzerService analyzerService, CodeFixService codeFixService, IErrorLoggerService errorLogger) ServiceSetup(
+    private static (EditorTestWorkspace workspace, CodeFixService codeFixService, IErrorLoggerService errorLogger) ServiceSetup(
         CodeFixProvider codefix,
         bool includeConfigurationFixProviders = false,
         bool throwExceptionInFixerCreation = false,
         EditorTestHostDocument? additionalDocument = null,
         string code = "class Program { }")
         => ServiceSetup([codefix], includeConfigurationFixProviders, throwExceptionInFixerCreation, additionalDocument, code);
 
-    private static (EditorTestWorkspace workspace, IDiagnosticAnalyzerService analyzerService, CodeFixService codeFixService, IErrorLoggerService errorLogger) ServiceSetup(
+    private static (EditorTestWorkspace workspace, CodeFixService codeFixService, IErrorLoggerService errorLogger) ServiceSetup(
         ImmutableArray<CodeFixProvider> codefixers,
         bool includeConfigurationFixProviders = false,
         bool throwExceptionInFixerCreation = false,
@@ -355,21 +355,16 @@ private static (EditorTestWorkspace workspace, IDiagnosticAnalyzerService analyz
         var analyzerReference = new TestAnalyzerReferenceByLanguage(DiagnosticExtensions.GetCompilerDiagnosticAnalyzersMap());
         workspace.TryApplyChanges(workspace.CurrentSolution.WithAnalyzerReferences([analyzerReference]));
 
-        var diagnosticService = workspace.GetService<IDiagnosticAnalyzerService>();
+        var diagnosticService = workspace.Services.GetRequiredService<IDiagnosticAnalyzerService>();
         var logger = SpecializedCollections.SingletonEnumerable(new Lazy<IErrorLoggerService>(() => new TestErrorLogger()));
         var errorLogger = logger.First().Value;
 
         var configurationFixProviders = includeConfigurationFixProviders
             ? workspace.ExportProvider.GetExports<IConfigurationFixProvider, CodeChangeProviderMetadata>()
             : [];
 
-        var fixService = new CodeFixService(
-            diagnosticService,
-            logger,
-            fixers,
-            configurationFixProviders);
-
-        return (workspace, diagnosticService, fixService, errorLogger);
+        var fixService = new CodeFixService(logger, fixers, configurationFixProviders);
+        return (workspace, fixService, errorLogger);
     }
 
     private static void GetDocumentAndExtensionManager(
@@ -757,11 +752,10 @@ private static async Task<ImmutableArray<CodeFixCollection>> GetNuGetAndVsixCode
 
         using var workspace = TestWorkspace.CreateCSharp(code, composition: s_compositionWithMockDiagnosticUpdateSourceRegistrationService, openDocuments: true);
 
-        var diagnosticService = workspace.GetService<IDiagnosticAnalyzerService>();
+        var diagnosticService = workspace.Services.GetRequiredService<IDiagnosticAnalyzerService>();
 
         var logger = SpecializedCollections.SingletonEnumerable(new Lazy<IErrorLoggerService>(() => workspace.Services.GetRequiredService<IErrorLoggerService>()));
-        var fixService = new CodeFixService(
-            diagnosticService, logger, vsixFixers, configurationProviders: []);
+        var fixService = new CodeFixService(logger, vsixFixers, configurationProviders: []);
 
         diagnosticAnalyzer ??= new MockAnalyzerReference.MockDiagnosticAnalyzer();
         var analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(diagnosticAnalyzer);
@@ -1033,7 +1027,6 @@ void M()
 
         var tuple = ServiceSetup(codeFix, code: code);
         using var workspace = tuple.workspace;
-        var analyzerService = tuple.analyzerService;
         GetDocumentAndExtensionManager(workspace, out var document,
             out var extensionManager, analyzerReference);
 
@@ -1047,6 +1040,7 @@ void M()
         // We enable full solution analysis so the 'AnalyzeDocumentAsync' doesn't skip analysis based on whether the document is active/open.
         workspace.GlobalOptions.SetGlobalOption(SolutionCrawlerOptionsStorage.BackgroundAnalysisScopeOption, LanguageNames.CSharp, BackgroundAnalysisScope.FullSolution);
 
+        var analyzerService = workspace.Services.GetRequiredService<IDiagnosticAnalyzerService>();
         var diagnostics = await analyzerService.ForceAnalyzeProjectAsync(sourceDocument.Project, CancellationToken.None);
         await VerifyCachedDiagnosticsAsync(
             sourceDocument, expectedCachedDiagnostic: diagnosticOnFixLineInPriorSnapshot, testSpan, diagnostics);