private void ExecuteSyntaxNodeActions <TLanguageKindEnum>(
IEnumerable <SyntaxNode> nodesToAnalyze,
IDictionary <TLanguageKindEnum, ImmutableArray <SyntaxNodeAnalyzerAction <TLanguageKindEnum> > > nodeActionsByKind,
SemanticModel model,
Func <SyntaxNode, TLanguageKindEnum> getKind,
Action <Diagnostic> addDiagnostic,
SyntaxNodeAnalyzerStateData analyzerStateOpt)
where TLanguageKindEnum : struct
{
Debug.Assert(nodeActionsByKind != null);
Debug.Assert(nodeActionsByKind.Any());
SyntaxNode partiallyProcessedNode = analyzerStateOpt?.CurrentNode;
if (partiallyProcessedNode != null)
{
ExecuteSyntaxNodeActions(partiallyProcessedNode, nodeActionsByKind, model, getKind, addDiagnostic, analyzerStateOpt);
}
foreach (var child in nodesToAnalyze)
{
if (ShouldExecuteNode(analyzerStateOpt, child))
{
SetCurrentNode(analyzerStateOpt, child);
ExecuteSyntaxNodeActions(child, nodeActionsByKind, model, getKind, addDiagnostic, analyzerStateOpt);
}
}
}
private static void SetCurrentNode(SyntaxNodeAnalyzerStateData analyzerStateOpt, SyntaxNode node)
{
if (analyzerStateOpt != null)
{
Debug.Assert(node != null);
analyzerStateOpt.CurrentNode = node;
}
}
private void ExecuteSyntaxNodeActionsCore <TLanguageKindEnum>(
IEnumerable <SyntaxNode> nodesToAnalyze,
IDictionary <TLanguageKindEnum, ImmutableArray <SyntaxNodeAnalyzerAction <TLanguageKindEnum> > > nodeActionsByKind,
DiagnosticAnalyzer analyzer,
SemanticModel model,
Func <SyntaxNode, TLanguageKindEnum> getKind,
TextSpan filterSpan,
SyntaxNodeAnalyzerStateData analyzerStateOpt)
where TLanguageKindEnum : struct
{
var addDiagnostic = GetAddDiagnostic(model.SyntaxTree, filterSpan, analyzer, isSyntaxDiagnostic: false);
ExecuteSyntaxNodeActions(nodesToAnalyze, nodeActionsByKind, model, getKind, addDiagnostic, analyzerStateOpt);
}
private void ExecuteSyntaxNodeAction <TLanguageKindEnum>(
SyntaxNodeAnalyzerAction <TLanguageKindEnum> syntaxNodeAction,
SyntaxNode node,
SemanticModel semanticModel,
Action <Diagnostic> addDiagnostic,
SyntaxNodeAnalyzerStateData analyzerStateOpt)
where TLanguageKindEnum : struct
{
Debug.Assert(analyzerStateOpt == null || analyzerStateOpt.CurrentNode == node);
if (ShouldExecuteAction(analyzerStateOpt, syntaxNodeAction))
{
var syntaxNodeContext = new SyntaxNodeAnalysisContext(node, semanticModel, _analyzerOptions, addDiagnostic,
d => IsSupportedDiagnostic(syntaxNodeAction.Analyzer, d), _cancellationToken);
ExecuteAndCatchIfThrows(syntaxNodeAction.Analyzer, () => syntaxNodeAction.Action(syntaxNodeContext));
analyzerStateOpt?.ProcessedActions.Add(syntaxNodeAction);
}
}
private void ExecuteSyntaxNodeActions <TLanguageKindEnum>(
SyntaxNode node,
IDictionary <TLanguageKindEnum, ImmutableArray <SyntaxNodeAnalyzerAction <TLanguageKindEnum> > > nodeActionsByKind,
SemanticModel model,
Func <SyntaxNode, TLanguageKindEnum> getKind,
Action <Diagnostic> addDiagnostic,
SyntaxNodeAnalyzerStateData analyzerStateOpt)
where TLanguageKindEnum : struct
{
ImmutableArray <SyntaxNodeAnalyzerAction <TLanguageKindEnum> > actionsForKind;
if (nodeActionsByKind.TryGetValue(getKind(node), out actionsForKind))
{
foreach (var action in actionsForKind)
{
ExecuteSyntaxNodeAction(action, node, model, addDiagnostic, analyzerStateOpt);
}
}
analyzerStateOpt?.ClearNodeAnalysisState();
}
private static bool ShouldExecuteNode(SyntaxNodeAnalyzerStateData analyzerStateOpt, SyntaxNode node)
{
return(analyzerStateOpt == null || !analyzerStateOpt.ProcessedNodes.Contains(node));
}
