private async Task ProcessSymbolDeclaredAsync(SymbolDeclaredCompilationEvent symbolEvent, CancellationToken cancellationToken)
{
// Create a task per-analyzer to execute analyzer actions.
// We execute analyzers in parallel, but for a given analyzer we execute actions sequentially.
var tasksMap = PooledDictionary <DiagnosticAnalyzer, Task> .GetInstance();
try
{
var symbol = symbolEvent.Symbol;
// Skip symbol actions for implicitly declared symbols.
if (!symbol.IsImplicitlyDeclared)
{
AddTasksForExecutingSymbolActions(symbolEvent, tasksMap, cancellationToken);
}
// Skip syntax actions for implicitly declared symbols, except for implicitly declared global namespace symbols.
if (!symbol.IsImplicitlyDeclared ||
(symbol.Kind == SymbolKind.Namespace && ((INamespaceSymbol)symbol).IsGlobalNamespace))
{
AddTasksForExecutingDeclaringReferenceActions(symbolEvent, tasksMap, cancellationToken);
}
// Execute all analyzer actions.
await Task.WhenAll(tasksMap.Values).ConfigureAwait(false);
}
finally
{
tasksMap.Free();
symbolEvent.FlushCache();
}
}
private Task ProcessSymbolDeclared(SymbolDeclaredCompilationEvent symbolEvent, CancellationToken cancellationToken)
{
try
{
return(AnalyzeSymbol(symbolEvent, cancellationToken));
}
finally
{
symbolEvent.FlushCache();
}
}
private void ProcessSymbolDeclared(SymbolDeclaredCompilationEvent symbolEvent, AnalysisScope analysisScope, AnalysisState analysisStateOpt, CancellationToken cancellationToken)
{
try
{
// Execute all analyzer actions.
var symbol = symbolEvent.Symbol;
var references = symbolEvent.DeclaringSyntaxReferences;
if (!AnalysisScope.ShouldSkipSymbolAnalysis(symbolEvent))
{
ExecuteSymbolActions(symbolEvent, analysisScope, analysisStateOpt, cancellationToken);
}
if (!AnalysisScope.ShouldSkipDeclarationAnalysis(symbol))
{
ExecuteDeclaringReferenceActions(symbolEvent, analysisScope, analysisStateOpt, cancellationToken);
}
}
finally
{
symbolEvent.FlushCache();
}
}
private async Task ProcessSymbolDeclaredAsync(SymbolDeclaredCompilationEvent symbolEvent, AnalysisScope analysisScope, AnalysisState analysisStateOpt, CancellationToken cancellationToken)
{
try
{
// Execute all analyzer actions.
var symbol = symbolEvent.Symbol;
var references = symbolEvent.DeclaringSyntaxReferences;
if (!AnalysisScope.ShouldSkipSymbolAnalysis(symbolEvent))
{
await ExecuteSymbolActionsAsync(symbolEvent, analysisScope, analysisStateOpt, cancellationToken).ConfigureAwait(false);
}
if (!AnalysisScope.ShouldSkipDeclarationAnalysis(symbol))
{
await ExecuteDeclaringReferenceActionsAsync(symbolEvent, analysisScope, analysisStateOpt, cancellationToken).ConfigureAwait(false);
}
}
finally
{
symbolEvent.FlushCache();
}
}
private Task ProcessSymbolDeclared(SymbolDeclaredCompilationEvent symbolEvent, CancellationToken cancellationToken)
{
try
{
return AnalyzeSymbol(symbolEvent, cancellationToken);
}
finally
{
symbolEvent.FlushCache();
}
}
/// <summary>
/// Tries to execute symbol and declaration actions for the given symbol.
/// </summary>
/// <returns>
/// True, if successfully executed the actions for the given analysis scope OR no actions were required to be executed for the given analysis scope.
/// False, otherwise.
/// </returns>
private bool TryProcessSymbolDeclared(SymbolDeclaredCompilationEvent symbolEvent, AnalysisScope analysisScope, AnalysisState analysisStateOpt, CancellationToken cancellationToken)
{
try
{
// Attempt to execute all analyzer actions.
var success = true;
var symbol = symbolEvent.Symbol;
var isGeneratedCodeSymbol = IsGeneratedCodeSymbol(symbol);
if (!AnalysisScope.ShouldSkipSymbolAnalysis(symbolEvent) &&
!TryExecuteSymbolActions(symbolEvent, analysisScope, analysisStateOpt, isGeneratedCodeSymbol, cancellationToken))
{
success = false;
}
if (!AnalysisScope.ShouldSkipDeclarationAnalysis(symbol) &&
!TryExecuteDeclaringReferenceActions(symbolEvent, analysisScope, analysisStateOpt, isGeneratedCodeSymbol, cancellationToken))
{
success = false;
}
return success;
}
finally
{
symbolEvent.FlushCache();
}
}
private async Task ProcessSymbolDeclaredAsync(SymbolDeclaredCompilationEvent symbolEvent, CancellationToken cancellationToken)
{
// Collect all the analyzer action executors grouped by analyzer.
// NOTE: Right now we execute all the actions sequentially, but there is scope to fine tune this to execute certain actions in parallel.
var actionsMap = PooledDictionary<DiagnosticAnalyzer, ArrayBuilder<Action>>.GetInstance();
try
{
var symbol = symbolEvent.Symbol;
// Skip symbol actions for implicitly declared symbols.
if (!symbol.IsImplicitlyDeclared)
{
AddTasksForExecutingSymbolActions(symbolEvent, actionsMap, cancellationToken);
}
// Skip syntax actions for implicitly declared symbols, except for implicitly declared global namespace symbols.
if (!symbol.IsImplicitlyDeclared ||
(symbol.Kind == SymbolKind.Namespace && ((INamespaceSymbol)symbol).IsGlobalNamespace))
{
AddTasksForExecutingDeclaringReferenceActions(symbolEvent, actionsMap, cancellationToken);
}
// Execute all analyzer actions.
await Task.Run(() =>
{
foreach (var builder in actionsMap.Values)
{
foreach (var action in builder)
{
action();
}
builder.Free();
};
}, cancellationToken).ConfigureAwait(false);
}
finally
{
actionsMap.Free();
symbolEvent.FlushCache();
}
}
private async Task ProcessSymbolDeclaredAsync(SymbolDeclaredCompilationEvent symbolEvent, CancellationToken cancellationToken)
{
// Create a task per-analyzer to execute analyzer actions.
// We execute analyzers in parallel, but for a given analyzer we execute actions sequentially.
var tasksMap = PooledDictionary<DiagnosticAnalyzer, Task>.GetInstance();
try
{
var symbol = symbolEvent.Symbol;
// Skip symbol actions for implicitly declared symbols.
if (!symbol.IsImplicitlyDeclared)
{
AddTasksForExecutingSymbolActions(symbolEvent, tasksMap, cancellationToken);
}
// Skip syntax actions for implicitly declared symbols, except for implicitly declared global namespace symbols.
if (!symbol.IsImplicitlyDeclared ||
(symbol.Kind == SymbolKind.Namespace && ((INamespaceSymbol)symbol).IsGlobalNamespace))
{
AddTasksForExecutingDeclaringReferenceActions(symbolEvent, tasksMap, _addDiagnostic, cancellationToken);
}
// Execute all analyzer actions.
await Task.WhenAll(tasksMap.Values).ConfigureAwait(false);
}
finally
{
tasksMap.Free();
symbolEvent.FlushCache();
}
}
