private SyntaxNode Mutate(SyntaxNode currentNode, SyntaxNodeAnalysis analysis)
{
if (currentNode is MethodDeclarationSyntax ||
currentNode is ConstructorDeclarationSyntax ||
currentNode is PropertyDeclarationSyntax)
{
foreach (var blockNode in currentNode.DescendantNodes <BlockSyntax>())
{
if (analysis.IsNodeArid(blockNode))
{
continue;
}
AddBlockMutants(blockNode);
}
}
if (GetExpressionSyntax(currentNode) is var expressionSyntax &&
expressionSyntax != null &&
!analysis.IsNodeArid(expressionSyntax))
{
if (currentNode is ExpressionStatementSyntax syntax)
{
if (expressionSyntax is AssignmentExpressionSyntax)
{
return(MutateWithIfStatements(expressionSyntax.Parent));
}
if (GetExpressionSyntax(expressionSyntax) is var subExpressionSyntax && subExpressionSyntax != null)
{
return(currentNode.ReplaceNode(expressionSyntax, Mutate(expressionSyntax, analysis)));
}
return(MutateWithIfStatements(syntax));
}
return(currentNode.ReplaceNode(expressionSyntax, MutateWithConditionalExpressions(expressionSyntax)));
}
if (currentNode is StatementSyntax statement &&
currentNode.Kind() != SyntaxKind.Block &&
!analysis.IsNodeArid(statement))
{
if (currentNode is LocalFunctionStatementSyntax localFunction)
{
return(localFunction.ReplaceNode(localFunction.Body, Mutate(localFunction.Body, analysis)));
}
if (currentNode is IfStatementSyntax ifStatement)
{
if (!ifStatement.Statement.ChildNodes().Any())
{
return(null);
}
ifStatement = ifStatement.ReplaceNode(ifStatement.Condition,
MutateWithConditionalExpressions(ifStatement.Condition));
if (ifStatement.Else != null)
{
ifStatement = ifStatement.ReplaceNode(ifStatement.Else, Mutate(ifStatement.Else, analysis));
}
try
{
if (ifStatement.Statement != null)
{
return(ifStatement.ReplaceNode(ifStatement.Statement,
Mutate(ifStatement.Statement, analysis)));
}
}
catch (Exception e)
{
Trace.TraceError("unable to process if statement at line {0} {1}",
ifStatement?.Statement?.LineNumber() + 1, e);
}
}
return(MutateWithIfStatements(statement));
}
if (currentNode is InvocationExpressionSyntax invocationExpression &&
invocationExpression.ArgumentList.Arguments.Count == 0 &&
!analysis.IsNodeArid(invocationExpression))
{
var mutant = FindMutants(invocationExpression).FirstOrDefault();
if (mutant != null)
{
Mutants.Add(mutant);
}
}
var children = currentNode.ChildNodes().ToList();
foreach (var child in children)
{
Mutate(child, analysis);
}
return(currentNode);
}
public SyntaxNode Mutate(SyntaxNodeAnalysis analysis)
{
return(Mutate(analysis.Root, analysis));
}
