renaming

Meir017 · Meir017 · commit 4b48c8385c83 · 2017-10-25T20:59:40.000+03:00
diff --git a/src/FluentAssertions.Analyzers.Tests/Tips/CollectionTests.cs b/src/FluentAssertions.Analyzers.Tests/Tips/CollectionTests.cs
@@ -15,7 +15,6 @@ public class CollectionTests
         [NotImplemented]
         public void NoDiagnostics(string assertion) => VerifyCSharpNoDiagnosticsCodeBlock(assertion);
 
-
         [AssertionDataTestMethod]
         [AssertionDiagnostic("actual.Any().Should().BeTrue({0});")]
         [AssertionDiagnostic("actual.AsEnumerable().Any().Should().BeTrue({0}).And.ToString();")]
diff --git a/src/FluentAssertions.Analyzers/Tips/Collections/CollectionShouldBeInAscendingOrder.cs b/src/FluentAssertions.Analyzers/Tips/Collections/CollectionShouldBeInAscendingOrder.cs
@@ -41,11 +41,11 @@ public class CollectionShouldBeInAscendingOrderCodeFix : FluentAssertionsCodeFix
         protected override ExpressionSyntax GetNewExpression(ExpressionSyntax expression, FluentAssertionsDiagnosticProperties properties)
         {
             var remove = NodeReplacement.RemoveAndExtractArguments("OrderBy");
-            var newStatement = GetNewExpression(expression, remove);
+            var newExpression = GetNewExpression(expression, remove);
 
-            newStatement = GetNewExpression(newStatement, NodeReplacement.RenameAndRemoveFirstArgument("Equal", "BeInAscendingOrder"));
+            newExpression = GetNewExpression(newExpression, NodeReplacement.RenameAndRemoveFirstArgument("Equal", "BeInAscendingOrder"));
 
-            return GetNewExpression(newStatement, NodeReplacement.PrependArguments("BeInAscendingOrder", remove.Arguments));
+            return GetNewExpression(newExpression, NodeReplacement.PrependArguments("BeInAscendingOrder", remove.Arguments));
         }
     }
 }
diff --git a/src/FluentAssertions.Analyzers/Tips/Collections/CollectionShouldBeInDescendingOrder.cs b/src/FluentAssertions.Analyzers/Tips/Collections/CollectionShouldBeInDescendingOrder.cs
@@ -41,11 +41,11 @@ public class CollectionShouldBeInDescendingOrderCodeFix : FluentAssertionsCodeFi
         protected override ExpressionSyntax GetNewExpression(ExpressionSyntax expression, FluentAssertionsDiagnosticProperties properties)
         {
             var remove = NodeReplacement.RemoveAndExtractArguments("OrderByDescending");
-            var newStatement = GetNewExpression(expression, remove);
+            var newExpression = GetNewExpression(expression, remove);
 
-            newStatement = GetNewExpression(newStatement, NodeReplacement.RenameAndRemoveFirstArgument("Equal", "BeInDescendingOrder"));
+            newExpression = GetNewExpression(newExpression, NodeReplacement.RenameAndRemoveFirstArgument("Equal", "BeInDescendingOrder"));
 
-            return GetNewExpression(newStatement, NodeReplacement.PrependArguments("BeInDescendingOrder", remove.Arguments));
+            return GetNewExpression(newExpression, NodeReplacement.PrependArguments("BeInDescendingOrder", remove.Arguments));
         }
     }
 }
diff --git a/src/FluentAssertions.Analyzers/Tips/Collections/CollectionShouldContainItem.cs b/src/FluentAssertions.Analyzers/Tips/Collections/CollectionShouldContainItem.cs
@@ -42,9 +42,9 @@ public class CollectionShouldContainItemCodeFix : FluentAssertionsCodeFixProvide
         protected override ExpressionSyntax GetNewExpression(ExpressionSyntax expression, FluentAssertionsDiagnosticProperties properties)
         {
             var remove = new NodeReplacement.RemoveAndExtractArgumentsNodeReplacement("Contains");
-            var newStatement = GetNewExpression(expression, remove);
+            var newExpression = GetNewExpression(expression, remove);
 
-            return GetNewExpression(newStatement, new NodeReplacement.RenameAndPrependArgumentsNodeReplacement("BeTrue", "Contain", remove.Arguments));
+            return GetNewExpression(newExpression, new NodeReplacement.RenameAndPrependArgumentsNodeReplacement("BeTrue", "Contain", remove.Arguments));
         }
     }
 }
