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 ReplacePreDecrementWithPreIncrement(RefactoringContext context, PrefixUnaryExpressionSyntax preDecrement)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceIncrementOperatorWithDecrementOperator))
{
PrefixUnaryExpressionSyntax preIncrement = preDecrement
.WithOperatorToken(PlusPlusToken())
.WithTriviaFrom(preDecrement)
.WithFormatterAnnotation();
context.RegisterRefactoring(
$"Replace '{preDecrement}' with '{preIncrement}'",
cancellationToken => ChangePreDecrementToPreIncrementAsync(context.Document, preDecrement, preIncrement, cancellationToken));
}
}
private static async Task <Document> ChangePreDecrementToPreIncrementAsync(
Document document,
PrefixUnaryExpressionSyntax prefixUnaryExpression,
CancellationToken cancellationToken)
{
SyntaxNode oldRoot = await document.GetSyntaxRootAsync(cancellationToken);
PrefixUnaryExpressionSyntax newNode = prefixUnaryExpression.WithOperatorToken(SyntaxFactory.Token(SyntaxKind.PlusPlusToken))
.WithAdditionalAnnotations(Formatter.Annotation);
SyntaxNode newRoot = oldRoot.ReplaceNode(prefixUnaryExpression, newNode);
return(document.WithSyntaxRoot(newRoot));
}
private static void InvertPreIncrement(RefactoringContext context, PrefixUnaryExpressionSyntax preIncrement)
{
if (!context.IsRefactoringEnabled(RefactoringIdentifiers.InvertPrefixOrPostfixUnaryOperator))
{
return;
}
PrefixUnaryExpressionSyntax preDecrement = preIncrement
.WithOperatorToken(MinusMinusToken())
.WithTriviaFrom(preIncrement)
.WithFormatterAnnotation();
context.RegisterRefactoring(
$"Invert {preIncrement.OperatorToken}",
cancellationToken => ChangePreIncrementToPreDecrementAsync(context.Document, preIncrement, preDecrement, cancellationToken));
}
private static void InvertPreDecrement(RefactoringContext context, PrefixUnaryExpressionSyntax preDecrement)
{
if (!context.IsRefactoringEnabled(RefactoringDescriptors.InvertPrefixOrPostfixUnaryOperator))
{
return;
}
PrefixUnaryExpressionSyntax preIncrement = preDecrement
.WithOperatorToken(Token(SyntaxKind.PlusPlusToken))
.WithTriviaFrom(preDecrement)
.WithFormatterAnnotation();
context.RegisterRefactoring(
$"Invert {preDecrement.OperatorToken}",
ct => ChangePreDecrementToPreIncrementAsync(context.Document, preDecrement, preIncrement, ct),
RefactoringDescriptors.InvertPrefixOrPostfixUnaryOperator);
}
