refactor diagnostic analyzer service v1 state management code

src/EditorFeatures/Test2/Diagnostics/DiagnosticServiceTests.vb

@@ -113,7 +113,8 @@ Namespace Microsoft.CodeAnalysis.Editor.Implementation.Diagnostics.UnitTests
                 Dim duplicateProjectAnalyzersReference = New AnalyzerImageReference(duplicateProjectAnalyzers)
                 project = project.WithAnalyzerReferences({duplicateProjectAnalyzersReference})
 
-                ' Verify no duplicate descriptors or diagnsotics.
+                ' Verify duplicate descriptors or diagnsotics.
+                ' We don't do de-duplication of analyzer that belong to different layer (host and project)
                 descriptorsMap = diagnosticService.GetDiagnosticDescriptors(project)
                 Assert.Equal(2, descriptorsMap.Count)
                 descriptors = descriptorsMap.Values.SelectMany(Function(d) d).OrderBy(Function(d) d.Id).ToImmutableArray()
@@ -123,7 +124,7 @@ Namespace Microsoft.CodeAnalysis.Editor.Implementation.Diagnostics.UnitTests
                 diagnostics = diagnosticService.GetDiagnosticsForSpanAsync(document,
                                                                     document.GetSyntaxRootAsync().WaitAndGetResult(CancellationToken.None).FullSpan,
                                                                     CancellationToken.None).WaitAndGetResult(CancellationToken.None)
-                Assert.Equal(1, diagnostics.Count())
+                Assert.Equal(2, diagnostics.Count())
             End Using
         End Sub
 

src/Features/Core/Diagnostics/AbstractHostDiagnosticUpdateSource.cs