diff --git a/src/FluentAssertions.Analyzers/Tips/Collections/CollectionShouldContainProperty.cs b/src/FluentAssertions.Analyzers/Tips/Collections/CollectionShouldContainProperty.cs
@@ -51,16 +51,16 @@ protected override ExpressionSyntax GetNewExpression(ExpressionSyntax expression
             if (properties.VisitorName == nameof(CollectionShouldContainPropertyAnalyzer.AnyShouldBeTrueSyntaxVisitor))
             {
                 var remove = new NodeReplacement.RemoveAndExtractArgumentsNodeReplacement("Any");
-                var newStatement = GetNewExpression(expression, remove);
+                var newExpression = GetNewExpression(expression, remove);
 
-                return GetNewExpression(newStatement, new NodeReplacement.RenameAndPrependArgumentsNodeReplacement("BeTrue", "Contain", remove.Arguments));
+                return GetNewExpression(newExpression, new NodeReplacement.RenameAndPrependArgumentsNodeReplacement("BeTrue", "Contain", remove.Arguments));
             }
             else if (properties.VisitorName == nameof(CollectionShouldContainPropertyAnalyzer.WhereShouldNotBeEmptySyntaxVisitor))
             {
                 var remove = new NodeReplacement.RemoveAndExtractArgumentsNodeReplacement("Where");
-                var newStatement = GetNewExpression(expression, remove);
+                var newExpression = GetNewExpression(expression, remove);
 
-                return GetNewExpression(newStatement, new NodeReplacement.RenameAndPrependArgumentsNodeReplacement("NotBeEmpty", "Contain", remove.Arguments));
+                return GetNewExpression(newExpression, new NodeReplacement.RenameAndPrependArgumentsNodeReplacement("NotBeEmpty", "Contain", remove.Arguments));
             }
             throw new System.InvalidOperationException($"Invalid visitor name - {properties.VisitorName}");
         }
diff --git a/src/FluentAssertions.Analyzers/Tips/Collections/CollectionShouldContainSingle.cs b/src/FluentAssertions.Analyzers/Tips/Collections/CollectionShouldContainSingle.cs
@@ -48,17 +48,17 @@ public class CollectionShouldContainSingleCodeFix : FluentAssertionsCodeFixProvi
 
         protected override ExpressionSyntax GetNewExpression(ExpressionSyntax expression, FluentAssertionsDiagnosticProperties properties)
         {
-            var newStatement = GetNewExpression(expression, NodeReplacement.RenameAndRemoveFirstArgument("HaveCount", "ContainSingle"));
+            var newExpression = GetNewExpression(expression, NodeReplacement.RenameAndRemoveFirstArgument("HaveCount", "ContainSingle"));
             if (properties.VisitorName == nameof(CollectionShouldContainSingleAnalyzer.ShouldHaveCount1SyntaxVisitor))
             {
-                return newStatement;
+                return newExpression;
             }
             else if (properties.VisitorName == nameof(CollectionShouldContainSingleAnalyzer.WhereShouldHaveCount1SyntaxVisitor))
             {
                 var remove = NodeReplacement.RemoveAndExtractArguments("Where");
-                newStatement = GetNewExpression(newStatement, remove);
+                newExpression = GetNewExpression(newExpression, remove);
 
-                return GetNewExpression(newStatement, NodeReplacement.PrependArguments("ContainSingle", remove.Arguments));
+                return GetNewExpression(newExpression, NodeReplacement.PrependArguments("ContainSingle", remove.Arguments));
             }
             throw new System.InvalidOperationException($"Invalid visitor name - {properties.VisitorName}");
         }
