private async Task <IEnumerable <Diagnostic> > ComputeDocumentDiagnosticAnalyzerDiagnosticsAsync(
Document document, DocumentDiagnosticAnalyzer analyzer, AnalysisKind kind, Compilation compilationOpt, CancellationToken cancellationToken)
{
using (var pooledObject = SharedPools.Default <List <Diagnostic> >().GetPooledObject())
{
var diagnostics = pooledObject.Object;
cancellationToken.ThrowIfCancellationRequested();
try
{
switch (kind)
{
case AnalysisKind.Syntax:
await analyzer.AnalyzeSyntaxAsync(document, diagnostics.Add, cancellationToken).ConfigureAwait(false);
return(compilationOpt == null?diagnostics.ToImmutableArrayOrEmpty() : CompilationWithAnalyzers.GetEffectiveDiagnostics(diagnostics, compilationOpt));
case AnalysisKind.Semantic:
await analyzer.AnalyzeSemanticsAsync(document, diagnostics.Add, cancellationToken).ConfigureAwait(false);
return(compilationOpt == null?diagnostics.ToImmutableArrayOrEmpty() : CompilationWithAnalyzers.GetEffectiveDiagnostics(diagnostics, compilationOpt));
default:
return(Contract.FailWithReturn <ImmutableArray <Diagnostic> >("shouldn't reach here"));
}
}
catch (Exception e) when(!IsCanceled(e, cancellationToken))
{
OnAnalyzerException(analyzer, document.Project.Id, compilationOpt, e);
return(ImmutableArray <Diagnostic> .Empty);
}
}
}
private Task <IEnumerable <Diagnostic> > ComputeDocumentDiagnosticAnalyzerDiagnosticsAsync(
Document document,
DocumentDiagnosticAnalyzer analyzer,
AnalysisKind kind,
Compilation compilationOpt,
CancellationToken cancellationToken)
{
return(_owner.Owner.ComputeDocumentDiagnosticAnalyzerDiagnosticsAsync(document, analyzer, kind, compilationOpt, _owner.DiagnosticLogAggregator, cancellationToken));
}
private Task <IEnumerable <Diagnostic> > ComputeDocumentDiagnosticAnalyzerDiagnosticsAsync(
Document document,
DocumentDiagnosticAnalyzer analyzer,
AnalysisKind kind,
Compilation?compilation,
CancellationToken cancellationToken)
{
return(AnalyzerService.ComputeDocumentDiagnosticAnalyzerDiagnosticsAsync(document, analyzer, kind, compilation, DiagnosticLogAggregator, cancellationToken));
}
private static int GetPriority(StateSet state)
{
// compiler gets highest priority
if (state.Analyzer.IsCompilerAnalyzer())
{
return(BuiltInCompilerPriority);
}
return(state.Analyzer switch
{
FileContentLoadAnalyzer _ => FileContentLoadAnalyzerPriority,
DocumentDiagnosticAnalyzer analyzer => Math.Max(0, analyzer.Priority),
ProjectDiagnosticAnalyzer analyzer => Math.Max(0, analyzer.Priority),
_ => RegularDiagnosticAnalyzerPriority,
});
private async Task <IEnumerable <Diagnostic> > ComputeDocumentDiagnosticAnalyzerDiagnosticsAsync(
Document document, DocumentDiagnosticAnalyzer analyzer, AnalysisKind kind, Compilation compilationOpt, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
try
{
Task <ImmutableArray <Diagnostic> > analyzeAsync;
switch (kind)
{
case AnalysisKind.Syntax:
analyzeAsync = analyzer.AnalyzeSyntaxAsync(document, cancellationToken);
break;
case AnalysisKind.Semantic:
analyzeAsync = analyzer.AnalyzeSemanticsAsync(document, cancellationToken);
break;
default:
throw ExceptionUtilities.UnexpectedValue(kind);
}
var diagnostics = (await analyzeAsync.ConfigureAwait(false)).NullToEmpty();
if (compilationOpt != null)
{
return(CompilationWithAnalyzers.GetEffectiveDiagnostics(diagnostics, compilationOpt));
}
#if DEBUG
// since all DocumentDiagnosticAnalyzers are from internal users, we only do debug check. also this can be expensive at runtime
// since it requires await. if we find any offender through NFW, we should be able to fix those since all those should
// from intern teams.
await VerifyDiagnosticLocationsAsync(diagnostics, document.Project, cancellationToken).ConfigureAwait(false);
#endif
return(diagnostics);
}
catch (Exception e) when(!IsCanceled(e, cancellationToken))
{
OnAnalyzerException(analyzer, document.Project.Id, compilationOpt, e);
return(ImmutableArray <Diagnostic> .Empty);
}
}
private async Task <IEnumerable <Diagnostic> > ComputeDocumentDiagnosticAnalyzerDiagnosticsAsync(
Document document, DocumentDiagnosticAnalyzer analyzer, AnalysisKind kind, Compilation compilationOpt, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
try
{
Task <ImmutableArray <Diagnostic> > analyzeAsync;
switch (kind)
{
case AnalysisKind.Syntax:
analyzeAsync = analyzer.AnalyzeSyntaxAsync(document, cancellationToken);
break;
case AnalysisKind.Semantic:
analyzeAsync = analyzer.AnalyzeSemanticsAsync(document, cancellationToken);
break;
default:
throw ExceptionUtilities.UnexpectedValue(kind);
}
var diagnostics = (await analyzeAsync.ConfigureAwait(false)).NullToEmpty();
if (compilationOpt != null)
{
return(CompilationWithAnalyzers.GetEffectiveDiagnostics(diagnostics, compilationOpt));
}
return(diagnostics);
}
catch (Exception e) when(!IsCanceled(e, cancellationToken))
{
OnAnalyzerException(analyzer, document.Project.Id, compilationOpt, e);
return(ImmutableArray <Diagnostic> .Empty);
}
}
private async Task<IEnumerable<Diagnostic>> ComputeDocumentDiagnosticAnalyzerDiagnosticsAsync(
Document document, DocumentDiagnosticAnalyzer analyzer, AnalysisKind kind, Compilation compilationOpt, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
try
{
Task<ImmutableArray<Diagnostic>> analyzeAsync;
switch (kind)
{
case AnalysisKind.Syntax:
analyzeAsync = analyzer.AnalyzeSyntaxAsync(document, cancellationToken);
break;
case AnalysisKind.Semantic:
analyzeAsync = analyzer.AnalyzeSemanticsAsync(document, cancellationToken);
break;
default:
throw ExceptionUtilities.UnexpectedValue(kind);
}
var diagnostics = (await analyzeAsync.ConfigureAwait(false)).NullToEmpty();
if (compilationOpt != null)
{
return CompilationWithAnalyzers.GetEffectiveDiagnostics(diagnostics, compilationOpt);
}
return diagnostics;
}
catch (Exception e) when (!IsCanceled(e, cancellationToken))
{
OnAnalyzerException(analyzer, document.Project.Id, compilationOpt, e);
return ImmutableArray<Diagnostic>.Empty;
}
}
private async Task<IEnumerable<Diagnostic>> ComputeDocumentDiagnosticAnalyzerDiagnosticsAsync(
Document document, DocumentDiagnosticAnalyzer analyzer, AnalysisKind kind, Compilation compilationOpt, CancellationToken cancellationToken)
{
using (var pooledObject = SharedPools.Default<List<Diagnostic>>().GetPooledObject())
{
var diagnostics = pooledObject.Object;
cancellationToken.ThrowIfCancellationRequested();
try
{
switch (kind)
{
case AnalysisKind.Syntax:
await analyzer.AnalyzeSyntaxAsync(document, diagnostics.Add, cancellationToken).ConfigureAwait(false);
return compilationOpt == null ? diagnostics.ToImmutableArrayOrEmpty() : CompilationWithAnalyzers.GetEffectiveDiagnostics(diagnostics, compilationOpt);
case AnalysisKind.Semantic:
await analyzer.AnalyzeSemanticsAsync(document, diagnostics.Add, cancellationToken).ConfigureAwait(false);
return compilationOpt == null ? diagnostics.ToImmutableArrayOrEmpty() : CompilationWithAnalyzers.GetEffectiveDiagnostics(diagnostics, compilationOpt);
default:
return Contract.FailWithReturn<ImmutableArray<Diagnostic>>("shouldn't reach here");
}
}
catch (Exception e) when (!IsCanceled(e, cancellationToken))
{
OnAnalyzerException(analyzer, document.Project.Id, compilationOpt, e);
return ImmutableArray<Diagnostic>.Empty;
}
}
}