@@ -114,7 +114,7 @@ private void ClearAnalyzerDiagnostics(DiagnosticAnalyzer analyzer, ProjectId pro
 
         private DiagnosticsUpdatedArgs MakeArgs(DiagnosticAnalyzer analyzer, ImmutableHashSet<DiagnosticData> items, Project project)
         {
-            var id = WorkspaceAnalyzerManager.GetUniqueIdForAnalyzer(analyzer);
+            var id = analyzer.GetUniqueId();
 
             return new DiagnosticsUpdatedArgs(
                 id: Tuple.Create(this, id, project?.Id),

src/Features/Core/Diagnostics/AnalyzerHelper.cs

@@ -1,9 +1,11 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using System;
+using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.ErrorReporting;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Diagnostics
 {
@@ -12,12 +14,12 @@ internal static class AnalyzerHelper
         private const string CSharpCompilerAnalyzerTypeName = "Microsoft.CodeAnalysis.Diagnostics.CSharp.CSharpCompilerDiagnosticAnalyzer";
         private const string VisualBasicCompilerAnalyzerTypeName = "Microsoft.CodeAnalysis.Diagnostics.VisualBasic.VisualBasicCompilerDiagnosticAnalyzer";
 
-        public static bool IsBuiltInAnalyzer(DiagnosticAnalyzer analyzer)
+        public static bool IsBuiltInAnalyzer(this DiagnosticAnalyzer analyzer)
         {
-            return analyzer is IBuiltInAnalyzer || analyzer is DocumentDiagnosticAnalyzer || analyzer is ProjectDiagnosticAnalyzer || IsCompilerAnalyzer(analyzer);
+            return analyzer is IBuiltInAnalyzer || analyzer is DocumentDiagnosticAnalyzer || analyzer is ProjectDiagnosticAnalyzer || analyzer.IsCompilerAnalyzer();
         }
 
-        public static bool IsCompilerAnalyzer(DiagnosticAnalyzer analyzer)
+        public static bool IsCompilerAnalyzer(this DiagnosticAnalyzer analyzer)
         {
             // TODO: find better way.
             var typeString = analyzer.GetType().ToString();
@@ -34,43 +36,61 @@ public static bool IsCompilerAnalyzer(DiagnosticAnalyzer analyzer)
             return false;
         }
 
-        public static Action<Diagnostic> GetAddExceptionDiagnosticDelegate(DiagnosticAnalyzer analyzer, AbstractHostDiagnosticUpdateSource hostDiagnosticUpdateSource, Project project)
+        public static ValueTuple<string, VersionStamp> GetUniqueId(this DiagnosticAnalyzer analyzer)
+        {
+            // Get the unique ID for given diagnostic analyzer.
+            // note that we also put version stamp so that we can detect changed analyzer.
+            var type = analyzer.GetType();
+            return ValueTuple.Create(type.AssemblyQualifiedName, GetAnalyzerVersion(type.Assembly.Location));
+        }
+
+        public static Action<Diagnostic> GetAddExceptionDiagnosticDelegate(this DiagnosticAnalyzer analyzer, AbstractHostDiagnosticUpdateSource hostDiagnosticUpdateSource, Project project)
         {
             return diagnostic =>
                 hostDiagnosticUpdateSource?.ReportAnalyzerDiagnostic(analyzer, diagnostic, project.Solution.Workspace, project);
         }
 
-        public static Action<Diagnostic> GetAddExceptionDiagnosticDelegate(DiagnosticAnalyzer analyzer, AbstractHostDiagnosticUpdateSource hostDiagnosticUpdateSource, Workspace workspace)
+        public static Action<Diagnostic> GetAddExceptionDiagnosticDelegate(this DiagnosticAnalyzer analyzer, AbstractHostDiagnosticUpdateSource hostDiagnosticUpdateSource, Workspace workspace)
         {
             return diagnostic =>
                 hostDiagnosticUpdateSource?.ReportAnalyzerDiagnostic(analyzer, diagnostic, workspace, null);
         }
 
         public static AnalyzerExecutor GetAnalyzerExecutorForSupportedDiagnostics(
-            DiagnosticAnalyzer analyzer,
+            this DiagnosticAnalyzer analyzer, 
             AbstractHostDiagnosticUpdateSource hostDiagnosticUpdateSource,
-            Func<Exception, DiagnosticAnalyzer, bool> continueOnAnalyzerException,
+            Func<Exception, DiagnosticAnalyzer, bool> continueOnAnalyzerException, 
             CancellationToken cancellationToken)
         {
-            var addExceptionDiagnostic = GetAddExceptionDiagnosticDelegate(analyzer, hostDiagnosticUpdateSource, hostDiagnosticUpdateSource?.Workspace);
+            var addExceptionDiagnostic = analyzer.GetAddExceptionDiagnosticDelegate(hostDiagnosticUpdateSource, hostDiagnosticUpdateSource?.Workspace);
 
             // Skip telemetry logging if the exception is thrown as we are computing supported diagnostics and
             // we can't determine if any descriptors support getting telemetry without having the descriptors.
             return AnalyzerExecutor.CreateForSupportedDiagnostics(addExceptionDiagnostic, continueOnAnalyzerException, cancellationToken);
         }
-
+        
         public static AnalyzerExecutor GetAnalyzerExecutor(
-            DiagnosticAnalyzer analyzer,
-            AbstractHostDiagnosticUpdateSource hostDiagnosticUpdateSource,
-            Project project,
-            Compilation compilation,
+            this DiagnosticAnalyzer analyzer, 
+            AbstractHostDiagnosticUpdateSource hostDiagnosticUpdateSource, 
+            Project project, 
+            Compilation compilation, 
             Action<Diagnostic> addDiagnostic,
             AnalyzerOptions analyzerOptions,
             Func<Exception, DiagnosticAnalyzer, bool> continueOnAnalyzerException,
             CancellationToken cancellationToken)
         {
-            var addExceptionDiagnostic = GetAddExceptionDiagnosticDelegate(analyzer, hostDiagnosticUpdateSource, project);
+            var addExceptionDiagnostic = analyzer.GetAddExceptionDiagnosticDelegate(hostDiagnosticUpdateSource, project);
             return AnalyzerExecutor.Create(compilation, analyzerOptions, addDiagnostic, addExceptionDiagnostic, continueOnAnalyzerException, cancellationToken);
         }
+
+        private static VersionStamp GetAnalyzerVersion(string path)
+        {
+            if (path == null || !File.Exists(path))
+            {
+                return VersionStamp.Default;
+            }
+
+            return VersionStamp.Create(File.GetLastWriteTimeUtc(path));
+        }
     }
 }

src/Features/Core/Diagnostics/BaseDiagnosticIncrementalAnalyzer.cs

@@ -162,7 +162,7 @@ protected BaseDiagnosticIncrementalAnalyzer(Workspace workspace, AbstractHostDia
         public abstract Task<IEnumerable<DiagnosticData>> GetDiagnosticsForSpanAsync(Document document, TextSpan range, CancellationToken cancellationToken);
         #endregion
 
-        public Workspace Workspace { get; private set; }
+        protected Workspace Workspace { get; private set; }
         protected AbstractHostDiagnosticUpdateSource HostDiagnosticUpdateSource { get; private set; }
 
         public virtual bool NeedsReanalysisOnOptionChanged(object sender, OptionChangedEventArgs e)

src/Features/Core/Diagnostics/DiagnosticAnalyzerService.cs

@@ -1,10 +1,12 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Composition;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.SolutionCrawler;
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
@@ -15,45 +17,51 @@ namespace Microsoft.CodeAnalysis.Diagnostics
     [Shared]
     internal partial class DiagnosticAnalyzerService : IDiagnosticAnalyzerService
     {
-        private readonly WorkspaceAnalyzerManager _workspaceAnalyzerManager;
+        private readonly HostAnalyzerManager _hostAnalyzerManager;
         private readonly AbstractHostDiagnosticUpdateSource _hostDiagnosticUpdateSource;
+        private readonly IAsynchronousOperationListener _listener;
 
         [ImportingConstructor]
-        public DiagnosticAnalyzerService([Import(AllowDefault = true)]IWorkspaceDiagnosticAnalyzerProviderService diagnosticAnalyzerProviderService = null,
+        public DiagnosticAnalyzerService(
+            [ImportMany] IEnumerable<Lazy<IAsynchronousOperationListener, FeatureMetadata>> asyncListeners,
+            [Import(AllowDefault = true)]IWorkspaceDiagnosticAnalyzerProviderService diagnosticAnalyzerProviderService = null,
             [Import(AllowDefault = true)]AbstractHostDiagnosticUpdateSource hostDiagnosticUpdateSource = null)
             : this(workspaceAnalyzerAssemblies: diagnosticAnalyzerProviderService != null ?
                    diagnosticAnalyzerProviderService.GetWorkspaceAnalyzerAssemblies() :
                    SpecializedCollections.EmptyEnumerable<string>(),
                   hostDiagnosticUpdateSource: hostDiagnosticUpdateSource)
         {
+            _listener = new AggregateAsynchronousOperationListener(asyncListeners, FeatureAttribute.DiagnosticService);
         }
 
+        public IAsynchronousOperationListener Listener => _listener;
+
         private DiagnosticAnalyzerService(IEnumerable<string> workspaceAnalyzerAssemblies, AbstractHostDiagnosticUpdateSource hostDiagnosticUpdateSource) : this()
         {
-            _workspaceAnalyzerManager = new WorkspaceAnalyzerManager(workspaceAnalyzerAssemblies, hostDiagnosticUpdateSource);
+            _hostAnalyzerManager = new HostAnalyzerManager(workspaceAnalyzerAssemblies, hostDiagnosticUpdateSource);
             _hostDiagnosticUpdateSource = hostDiagnosticUpdateSource;
         }
 
         // internal for testing purposes.
         internal DiagnosticAnalyzerService(ImmutableArray<AnalyzerReference> workspaceAnalyzers, AbstractHostDiagnosticUpdateSource hostDiagnosticUpdateSource = null) : this()
         {
-            _workspaceAnalyzerManager = new WorkspaceAnalyzerManager(workspaceAnalyzers, hostDiagnosticUpdateSource);
+            _hostAnalyzerManager = new HostAnalyzerManager(workspaceAnalyzers, hostDiagnosticUpdateSource);
             _hostDiagnosticUpdateSource = hostDiagnosticUpdateSource;
         }
 
         public ImmutableDictionary<string, ImmutableArray<DiagnosticDescriptor>> GetDiagnosticDescriptors(Project projectOpt)
         {
             if (projectOpt == null)
             {
-                return _workspaceAnalyzerManager.GetHostDiagnosticDescriptorsPerReference();
+                return _hostAnalyzerManager.GetHostDiagnosticDescriptorsPerReference();
             }
 
-            return _workspaceAnalyzerManager.CreateDiagnosticDescriptorsPerReference(projectOpt);
+            return _hostAnalyzerManager.CreateDiagnosticDescriptorsPerReference(projectOpt);
         }
 
         public ImmutableArray<DiagnosticDescriptor> GetDiagnosticDescriptors(DiagnosticAnalyzer analyzer)
         {
-            return _workspaceAnalyzerManager.GetDiagnosticDescriptors(analyzer);
+            return _hostAnalyzerManager.GetDiagnosticDescriptors(analyzer);
         }
 
         public void Reanalyze(Workspace workspace, IEnumerable<ProjectId> projectIds = null, IEnumerable<DocumentId> documentIds = null)

src/Features/Core/Diagnostics/DiagnosticAnalyzerService_IncrementalAnalyzer.cs

@@ -49,7 +49,7 @@ private BaseDiagnosticIncrementalAnalyzer CreateIncrementalAnalyzerCallback(Work
         {
             // subscribe to active context changed event for new workspace
             workspace.DocumentActiveContextChanged += OnDocumentActiveContextChanged;
-            return new IncrementalAnalyzerDelegatee(this, workspace, _workspaceAnalyzerManager, _hostDiagnosticUpdateSource);
+            return new IncrementalAnalyzerDelegatee(this, workspace, _hostAnalyzerManager, _hostDiagnosticUpdateSource);
         }
 
         private void OnDocumentActiveContextChanged(object sender, DocumentEventArgs e)
@@ -60,7 +60,7 @@ private void OnDocumentActiveContextChanged(object sender, DocumentEventArgs e)
         // internal for testing
         internal class IncrementalAnalyzerDelegatee : BaseDiagnosticIncrementalAnalyzer
         {
-            private readonly WorkspaceAnalyzerManager _workspaceAnalyzerManager;
+            private readonly HostAnalyzerManager _hostAnalyzerManager;
             private readonly DiagnosticAnalyzerService _owner;
 
             // v1 diagnostic engine
@@ -69,17 +69,17 @@ internal class IncrementalAnalyzerDelegatee : BaseDiagnosticIncrementalAnalyzer
             // v2 diagnostic engine - for now v1
             private readonly EngineV2.DiagnosticIncrementalAnalyzer _engineV2;
 
-            public IncrementalAnalyzerDelegatee(DiagnosticAnalyzerService owner, Workspace workspace, WorkspaceAnalyzerManager workspaceAnalyzerManager, AbstractHostDiagnosticUpdateSource hostDiagnosticUpdateSource)
+            public IncrementalAnalyzerDelegatee(DiagnosticAnalyzerService owner, Workspace workspace, HostAnalyzerManager hostAnalyzerManager, AbstractHostDiagnosticUpdateSource hostDiagnosticUpdateSource)
                 : base(workspace, hostDiagnosticUpdateSource)
             {
-                _workspaceAnalyzerManager = workspaceAnalyzerManager;
+                _hostAnalyzerManager = hostAnalyzerManager;
                 _owner = owner;
 
                 var v1CorrelationId = LogAggregator.GetNextId();
-                _engineV1 = new EngineV1.DiagnosticIncrementalAnalyzer(_owner, v1CorrelationId, workspace, _workspaceAnalyzerManager, hostDiagnosticUpdateSource);
+                _engineV1 = new EngineV1.DiagnosticIncrementalAnalyzer(_owner, v1CorrelationId, workspace, _hostAnalyzerManager, hostDiagnosticUpdateSource);
 
                 var v2CorrelationId = LogAggregator.GetNextId();
-                _engineV2 = new EngineV2.DiagnosticIncrementalAnalyzer(_owner, v2CorrelationId, workspace, _workspaceAnalyzerManager, hostDiagnosticUpdateSource);
+                _engineV2 = new EngineV2.DiagnosticIncrementalAnalyzer(_owner, v2CorrelationId, workspace, _hostAnalyzerManager, hostDiagnosticUpdateSource);
             }
 
             #region IIncrementalAnalyzer

src/Features/Core/Diagnostics/DiagnosticAnalyzerService_Test.cs

@@ -28,6 +28,12 @@ internal DiagnosticAnalyzerService(ImmutableDictionary<string, ImmutableArray<Di
         {
         }
 
+        // Internal for testing purposes.
+        internal DiagnosticAnalyzerService(AbstractHostDiagnosticUpdateSource hostDiagnosticUpdateSource = null)
+           : this(workspaceAnalyzerAssemblies: SpecializedCollections.EmptyEnumerable<string>(), hostDiagnosticUpdateSource: hostDiagnosticUpdateSource)
+        {
+        }
+
         private class TestAnalyzerReferenceByLanguage : AnalyzerReference
         {
             private readonly ImmutableDictionary<string, ImmutableArray<DiagnosticAnalyzer>> _analyzersMap;

src/Features/Core/Diagnostics/EngineV1/DiagnosticAnalyzerDriver.cs

@@ -339,19 +339,19 @@ internal void ReportAnalyzerExceptionDiagnostic(DiagnosticAnalyzer analyzer, Dia
 
         private Action<Diagnostic> GetAddExceptionDiagnosticDelegate(DiagnosticAnalyzer analyzer)
         {
-            return AnalyzerHelper.GetAddExceptionDiagnosticDelegate(analyzer, _hostDiagnosticUpdateSource, _project);
+            return analyzer.GetAddExceptionDiagnosticDelegate(_hostDiagnosticUpdateSource, _project);
         }
 
         private AnalyzerExecutor GetAnalyzerExecutorForSupportedDiagnostics(DiagnosticAnalyzer analyzer)
         {
             // Skip telemetry logging if the exception is thrown as we are computing supported diagnostics and
             // we can't determine if any descriptors support getting telemetry without having the descriptors.
-            return AnalyzerHelper.GetAnalyzerExecutorForSupportedDiagnostics(analyzer, _hostDiagnosticUpdateSource, CatchAnalyzerException_NoTelemetryLogging, _cancellationToken);
+            return analyzer.GetAnalyzerExecutorForSupportedDiagnostics(_hostDiagnosticUpdateSource, CatchAnalyzerException_NoTelemetryLogging, _cancellationToken);
         }
 
         private AnalyzerExecutor GetAnalyzerExecutor(DiagnosticAnalyzer analyzer, Compilation compilation, Action<Diagnostic> addDiagnostic)
         {
-            return AnalyzerHelper.GetAnalyzerExecutor(analyzer, _hostDiagnosticUpdateSource, _project,
+            return analyzer.GetAnalyzerExecutor(_hostDiagnosticUpdateSource, _project,
                 compilation, addDiagnostic, _analyzerOptions, CatchAnalyzerException, _cancellationToken);
         }
 
@@ -573,7 +573,7 @@ internal static bool CatchAnalyzerException_NoTelemetryLogging(Exception e, Diag
                 return false;
             }
 
-            if (AnalyzerHelper.IsBuiltInAnalyzer(analyzer))
+            if (analyzer.IsBuiltInAnalyzer())
             {
                 return FatalError.ReportWithoutCrashUnlessCanceled(e);
             }