diff --git a/src/FluentAssertions.Analyzers/Tips/Collections/CollectionShouldEqualOtherCollectionByComparer.cs b/src/FluentAssertions.Analyzers/Tips/Collections/CollectionShouldEqualOtherCollectionByComparer.cs
@@ -52,10 +52,10 @@ public class CollectionShouldEqualOtherCollectionByComparerCodeFix : FluentAsser
         protected override ExpressionSyntax GetNewExpression(ExpressionSyntax expression, FluentAssertionsDiagnosticProperties properties)
         {
             var removeMethodContainingFirstLambda = NodeReplacement.RemoveAndExtractArguments("Select");
-            var newStatement = GetNewExpression(expression, removeMethodContainingFirstLambda);
+            var newExpression = GetNewExpression(expression, removeMethodContainingFirstLambda);
 
             var removeArgument = NodeReplacement.RemoveFirstArgument("Equal");
-            newStatement = GetNewExpression(newStatement, removeArgument);
+            newExpression = GetNewExpression(newExpression, removeArgument);
 
             var argumentInvocation = (InvocationExpressionSyntax)removeArgument.Argument.Expression;
             var identifier = ((MemberAccessExpressionSyntax)argumentInvocation.Expression).Expression;
@@ -68,7 +68,7 @@ protected override ExpressionSyntax GetNewExpression(ExpressionSyntax expression
                 .Add(removeArgument.Argument.WithExpression(CombineLambdas(firstLambda, secondLambda).NormalizeWhitespace()
             ));
 
-            return GetNewExpression(newStatement, NodeReplacement.PrependArguments("Equal", newArguments));
+            return GetNewExpression(newExpression, NodeReplacement.PrependArguments("Equal", newArguments));
         }
 
         private ParenthesizedLambdaExpressionSyntax CombineLambdas(SimpleLambdaExpressionSyntax left, SimpleLambdaExpressionSyntax right) => SyntaxFactory.ParenthesizedLambdaExpression(
diff --git a/src/FluentAssertions.Analyzers/Tips/Collections/CollectionShouldHaveElementAt.cs b/src/FluentAssertions.Analyzers/Tips/Collections/CollectionShouldHaveElementAt.cs
@@ -59,23 +59,23 @@ protected override ExpressionSyntax GetNewExpression(ExpressionSyntax expression
             if (properties.VisitorName == nameof(CollectionShouldHaveElementAtAnalyzer.ElementAtIndexShouldBeSyntaxVisitor))
             {
                 var remove = NodeReplacement.RemoveAndExtractArguments("ElementAt");
-                var newStatement = GetNewExpression(expression, remove);
+                var newExpression = GetNewExpression(expression, remove);
 
-                return GetNewExpression(newStatement, NodeReplacement.RenameAndPrependArguments("Be", "HaveElementAt", remove.Arguments));
+                return GetNewExpression(newExpression, NodeReplacement.RenameAndPrependArguments("Be", "HaveElementAt", remove.Arguments));
             }
             else if (properties.VisitorName == nameof(CollectionShouldHaveElementAtAnalyzer.IndexerShouldBeSyntaxVisitor))
             {
                 var remove = NodeReplacement.RemoveAndRetrieveIndexerArguments("Should");
-                var newStatement = GetNewExpression(expression, remove);
+                var newExpression = GetNewExpression(expression, remove);
 
-                return GetNewExpression(newStatement, NodeReplacement.RenameAndPrependArguments("Be", "HaveElementAt", remove.Arguments));
+                return GetNewExpression(newExpression, NodeReplacement.RenameAndPrependArguments("Be", "HaveElementAt", remove.Arguments));
             }
             else if (properties.VisitorName == nameof(CollectionShouldHaveElementAtAnalyzer.SkipFirstShouldBeSyntaxVisitor))
             {
                 var remove = NodeReplacement.RemoveAndExtractArguments("Skip");
-                var newStatement = GetNewExpression(expression, remove, NodeReplacement.Remove("First"));
+                var newExpression = GetNewExpression(expression, remove, NodeReplacement.Remove("First"));
 
-                return GetNewExpression(newStatement, NodeReplacement.RenameAndPrependArguments("Be", "HaveElementAt", remove.Arguments));
+                return GetNewExpression(newExpression, NodeReplacement.RenameAndPrependArguments("Be", "HaveElementAt", remove.Arguments));
             }
             throw new System.InvalidOperationException($"Invalid visitor name - {properties.VisitorName}");
         }
diff --git a/src/FluentAssertions.Analyzers/Tips/Collections/CollectionShouldIntersectWith.cs b/src/FluentAssertions.Analyzers/Tips/Collections/CollectionShouldIntersectWith.cs
@@ -41,9 +41,9 @@ public class CollectionShouldIntersectWithCodeFix : FluentAssertionsCodeFixProvi
         protected override ExpressionSyntax GetNewExpression(ExpressionSyntax expression, FluentAssertionsDiagnosticProperties properties)
         {
             var remove = NodeReplacement.RemoveAndExtractArguments("Intersect");
-            var newStatement = GetNewExpression(expression, remove);
+            var newExpression = GetNewExpression(expression, remove);
 
-            return GetNewExpression(newStatement, NodeReplacement.RenameAndPrependArguments("NotBeEmpty", "IntersectWith", remove.Arguments));
+            return GetNewExpression(newExpression, NodeReplacement.RenameAndPrependArguments("NotBeEmpty", "IntersectWith", remove.Arguments));
         }
     }
 }
diff --git a/src/FluentAssertions.Analyzers/Tips/Collections/CollectionShouldNotBeNullOrEmpty.cs b/src/FluentAssertions.Analyzers/Tips/Collections/CollectionShouldNotBeNullOrEmpty.cs
@@ -63,16 +63,16 @@ protected override ExpressionSyntax GetNewExpression(ExpressionSyntax expression
             if (properties.VisitorName == nameof(CollectionShouldNotBeNullOrEmptyAnalyzer.ShouldNotBeNullAndNotBeEmptySyntaxVisitor))
             {
                 var remove = NodeReplacement.RemoveAndExtractArguments("NotBeEmpty");
-                var newStatement = GetNewExpression(expression, remove);
+                var newExpression = GetNewExpression(expression, remove);
 
-                return GetNewExpression(newStatement, NodeReplacement.RenameAndPrependArguments("NotBeNull", "NotBeNullOrEmpty", remove.Arguments));
+                return GetNewExpression(newExpression, NodeReplacement.RenameAndPrependArguments("NotBeNull", "NotBeNullOrEmpty", remove.Arguments));
             }
             else if (properties.VisitorName == nameof(CollectionShouldNotBeNullOrEmptyAnalyzer.ShouldNotBeEmptyAndNotBeNullSyntaxVisitor))
             {
                 var remove = NodeReplacement.RemoveAndExtractArguments("NotBeNull");
-                var newStatement = GetNewExpression(expression, remove);
+                var newExpression = GetNewExpression(expression, remove);
 
-                return GetNewExpression(newStatement, NodeReplacement.RenameAndPrependArguments("NotBeEmpty", "NotBeNullOrEmpty", remove.Arguments));
+                return GetNewExpression(newExpression, NodeReplacement.RenameAndPrependArguments("NotBeEmpty", "NotBeNullOrEmpty", remove.Arguments));
             }
             throw new System.InvalidOperationException($"Invalid visitor name - {properties.VisitorName}");
         }
