private static async Task <DocumentAnalysisData> ComputeDocumentAnalysisDataAsync(
DocumentAnalysisExecutor executor, StateSet stateSet, CancellationToken cancellationToken)
{
var kind = executor.AnalysisScope.Kind;
var document = executor.AnalysisScope.TextDocument;
// get log title and functionId
GetLogFunctionIdAndTitle(kind, out var functionId, out var title);
using (Logger.LogBlock(functionId, GetDocumentLogMessage, title, document, stateSet.Analyzer, cancellationToken))
{
try
{
var diagnostics = await executor.ComputeDiagnosticsAsync(stateSet.Analyzer, cancellationToken).ConfigureAwait(false);
// this is no-op in product. only run in test environment
Logger.Log(functionId, (t, d, a, ds) => $"{GetDocumentLogMessage(t, d, a)}, {string.Join(Environment.NewLine, ds)}",
title, document, stateSet.Analyzer, diagnostics);
var version = await GetDiagnosticVersionAsync(document.Project, cancellationToken).ConfigureAwait(false);
var state = stateSet.GetOrCreateActiveFileState(document.Id);
var existingData = state.GetAnalysisData(kind);
// we only care about local diagnostics
return(new DocumentAnalysisData(version, existingData.Items, diagnostics.ToImmutableArrayOrEmpty()));
}
catch (Exception e) when(FatalError.ReportUnlessCanceled(e))
{
throw ExceptionUtilities.Unreachable;
}
}
}
private async Task ComputeDocumentDiagnosticsAsync(
ImmutableArray <DiagnosticAnalyzer> analyzers,
AnalysisKind kind,
TextSpan?span,
ArrayBuilder <DiagnosticData> list,
CancellationToken cancellationToken)
{
if (analyzers.IsEmpty)
{
return;
}
var analysisScope = new DocumentAnalysisScope(_document, span, analyzers, kind);
var executor = new DocumentAnalysisExecutor(analysisScope, _compilationWithAnalyzers, _owner._diagnosticAnalyzerRunner, logPerformanceInfo: false);
foreach (var analyzer in analyzers)
{
cancellationToken.ThrowIfCancellationRequested();
var analyzerTypeName = analyzer.GetType().Name;
using (_addOperationScope?.Invoke(analyzerTypeName))
using (_addOperationScope is object?RoslynEventSource.LogInformationalBlock(FunctionId.DiagnosticAnalyzerService_GetDiagnosticsForSpanAsync, analyzerTypeName, cancellationToken) : default)
{
var dx = await executor.ComputeDiagnosticsAsync(analyzer, cancellationToken).ConfigureAwait(false);
if (dx != null)
{
// no state yet
list.AddRange(dx.Where(ShouldInclude));
}
}
}
}
private async Task <ImmutableArray <DiagnosticData> > GetDiagnosticsAsync(
TextDocument document, AnalysisKind kind, CancellationToken cancellationToken)
{
var loadDiagnostic = await document.State.GetLoadDiagnosticAsync(cancellationToken).ConfigureAwait(false);
if (loadDiagnostic != null)
{
return(ImmutableArray.Create(DiagnosticData.Create(loadDiagnostic, document)));
}
var project = document.Project;
var analyzers = GetAnalyzers(project.Solution.State.Analyzers, project);
if (analyzers.IsEmpty)
{
return(ImmutableArray <DiagnosticData> .Empty);
}
var ideOptions = _service._globalOptions.GetIdeAnalyzerOptions(project);
var compilationWithAnalyzers = await DocumentAnalysisExecutor.CreateCompilationWithAnalyzersAsync(
project, ideOptions, analyzers, includeSuppressedDiagnostics : false, cancellationToken).ConfigureAwait(false);
var analysisScope = new DocumentAnalysisScope(document, span: null, analyzers, kind);
var executor = new DocumentAnalysisExecutor(analysisScope, compilationWithAnalyzers, _diagnosticAnalyzerRunner, logPerformanceInfo: true);
using var _ = ArrayBuilder <DiagnosticData> .GetInstance(out var builder);
foreach (var analyzer in analyzers)
{
builder.AddRange(await executor.ComputeDiagnosticsAsync(analyzer, cancellationToken).ConfigureAwait(false));
}
return(builder.ToImmutable());
}