Implement CodeFix for CA2246

src/NetAnalyzers/CSharp/AnalyzerReleases.Unshipped.md

@@ -1 +1,5 @@
 ; Please do not edit this file manually, it should only be updated through code fix application.
+### New Rules
+Rule ID | Category | Severity | Notes
+--------|----------|----------|-------
+CA2246 | Usage | Info | CSharpAssigningSymbolAndItsMemberInSameStatement, [Documentation](https://docs.microsoft.com/visualstudio/code-quality/ca2246)

src/NetAnalyzers/CSharp/Microsoft.CodeQuality.Analyzers/QualityGuidelines/CSharpAssigningSymbolAndItsMemberInSameStatement.Fixer.cs

@@ -0,0 +1,123 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Composition;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Analyzer.Utilities;
+using Analyzer.Utilities.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeQuality.Analyzers;
+
+namespace Microsoft.CodeQuality.CSharp.Analyzers.QualityGuidelines
+{
+    [ExportCodeFixProvider(LanguageNames.CSharp, Name = CSharpAssigningSymbolAndItsMemberInSameStatement.RuleId), Shared]
+    public sealed class AssigningSymbolAndItsMemberInSameStatementFixer : CodeFixProvider
+    {
+        public override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(CSharpAssigningSymbolAndItsMemberInSameStatement.RuleId);
+
+        public override async Task RegisterCodeFixesAsync(CodeFixContext context)
+        {
+            // For something like `a.x = a = b;`, we offer 3 code fixes:
+            // First:
+            //     a = b;
+            //     a.x = b;
+            // Second:
+            //     a = b;
+            //     a.x = a;
+            // Third: (Not currently implemented)
+            //     var temp = a;
+            //     a = b;
+            //     temp.x = b;
+
+            var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
+            if (root.FindNode(context.Span).Parent is not AssignmentExpressionSyntax assignment)
+            {
+                return;
+            }
+
+            var members = GetAssignmentMembers(assignment);
+            if (members.Count < 3)
+            {
+                return;
+            }
+
+            var mostRightMember = members.Peek(); // Don't move this near its usage. The result will be different.
+            var leadingTrivia = assignment.Parent.GetLeadingTrivia();
+            var trailingTrivia = assignment.Parent.GetTrailingTrivia();
+            var replacements = new List<SyntaxNode>(members.Count - 1);
+
+            while (members.Count > 2)
+            {
+                replacements.Add(GetAssignmentExpressionStatement(members, leadingTrivia, trailingTrivia));
+                // For the first statement, take all trivia.
+                // For following statements, take only whitespace trivia.
+                trailingTrivia = trailingTrivia.Where(t => t.IsKind(SyntaxKind.WhitespaceTrivia)).ToSyntaxTriviaList();
+            }
+
+            var title = MicrosoftCodeQualityAnalyzersResources.AssigningSymbolAndItsMemberInSameStatementTitle;
+
+            var replacements1 = replacements.Concat(GetAssignmentExpressionStatement(assignment.Left, mostRightMember, leadingTrivia, trailingTrivia));
+            var replacements2 = replacements.Concat(GetAssignmentExpressionStatement(members, leadingTrivia, trailingTrivia));
+
+#pragma warning disable RS1010 // Provide an explicit value for EquivalenceKey - false positve 
+            var nestedCodeAction = CodeAction.Create(title, ImmutableArray.Create<CodeAction>(
+                new MyCodeAction($"{title} 1", ct => GetDocument(context.Document, root, assignment.Parent, replacements1)),
+                new MyCodeAction($"{title} 2", ct => GetDocument(context.Document, root, assignment.Parent, replacements2))
+                ), isInlinable: false);
+#pragma warning restore RS1010
+
+            context.RegisterCodeFix(nestedCodeAction, context.Diagnostics);
+        }
+
+        /// <summary>
+        /// If the assignment expression is:  a = b = c = d
+        /// Return a stack containing a, b, c, d with `a` at the bottom and `d` at the top.
+        /// </summary>
+        private static Stack<ExpressionSyntax> GetAssignmentMembers(AssignmentExpressionSyntax node)
+        {
+            var stack = new Stack<ExpressionSyntax>();
+            ExpressionSyntax current = node;
+            while (current is AssignmentExpressionSyntax assignment)
+            {
+                stack.Push(assignment.Left);
+                current = assignment.Right;
+            }
+            stack.Push(current);
+            return stack;
+        }
+
+        private static ExpressionStatementSyntax GetAssignmentExpressionStatement(Stack<ExpressionSyntax> stack, SyntaxTriviaList leadingTrivia, SyntaxTriviaList trailingTrivia)
+        {
+            var right = stack.Pop();
+            var left = stack.Peek();
+            return GetAssignmentExpressionStatement(left, right, leadingTrivia, trailingTrivia);
+        }
+
+        private static ExpressionStatementSyntax GetAssignmentExpressionStatement(ExpressionSyntax left, ExpressionSyntax right, SyntaxTriviaList leadingTrivia, SyntaxTriviaList trailingTrivia)
+            => SyntaxFactory.ExpressionStatement(
+                SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, left, right))
+                    .WithLeadingTrivia(leadingTrivia).WithTrailingTrivia(trailingTrivia);
+
+        private static Task<Document> GetDocument(Document document, SyntaxNode root, SyntaxNode oldNode, IEnumerable<SyntaxNode> replacements)
+            => Task.FromResult(document.WithSyntaxRoot(root.ReplaceNode(oldNode, replacements)));
+
+        public override FixAllProvider GetFixAllProvider()
+            => WellKnownFixAllProviders.BatchFixer;
+
+        private class MyCodeAction : DocumentChangeAction
+        {
+            public MyCodeAction(string title, Func<CancellationToken, Task<Document>> createChangedDocument)
+                : base(title, createChangedDocument, title)
+            {
+            }
+        }
+    }
+}

src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/QualityGuidelines/AssigningSymbolAndItsMemberInSameStatement.cs → src/NetAnalyzers/CSharp/Microsoft.CodeQuality.Analyzers/QualityGuidelines/CSharpAssigningSymbolAndItsMemberInSameStatement.cs

@@ -7,14 +7,15 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Operations;
+using Microsoft.CodeQuality.Analyzers;
 
-namespace Microsoft.CodeQuality.Analyzers.QualityGuidelines
+namespace Microsoft.CodeQuality.CSharp.Analyzers.QualityGuidelines
 {
     /// <summary>
     /// CA2246: Prevent objects from being referenced in statements where they are reassigned
     /// </summary>
     [DiagnosticAnalyzer(LanguageNames.CSharp)]
-    public sealed class AssigningSymbolAndItsMemberInSameStatement : DiagnosticAnalyzer
+    public sealed class CSharpAssigningSymbolAndItsMemberInSameStatement : DiagnosticAnalyzer
     {
         internal const string RuleId = "CA2246";