diff --git a/src/FluentAssertions.Analyzers/Tips/Collections/CollectionShouldNotContainItem.cs b/src/FluentAssertions.Analyzers/Tips/Collections/CollectionShouldNotContainItem.cs
@@ -41,9 +41,9 @@ public class CollectionShouldNotContainItemCodeFix : FluentAssertionsCodeFixProv
         protected override ExpressionSyntax GetNewExpression(ExpressionSyntax expression, FluentAssertionsDiagnosticProperties properties)
         {
             var remove = new NodeReplacement.RemoveAndExtractArgumentsNodeReplacement("Contains");
-            var newStatement = GetNewExpression(expression, remove);
+            var newExpression = GetNewExpression(expression, remove);
 
-            return GetNewExpression(newStatement, new NodeReplacement.RenameAndPrependArgumentsNodeReplacement("BeFalse", "NotContain", remove.Arguments));
+            return GetNewExpression(newExpression, new NodeReplacement.RenameAndPrependArgumentsNodeReplacement("BeFalse", "NotContain", remove.Arguments));
         }
     }
 }
diff --git a/src/FluentAssertions.Analyzers/Tips/Collections/CollectionShouldNotContainNulls.cs b/src/FluentAssertions.Analyzers/Tips/Collections/CollectionShouldNotContainNulls.cs
@@ -41,9 +41,9 @@ public class CollectionShouldNotContainNullsCodeFix : FluentAssertionsCodeFixPro
         protected override ExpressionSyntax GetNewExpression(ExpressionSyntax expression, FluentAssertionsDiagnosticProperties properties)
         {
             var remove = NodeReplacement.RemoveAndExtractArguments("Select");
-            var newStatement = GetNewExpression(expression, remove);
+            var newExpression = GetNewExpression(expression, remove);
 
-            return GetNewExpression(newStatement, NodeReplacement.PrependArguments("NotContainNulls", remove.Arguments));
+            return GetNewExpression(newExpression, NodeReplacement.PrependArguments("NotContainNulls", remove.Arguments));
         }
     }
 }
diff --git a/src/FluentAssertions.Analyzers/Tips/Collections/CollectionShouldNotContainProperty.cs b/src/FluentAssertions.Analyzers/Tips/Collections/CollectionShouldNotContainProperty.cs
@@ -59,16 +59,16 @@ protected override ExpressionSyntax GetNewExpression(ExpressionSyntax expression
             if (properties.VisitorName == nameof(CollectionShouldNotContainPropertyAnalyzer.AnyShouldBeFalseSyntaxVisitor))
             {
                 var remove = new NodeReplacement.RemoveAndExtractArgumentsNodeReplacement("Any");
-                var newStatement = GetNewExpression(expression, remove);
+                var newExpression = GetNewExpression(expression, remove);
 
-                return GetNewExpression(newStatement, NodeReplacement.RenameAndPrependArguments("BeFalse", "NotContain", remove.Arguments));
+                return GetNewExpression(newExpression, NodeReplacement.RenameAndPrependArguments("BeFalse", "NotContain", remove.Arguments));
             }
             else if (properties.VisitorName == nameof(CollectionShouldNotContainPropertyAnalyzer.WhereShouldBeEmptySyntaxVisitor))
             {
                 var remove = new NodeReplacement.RemoveAndExtractArgumentsNodeReplacement("Where");
-                var newStatement = GetNewExpression(expression, remove);
+                var newExpression = GetNewExpression(expression, remove);
 
-                return GetNewExpression(newStatement, NodeReplacement.RenameAndPrependArguments("BeEmpty", "NotContain", remove.Arguments));
+                return GetNewExpression(newExpression, NodeReplacement.RenameAndPrependArguments("BeEmpty", "NotContain", remove.Arguments));
             }
             else if (properties.VisitorName == nameof(CollectionShouldNotContainPropertyAnalyzer.ShouldOnlyContainNotSyntaxVisitor))
             {
diff --git a/src/FluentAssertions.Analyzers/Tips/Collections/CollectionShouldNotIntersectWith.cs b/src/FluentAssertions.Analyzers/Tips/Collections/CollectionShouldNotIntersectWith.cs
@@ -40,9 +40,9 @@ public class CollectionShouldNotIntersectWithCodeFix : FluentAssertionsCodeFixPr
         protected override ExpressionSyntax GetNewExpression(ExpressionSyntax expression, FluentAssertionsDiagnosticProperties properties)
         {
             var remove = NodeReplacement.RemoveAndExtractArguments("Intersect");
-            var newStatement = GetNewExpression(expression, remove);
+            var newExpression = GetNewExpression(expression, remove);
 
-            return GetNewExpression(newStatement, NodeReplacement.RenameAndPrependArguments("BeEmpty", "NotIntersectWith", remove.Arguments));
+            return GetNewExpression(newExpression, NodeReplacement.RenameAndPrependArguments("BeEmpty", "NotIntersectWith", remove.Arguments));
         }
     }
 }
