Roslyn C# incrementing change

Question

Trying with a Diagnostic and a CodeFix to make a code who transform that:

variable = variable + 1;
otherVariable = otherVariable -1;

Into:

variable++;
otherVariable--;

Already done the diagnostic (it works):

var incrementing = node as BinaryExpressionSyntax;
if (incrementing != null)
{
    string right = incrementing .Right.ToString();
    string left = incrementing .Left.ToString();

    if (right == left + " - 1" || right == left + " + 1")
    {
        addDiagnostic(Diagnostic.Create(Rule, incrementation.GetLocation(), "Use the shorter way"));
    }
}

Edit: I've made some change. Now the incrementating is always recognized. The program go in the CodeFix, but my ReplaceToken with a SyntaxFactory don't work. (It's now only for "++" and not "--"):

 if (node.IsKind(SyntaxKind.SimpleAssignmentExpression)) //I use a node instead of a token
 {
     var IncrementationClause = (BinaryExpressionSyntax)node;

      string left = IncrementationClause.Left.ToString();
      left = left + "++";
      string rigt = IncrementationClause.Right.ToString();

      var newIncrementationClause = IncrementationClause.ReplaceToken(SyntaxFactory.Identifier(IncrementationClause.Left.ToString()), SyntaxFactory.Identifier(left));
      newIncrementationClause = IncrementationClause.ReplaceToken(SyntaxFactory.Identifier(IncrementationClause.Right.ToString()), SyntaxFactory.Identifier(String.Empty));
      newIncrementationClause = IncrementationClause.ReplaceToken(SyntaxFactory.Identifier(IncrementationClause.OperatorToken.ToString()), SyntaxFactory.Identifier(String.Empty));

      var newRoot = root.ReplaceNode(IncrementationClause, newIncrementationClause);

      return new[] { CodeAction.Create("Changer la mise en forme", document.WithSyntaxRoot(newRoot)) };
 }

You should analyze the syntax tree, not check the string representation. `ToString()` probably doesn't return what you expect. — SLaks, Apr 28 '14 at 14:11
I've find the way and now it goes in the CodeFix. But nothing change... I have a CodeAction, but no action is done. When I debug step by step, I can see that the newIncrementationClause is exactly the same as IncrementationClause. Maybe you can help me :) — Maloz, May 02 '14 at 06:39
You're replacing a new node that you just created, which by definition is not in the tree. You should never work with `node.ToString()`; always use Node APIs directly. — SLaks, May 02 '14 at 21:22

score 2 · Answer 1 · answered Apr 29 '14 at 05:09

Try using the source span of the diagnostic and not the span argument. Also, the parent of the first token in the span won't necessarily be the binary expression you are looking for. You'll have to either search up the parent chain using .AncestorsAndSelf() or use FindNode() to find the node that best matches the span.

Also you are checking a token to see if it has the kind of a node. As a rule all token kinds end in Token or Keyword. You need to be finding the node that has that SyntaxKind.

Maloz · Accepted Answer · 2014-05-13T09:04:31.927

Okey, I find the way by myself! Here is the CodeFix:

 if (node.IsKind(SyntaxKind.SimpleAssignmentExpression)) 
 {
        var IncrementationClause = (BinaryExpressionSyntax)node;
        var IncrementionClauseExpressionStatement = IncrementationClause.Parent;

        string right = IncrementationClause.Right.ToString(); 
        string left = IncrementationClause.Left.ToString();

        var ExpressionNew = SyntaxFactory.ExpressionStatement(IncrementationClause); 

         if (right == left + " - 1")
         {
           var BonneIncrementation = SyntaxFactory.PostfixUnaryExpression(SyntaxKind.PostDecrementExpression, IncrementationClause.Left);
           ExpressionNew = SyntaxFactory.ExpressionStatement(BonneIncrementation).WithAdditionalAnnotations(Formatter.Annotation).WithLeadingTrivia(leading).WithTrailingTrivia(trailing); 
          }
          else 
          {
            var BonneIncrementation = SyntaxFactory.PostfixUnaryExpression(SyntaxKind.PostIncrementExpression, IncrementationClause.Left); 
            ExpressionNew = SyntaxFactory.ExpressionStatement(BonneIncrementation).WithAdditionalAnnotations(Formatter.Annotation).WithLeadingTrivia(leading).WithTrailingTrivia(trailing);
          }

          var newRoot = root.ReplaceNode(IncrementionClauseExpressionStatement, ExpressionNew);

          return new[] { CodeAction.Create("Convert in the good way of incrementing", document.WithSyntaxRoot(newRoot)) };


 }

Roslyn C# incrementing change

2 Answers2