internal ProjectAnalyzerStateSets(
IReadOnlyList <AnalyzerReference> analyzerReferences,
ImmutableDictionary <object, ImmutableArray <DiagnosticAnalyzer> > mapPerReferences,
ImmutableDictionary <DiagnosticAnalyzer, StateSet> stateSetMap,
SkippedHostAnalyzersInfo skippedAnalyzersInfo)
{
AnalyzerReferences = analyzerReferences;
MapPerReferences = mapPerReferences;
StateSetMap = stateSetMap;
SkippedAnalyzersInfo = skippedAnalyzersInfo;
}
private async Task <DiagnosticAnalysisResultMap <string, DiagnosticAnalysisResultBuilder> > AnalyzeAsync(
BidirectionalMap <string, DiagnosticAnalyzer> analyzerMap,
ImmutableArray <DiagnosticAnalyzer> analyzers,
SkippedHostAnalyzersInfo skippedAnalyzersInfo,
bool reportSuppressedDiagnostics,
bool logAnalyzerExecutionTime,
CancellationToken cancellationToken)
{
// flag that controls concurrency
var useConcurrent = true;
// get original compilation
var compilation = await _project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);
// fork compilation with concurrent build. this is okay since WithAnalyzers will fork compilation
// anyway to attach event queue. this should make compiling compilation concurrent and make things
// faster
compilation = compilation.WithOptions(compilation.Options.WithConcurrentBuild(useConcurrent));
// TODO: can we support analyzerExceptionFilter in remote host?
// right now, host doesn't support watson, we might try to use new NonFatal watson API?
var analyzerOptions = new CompilationWithAnalyzersOptions(
options: new WorkspaceAnalyzerOptions(_project.AnalyzerOptions, _project.Solution),
onAnalyzerException: null,
analyzerExceptionFilter: null,
concurrentAnalysis: useConcurrent,
logAnalyzerExecutionTime: logAnalyzerExecutionTime,
reportSuppressedDiagnostics: reportSuppressedDiagnostics);
var analyzerDriver = compilation.WithAnalyzers(analyzers, analyzerOptions);
// PERF: Run all analyzers at once using the new GetAnalysisResultAsync API.
var analysisResult = await analyzerDriver.GetAnalysisResultAsync(cancellationToken).ConfigureAwait(false);
// record performance if tracker is available
if (_performanceTracker != null)
{
// +1 to include project itself
_performanceTracker.AddSnapshot(analysisResult.AnalyzerTelemetryInfo.ToAnalyzerPerformanceInfo(_analyzerInfoCache), _project.DocumentIds.Count + 1);
}
var builderMap = analysisResult.ToResultBuilderMap(_project, VersionStamp.Default, compilation, analysisResult.Analyzers, skippedAnalyzersInfo, cancellationToken);
return(DiagnosticAnalysisResultMap.Create(
builderMap.ToImmutableDictionary(kv => GetAnalyzerId(analyzerMap, kv.Key), kv => kv.Value),
analysisResult.AnalyzerTelemetryInfo.ToImmutableDictionary(kv => GetAnalyzerId(analyzerMap, kv.Key), kv => kv.Value)));
}
private async Task <DiagnosticAnalysisResultMap <string, DiagnosticAnalysisResultBuilder> > AnalyzeAsync(
CompilationWithAnalyzers compilationWithAnalyzers,
BidirectionalMap <string, DiagnosticAnalyzer> analyzerToIdMap,
ImmutableArray <DiagnosticAnalyzer> analyzers,
SkippedHostAnalyzersInfo skippedAnalyzersInfo,
bool reportSuppressedDiagnostics,
bool logPerformanceInfo,
bool getTelemetryInfo,
CancellationToken cancellationToken)
{
var documentAnalysisScope = _document != null
? new DocumentAnalysisScope(_document, _span, analyzers, _analysisKind !.Value)
: null;
var(analysisResult, additionalPragmaSuppressionDiagnostics) = await compilationWithAnalyzers.GetAnalysisResultAsync(
documentAnalysisScope, _project, _analyzerInfoCache, cancellationToken).ConfigureAwait(false);
// Record performance if tracker is available
if (logPerformanceInfo && _performanceTracker != null)
{
// +1 to include project itself
var unitCount = documentAnalysisScope != null ? 1 : _project.DocumentIds.Count + 1;
_performanceTracker.AddSnapshot(analysisResult.AnalyzerTelemetryInfo.ToAnalyzerPerformanceInfo(_analyzerInfoCache), unitCount);
}
var builderMap = await analysisResult.ToResultBuilderMapAsync(
additionalPragmaSuppressionDiagnostics, documentAnalysisScope,
_project, VersionStamp.Default, compilationWithAnalyzers.Compilation,
analyzers, skippedAnalyzersInfo, reportSuppressedDiagnostics, cancellationToken).ConfigureAwait(false);
var result = builderMap.ToImmutableDictionary(kv => GetAnalyzerId(analyzerToIdMap, kv.Key), kv => kv.Value);
var telemetry = getTelemetryInfo
? GetTelemetryInfo(analysisResult, analyzers, analyzerToIdMap)
: ImmutableDictionary <string, AnalyzerTelemetryInfo> .Empty;
return(DiagnosticAnalysisResultMap.Create(result, telemetry));