diff --git a/src/FluentAssertions.Analyzers/Tips/Collections/CollectionShouldOnlyContainProperty.cs b/src/FluentAssertions.Analyzers/Tips/Collections/CollectionShouldOnlyContainProperty.cs
@@ -42,9 +42,9 @@ public class CollectionShouldOnlyContainPropertyCodeFix : FluentAssertionsCodeFi
         protected override ExpressionSyntax GetNewExpression(ExpressionSyntax expression, FluentAssertionsDiagnosticProperties properties)
         {
             var remove = new NodeReplacement.RemoveAndExtractArgumentsNodeReplacement("All");
-            var newStatement = GetNewExpression(expression, remove);
+            var newExpression = GetNewExpression(expression, remove);
 
-            return GetNewExpression(newStatement, new NodeReplacement.RenameAndPrependArgumentsNodeReplacement("BeTrue", "OnlyContain", remove.Arguments));
+            return GetNewExpression(newExpression, new NodeReplacement.RenameAndPrependArgumentsNodeReplacement("BeTrue", "OnlyContain", remove.Arguments));
         }
     }
 }
diff --git a/src/FluentAssertions.Analyzers/Tips/Collections/CollectionShouldOnlyHaveUniqueItemsByComparer.cs b/src/FluentAssertions.Analyzers/Tips/Collections/CollectionShouldOnlyHaveUniqueItemsByComparer.cs
@@ -42,9 +42,9 @@ public class CollectionShouldOnlyHaveUniqueItemsByComparerCodeFix : FluentAssert
         protected override ExpressionSyntax GetNewExpression(ExpressionSyntax expression, FluentAssertionsDiagnosticProperties properties)
         {
             var remove = NodeReplacement.RemoveAndExtractArguments("Select");
-            var newStatement = GetNewExpression(expression, remove);
+            var newExpression = GetNewExpression(expression, remove);
 
-            return GetNewExpression(newStatement, NodeReplacement.PrependArguments("OnlyHaveUniqueItems", remove.Arguments));
+            return GetNewExpression(newExpression, NodeReplacement.PrependArguments("OnlyHaveUniqueItems", remove.Arguments));
         }
     }
 }
diff --git a/src/FluentAssertions.Analyzers/Tips/Dictionaries/DictionaryShouldContainKey.cs b/src/FluentAssertions.Analyzers/Tips/Dictionaries/DictionaryShouldContainKey.cs
@@ -41,9 +41,9 @@ public class DictionaryShouldContainKeyCodeFix : FluentAssertionsCodeFixProvider
         protected override ExpressionSyntax GetNewExpression(ExpressionSyntax expression, FluentAssertionsDiagnosticProperties properties)
         {
             var remove = NodeReplacement.RemoveAndExtractArguments("ContainsKey");
-            var newStatement = GetNewExpression(expression, remove);
+            var newExpression = GetNewExpression(expression, remove);
 
-            return GetNewExpression(newStatement, NodeReplacement.RenameAndPrependArguments("BeTrue", "ContainKey", remove.Arguments));
+            return GetNewExpression(newExpression, NodeReplacement.RenameAndPrependArguments("BeTrue", "ContainKey", remove.Arguments));
         }
     }
 }
diff --git a/src/FluentAssertions.Analyzers/Tips/Dictionaries/DictionaryShouldContainKeyAndValue.cs b/src/FluentAssertions.Analyzers/Tips/Dictionaries/DictionaryShouldContainKeyAndValue.cs
diff --git a/src/FluentAssertions.Analyzers/Tips/Dictionaries/DictionaryShouldContainPair.cs b/src/FluentAssertions.Analyzers/Tips/Dictionaries/DictionaryShouldContainPair.cs
diff --git a/src/FluentAssertions.Analyzers/Tips/Dictionaries/DictionaryShouldContainValue.cs b/src/FluentAssertions.Analyzers/Tips/Dictionaries/DictionaryShouldContainValue.cs
diff --git a/src/FluentAssertions.Analyzers/Tips/Dictionaries/DictionaryShouldNotContainKey.cs b/src/FluentAssertions.Analyzers/Tips/Dictionaries/DictionaryShouldNotContainKey.cs
diff --git a/src/FluentAssertions.Analyzers/Tips/Dictionaries/DictionaryShouldNotContainValue.cs b/src/FluentAssertions.Analyzers/Tips/Dictionaries/DictionaryShouldNotContainValue.cs

Original file line number	Diff line number	Diff line change
`@@ -41,11 +41,11 @@ public class CollectionShouldBeInAscendingOrderCodeFix : FluentAssertionsCodeFix`
`41`	`41`	`protected override ExpressionSyntax GetNewExpression(ExpressionSyntax expression, FluentAssertionsDiagnosticProperties properties)`
`42`	`42`	`{`
`43`	`43`	`var remove = NodeReplacement.RemoveAndExtractArguments("OrderBy");`
`44`		`- var newStatement = GetNewExpression(expression, remove);`
	`44`	`+ var newExpression = GetNewExpression(expression, remove);`
`45`	`45`
`46`		`- newStatement = GetNewExpression(newStatement, NodeReplacement.RenameAndRemoveFirstArgument("Equal", "BeInAscendingOrder"));`
	`46`	`+ newExpression = GetNewExpression(newExpression, NodeReplacement.RenameAndRemoveFirstArgument("Equal", "BeInAscendingOrder"));`
`47`	`47`
`48`		`- return GetNewExpression(newStatement, NodeReplacement.PrependArguments("BeInAscendingOrder", remove.Arguments));`
	`48`	`+ return GetNewExpression(newExpression, NodeReplacement.PrependArguments("BeInAscendingOrder", remove.Arguments));`
