for statement increment as postfix added

MaStr11 · MaStr11 · commit 8b0e6572676c · 2021-06-23T20:36:22.000+01:00
diff --git a/src/Analyzers/CSharp/Tests/UseCompoundAssignment/UseCompoundAssignmentTests.cs b/src/Analyzers/CSharp/Tests/UseCompoundAssignment/UseCompoundAssignmentTests.cs
@@ -1087,7 +1087,7 @@ void M()
 {
     void M()
     {
-        for (int i = 0; i < 10; ++i)
+        for (int i = 0; i < 10; i++)
         {
         }
     }
diff --git a/src/Analyzers/Core/CodeFixes/UseCompoundAssignment/AbstractUseCompoundAssignmentCodeFixProvider.cs b/src/Analyzers/Core/CodeFixes/UseCompoundAssignment/AbstractUseCompoundAssignmentCodeFixProvider.cs
@@ -81,12 +81,12 @@ protected override Task FixAllAsync(
 
                         if (diagnostic.Properties.ContainsKey(UseCompoundAssignmentUtilities.Increment))
                         {
-                            return Increment((TExpressionSyntax)leftOfAssign.WithTriviaFrom(currentAssignment), postfix: syntaxFacts.IsSimpleAssignmentStatement(currentAssignment.Parent));
+                            return IncrementOrDecrement(Increment, currentAssignment, leftOfAssign);
                         }
 
                         if (diagnostic.Properties.ContainsKey(UseCompoundAssignmentUtilities.Decrement))
                         {
-                            return Decrement((TExpressionSyntax)leftOfAssign.WithTriviaFrom(currentAssignment), postfix: syntaxFacts.IsSimpleAssignmentStatement(currentAssignment.Parent));
+                            return IncrementOrDecrement(Decrement, currentAssignment, leftOfAssign);
                         }
 
                         var assignmentOpKind = _binaryToAssignmentMap[syntaxKinds.Convert<TSyntaxKind>(rightOfAssign.RawKind)];
@@ -100,6 +100,20 @@ protected override Task FixAllAsync(
             }
 
             return Task.CompletedTask;
+
+            SyntaxNode IncrementOrDecrement(Func<TExpressionSyntax, bool, TExpressionSyntax> incrementOrDecrementFactory, SyntaxNode currentAssignment, SyntaxNode leftOfAssignment)
+            {
+                var postfix = syntaxFacts.IsSimpleAssignmentStatement(currentAssignment.Parent);
+                if (!postfix)
+                {
+                    syntaxFacts.GetPartsOfForStatement(currentAssignment.Parent, out _, out _, out _, out var increments);
+                    if (increments.Contains(currentAssignment))
+                    {
+                        postfix = true;
+                    }
+                }
+                return incrementOrDecrementFactory((TExpressionSyntax)leftOfAssignment.WithTriviaFrom(currentAssignment), postfix);
+            }
         }
 
         private class MyCodeAction : CustomCodeActions.DocumentChangeAction
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpSyntaxFacts.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpSyntaxFacts.cs
@@ -1453,6 +1453,21 @@ public SyntaxNode GetExpressionOfAwaitExpression(SyntaxNode node)
         public bool IsExpressionOfForeach([NotNullWhen(true)] SyntaxNode? node)
             => node?.Parent is ForEachStatementSyntax foreachStatement && foreachStatement.Expression == node;
 
+        public void GetPartsOfForStatement(SyntaxNode? node, out SyntaxNode? variableDeclaration, out SyntaxNode? startvalue, out SyntaxNode? endCondition, out ImmutableArray<SyntaxNode> increments)
+        {
+            variableDeclaration = null;
+            startvalue = null;
+            endCondition = null;
+            increments = ImmutableArray<SyntaxNode>.Empty;
+
+            if (node is ForStatementSyntax forStatement)
+            {
+                variableDeclaration = forStatement.Declaration;
+                endCondition = forStatement.Condition;
+                increments = forStatement.Incrementors.ToImmutableArray<SyntaxNode>();
+            }
+        }
+
         public SyntaxNode GetExpressionOfExpressionStatement(SyntaxNode node)
             => ((ExpressionStatementSyntax)node).Expression;
 
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SyntaxFacts/ISyntaxFacts.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SyntaxFacts/ISyntaxFacts.cs
@@ -143,6 +143,15 @@ internal interface ISyntaxFacts
         bool IsExpressionOfAwaitExpression([NotNullWhen(true)] SyntaxNode? node);
         SyntaxNode GetExpressionOfAwaitExpression(SyntaxNode node);
         bool IsExpressionOfForeach([NotNullWhen(true)] SyntaxNode? node);
+        /// <summary>
+        /// Returns the parts of a for loop. C#: for(var i = 0; i &lt; 10; i++) VB: For i = 0 To 10 Step 1
+        /// </summary>
+        /// <param name="node">The for loop statement</param>
+        /// <param name="variableDeclaration">C#: var i = 0 | VB: i</param>
+        /// <param name="startValue">C#: null | VB: 0</param>
+        /// <param name="endCondition">C#: i &lt; 10 | VB: 10</param>
+        /// <param name="increments">C#: i++ | VB: Step 1</param>
+        void GetPartsOfForStatement(SyntaxNode? node, out SyntaxNode? variableDeclaration, out SyntaxNode? startValue, out SyntaxNode? endCondition, out ImmutableArray<SyntaxNode> increments);
 
         void GetPartsOfTupleExpression<TArgumentSyntax>(SyntaxNode node,
             out SyntaxToken openParen, out SeparatedSyntaxList<TArgumentSyntax> arguments, out SyntaxToken closeParen) where TArgumentSyntax : SyntaxNode;
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SyntaxFacts/VisualBasicSyntaxFacts.vb b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SyntaxFacts/VisualBasicSyntaxFacts.vb
@@ -1515,6 +1515,16 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.LanguageServices
             Return node IsNot Nothing AndAlso TryCast(node.Parent, ForEachStatementSyntax)?.Expression Is node
         End Function
 
+        Public Sub GetPartsOfForStatement(node As SyntaxNode, ByRef variableDeclaration As SyntaxNode, ByRef startValue As SyntaxNode, ByRef endCondition As SyntaxNode, ByRef increments As ImmutableArray(Of SyntaxNode)) Implements ISyntaxFacts.GetPartsOfForStatement
+            If TypeOf node Is ForStatementSyntax Then
+                Dim forStatement = DirectCast(node, ForStatementSyntax)
+                variableDeclaration = forStatement.ControlVariable
+                startValue = forStatement.FromValue
+                endCondition = forStatement.ToValue
+                increments = ImmutableArray.Create(Of SyntaxNode)(forStatement.StepClause)
+            End If
+        End Sub
+
         Public Function GetExpressionOfExpressionStatement(node As SyntaxNode) As SyntaxNode Implements ISyntaxFacts.GetExpressionOfExpressionStatement
             Return DirectCast(node, ExpressionStatementSyntax).Expression
         End Function

Original file line number	Diff line number	Diff line change
`@@ -1087,7 +1087,7 @@ void M()`
`1087`	`1087`	`{`
`1088`	`1088`	`void M()`
`1089`	`1089`	`{`
`1090`		`- for (int i = 0; i < 10; ++i)`
	`1090`	`+ for (int i = 0; i < 10; i++)`
`1091`	`1091`	`{`
`1092`	`1092`	`}`
`1093`	`1093`	`}`
Original file line number	Diff line number	Diff line change
`@@ -81,12 +81,12 @@ protected override Task FixAllAsync(`
`81`	`81`
`82`	`82`	`if (diagnostic.Properties.ContainsKey(UseCompoundAssignmentUtilities.Increment))`
`83`	`83`	`{`
`84`		`- return Increment((TExpressionSyntax)leftOfAssign.WithTriviaFrom(currentAssignment), postfix: syntaxFacts.IsSimpleAssignmentStatement(currentAssignment.Parent));`
	`84`	`+ return IncrementOrDecrement(Increment, currentAssignment, leftOfAssign);`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`if (diagnostic.Properties.ContainsKey(UseCompoundAssignmentUtilities.Decrement))`
`88`	`88`	`{`
`89`		`- return Decrement((TExpressionSyntax)leftOfAssign.WithTriviaFrom(currentAssignment), postfix: syntaxFacts.IsSimpleAssignmentStatement(currentAssignment.Parent));`
	`89`	`+ return IncrementOrDecrement(Decrement, currentAssignment, leftOfAssign);`
`90`	`90`	`}`
`91`	`91`
`92`	`92`	`var assignmentOpKind = _binaryToAssignmentMap[syntaxKinds.Convert<TSyntaxKind>(rightOfAssign.RawKind)];`
`@@ -100,6 +100,20 @@ protected override Task FixAllAsync(`
`100`	`100`	`}`
`101`	`101`
`102`	`102`	`return Task.CompletedTask;`
	`103`	`+`
	`104`	`+ SyntaxNode IncrementOrDecrement(Func<TExpressionSyntax, bool, TExpressionSyntax> incrementOrDecrementFactory, SyntaxNode currentAssignment, SyntaxNode leftOfAssignment)`
	`105`	`+ {`
	`106`	`+ var postfix = syntaxFacts.IsSimpleAssignmentStatement(currentAssignment.Parent);`
	`107`	`+ if (!postfix)`
	`108`	`+ {`
	`109`	`+ syntaxFacts.GetPartsOfForStatement(currentAssignment.Parent, out _, out _, out _, out var increments);`
	`110`	`+ if (increments.Contains(currentAssignment))`
	`111`	`+ {`
	`112`	`+ postfix = true;`
	`113`	`+ }`
	`114`	`+ }`
	`115`	`+ return incrementOrDecrementFactory((TExpressionSyntax)leftOfAssignment.WithTriviaFrom(currentAssignment), postfix);`
	`116`	`+ }`
`103`	`117`	`}`
`104`	`118`
`105`	`119`	`private class MyCodeAction : CustomCodeActions.DocumentChangeAction`