private async Task ProcessEventAsync(CompilationEvent e, AnalysisScope analysisScope, AnalysisState analysisStateOpt, CancellationToken cancellationToken)
        {
            await ProcessEventCoreAsync(e, analysisScope, analysisStateOpt, cancellationToken).ConfigureAwait(false);

            if (analysisStateOpt != null)
            {
                await analysisStateOpt.OnCompilationEventProcessedAsync(e, analysisScope, cancellationToken).ConfigureAwait(false);
            }
        }

        private async Task ExecuteCompilationActionsAsync(
            ImmutableDictionary<DiagnosticAnalyzer, ImmutableArray<CompilationAnalyzerAction>> compilationActionsMap,
            CompilationEvent compilationEvent,
            AnalysisScope analysisScope,
            AnalysisState analysisStateOpt,
            CancellationToken cancellationToken)
        {
            Debug.Assert(compilationEvent is CompilationStartedEvent || compilationEvent is CompilationCompletedEvent);

            try
            {
                foreach (var analyzer in analysisScope.Analyzers)
                {
                    ImmutableArray<CompilationAnalyzerAction> compilationActions;
                    if (compilationActionsMap.TryGetValue(analyzer, out compilationActions))
                    {
                        await analyzerExecutor.ExecuteCompilationActionsAsync(compilationActions, analyzer, compilationEvent, analysisScope, analysisStateOpt).ConfigureAwait(false);
                    }
                    else if (analysisStateOpt != null)
                    {
                        await analysisStateOpt.MarkEventCompleteAsync(compilationEvent, analyzer, cancellationToken).ConfigureAwait(false);
                    }
                }
            }
            finally
            {
                compilationEvent.FlushCache();
            }
        }

        private void ProcessEventCore(CompilationEvent e, AnalysisScope analysisScope, AnalysisState analysisStateOpt, CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();

            var symbolEvent = e as SymbolDeclaredCompilationEvent;
            if (symbolEvent != null)
            {
                ProcessSymbolDeclared(symbolEvent, analysisScope, analysisStateOpt, cancellationToken);
                return;
            }

            var completedEvent = e as CompilationUnitCompletedEvent;
            if (completedEvent != null)
            {
                ProcessCompilationUnitCompleted(completedEvent, analysisScope, analysisStateOpt, cancellationToken);
                return;
            }

            var endEvent = e as CompilationCompletedEvent;
            if (endEvent != null)
            {
                ProcessCompilationCompleted(endEvent, analysisScope, analysisStateOpt, cancellationToken);
                return;
            }

            var startedEvent = e as CompilationStartedEvent;
            if (startedEvent != null)
            {
                ProcessCompilationStarted(startedEvent, analysisScope, analysisStateOpt, cancellationToken);
                return;
            }

            throw new InvalidOperationException("Unexpected compilation event of type " + e.GetType().Name);
        }

        private void AddPendingSourceEvent_NoLock(SyntaxTree tree, CompilationEvent compilationEvent)
        {
            HashSet<CompilationEvent> currentEvents;
            if (!_pendingSourceEvents.TryGetValue(tree, out currentEvents))
            {
                currentEvents = _compilationEventsPool.Allocate();
                _pendingSourceEvents[tree] = currentEvents;
                AnalyzerDriver.RemoveCachedSemanticModel(tree, compilationEvent.Compilation);
            }

            currentEvents.Add(compilationEvent);
        }

        /// <summary>
        /// Invoke this method at completion of event processing for the given analysis scope.
        /// It updates the analysis state of this event for each analyzer and if the event has been fully processed for all analyzers, then removes it from our event cache.
        /// </summary>
        public void OnCompilationEventProcessed(CompilationEvent compilationEvent, AnalysisScope analysisScope)
        {
            // Analyze if the symbol and all its declaring syntax references are analyzed.
            var symbolDeclaredEvent = compilationEvent as SymbolDeclaredCompilationEvent;
            if (symbolDeclaredEvent != null)
            {
                OnSymbolDeclaredEventProcessed(symbolDeclaredEvent, analysisScope.Analyzers);
            }

            // Check if event is fully analyzed for all analyzers.
            foreach (var analyzerState in _analyzerStateMap.Values)
            {
                if (!analyzerState.IsEventAnalyzed(compilationEvent))
                {
                    return;
                }
            }

            // Remove the event from event map.
            lock (_gate)
            {
                UpdateEventsMap_NoLock(compilationEvent, add: false);
            }
        }

 /// <summary>
 /// Marks the given event as fully analyzed for the given analyzer.
 /// </summary>
 public void MarkEventComplete(CompilationEvent compilationEvent, DiagnosticAnalyzer analyzer)
 {
     _analyzerStateMap[analyzer].MarkEventComplete(compilationEvent);
 }

        private void AddPendingSourceEvent_NoLock(SyntaxTree tree, CompilationEvent compilationEvent)
        {
            HashSet<CompilationEvent> currentEvents;
            if (!_pendingSourceEvents.TryGetValue(tree, out currentEvents))
            {
                currentEvents = new HashSet<CompilationEvent>();
                _pendingSourceEvents[tree] = currentEvents;
                _compilationData.RemoveCachedSemanticModel(tree);
            }

            currentEvents.Add(compilationEvent);
        }

 private void RemovePendingSourceEvent_NoLock(SyntaxTree tree, CompilationEvent compilationEvent)
 {
     HashSet<CompilationEvent> currentEvents;
     if (_pendingSourceEvents.TryGetValue(tree, out currentEvents))
     {
         if (currentEvents.Remove(compilationEvent) && currentEvents.Count == 0)
         {
             _compilationEventsPool.Free(currentEvents);
             _pendingSourceEvents.Remove(tree);
         }
     }
 }

 private async Task ProcessEventAsync(CompilationEvent e, CancellationToken cancellationToken)
 {
     try
     {
         var processEventTask = ProcessEventCoreAsync(e, cancellationToken);
         if (processEventTask != null)
         {
             await processEventTask.ConfigureAwait(false);
         }
     }
     catch (OperationCanceledException)
     {
         // when just a single operation is cancelled, we continue processing events.
         // TODO: what is the desired behavior in this case?
     }
 }

        private Task ProcessEventCoreAsync(CompilationEvent e, CancellationToken cancellationToken)
        {
            var symbolEvent = e as SymbolDeclaredCompilationEvent;
            if (symbolEvent != null)
            {
                return ProcessSymbolDeclaredAsync(symbolEvent, cancellationToken);
            }

            var completedEvent = e as CompilationUnitCompletedEvent;
            if (completedEvent != null)
            {
                return ProcessCompilationUnitCompletedAsync(completedEvent, cancellationToken);
            }

            var endEvent = e as CompilationCompletedEvent;
            if (endEvent != null)
            {
                return ProcessCompilationCompletedAsync(endEvent, cancellationToken);
            }

            if (e is CompilationStartedEvent)
            {
                // Ignore CompilationStartedEvent.
                return null;
            }

            throw new InvalidOperationException("Unexpected compilation event of type " + e.GetType().Name);
        }

 /// <summary>
 /// Marks the given event as fully analyzed for the given analyzer.
 /// </summary>
 public Task MarkEventCompleteAsync(CompilationEvent compilationEvent, DiagnosticAnalyzer analyzer, CancellationToken cancellationToken)
 {
     return GetAnalyzerState(analyzer).MarkEventCompleteAsync(compilationEvent, cancellationToken);
 }

 /// <summary>
 /// Attempts to start processing a compilation event for the given analyzer.
 /// </summary>
 /// <returns>
 /// Returns null if the event has already been processed for the analyzer OR is currently being processed by another task.
 /// Otherwise, returns a non-null state representing partial analysis state for the given event for the given analyzer.
 /// </returns>
 public Task<AnalyzerStateData> TryStartProcessingEventAsync(CompilationEvent compilationEvent, DiagnosticAnalyzer analyzer, CancellationToken cancellationToken)
 {
     return GetAnalyzerState(analyzer).TryStartProcessingEventAsync(compilationEvent, cancellationToken);
 }

        /// <summary>
        /// Invoke this method at completion of event processing for the given analysis scope.
        /// It updates the analysis state of this event for each analyzer and if the event has been fully processed for all analyzers, then removes it from our event cache.
        /// </summary>
        public async Task OnCompilationEventProcessedAsync(CompilationEvent compilationEvent, AnalysisScope analysisScope, CancellationToken cancellationToken)
        {
            // Analyze if the symbol and all its declaring syntax references are analyzed.
            var symbolDeclaredEvent = compilationEvent as SymbolDeclaredCompilationEvent;
            if (symbolDeclaredEvent != null)
            {
                await OnSymbolDeclaredEventProcessedAsync(symbolDeclaredEvent, analysisScope.Analyzers, cancellationToken).ConfigureAwait(false);
            }

            // Check if event is fully analyzed for all analyzers.
            foreach (var analyzerState in _analyzerStates)
            {
                var eventAnalyzed = await analyzerState.IsEventAnalyzedAsync(compilationEvent, cancellationToken).ConfigureAwait(false);
                if (!eventAnalyzed)
                {
                    return;
                }
            }

            // Remove the event from event map.
            using (await _gate.DisposableWaitAsync(cancellationToken).ConfigureAwait(false))
            {
                UpdateEventsMap_NoLock(compilationEvent, add: false);
            }

            if (symbolDeclaredEvent != null)
            {
                AnalyzerDriver.RemoveCachedDeclaringReferences(symbolDeclaredEvent.Symbol, symbolDeclaredEvent.Compilation);
            }
        }

 private void UpdateEventsMap_NoLock(CompilationEvent compilationEvent, bool add)
 {
     var symbolEvent = compilationEvent as SymbolDeclaredCompilationEvent;
     if (symbolEvent != null)
     {
         // Add/remove symbol events.
         // Any diagnostics request for a tree should trigger symbol and syntax node analysis for symbols with at least one declaring reference in the tree.
         foreach (var location in symbolEvent.Symbol.Locations)
         {
             if (location.SourceTree != null)
             {
                 if (add)
                 {
                     AddPendingSourceEvent_NoLock(location.SourceTree, compilationEvent);
                 }
                 else
                 {
                     RemovePendingSourceEvent_NoLock(location.SourceTree, compilationEvent);
                 }
             }
         }
     }
     else
     {
         // Add/remove compilation unit completed events.
         var compilationUnitCompletedEvent = compilationEvent as CompilationUnitCompletedEvent;
         if (compilationUnitCompletedEvent != null)
         {
             var tree = compilationUnitCompletedEvent.SemanticModel.SyntaxTree;
             if (add)
             {
                 AddPendingSourceEvent_NoLock(tree, compilationEvent);
             }
             else
             {
                 RemovePendingSourceEvent_NoLock(tree, compilationEvent);
             }
         }
         else if (compilationEvent is CompilationStartedEvent || compilationEvent is CompilationCompletedEvent)
         {
             // Add/remove compilation events.
             if (add)
             {
                 _pendingNonSourceEvents.Add(compilationEvent);
             }
             else
             {
                 _pendingNonSourceEvents.Remove(compilationEvent);
             }
         }
         else
         {
             throw new InvalidOperationException("Unexpected compilation event of type " + compilationEvent.GetType().Name);
         }
     }
 }

 private void RemovePendingSourceEvent_NoLock(SyntaxTree tree, CompilationEvent compilationEvent)
 {
     HashSet<CompilationEvent> currentEvents;
     if (_pendingSourceEvents.TryGetValue(tree, out currentEvents))
     {
         if (currentEvents.Remove(compilationEvent) && currentEvents.Count == 0)
         {
             _pendingSourceEvents.Remove(tree);
             _compilationData.RemoveCachedSemanticModel(tree);
         }
     }
 }

        private void AddPendingSourceEvent_NoLock(SyntaxTree tree, CompilationEvent compilationEvent)
        {
            HashSet<CompilationEvent> currentEvents;
            if (!_pendingSourceEvents.TryGetValue(tree, out currentEvents))
            {
                currentEvents = _compilationEventsPool.Allocate();
                _pendingSourceEvents[tree] = currentEvents;
            }

            currentEvents.Add(compilationEvent);
        }

 private static bool HasActionsForEvent(CompilationEvent compilationEvent, AnalyzerActionCounts actionCounts)
 {
     if (compilationEvent is CompilationStartedEvent)
     {
         return actionCounts.CompilationActionsCount > 0 ||
             actionCounts.SyntaxTreeActionsCount > 0;
     }
     else if (compilationEvent is CompilationCompletedEvent)
     {
         return actionCounts.CompilationEndActionsCount > 0;
     }
     else if (compilationEvent is SymbolDeclaredCompilationEvent)
     {
         return actionCounts.SymbolActionsCount > 0 || actionCounts.HasAnyExecutableCodeActions;
     }
     else
     {
         return actionCounts.SemanticModelActionsCount > 0;
     }
 }

 private static bool HasActionsForEvent(CompilationEvent compilationEvent, ActionCounts actionCounts)
 {
     if (compilationEvent is CompilationStartedEvent)
     {
         return actionCounts.CompilationActionsCount > 0 ||
             actionCounts.SyntaxTreeActionsCount > 0;
     }
     else if (compilationEvent is CompilationCompletedEvent)
     {
         return actionCounts.CompilationEndActionsCount > 0;
     }
     else if (compilationEvent is SymbolDeclaredCompilationEvent)
     {
         return actionCounts.CodeBlockActionsCount > 0 ||
             actionCounts.CodeBlockStartActionsCount > 0 ||
             actionCounts.SymbolActionsCount > 0 ||
             actionCounts.SyntaxNodeActionsCount > 0;
     }
     else
     {
         return actionCounts.SemanticModelActionsCount > 0;
     }
 }

 /// <summary>
 /// Marks the given event as fully analyzed for the given analyzer.
 /// </summary>
 public void MarkEventComplete(CompilationEvent compilationEvent, DiagnosticAnalyzer analyzer)
 {
     GetAnalyzerState(analyzer).MarkEventComplete(compilationEvent);
 }

 /// <summary>
 /// Attempts to start processing a compilation event for the given analyzer.
 /// </summary>
 /// <returns>
 /// Returns false if the event has already been processed for the analyzer OR is currently being processed by another task.
 /// If true, then it returns a non-null <paramref name="state"/> representing partial analysis state for the given event for the given analyzer.
 /// </returns>
 public bool TryStartProcessingEvent(CompilationEvent compilationEvent, DiagnosticAnalyzer analyzer, out AnalyzerStateData state)
 {
     return _analyzerStateMap[analyzer].TryStartProcessingEvent(compilationEvent, out state);
 }