static ISet <SyntaxTree> getMutationsForNode(SyntaxNode node, SyntaxNode rootNode, DataFlow optionalDataFlow = null)
{
ISet <SyntaxTree> toReturn = new HashSet <SyntaxTree>();
BinaryExpressionSyntax binaryExpression = node as BinaryExpressionSyntax;
PostfixUnaryExpressionSyntax postfixUnaryExpression = node as PostfixUnaryExpressionSyntax;
PrefixUnaryExpressionSyntax prefixUnaryExpression = node as PrefixUnaryExpressionSyntax;
BlockSyntax block = node as BlockSyntax;
StatementSyntax statement = node as StatementSyntax;
IdentifierNameSyntax identifierName = node as IdentifierNameSyntax;
if (binaryExpression != null)
{
ISet <SyntaxToken> validMutations = validBinaryOperatorMutations(binaryExpression);
foreach (SyntaxToken mutatedToken in validMutations)
{
SyntaxNode newRoot = rootNode.ReplaceNode(node, binaryExpression.WithOperatorToken(mutatedToken).WithTrailingTrivia(syntaxTrivias));
toReturn.Add(newRoot.SyntaxTree);
}
}
else if (postfixUnaryExpression != null)
{
ISet <SyntaxToken> validMutations = validUnaryOperatorMutations(postfixUnaryExpression);
foreach (SyntaxToken mutatedToken in validMutations)
{
SyntaxNode newRoot = rootNode.ReplaceNode(node, postfixUnaryExpression.WithOperatorToken(mutatedToken).WithTrailingTrivia(syntaxTrivias));
toReturn.Add(newRoot.SyntaxTree);
}
}
else if (prefixUnaryExpression != null)
{
ISet <SyntaxToken> validMutations = validUnaryOperatorMutations(prefixUnaryExpression);
foreach (SyntaxToken mutatedToken in validMutations)
{
SyntaxNode newRoot = rootNode.ReplaceNode(node, prefixUnaryExpression.WithOperatorToken(mutatedToken).WithTrailingTrivia(syntaxTrivias));
toReturn.Add(newRoot.SyntaxTree);
}
}
else if (statement != null && block == null)
{
//replace statements with semicolons
toReturn.Add(rootNode.ReplaceNode(node, SyntaxFactory.EmptyStatement(SyntaxFactory.Token(SyntaxKind.SemicolonToken)).WithTrailingTrivia(syntaxTrivias)).SyntaxTree);
}
else if (identifierName != null && optionalDataFlow != null)
{
//Go through reaching definitions and replace with all other variables available
ISet <SyntaxToken> validMutations = validIdentifierNames(identifierName, optionalDataFlow);
foreach (SyntaxToken mutatedToken in validMutations)
{
SyntaxNode newRoot = rootNode.ReplaceNode(node, identifierName.WithIdentifier(mutatedToken).WithTrailingTrivia(syntaxTrivias));
toReturn.Add(newRoot.SyntaxTree);
}
}
return(toReturn);
}
private static void ReplacePostDecrementWithPostIncrement(RefactoringContext context, PostfixUnaryExpressionSyntax postDecrement)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceIncrementOperatorWithDecrementOperator))
{
PostfixUnaryExpressionSyntax postIncrement = postDecrement
.WithOperatorToken(PlusPlusToken())
.WithTriviaFrom(postDecrement)
.WithFormatterAnnotation();
context.RegisterRefactoring(
$"Replace '{postDecrement}' with '{postIncrement}'",
cancellationToken => ChangePostDecrementToPostIncrementAsync(context.Document, postDecrement, postIncrement, cancellationToken));
}
}
private static async Task <Document> ChangePostDecrementToPostIncrementAsync(
Document document,
PostfixUnaryExpressionSyntax postfixUnaryExpression,
CancellationToken cancellationToken)
{
SyntaxNode oldRoot = await document.GetSyntaxRootAsync(cancellationToken);
PostfixUnaryExpressionSyntax newNode = postfixUnaryExpression
.WithOperatorToken(SyntaxFactory.Token(SyntaxKind.PlusPlusToken))
.WithAdditionalAnnotations(Formatter.Annotation);
SyntaxNode newRoot = oldRoot.ReplaceNode(postfixUnaryExpression, newNode);
return(document.WithSyntaxRoot(newRoot));
}
private static void InvertPostIncrement(RefactoringContext context, PostfixUnaryExpressionSyntax postIncrement)
{
if (!context.IsRefactoringEnabled(RefactoringIdentifiers.InvertPrefixOrPostfixUnaryOperator))
{
return;
}
PostfixUnaryExpressionSyntax postDecrement = postIncrement
.WithOperatorToken(MinusMinusToken())
.WithTriviaFrom(postIncrement)
.WithFormatterAnnotation();
context.RegisterRefactoring(
$"Invert {postIncrement.OperatorToken}",
cancellationToken => ChangePostIncrementToPostDecrementAsync(context.Document, postIncrement, postDecrement, cancellationToken));
}
private static void InvertPostDecrement(RefactoringContext context, PostfixUnaryExpressionSyntax postDecrement)
{
if (!context.IsRefactoringEnabled(RefactoringDescriptors.InvertPrefixOrPostfixUnaryOperator))
{
return;
}
PostfixUnaryExpressionSyntax postIncrement = postDecrement
.WithOperatorToken(Token(SyntaxKind.PlusPlusToken))
.WithTriviaFrom(postDecrement)
.WithFormatterAnnotation();
context.RegisterRefactoring(
$"Invert {postDecrement.OperatorToken}",
ct => ChangePostDecrementToPostIncrementAsync(context.Document, postDecrement, postIncrement, ct),
RefactoringDescriptors.InvertPrefixOrPostfixUnaryOperator);
}