`49`	`49`	`}`
`50`	`50`	`}`
`51`	`51`	`}`
Original file line number	Diff line number	Diff line change
`@@ -42,9 +42,9 @@ public class CollectionShouldContainItemCodeFix : FluentAssertionsCodeFixProvide`
`42`	`42`	`protected override ExpressionSyntax GetNewExpression(ExpressionSyntax expression, FluentAssertionsDiagnosticProperties properties)`
`43`	`43`	`{`
`44`	`44`	`var remove = new NodeReplacement.RemoveAndExtractArgumentsNodeReplacement("Contains");`
`45`		`- var newStatement = GetNewExpression(expression, remove);`
	`45`	`+ var newExpression = GetNewExpression(expression, remove);`
`46`	`46`
`47`		`- return GetNewExpression(newStatement, new NodeReplacement.RenameAndPrependArgumentsNodeReplacement("BeTrue", "Contain", remove.Arguments));`
	`47`	`+ return GetNewExpression(newExpression, new NodeReplacement.RenameAndPrependArgumentsNodeReplacement("BeTrue", "Contain", remove.Arguments));`
`48`	`48`	`}`
`49`	`49`	`}`
`50`	`50`	`}`
Original file line number	Diff line number	Diff line change
`@@ -51,16 +51,16 @@ protected override ExpressionSyntax GetNewExpression(ExpressionSyntax expression`
`51`	`51`	`if (properties.VisitorName == nameof(CollectionShouldContainPropertyAnalyzer.AnyShouldBeTrueSyntaxVisitor))`
`52`	`52`	`{`
`53`	`53`	`var remove = new NodeReplacement.RemoveAndExtractArgumentsNodeReplacement("Any");`
`54`		`- var newStatement = GetNewExpression(expression, remove);`
	`54`	`+ var newExpression = GetNewExpression(expression, remove);`
`55`	`55`
`56`		`- return GetNewExpression(newStatement, new NodeReplacement.RenameAndPrependArgumentsNodeReplacement("BeTrue", "Contain", remove.Arguments));`
	`56`	`+ return GetNewExpression(newExpression, new NodeReplacement.RenameAndPrependArgumentsNodeReplacement("BeTrue", "Contain", remove.Arguments));`
`57`	`57`	`}`
`58`	`58`	`else if (properties.VisitorName == nameof(CollectionShouldContainPropertyAnalyzer.WhereShouldNotBeEmptySyntaxVisitor))`
`59`	`59`	`{`
`60`	`60`	`var remove = new NodeReplacement.RemoveAndExtractArgumentsNodeReplacement("Where");`
`61`		`- var newStatement = GetNewExpression(expression, remove);`
	`61`	`+ var newExpression = GetNewExpression(expression, remove);`
`62`	`62`
`63`		`- return GetNewExpression(newStatement, new NodeReplacement.RenameAndPrependArgumentsNodeReplacement("NotBeEmpty", "Contain", remove.Arguments));`
	`63`	`+ return GetNewExpression(newExpression, new NodeReplacement.RenameAndPrependArgumentsNodeReplacement("NotBeEmpty", "Contain", remove.Arguments));`
`64`	`64`	`}`
`65`	`65`	`throw new System.InvalidOperationException($"Invalid visitor name - {properties.VisitorName}");`
`66`	`66`	`}`
Original file line number	Diff line number	Diff line change
`@@ -48,17 +48,17 @@ public class CollectionShouldContainSingleCodeFix : FluentAssertionsCodeFixProvi`
`48`	`48`
`49`	`49`	`protected override ExpressionSyntax GetNewExpression(ExpressionSyntax expression, FluentAssertionsDiagnosticProperties properties)`
`50`	`50`	`{`
`51`		`- var newStatement = GetNewExpression(expression, NodeReplacement.RenameAndRemoveFirstArgument("HaveCount", "ContainSingle"));`
	`51`	`+ var newExpression = GetNewExpression(expression, NodeReplacement.RenameAndRemoveFirstArgument("HaveCount", "ContainSingle"));`
`52`	`52`	`if (properties.VisitorName == nameof(CollectionShouldContainSingleAnalyzer.ShouldHaveCount1SyntaxVisitor))`
`53`	`53`	`{`
`54`		`- return newStatement;`
	`54`	`+ return newExpression;`
`55`	`55`	`}`
`56`	`56`	`else if (properties.VisitorName == nameof(CollectionShouldContainSingleAnalyzer.WhereShouldHaveCount1SyntaxVisitor))`
`57`	`57`	`{`
`58`	`58`	`var remove = NodeReplacement.RemoveAndExtractArguments("Where");`
`59`		`- newStatement = GetNewExpression(newStatement, remove);`
	`59`	`+ newExpression = GetNewExpression(newExpression, remove);`
`60`	`60`
`61`		`- return GetNewExpression(newStatement, NodeReplacement.PrependArguments("ContainSingle", remove.Arguments));`
	`61`	`+ return GetNewExpression(newExpression, NodeReplacement.PrependArguments("ContainSingle", remove.Arguments));`
