private static bool ShouldRunAnalyzerForStateType(DiagnosticAnalyzer analyzer, StateType stateTypeId,
ImmutableHashSet <string> diagnosticIds = null, Func <DiagnosticAnalyzer, ImmutableArray <DiagnosticDescriptor> > getDescriptors = null)
{
// PERF: Don't query descriptors for compiler analyzer, always execute it for all state types.
if (analyzer.IsCompilerAnalyzer())
{
return(true);
}
if (diagnosticIds != null && getDescriptors(analyzer).All(d => !diagnosticIds.Contains(d.Id)))
{
return(false);
}
switch (stateTypeId)
{
case StateType.Syntax:
return(analyzer.SupportsSyntaxDiagnosticAnalysis());
case StateType.Document:
return(analyzer.SupportsSemanticDiagnosticAnalysis());
case StateType.Project:
return(analyzer.SupportsProjectDiagnosticAnalysis());
default:
throw ExceptionUtilities.Unreachable;
}
}
private static bool ShouldRunAnalyzerForStateType(DiagnosticAnalyzerDriver driver, DiagnosticAnalyzer analyzer, StateType stateTypeId,
out bool supportsSemanticInSpan, ImmutableHashSet <string> diagnosticIds = null, Func <DiagnosticAnalyzer, ImmutableArray <DiagnosticDescriptor> > getDescriptor = null)
{
Debug.Assert(!driver.IsAnalyzerSuppressed(analyzer));
supportsSemanticInSpan = false;
if (diagnosticIds != null && getDescriptor(analyzer).All(d => !diagnosticIds.Contains(d.Id)))
{
return(false);
}
switch (stateTypeId)
{
case StateType.Syntax:
return(analyzer.SupportsSyntaxDiagnosticAnalysis(driver));
case StateType.Document:
return(analyzer.SupportsSemanticDiagnosticAnalysis(driver, out supportsSemanticInSpan));
case StateType.Project:
return(analyzer.SupportsProjectDiagnosticAnalysis(driver));
default:
throw ExceptionUtilities.Unreachable;
}
}
public async Task <IEnumerable <Diagnostic> > GetSyntaxDiagnosticsAsync(DiagnosticAnalyzer analyzer)
{
var compilation = _document.Project.SupportsCompilation ? await _document.Project.GetCompilationAsync(_cancellationToken).ConfigureAwait(false) : null;
Contract.ThrowIfNull(_document);
Contract.ThrowIfFalse(analyzer.SupportsSyntaxDiagnosticAnalysis(this));
using (var pooledObject = SharedPools.Default <List <Diagnostic> >().GetPooledObject())
{
var diagnostics = pooledObject.Object;
_cancellationToken.ThrowIfCancellationRequested();
var documentAnalyzer = analyzer as DocumentDiagnosticAnalyzer;
if (documentAnalyzer != null)
{
try
{
await documentAnalyzer.AnalyzeSyntaxAsync(_document, diagnostics.Add, _cancellationToken).ConfigureAwait(false);
return(diagnostics.ToImmutableArrayOrEmpty());
}
catch (Exception e) when(CatchAnalyzerException(e, analyzer))
{
var exceptionDiagnostics = AnalyzerExceptionToDiagnostics(analyzer, e, _cancellationToken);
return(GetFilteredDocumentDiagnostics(exceptionDiagnostics, compilation).ToImmutableArray());
}
}
var analyzerActions = await this.GetAnalyzerActionsAsync(analyzer, diagnostics.Add).ConfigureAwait(false);
DiagnosticAnalyzerLogger.UpdateAnalyzerTypeCount(analyzer, analyzerActions, (DiagnosticLogAggregator)_logAggregator);
if (analyzerActions != null)
{
if (_document.SupportsSyntaxTree)
{
AnalyzerDriverHelper.ExecuteSyntaxTreeActions(analyzerActions, _root.SyntaxTree,
_analyzerOptions, diagnostics.Add, CatchAnalyzerException, _cancellationToken);
}
}
if (diagnostics.Count == 0)
{
return(SpecializedCollections.EmptyEnumerable <Diagnostic>());
}
return(GetFilteredDocumentDiagnostics(diagnostics, compilation).ToImmutableArray());
}
}
private bool SupportAnalysisKind(DiagnosticAnalyzer analyzer, string language, AnalysisKind kind)
{
// compiler diagnostic analyzer always support all kinds
if (HostAnalyzerManager.IsCompilerDiagnosticAnalyzer(language, analyzer))
{
return true;
}
switch (kind)
{
case AnalysisKind.Syntax:
return analyzer.SupportsSyntaxDiagnosticAnalysis();
case AnalysisKind.Semantic:
return analyzer.SupportsSemanticDiagnosticAnalysis();
default:
return Contract.FailWithReturn<bool>("shouldn't reach here");
}
}
private bool SupportAnalysisKind(DiagnosticAnalyzer analyzer, string language, AnalysisKind kind)
{
// compiler diagnostic analyzer always support all kinds
if (HostAnalyzerManager.IsCompilerDiagnosticAnalyzer(language, analyzer))
{
return(true);
}
switch (kind)
{
case AnalysisKind.Syntax:
return(analyzer.SupportsSyntaxDiagnosticAnalysis());
case AnalysisKind.Semantic:
return(analyzer.SupportsSemanticDiagnosticAnalysis());
default:
return(Contract.FailWithReturn <bool>("shouldn't reach here"));
}
}
private static bool ShouldRunAnalyzerForStateType(DiagnosticAnalyzer analyzer, StateType stateTypeId,
ImmutableHashSet<string> diagnosticIds = null, Func<DiagnosticAnalyzer, ImmutableArray<DiagnosticDescriptor>> getDescriptors = null)
{
if (diagnosticIds != null && getDescriptors(analyzer).All(d => !diagnosticIds.Contains(d.Id)))
{
return false;
}
switch (stateTypeId)
{
case StateType.Syntax:
return analyzer.SupportsSyntaxDiagnosticAnalysis();
case StateType.Document:
return analyzer.SupportsSemanticDiagnosticAnalysis();
case StateType.Project:
return analyzer.SupportsProjectDiagnosticAnalysis();
default:
throw ExceptionUtilities.Unreachable;
}
}
private static bool ShouldRunProviderForStateType(StateType stateTypeId, DiagnosticAnalyzer provider, DiagnosticAnalyzerDriver driver,
out bool supportsSemanticInSpan, ImmutableHashSet<string> diagnosticIds = null, Func<DiagnosticAnalyzer, ImmutableArray<DiagnosticDescriptor>> getDescriptor = null)
{
Debug.Assert(!IsAnalyzerSuppressed(provider, driver.Project.CompilationOptions, driver));
supportsSemanticInSpan = false;
if (diagnosticIds != null && getDescriptor(provider).All(d => !diagnosticIds.Contains(d.Id)))
{
return false;
}
switch (stateTypeId)
{
case StateType.Syntax:
return provider.SupportsSyntaxDiagnosticAnalysis(driver);
case StateType.Document:
return provider.SupportsSemanticDiagnosticAnalysis(driver, out supportsSemanticInSpan);
case StateType.Project:
return provider.SupportsProjectDiagnosticAnalysis(driver);
default:
throw ExceptionUtilities.Unreachable;
}
}
public async Task<IEnumerable<Diagnostic>> GetSyntaxDiagnosticsAsync(DiagnosticAnalyzer analyzer)
{
var compilation = _document.Project.SupportsCompilation ? await _document.Project.GetCompilationAsync(_cancellationToken).ConfigureAwait(false) : null;
Contract.ThrowIfNull(_document);
Contract.ThrowIfFalse(analyzer.SupportsSyntaxDiagnosticAnalysis(this));
using (var pooledObject = SharedPools.Default<List<Diagnostic>>().GetPooledObject())
{
var diagnostics = pooledObject.Object;
_cancellationToken.ThrowIfCancellationRequested();
var documentAnalyzer = analyzer as DocumentDiagnosticAnalyzer;
if (documentAnalyzer != null)
{
try
{
await documentAnalyzer.AnalyzeSyntaxAsync(_document, diagnostics.Add, _cancellationToken).ConfigureAwait(false);
return diagnostics.ToImmutableArrayOrEmpty();
}
catch (Exception e) when(CatchAnalyzerException(e, analyzer))
{
var exceptionDiagnostics = AnalyzerExceptionToDiagnostics(analyzer, e, _cancellationToken);
return GetFilteredDocumentDiagnostics(exceptionDiagnostics, compilation).ToImmutableArray();
}
}
var analyzerActions = await this.GetAnalyzerActionsAsync(analyzer, diagnostics.Add).ConfigureAwait(false);
DiagnosticAnalyzerLogger.UpdateAnalyzerTypeCount(analyzer, analyzerActions, (DiagnosticLogAggregator)_logAggregator);
if (analyzerActions != null)
{
if (_document.SupportsSyntaxTree)
{
AnalyzerDriverHelper.ExecuteSyntaxTreeActions(analyzerActions, _root.SyntaxTree,
_analyzerOptions, diagnostics.Add, CatchAnalyzerException, _cancellationToken);
}
}
if (diagnostics.Count == 0)
{
return SpecializedCollections.EmptyEnumerable<Diagnostic>();
}
return GetFilteredDocumentDiagnostics(diagnostics, compilation).ToImmutableArray();
}
}
