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());
}
private async Task AnalyzeDocumentForKindAsync(TextDocument document, AnalysisKind kind, CancellationToken cancellationToken)
{
try
{
if (!document.SupportsDiagnostics())
{
return;
}
var isActiveDocument = _documentTrackingService.TryGetActiveDocument() == document.Id;
var isOpenDocument = document.IsOpen();
var isGeneratedRazorDocument = document.Services.GetService <DocumentPropertiesService>()?.DiagnosticsLspClientName != null;
// Only analyze open/active documents, unless it is a generated Razor document.
if (!isActiveDocument && !isOpenDocument && !isGeneratedRazorDocument)
{
return;
}
var stateSets = _stateManager.GetOrUpdateStateSets(document.Project);
var compilationWithAnalyzers = await GetOrCreateCompilationWithAnalyzersAsync(document.Project, stateSets, cancellationToken).ConfigureAwait(false);
var version = await GetDiagnosticVersionAsync(document.Project, cancellationToken).ConfigureAwait(false);
var backgroundAnalysisScope = GlobalOptions.GetBackgroundAnalysisScope(document.Project.Language);
// We split the diagnostic computation for document into following steps:
// 1. Try to get cached diagnostics for each analyzer, while computing the set of analyzers that do not have cached diagnostics.
// 2. Execute all the non-cached analyzers with a single invocation into CompilationWithAnalyzers.
// 3. Fetch computed diagnostics per-analyzer from the above invocation, and cache and raise diagnostic reported events.
// In near future, the diagnostic computation invocation into CompilationWithAnalyzers will be moved to OOP.
// This should help simplify and/or remove the IDE layer diagnostic caching in devenv process.
// First attempt to fetch diagnostics from the cache, while computing the state sets for analyzers that are not cached.
using var _ = ArrayBuilder <StateSet> .GetInstance(out var nonCachedStateSets);
foreach (var stateSet in stateSets)
{
var data = TryGetCachedDocumentAnalysisData(document, stateSet, kind, version,
backgroundAnalysisScope, isActiveDocument, isOpenDocument, isGeneratedRazorDocument, cancellationToken);
if (data.HasValue)
{
// We need to persist and raise diagnostics for suppressed analyzer.
PersistAndRaiseDiagnosticsIfNeeded(data.Value, stateSet);
}
else
{
nonCachedStateSets.Add(stateSet);
}
}
// Then, compute the diagnostics for non-cached state sets, and cache and raise diagnostic reported events for these diagnostics.
if (nonCachedStateSets.Count > 0)
{
var analysisScope = new DocumentAnalysisScope(document, span: null, nonCachedStateSets.SelectAsArray(s => s.Analyzer), kind);
var executor = new DocumentAnalysisExecutor(analysisScope, compilationWithAnalyzers, _diagnosticAnalyzerRunner, logPerformanceInfo: true, onAnalysisException: OnAnalysisException);
var logTelemetry = document.Project.Solution.Options.GetOption(DiagnosticOptions.LogTelemetryForBackgroundAnalyzerExecution);
foreach (var stateSet in nonCachedStateSets)
{
var computedData = await ComputeDocumentAnalysisDataAsync(executor, stateSet, logTelemetry, cancellationToken).ConfigureAwait(false);
PersistAndRaiseDiagnosticsIfNeeded(computedData, stateSet);
}
}
}
catch (Exception e) when(FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken))
{
throw ExceptionUtilities.Unreachable;
}
void PersistAndRaiseDiagnosticsIfNeeded(DocumentAnalysisData result, StateSet stateSet)
{
if (result.FromCache == true)
{
RaiseDocumentDiagnosticsIfNeeded(document, stateSet, kind, result.Items);
return;
}
// no cancellation after this point.
var state = stateSet.GetOrCreateActiveFileState(document.Id);
state.Save(kind, result.ToPersistData());
RaiseDocumentDiagnosticsIfNeeded(document, stateSet, kind, result.OldItems, result.Items);
}
void OnAnalysisException()
{
// Do not re-use cached CompilationWithAnalyzers instance in presence of an exception, as the underlying analysis state might be corrupt.
ClearCompilationsWithAnalyzersCache(document.Project);
}
}
private async Task AnalyzeDocumentForKindAsync(TextDocument document, AnalysisKind kind, CancellationToken cancellationToken)
{
try
{
if (!AnalysisEnabled(document))
{
// to reduce allocations, here, we don't clear existing diagnostics since it is dealt by other entry point such as
// DocumentReset or DocumentClosed.
return;
}
var stateSets = _stateManager.GetOrUpdateStateSets(document.Project);
var compilationWithAnalyzers = await GetOrCreateCompilationWithAnalyzersAsync(document.Project, stateSets, cancellationToken).ConfigureAwait(false);
// We split the diagnostic computation for document into following steps:
// 1. Try to get cached diagnostics for each analyzer, while computing the set of analyzers that do not have cached diagnostics.
// 2. Execute all the non-cached analyzers with a single invocation into CompilationWithAnalyzers.
// 3. Fetch computed diagnostics per-analyzer from the above invocation, and cache and raise diagnostic reported events.
// In near future, the diagnostic computation invocation into CompilationWithAnalyzers will be moved to OOP.
// This should help simplify and/or remove the IDE layer diagnostic caching in devenv process.
// First attempt to fetch diagnostics from the cache, while computing the state sets for analyzers that are not cached.
using var _ = ArrayBuilder <StateSet> .GetInstance(out var nonCachedStateSets);
foreach (var stateSet in stateSets)
{
var data = await TryGetCachedDocumentAnalysisDataAsync(document, stateSet, kind, cancellationToken).ConfigureAwait(false);
if (data.HasValue)
{
// We need to persist and raise diagnostics for suppressed analyzer.
PersistAndRaiseDiagnosticsIfNeeded(data.Value, stateSet);
}
else
{
nonCachedStateSets.Add(stateSet);
}
}
// Then, compute the diagnostics for non-cached state sets, and cache and raise diagnostic reported events for these diagnostics.
if (nonCachedStateSets.Count > 0)
{
var analysisScope = new DocumentAnalysisScope(document, span: null, nonCachedStateSets.SelectAsArray(s => s.Analyzer), kind);
var executor = new DocumentAnalysisExecutor(analysisScope, compilationWithAnalyzers, DiagnosticAnalyzerInfoCache);
foreach (var stateSet in nonCachedStateSets)
{
var computedData = await ComputeDocumentAnalysisDataAsync(executor, stateSet, cancellationToken).ConfigureAwait(false);
PersistAndRaiseDiagnosticsIfNeeded(computedData, stateSet);
}
var asyncToken = AnalyzerService.Listener.BeginAsyncOperation(nameof(AnalyzeDocumentForKindAsync));
var _2 = ReportAnalyzerPerformanceAsync(document, compilationWithAnalyzers, cancellationToken).CompletesAsyncOperation(asyncToken);
}
}
catch (Exception e) when(FatalError.ReportUnlessCanceled(e))
{
throw ExceptionUtilities.Unreachable;
}
void PersistAndRaiseDiagnosticsIfNeeded(DocumentAnalysisData result, StateSet stateSet)
{
if (result.FromCache == true)
{
RaiseDocumentDiagnosticsIfNeeded(document, stateSet, kind, result.Items);
return;
}
// no cancellation after this point.
var state = stateSet.GetOrCreateActiveFileState(document.Id);
state.Save(kind, result.ToPersistData());
RaiseDocumentDiagnosticsIfNeeded(document, stateSet, kind, result.OldItems, result.Items);
}
}