`62`	`62`	`}`
`63`	`63`	`throw new System.InvalidOperationException($"Invalid visitor name - {properties.VisitorName}");`
`64`	`64`	`}`
Original file line number	Diff line number	Diff line change
`@@ -59,23 +59,23 @@ protected override ExpressionSyntax GetNewExpression(ExpressionSyntax expression`
`59`	`59`	`if (properties.VisitorName == nameof(CollectionShouldHaveElementAtAnalyzer.ElementAtIndexShouldBeSyntaxVisitor))`
`60`	`60`	`{`
`61`	`61`	`var remove = NodeReplacement.RemoveAndExtractArguments("ElementAt");`
`62`		`- var newStatement = GetNewExpression(expression, remove);`
	`62`	`+ var newExpression = GetNewExpression(expression, remove);`
`63`	`63`
`64`		`- return GetNewExpression(newStatement, NodeReplacement.RenameAndPrependArguments("Be", "HaveElementAt", remove.Arguments));`
	`64`	`+ return GetNewExpression(newExpression, NodeReplacement.RenameAndPrependArguments("Be", "HaveElementAt", remove.Arguments));`
`65`	`65`	`}`
`66`	`66`	`else if (properties.VisitorName == nameof(CollectionShouldHaveElementAtAnalyzer.IndexerShouldBeSyntaxVisitor))`
`67`	`67`	`{`
`68`	`68`	`var remove = NodeReplacement.RemoveAndRetrieveIndexerArguments("Should");`
`69`		`- var newStatement = GetNewExpression(expression, remove);`
	`69`	`+ var newExpression = GetNewExpression(expression, remove);`
`70`	`70`
`71`		`- return GetNewExpression(newStatement, NodeReplacement.RenameAndPrependArguments("Be", "HaveElementAt", remove.Arguments));`
	`71`	`+ return GetNewExpression(newExpression, NodeReplacement.RenameAndPrependArguments("Be", "HaveElementAt", remove.Arguments));`
`72`	`72`	`}`
`73`	`73`	`else if (properties.VisitorName == nameof(CollectionShouldHaveElementAtAnalyzer.SkipFirstShouldBeSyntaxVisitor))`
`74`	`74`	`{`
`75`	`75`	`var remove = NodeReplacement.RemoveAndExtractArguments("Skip");`
`76`		`- var newStatement = GetNewExpression(expression, remove, NodeReplacement.Remove("First"));`
	`76`	`+ var newExpression = GetNewExpression(expression, remove, NodeReplacement.Remove("First"));`
`77`	`77`
`78`		`- return GetNewExpression(newStatement, NodeReplacement.RenameAndPrependArguments("Be", "HaveElementAt", remove.Arguments));`
	`78`	`+ return GetNewExpression(newExpression, NodeReplacement.RenameAndPrependArguments("Be", "HaveElementAt", remove.Arguments));`
`79`	`79`	`}`
`80`	`80`	`throw new System.InvalidOperationException($"Invalid visitor name - {properties.VisitorName}");`
`81`	`81`	`}`
Original file line number	Diff line number	Diff line change
`@@ -41,9 +41,9 @@ public class CollectionShouldIntersectWithCodeFix : FluentAssertionsCodeFixProvi`
`41`	`41`	`protected override ExpressionSyntax GetNewExpression(ExpressionSyntax expression, FluentAssertionsDiagnosticProperties properties)`
`42`	`42`	`{`
`43`	`43`	`var remove = NodeReplacement.RemoveAndExtractArguments("Intersect");`
`44`		`- var newStatement = GetNewExpression(expression, remove);`
	`44`	`+ var newExpression = GetNewExpression(expression, remove);`
`45`	`45`
`46`		`- return GetNewExpression(newStatement, NodeReplacement.RenameAndPrependArguments("NotBeEmpty", "IntersectWith", remove.Arguments));`
	`46`	`+ return GetNewExpression(newExpression, NodeReplacement.RenameAndPrependArguments("NotBeEmpty", "IntersectWith", remove.Arguments));`
`47`	`47`	`}`
`48`	`48`	`}`
`49`	`49`	`}`
Original file line number	Diff line number	Diff line change
`@@ -63,16 +63,16 @@ protected override ExpressionSyntax GetNewExpression(ExpressionSyntax expression`
`63`	`63`	`if (properties.VisitorName == nameof(CollectionShouldNotBeNullOrEmptyAnalyzer.ShouldNotBeNullAndNotBeEmptySyntaxVisitor))`
`64`	`64`	`{`
`65`	`65`	`var remove = NodeReplacement.RemoveAndExtractArguments("NotBeEmpty");`
`66`		`- var newStatement = GetNewExpression(expression, remove);`
	`66`	`+ var newExpression = GetNewExpression(expression, remove);`
`67`	`67`
`68`		`- return GetNewExpression(newStatement, NodeReplacement.RenameAndPrependArguments("NotBeNull", "NotBeNullOrEmpty", remove.Arguments));`
	`68`	`+ return GetNewExpression(newExpression, NodeReplacement.RenameAndPrependArguments("NotBeNull", "NotBeNullOrEmpty", remove.Arguments));`
