private async Task ProcessCompilationCompletedAsync(CompilationCompletedEvent endEvent, CancellationToken cancellationToken)
{
try
{
// Execute analyzers in parallel.
var tasks = ArrayBuilder <Task> .GetInstance();
foreach (var analyzerAndActions in _compilationEndActionsMap)
{
var task = Task.Run(() =>
{
// Execute actions for a given analyzer sequentially.
analyzerExecutor.ExecuteCompilationEndActions(analyzerAndActions.Value);
}, cancellationToken);
tasks.Add(task);
}
await Task.WhenAll(tasks.ToArrayAndFree()).ConfigureAwait(false);
}
finally
{
endEvent.FlushCache();
}
}
private async Task ProcessCompilationCompletedAsync(CompilationCompletedEvent endEvent, CancellationToken cancellationToken)
{
try
{
await ExecuteCompilationActionsAsync(_compilationActionsMap, cancellationToken).ConfigureAwait(false);
await ExecuteCompilationActionsAsync(_compilationEndActionsMap, cancellationToken).ConfigureAwait(false);
}
finally
{
endEvent.FlushCache();
}
}
private async Task ProcessCompilationCompleted(CompilationCompletedEvent endEvent, CancellationToken cancellationToken)
{
var tasks = ArrayBuilder <Task> .GetInstance();
foreach (var da in analyzers.OfType <ICompilationEndedAnalyzer>())
{
// TODO: is the overhead of creating tasks here too high compared to the cost of running them sequentially?
tasks.Add(Task.Run(() =>
{
// Catch Exception from da.OnCompilationEnded
ExecuteAndCatchIfThrows(da, addDiagnostic, continueOnError, cancellationToken, () =>
{
cancellationToken.ThrowIfCancellationRequested();
da.OnCompilationEnded(compilation, addDiagnostic, this.analyzerOptions, cancellationToken);
});
}));
}
await Task.WhenAll(tasks.Concat(this.syntaxAnalyzers)).ConfigureAwait(false);
DiagnosticQueue.Complete();
}
private void ProcessCompilationCompleted(CompilationCompletedEvent endEvent, AnalysisScope analysisScope, AnalysisState analysisStateOpt, CancellationToken cancellationToken)
{
ExecuteCompilationActions(_compilationEndActionsMap, endEvent, analysisScope, analysisStateOpt, cancellationToken);
}
private Task ProcessCompilationCompletedAsync(CompilationCompletedEvent endEvent, AnalysisScope analysisScope, AnalysisState analysisStateOpt, CancellationToken cancellationToken)
{
return ExecuteCompilationActionsAsync(_compilationEndActionsMap, endEvent, analysisScope, analysisStateOpt, cancellationToken);
}
private async Task ProcessCompilationCompletedAsync(CompilationCompletedEvent endEvent, CancellationToken cancellationToken)
{
var tasks = ArrayBuilder<Task>.GetInstance();
foreach (var da in analyzers.OfType<ICompilationAnalyzer>())
{
// TODO: is the overhead of creating tasks here too high compared to the cost of running them sequentially?
tasks.Add(Task.Run(() =>
{
// Catch Exception from da.OnCompilationEnded
ExecuteAndCatchIfThrows(da, addDiagnostic, continueOnAnalyzerException, cancellationToken, () =>
{
cancellationToken.ThrowIfCancellationRequested();
da.AnalyzeCompilation(compilation, addDiagnostic, this.analyzerOptions, cancellationToken);
});
}));
}
await Task.WhenAll(tasks.Concat(this.syntaxAnalyzers)).ConfigureAwait(false);
DiagnosticQueue.Complete();
}
private async Task ProcessCompilationCompletedAsync(CompilationCompletedEvent endEvent, CancellationToken cancellationToken)
{
try
{
await ExecuteCompilationActionsAsync(_compilationActionsMap, cancellationToken).ConfigureAwait(false);
await ExecuteCompilationActionsAsync(_compilationEndActionsMap, cancellationToken).ConfigureAwait(false);
}
finally
{
endEvent.FlushCache();
}
}
private async Task ProcessCompilationCompletedAsync(CompilationCompletedEvent endEvent, CancellationToken cancellationToken)
{
try
{
// Execute analyzers in parallel.
var tasks = ArrayBuilder<Task>.GetInstance();
foreach (var analyzerAndActions in _compilationEndActionsMap)
{
var task = Task.Run(() =>
{
// Execute actions for a given analyzer sequentially.
foreach (var endAction in analyzerAndActions.Value)
{
Debug.Assert(endAction.Analyzer == analyzerAndActions.Key);
// Catch Exception from endAction
AnalyzerDriverHelper.ExecuteAndCatchIfThrows(endAction.Analyzer, _addDiagnostic, continueOnAnalyzerException, () =>
{
cancellationToken.ThrowIfCancellationRequested();
var compilationContext = new CompilationEndAnalysisContext(_compilation, this.analyzerOptions, _addDiagnostic, cancellationToken);
endAction.Action(compilationContext);
}, cancellationToken);
}
}, cancellationToken);
tasks.Add(task);
}
await Task.WhenAll(tasks.ToArrayAndFree()).ConfigureAwait(false);
}
finally
{
endEvent.FlushCache();
}
}
