private CompilationWithAnalyzers(Compilation compilation, ImmutableArray <DiagnosticAnalyzer> analyzers, CompilationWithAnalyzersOptions analysisOptions, CancellationToken cancellationToken)
{
VerifyArguments(compilation, analyzers, analysisOptions);
_compilation = compilation.WithEventQueue(new AsyncQueue <CompilationEvent>());
_analyzers = analyzers;
_analysisOptions = analysisOptions;
_cancellationToken = cancellationToken;
_analysisState = new AnalysisState(analyzers);
_analysisResult = new AnalysisResult(analysisOptions.LogAnalyzerExecutionTime, analyzers);
_driverPool = new ObjectPool <AnalyzerDriver>(() => compilation.AnalyzerForLanguage(analyzers, AnalyzerManager.Instance));
_executingConcurrentTreeTasksOpt = analysisOptions.ConcurrentAnalysis ? new Dictionary <SyntaxTree, Tuple <Task, CancellationTokenSource> >() : null;
_concurrentTreeTaskTokensOpt = analysisOptions.ConcurrentAnalysis ? new Dictionary <Task, int>() : null;
_executingCompilationOrNonConcurrentTreeTask = null;
}
public static ImmutableDictionary <DiagnosticAnalyzer, DiagnosticAnalysisResultBuilder> ToResultBuilderMap(
this AnalysisResult analysisResult,
Project project, VersionStamp version, Compilation compilation, IEnumerable <DiagnosticAnalyzer> analyzers,
CancellationToken cancellationToken)
{
var builder = ImmutableDictionary.CreateBuilder <DiagnosticAnalyzer, DiagnosticAnalysisResultBuilder>();
ImmutableArray <Diagnostic> diagnostics;
ImmutableDictionary <DiagnosticAnalyzer, ImmutableArray <Diagnostic> > diagnosticsByAnalyzerMap;
foreach (var analyzer in analyzers)
{
cancellationToken.ThrowIfCancellationRequested();
var result = new DiagnosticAnalysisResultBuilder(project, version);
foreach (var tree in analysisResult.SyntaxDiagnostics.Keys)
{
if (analysisResult.SyntaxDiagnostics.TryGetValue(tree, out diagnosticsByAnalyzerMap) &&
diagnosticsByAnalyzerMap.TryGetValue(analyzer, out diagnostics))
{
Contract.Requires(diagnostics.Length == CompilationWithAnalyzers.GetEffectiveDiagnostics(diagnostics, compilation).Count());
result.AddSyntaxDiagnostics(tree, diagnostics);
}
}
foreach (var tree in analysisResult.SemanticDiagnostics.Keys)
{
if (analysisResult.SemanticDiagnostics.TryGetValue(tree, out diagnosticsByAnalyzerMap) &&
diagnosticsByAnalyzerMap.TryGetValue(analyzer, out diagnostics))
{
Contract.Requires(diagnostics.Length == CompilationWithAnalyzers.GetEffectiveDiagnostics(diagnostics, compilation).Count());
result.AddSemanticDiagnostics(tree, diagnostics);
}
}
if (analysisResult.CompilationDiagnostics.TryGetValue(analyzer, out diagnostics))
{
Contract.Requires(diagnostics.Length == CompilationWithAnalyzers.GetEffectiveDiagnostics(diagnostics, compilation).Count());
result.AddCompilationDiagnostics(diagnostics);
}
builder.Add(analyzer, result);
}
return(builder.ToImmutable());
}
private async Task FireAndForgetReportAnalyzerPerformanceAsync(
DocumentAnalysisScope?documentAnalysisScope,
Project project,
RemoteHostClient?client,
AnalysisResult analysisResult,
CancellationToken cancellationToken
)
{
if (client == null)
{
return;
}
try
{
// +1 for project itself
var count = documentAnalysisScope != null ? 1 : project.DocumentIds.Count + 1;
var performanceInfo = analysisResult.AnalyzerTelemetryInfo
.ToAnalyzerPerformanceInfo(AnalyzerInfoCache)
.ToImmutableArray();
_ = await client
.TryInvokeAsync <IRemoteDiagnosticAnalyzerService>(
(service, cancellationToken) =>
service.ReportAnalyzerPerformanceAsync(
performanceInfo,
count,
cancellationToken
),
cancellationToken
)
.ConfigureAwait(false);
}
catch (Exception ex)
when(FatalError.ReportAndCatchUnlessCanceled(ex, cancellationToken))
{
// ignore all, this is fire and forget method
}
}
public static ImmutableDictionary <DiagnosticAnalyzer, DiagnosticAnalysisResultBuilder> ToResultBuilderMap(
this AnalysisResult analysisResult,
ImmutableArray <Diagnostic> additionalPragmaSuppressionDiagnostics,
Project project, VersionStamp version, Compilation compilation, IEnumerable <DiagnosticAnalyzer> analyzers,
SkippedHostAnalyzersInfo skippedAnalyzersInfo,
CancellationToken cancellationToken)
{
var builder = ImmutableDictionary.CreateBuilder <DiagnosticAnalyzer, DiagnosticAnalysisResultBuilder>();
ImmutableArray <Diagnostic> diagnostics;
foreach (var analyzer in analyzers)
{
cancellationToken.ThrowIfCancellationRequested();
if (skippedAnalyzersInfo.SkippedAnalyzers.Contains(analyzer))
{
continue;
}
var result = new DiagnosticAnalysisResultBuilder(project, version);
var diagnosticIdsToFilter = skippedAnalyzersInfo.FilteredDiagnosticIdsForAnalyzers.GetValueOrDefault(
analyzer,
ImmutableArray <string> .Empty);
foreach (var(tree, diagnosticsByAnalyzerMap) in analysisResult.SyntaxDiagnostics)
{
if (diagnosticsByAnalyzerMap.TryGetValue(analyzer, out diagnostics))
{
diagnostics = diagnostics.Filter(diagnosticIdsToFilter);
Debug.Assert(diagnostics.Length == CompilationWithAnalyzers.GetEffectiveDiagnostics(diagnostics, compilation).Count());
result.AddSyntaxDiagnostics(tree, diagnostics);
}
}
foreach (var(tree, diagnosticsByAnalyzerMap) in analysisResult.SemanticDiagnostics)
{
if (diagnosticsByAnalyzerMap.TryGetValue(analyzer, out diagnostics))
{
diagnostics = diagnostics.Filter(diagnosticIdsToFilter);
Debug.Assert(diagnostics.Length == CompilationWithAnalyzers.GetEffectiveDiagnostics(diagnostics, compilation).Count());
result.AddSemanticDiagnostics(tree, diagnostics);
}
}
if (analysisResult.CompilationDiagnostics.TryGetValue(analyzer, out diagnostics))
{
diagnostics = diagnostics.Filter(diagnosticIdsToFilter);
Debug.Assert(diagnostics.Length == CompilationWithAnalyzers.GetEffectiveDiagnostics(diagnostics, compilation).Count());
result.AddCompilationDiagnostics(diagnostics);
}
// Special handling for pragma suppression diagnostics.
if (analyzer is IPragmaSuppressionsAnalyzer)
{
foreach (var group in additionalPragmaSuppressionDiagnostics.GroupBy(d => d.Location.SourceTree !))
{
diagnostics = group.AsImmutable().Filter(diagnosticIdsToFilter);
Debug.Assert(diagnostics.Length == CompilationWithAnalyzers.GetEffectiveDiagnostics(diagnostics, compilation).Count());
result.AddSemanticDiagnostics(group.Key, diagnostics);
}
additionalPragmaSuppressionDiagnostics = ImmutableArray <Diagnostic> .Empty;
}
builder.Add(analyzer, result);
}
return(builder.ToImmutable());
}
private CompilationWithAnalyzers(Compilation compilation, ImmutableArray<DiagnosticAnalyzer> analyzers, CompilationWithAnalyzersOptions analysisOptions, CancellationToken cancellationToken)
{
VerifyArguments(compilation, analyzers, analysisOptions);
_compilation = compilation.WithEventQueue(new AsyncQueue<CompilationEvent>());
_analyzers = analyzers;
_analysisOptions = analysisOptions;
_cancellationToken = cancellationToken;
_analysisState = new AnalysisState(analyzers);
_analysisResult = new AnalysisResult(analysisOptions.LogAnalyzerExecutionTime, analyzers);
_driverPool = new ObjectPool<AnalyzerDriver>(() => compilation.AnalyzerForLanguage(analyzers, AnalyzerManager.Instance));
_executingConcurrentTreeTasksOpt = analysisOptions.ConcurrentAnalysis ? new Dictionary<SyntaxTree, Tuple<Task, CancellationTokenSource>>() : null;
_concurrentTreeTaskTokensOpt = analysisOptions.ConcurrentAnalysis ? new Dictionary<Task, int>() : null;
_executingCompilationOrNonConcurrentTreeTask = null;
}
public static async Task <ImmutableDictionary <DiagnosticAnalyzer, DiagnosticAnalysisResultBuilder> > ToResultBuilderMapAsync(
this AnalysisResult analysisResult,
ImmutableArray <Diagnostic> additionalPragmaSuppressionDiagnostics,
DocumentAnalysisScope?documentAnalysisScope,
Project project,
VersionStamp version,
Compilation compilation,
IEnumerable <DiagnosticAnalyzer> analyzers,
SkippedHostAnalyzersInfo skippedAnalyzersInfo,
bool includeSuppressedDiagnostics,
CancellationToken cancellationToken)
{
SyntaxTree? treeToAnalyze = null;
AdditionalText?additionalFileToAnalyze = null;
if (documentAnalysisScope != null)
{
if (documentAnalysisScope.TextDocument is Document document)
{
treeToAnalyze = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
}
else
{
additionalFileToAnalyze = documentAnalysisScope.AdditionalFile;
}
}
var builder = ImmutableDictionary.CreateBuilder <DiagnosticAnalyzer, DiagnosticAnalysisResultBuilder>();
foreach (var analyzer in analyzers)
{
cancellationToken.ThrowIfCancellationRequested();
if (skippedAnalyzersInfo.SkippedAnalyzers.Contains(analyzer))
{
continue;
}
var result = new DiagnosticAnalysisResultBuilder(project, version);
var diagnosticIdsToFilter = skippedAnalyzersInfo.FilteredDiagnosticIdsForAnalyzers.GetValueOrDefault(
analyzer,
ImmutableArray <string> .Empty);
if (documentAnalysisScope != null)
{
RoslynDebug.Assert(treeToAnalyze != null || additionalFileToAnalyze != null);
var spanToAnalyze = documentAnalysisScope.Span;
var kind = documentAnalysisScope.Kind;
ImmutableDictionary <DiagnosticAnalyzer, ImmutableArray <Diagnostic> >?diagnosticsByAnalyzerMap;
switch (kind)
{
case AnalysisKind.Syntax:
if (treeToAnalyze != null)
{
if (analysisResult.SyntaxDiagnostics.TryGetValue(treeToAnalyze, out diagnosticsByAnalyzerMap))
{
AddAnalyzerDiagnosticsToResult(analyzer, diagnosticsByAnalyzerMap, ref result, compilation,
treeToAnalyze, additionalDocumentId: null, spanToAnalyze, AnalysisKind.Syntax, diagnosticIdsToFilter, includeSuppressedDiagnostics);
}
}
else if (analysisResult.AdditionalFileDiagnostics.TryGetValue(additionalFileToAnalyze !, out diagnosticsByAnalyzerMap))
{
AddAnalyzerDiagnosticsToResult(analyzer, diagnosticsByAnalyzerMap, ref result, compilation,
tree: null, documentAnalysisScope.TextDocument.Id, spanToAnalyze, AnalysisKind.Syntax, diagnosticIdsToFilter, includeSuppressedDiagnostics);
}
break;
case AnalysisKind.Semantic:
if (analysisResult.SemanticDiagnostics.TryGetValue(treeToAnalyze !, out diagnosticsByAnalyzerMap))
{
AddAnalyzerDiagnosticsToResult(analyzer, diagnosticsByAnalyzerMap, ref result, compilation,
treeToAnalyze, additionalDocumentId: null, spanToAnalyze, AnalysisKind.Semantic, diagnosticIdsToFilter, includeSuppressedDiagnostics);
}
break;
default:
throw ExceptionUtilities.UnexpectedValue(kind);
}
}
else
{
foreach (var(tree, diagnosticsByAnalyzerMap) in analysisResult.SyntaxDiagnostics)
{
AddAnalyzerDiagnosticsToResult(analyzer, diagnosticsByAnalyzerMap, ref result, compilation,
tree, additionalDocumentId: null, span: null, AnalysisKind.Syntax, diagnosticIdsToFilter, includeSuppressedDiagnostics);
}
foreach (var(tree, diagnosticsByAnalyzerMap) in analysisResult.SemanticDiagnostics)
{
AddAnalyzerDiagnosticsToResult(analyzer, diagnosticsByAnalyzerMap, ref result, compilation,
tree, additionalDocumentId: null, span: null, AnalysisKind.Semantic, diagnosticIdsToFilter, includeSuppressedDiagnostics);
}
foreach (var(file, diagnosticsByAnalyzerMap) in analysisResult.AdditionalFileDiagnostics)
{
var additionalDocumentId = project.GetDocumentForFile(file);
var kind = additionalDocumentId != null ? AnalysisKind.Syntax : AnalysisKind.NonLocal;
AddAnalyzerDiagnosticsToResult(analyzer, diagnosticsByAnalyzerMap, ref result, compilation,
tree: null, additionalDocumentId, span: null, kind, diagnosticIdsToFilter, includeSuppressedDiagnostics);
}
AddAnalyzerDiagnosticsToResult(analyzer, analysisResult.CompilationDiagnostics, ref result, compilation,
tree: null, additionalDocumentId: null, span: null, AnalysisKind.NonLocal, diagnosticIdsToFilter, includeSuppressedDiagnostics);
}
// Special handling for pragma suppression diagnostics.
if (!additionalPragmaSuppressionDiagnostics.IsEmpty &&
analyzer is IPragmaSuppressionsAnalyzer)
{
if (documentAnalysisScope != null)
{
if (treeToAnalyze != null)
{
var diagnostics = additionalPragmaSuppressionDiagnostics.WhereAsArray(d => d.Location.SourceTree == treeToAnalyze);
AddDiagnosticsToResult(diagnostics, ref result, compilation, treeToAnalyze, additionalDocumentId: null,
documentAnalysisScope !.Span, AnalysisKind.Semantic, diagnosticIdsToFilter, includeSuppressedDiagnostics);
}
}
else
{
foreach (var group in additionalPragmaSuppressionDiagnostics.GroupBy(d => d.Location.SourceTree !))
{
AddDiagnosticsToResult(group.AsImmutable(), ref result, compilation, group.Key, additionalDocumentId: null,
span: null, AnalysisKind.Semantic, diagnosticIdsToFilter, includeSuppressedDiagnostics);
}
}
additionalPragmaSuppressionDiagnostics = ImmutableArray <Diagnostic> .Empty;
}
builder.Add(analyzer, result);
}
return(builder.ToImmutable());