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