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); }