first draft

Author: Meir017

src/FluentAssertions.BestPractices.Tests/Tips/CollectionTests.cs

@@ -11,6 +11,8 @@ public static class DiagnosticProperties
             public const string UnexpectedItemString = nameof(UnexpectedItemString);
             public const string BecauseArgumentsString = nameof(BecauseArgumentsString);
             public const string ArgumentString = nameof(ArgumentString);
+
+            public const string VisitorName = nameof(VisitorName);
         }
 
         public static class Tips

src/FluentAssertions.BestPractices/Constants.cs

@@ -2,7 +2,6 @@
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using System.Collections.Generic;
 using System.Collections.Immutable;
-using Microsoft.CodeAnalysis;
 
 namespace FluentAssertions.BestPractices
 {
@@ -29,7 +28,8 @@ protected FluentAssertionsCSharpSyntaxVisitor(params string[] requiredMethods)
 
         public virtual ImmutableDictionary<string, string> ToDiagnosticProperties() => new Dictionary<string, string>
         {
-            [Constants.DiagnosticProperties.VariableName] = VariableName
+            [Constants.DiagnosticProperties.VariableName] = VariableName,
+            [Constants.DiagnosticProperties.VisitorName] = GetType().Name
         }.ToImmutableDictionary();
 
         public override void VisitInvocationExpression(InvocationExpressionSyntax node)

src/FluentAssertions.BestPractices/Utilities/FluentAssertionsCSharpSyntaxVisitor.cs

@@ -1,7 +1,9 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
 using System.Threading;
@@ -33,15 +35,57 @@ protected async Task<Document> RewriteAssertion(Document document, ExpressionSta
         {
             var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
 
-            var newStatement = GetNewStatement(statement, new FluentAssertionsDiagnosticProperties(properties)).WithTriviaFrom(statement);
+            var newStatement = GetNewStatement(statement, new FluentAssertionsDiagnosticProperties(properties));
 
             root = root.ReplaceNode(statement, newStatement);
 
             return document.WithSyntaxRoot(root);
         }
 
+        protected virtual StatementSyntax GetNewStatement(FluentAssertionsDiagnosticProperties properties) => throw new System.NotImplementedException();
         protected virtual StatementSyntax GetNewStatement(ExpressionStatementSyntax statement, FluentAssertionsDiagnosticProperties properties) => GetNewStatement(properties);
 
-        protected abstract StatementSyntax GetNewStatement(FluentAssertionsDiagnosticProperties properties);
+        protected ExpressionStatementSyntax GetNewStatement(ExpressionStatementSyntax statement, params NodeReplacement[] replacements)
+        {
+            var newStatement = statement;
+            void UpdateRoot(NodeReplacement replacement)
+            {
+                var visitor = new MemberAccessExpressionsCSharpSyntaxVisitor();
+                newStatement.Accept(visitor);
+                var members = new LinkedList<MemberAccessExpressionSyntax>(visitor.Members);
+
+                var current = members.Last;
+                while (current != null)
+                {
+                    if (replacement.IsValidNode(current.Value))
+                    {
+                        newStatement = newStatement.ReplaceNode(replacement.ComputeOld(current), replacement.ComputeNew(current));
+                        return;
+                    }
+                    current = current.Previous;
+                }
+            }
+
+            foreach (var replacement in replacements)
+            {
+                UpdateRoot(replacement);
+            }
+            return newStatement;
+        }
+
+        private class MemberAccessExpressionsCSharpSyntaxVisitor : CSharpSyntaxVisitor
+        {
+            public List<MemberAccessExpressionSyntax> Members { get; } = new List<MemberAccessExpressionSyntax>();
+
+            public override void VisitInvocationExpression(InvocationExpressionSyntax node) => Visit(node.Expression);
+
+            public sealed override void VisitExpressionStatement(ExpressionStatementSyntax node) => Visit(node.Expression);
+
+            public sealed override void VisitMemberAccessExpression(MemberAccessExpressionSyntax node)
+            {
+                Members.Add(node);
+                Visit(node.Expression);
+            }
+        }
     }
 }

src/FluentAssertions.BestPractices/Utilities/FluentAssertionsCodeFixProvider.cs

@@ -20,6 +20,8 @@ public FluentAssertionsDiagnosticProperties(ImmutableDictionary<string, string>
         public string UnexpectedItemString => GetPropertyOrDefault(Constants.DiagnosticProperties.UnexpectedItemString);
         public string ArgumentString => GetPropertyOrDefault(Constants.DiagnosticProperties.ArgumentString);
 
+        public string VisitorName => GetPropertyOrDefault(Constants.DiagnosticProperties.VisitorName);
+
         public string CombineWithBecauseArgumentsString(string validArgument)
         {
             if (!string.IsNullOrWhiteSpace(BecauseArgumentsString) && !string.IsNullOrWhiteSpace(validArgument))

src/FluentAssertions.BestPractices/Utilities/FluentAssertionsDiagnosticProperties.cs

@@ -0,0 +1,56 @@
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using System.Collections.Generic;
+
+namespace FluentAssertions.BestPractices
+{
+    public abstract class NodeReplacement
+    {
+        public abstract bool IsValidNode(MemberAccessExpressionSyntax node);
+        public abstract SyntaxNode ComputeOld(LinkedListNode<MemberAccessExpressionSyntax> listNode);
+        public abstract SyntaxNode ComputeNew(LinkedListNode<MemberAccessExpressionSyntax> listNode);
+        public virtual void ExtractValues() { }
+
+        public class Rename : NodeReplacement
+        {
+            private readonly string _oldName;
+            private readonly string _newName;
+
+            public Rename(string oldName, string newName)
+            {
+                _oldName = oldName;
+                _newName = newName;
+            }
+
+            public sealed override bool IsValidNode(MemberAccessExpressionSyntax node) => node.Name.Identifier.Text == _oldName;
+            public sealed override SyntaxNode ComputeOld(LinkedListNode<MemberAccessExpressionSyntax> listNode) => listNode.Value;
+            public override SyntaxNode ComputeNew(LinkedListNode<MemberAccessExpressionSyntax> listNode) => listNode.Value.WithName(SyntaxFactory.IdentifierName(_newName));
+        }
+
+        public class Remove : NodeReplacement
+        {
+            private readonly string _name;
+
+            public Remove(string name)
+            {
+                _name = name;
+            }
+
+            public sealed override bool IsValidNode(MemberAccessExpressionSyntax node) => node.Name.Identifier.Text == _name;
+            public sealed override SyntaxNode ComputeOld(LinkedListNode<MemberAccessExpressionSyntax> listNode) => listNode.Previous.Value;
+            public sealed override SyntaxNode ComputeNew(LinkedListNode<MemberAccessExpressionSyntax> listNode)
+            {
+                var previous = listNode.Previous.Value;
+                var next = listNode.Next?.Value ?? listNode.Value.Expression;
+
+                if (next.Parent is InvocationExpressionSyntax invocation)
+                {
+                    return previous.WithExpression(invocation);
+                }
+
+                return previous.WithExpression(next);
+            }
+        }
+    }
+}