`69`	`69`	`}`
`70`	`70`	`else if (properties.VisitorName == nameof(CollectionShouldNotBeNullOrEmptyAnalyzer.ShouldNotBeEmptyAndNotBeNullSyntaxVisitor))`
`71`	`71`	`{`
`72`	`72`	`var remove = NodeReplacement.RemoveAndExtractArguments("NotBeNull");`
`73`		`- var newStatement = GetNewExpression(expression, remove);`
	`73`	`+ var newExpression = GetNewExpression(expression, remove);`
`74`	`74`
`75`		`- return GetNewExpression(newStatement, NodeReplacement.RenameAndPrependArguments("NotBeEmpty", "NotBeNullOrEmpty", remove.Arguments));`
	`75`	`+ return GetNewExpression(newExpression, NodeReplacement.RenameAndPrependArguments("NotBeEmpty", "NotBeNullOrEmpty", remove.Arguments));`
`76`	`76`	`}`
`77`	`77`	`throw new System.InvalidOperationException($"Invalid visitor name - {properties.VisitorName}");`
`78`	`78`	`}`
Original file line number	Diff line number	Diff line change
`@@ -59,16 +59,16 @@ protected override ExpressionSyntax GetNewExpression(ExpressionSyntax expression`
`59`	`59`	`if (properties.VisitorName == nameof(CollectionShouldNotContainPropertyAnalyzer.AnyShouldBeFalseSyntaxVisitor))`
`60`	`60`	`{`
`61`	`61`	`var remove = new NodeReplacement.RemoveAndExtractArgumentsNodeReplacement("Any");`
`62`		`- var newStatement = GetNewExpression(expression, remove);`
	`62`	`+ var newExpression = GetNewExpression(expression, remove);`
`63`	`63`
`64`		`- return GetNewExpression(newStatement, NodeReplacement.RenameAndPrependArguments("BeFalse", "NotContain", remove.Arguments));`
	`64`	`+ return GetNewExpression(newExpression, NodeReplacement.RenameAndPrependArguments("BeFalse", "NotContain", remove.Arguments));`
`65`	`65`	`}`
`66`	`66`	`else if (properties.VisitorName == nameof(CollectionShouldNotContainPropertyAnalyzer.WhereShouldBeEmptySyntaxVisitor))`
`67`	`67`	`{`
`68`	`68`	`var remove = new NodeReplacement.RemoveAndExtractArgumentsNodeReplacement("Where");`
`69`		`- var newStatement = GetNewExpression(expression, remove);`
	`69`	`+ var newExpression = GetNewExpression(expression, remove);`
`70`	`70`
`71`		`- return GetNewExpression(newStatement, NodeReplacement.RenameAndPrependArguments("BeEmpty", "NotContain", remove.Arguments));`
	`71`	`+ return GetNewExpression(newExpression, NodeReplacement.RenameAndPrependArguments("BeEmpty", "NotContain", remove.Arguments));`
`72`	`72`	`}`
`73`	`73`	`else if (properties.VisitorName == nameof(CollectionShouldNotContainPropertyAnalyzer.ShouldOnlyContainNotSyntaxVisitor))`
`74`	`74`	`{`
Original file line number	Diff line number	Diff line change
`@@ -40,9 +40,9 @@ public class CollectionShouldNotIntersectWithCodeFix : FluentAssertionsCodeFixPr`
`40`	`40`	`protected override ExpressionSyntax GetNewExpression(ExpressionSyntax expression, FluentAssertionsDiagnosticProperties properties)`
`41`	`41`	`{`
`42`	`42`	`var remove = NodeReplacement.RemoveAndExtractArguments("Intersect");`
`43`		`- var newStatement = GetNewExpression(expression, remove);`
	`43`	`+ var newExpression = GetNewExpression(expression, remove);`
`44`	`44`
`45`		`- return GetNewExpression(newStatement, NodeReplacement.RenameAndPrependArguments("BeEmpty", "NotIntersectWith", remove.Arguments));`
	`45`	`+ return GetNewExpression(newExpression, NodeReplacement.RenameAndPrependArguments("BeEmpty", "NotIntersectWith", remove.Arguments));`
`46`	`46`	`}`
`47`	`47`	`}`
`48`	`48`	`}`
Original file line number	Diff line number	Diff line change
`@@ -41,9 +41,9 @@ public class DictionaryShouldContainKeyCodeFix : FluentAssertionsCodeFixProvider`
`41`	`41`	`protected override ExpressionSyntax GetNewExpression(ExpressionSyntax expression, FluentAssertionsDiagnosticProperties properties)`
`42`	`42`	`{`
`43`	`43`	`var remove = NodeReplacement.RemoveAndExtractArguments("ContainsKey");`
`44`		`- var newStatement = GetNewExpression(expression, remove);`
	`44`	`+ var newExpression = GetNewExpression(expression, remove);`
`45`	`45`
`46`		`- return GetNewExpression(newStatement, NodeReplacement.RenameAndPrependArguments("BeTrue", "ContainKey", remove.Arguments));`
	`46`	`+ return GetNewExpression(newExpression, NodeReplacement.RenameAndPrependArguments("BeTrue", "ContainKey", remove.Arguments));`
`47`	`47`	`}`
`48`	`48`	`}`
`49`	`49`	`}`