private void OnCompilationEventsGenerated_NoLock(ImmutableArray <CompilationEvent> compilationEvents, SyntaxTree filterTreeOpt, AnalyzerDriver driver, CancellationToken cancellationToken)
{
Debug.Assert(_lazyAnalyzerActionCountsMap != null);
// Add the events to our global pending events map.
AddToEventsMap_NoLock(compilationEvents, filterTreeOpt);
// Mark the events for analysis for each analyzer.
ArrayBuilder <ISymbol> newPartialSymbols = null;
Debug.Assert(_pooledEventsWithAnyActionsSet.Count == 0);
foreach (KeyValuePair <DiagnosticAnalyzer, int> kvp in _analyzerStateMap)
{
DiagnosticAnalyzer analyzer = kvp.Key;
PerAnalyzerState analyzerState = _analyzerStates[kvp.Value];
AnalyzerActionCounts actionCounts = _lazyAnalyzerActionCountsMap[analyzer];
foreach (CompilationEvent compilationEvent in compilationEvents)
{
if (HasActionsForEvent(compilationEvent, actionCounts))
{
_pooledEventsWithAnyActionsSet.Add(compilationEvent);
SymbolDeclaredCompilationEvent symbolDeclaredEvent = compilationEvent as SymbolDeclaredCompilationEvent;
if (symbolDeclaredEvent?.DeclaringSyntaxReferences.Length > 1)
{
if (_partialSymbolsWithGeneratedSourceEvents.Contains(symbolDeclaredEvent.Symbol))
{
// already processed.
continue;
}
else
{
newPartialSymbols = newPartialSymbols ?? ArrayBuilder <ISymbol> .GetInstance();
newPartialSymbols.Add(symbolDeclaredEvent.Symbol);
}
}
analyzerState.OnCompilationEventGenerated(compilationEvent, actionCounts);
}
}
}
foreach (CompilationEvent compilationEvent in compilationEvents)
{
if (!_pooledEventsWithAnyActionsSet.Remove(compilationEvent))
{
// Event has no relevant actions to execute, so mark it as complete.
UpdateEventsMap_NoLock(compilationEvent, add: false);
}
}
if (newPartialSymbols != null)
{
_partialSymbolsWithGeneratedSourceEvents.AddAll(newPartialSymbols);
newPartialSymbols.Free();
}
}
private void OnSymbolDeclaredEventProcessed(SymbolDeclaredCompilationEvent symbolDeclaredEvent, ImmutableArray <DiagnosticAnalyzer> analyzers)
{
foreach (DiagnosticAnalyzer analyzer in analyzers)
{
PerAnalyzerState analyzerState = GetAnalyzerState(analyzer);
analyzerState.OnSymbolDeclaredEventProcessed(symbolDeclaredEvent);
}
}
private HashSet <CompilationEvent> GetPendingEvents_NoLock(ImmutableArray <DiagnosticAnalyzer> analyzers)
{
HashSet <CompilationEvent> uniqueEvents = _compilationEventsPool.Allocate();
foreach (DiagnosticAnalyzer analyzer in analyzers)
{
PerAnalyzerState analyzerState = GetAnalyzerState(analyzer);
analyzerState.AddPendingEvents(uniqueEvents);
}
return(uniqueEvents);
}
private static ImmutableDictionary<DiagnosticAnalyzer, PerAnalyzerState> CreateAnalyzerStateMap(ImmutableArray<DiagnosticAnalyzer> analyzers)
{
var analyzerStateDataPool = new ObjectPool<AnalyzerStateData>(() => new AnalyzerStateData());
var declarationAnalyzerStateDataPool = new ObjectPool<DeclarationAnalyzerStateData>(() => new DeclarationAnalyzerStateData());
var map = ImmutableDictionary.CreateBuilder<DiagnosticAnalyzer, PerAnalyzerState>();
foreach (var analyzer in analyzers)
{
map[analyzer] = new PerAnalyzerState(analyzerStateDataPool, declarationAnalyzerStateDataPool);
}
return map.ToImmutable();
}
private static ImmutableDictionary <DiagnosticAnalyzer, PerAnalyzerState> CreateAnalyzerStateMap(ImmutableArray <DiagnosticAnalyzer> analyzers)
{
var analyzerStateDataPool = new ObjectPool <AnalyzerStateData>(() => new AnalyzerStateData());
var declarationAnalyzerStateDataPool = new ObjectPool <DeclarationAnalyzerStateData>(() => new DeclarationAnalyzerStateData());
var map = ImmutableDictionary.CreateBuilder <DiagnosticAnalyzer, PerAnalyzerState>();
foreach (var analyzer in analyzers)
{
map[analyzer] = new PerAnalyzerState(analyzerStateDataPool, declarationAnalyzerStateDataPool);
}
return(map.ToImmutable());
}
/// <summary>
/// Returns true if we have any pending syntax analysis for given analysis scope.
/// </summary>
public bool HasPendingSyntaxAnalysis(AnalysisScope analysisScope)
{
if (analysisScope.IsTreeAnalysis && !analysisScope.IsSyntaxOnlyTreeAnalysis)
{
return(false);
}
foreach (DiagnosticAnalyzer analyzer in analysisScope.Analyzers)
{
PerAnalyzerState analyzerState = GetAnalyzerState(analyzer);
if (analyzerState.HasPendingSyntaxAnalysis(analysisScope.FilterTreeOpt))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Returns true if we have any pending symbol analysis for given analysis scope.
/// </summary>
public bool HasPendingSymbolAnalysis(AnalysisScope analysisScope)
{
Debug.Assert(analysisScope.FilterTreeOpt != null);
ImmutableArray <SymbolDeclaredCompilationEvent> symbolDeclaredEvents = GetPendingSymbolDeclaredEvents(analysisScope.FilterTreeOpt);
foreach (SymbolDeclaredCompilationEvent symbolDeclaredEvent in symbolDeclaredEvents)
{
if (analysisScope.ShouldAnalyze(symbolDeclaredEvent.Symbol))
{
foreach (DiagnosticAnalyzer analyzer in analysisScope.Analyzers)
{
PerAnalyzerState analyzerState = GetAnalyzerState(analyzer);
if (analyzerState.HasPendingSymbolAnalysis(symbolDeclaredEvent.Symbol))
{
return(true);
}
}
}
}
return(false);
}
/// <summary>
/// True if the given symbol declaration is fully analyzed for the given analyzer.
/// </summary>
public bool IsDeclarationComplete(ISymbol symbol, int declarationIndex, DiagnosticAnalyzer analyzer)
{
PerAnalyzerState analyzerState = GetAnalyzerState(analyzer);
return(IsDeclarationComplete(symbol, declarationIndex, SpecializedCollections.SingletonEnumerable(analyzerState)));
}
