Merge pull request #2050 from vweijsters/implement-1787

Implement 1787

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/LayoutRules/SA1516CodeFixProvider.cs

@@ -39,16 +39,44 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
 
             foreach (Diagnostic diagnostic in context.Diagnostics)
             {
+                var insertBlankLine = DetermineCodeFixAction(diagnostic);
+                if (insertBlankLine == null)
+                {
+                    continue;
+                }
+
                 context.RegisterCodeFix(
                     CodeAction.Create(
-                        LayoutResources.SA1516CodeFix,
-                        cancellationToken => GetTransformedDocumentAsync(context.Document, syntaxRoot, diagnostic, context.CancellationToken),
+                        insertBlankLine.Value ? LayoutResources.SA1516CodeFixInsert : LayoutResources.SA1516CodeFixRemove,
+                        cancellationToken => GetTransformedDocumentAsync(context.Document, syntaxRoot, diagnostic, insertBlankLine.Value, context.CancellationToken),
                         nameof(SA1516CodeFixProvider)),
                     diagnostic);
             }
         }
 
-        private static Task<Document> GetTransformedDocumentAsync(Document document, SyntaxNode syntaxRoot, Diagnostic diagnostic, CancellationToken cancellationToken)
+        private static bool? DetermineCodeFixAction(Diagnostic diagnostic)
+        {
+            string codeFixAction;
+
+            if (!diagnostic.Properties.TryGetValue(SA1516ElementsMustBeSeparatedByBlankLine.CodeFixActionKey, out codeFixAction))
+            {
+                return null;
+            }
+
+            switch (codeFixAction)
+            {
+            case SA1516ElementsMustBeSeparatedByBlankLine.InsertBlankLineValue:
+                return true;
+
+            case SA1516ElementsMustBeSeparatedByBlankLine.RemoveBlankLinesValue:
+                return false;
+
+            default:
+                return null;
+            }
+        }
+
+        private static Task<Document> GetTransformedDocumentAsync(Document document, SyntaxNode syntaxRoot, Diagnostic diagnostic, bool insertBlankLine, CancellationToken cancellationToken)
         {
             var node = syntaxRoot.FindNode(diagnostic.Location.SourceSpan, getInnermostNodeForTie: true);
             node = GetRelevantNode(node);
@@ -58,18 +86,32 @@ private static Task<Document> GetTransformedDocumentAsync(Document document, Syn
                 return Task.FromResult(document);
             }
 
-            var leadingTrivia = node.GetLeadingTrivia();
-
-            var newTriviaList = leadingTrivia;
-            newTriviaList = newTriviaList.Insert(0, SyntaxFactory.CarriageReturnLineFeed);
-
-            var newNode = node.WithLeadingTrivia(newTriviaList);
-            var newSyntaxRoot = syntaxRoot.ReplaceNode(node, newNode);
+            // Using the token replacement here to use the same strategy as the FixAll.
+            var firstToken = node.GetFirstToken();
+            var newToken = ProcessToken(firstToken, insertBlankLine);
+            var newSyntaxRoot = syntaxRoot.ReplaceToken(firstToken, newToken);
             var newDocument = document.WithSyntaxRoot(newSyntaxRoot);
 
             return Task.FromResult(newDocument);
         }
 
+        private static SyntaxToken ProcessToken(SyntaxToken token, bool insertBlankLine)
+        {
+            var leadingTrivia = token.LeadingTrivia;
+            SyntaxTriviaList newLeadingTrivia;
+
+            if (insertBlankLine)
+            {
+                newLeadingTrivia = leadingTrivia.Insert(0, SyntaxFactory.CarriageReturnLineFeed);
+            }
+            else
+            {
+                newLeadingTrivia = leadingTrivia.WithoutBlankLines();
+            }
+
+            return token.WithLeadingTrivia(newLeadingTrivia);
+        }
+
         private static SyntaxNode GetRelevantNode(SyntaxNode innerNode)
         {
             SyntaxNode currentNode = innerNode;
@@ -112,7 +154,7 @@ private class FixAll : DocumentBasedFixAllProvider
                 new FixAll();
 
             protected override string CodeActionTitle =>
-                LayoutResources.SA1516CodeFix;
+                LayoutResources.SA1516CodeFixAll;
 
             protected override async Task<SyntaxNode> FixAllInDocumentAsync(FixAllContext fixAllContext, Document document, ImmutableArray<Diagnostic> diagnostics)
             {
@@ -123,26 +165,29 @@ protected override async Task<SyntaxNode> FixAllInDocumentAsync(FixAllContext fi
 
                 var syntaxRoot = await document.GetSyntaxRootAsync().ConfigureAwait(false);
 
-                List<SyntaxNode> nodes = new List<SyntaxNode>();
+                // Using token replacement, because node replacement will do nothing when replacing child nodes from a replaced parent node.
+                Dictionary<SyntaxToken, SyntaxToken> replaceMap = new Dictionary<SyntaxToken, SyntaxToken>();
 
                 foreach (var diagnostic in diagnostics)
                 {
+                    var insertBlankLine = DetermineCodeFixAction(diagnostic);
+                    if (insertBlankLine == null)
+                    {
+                        continue;
+                    }
+
                     var node = syntaxRoot.FindNode(diagnostic.Location.SourceSpan, getInnermostNodeForTie: true);
                     node = GetRelevantNode(node);
 
                     if (node != null)
                     {
-                        nodes.Add(node);
+                        var firstToken = node.GetFirstToken();
+
+                        replaceMap[firstToken] = ProcessToken(firstToken, insertBlankLine.Value);
                     }
                 }
 
-                return syntaxRoot.ReplaceNodes(nodes, (oldNode, newNode) =>
-                {
-                    var newTriviaList = newNode.GetLeadingTrivia();
-                    newTriviaList = newTriviaList.Insert(0, SyntaxFactory.CarriageReturnLineFeed);
-
-                    return newNode.WithLeadingTrivia(newTriviaList);
-                });
+                return syntaxRoot.ReplaceTokens(replaceMap.Keys, (original, rewritten) => replaceMap[original]);
             }
         }
     }

StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/LayoutRules/SA1518CodeFixProvider.cs

@@ -53,13 +53,13 @@ public override Task RegisterCodeFixesAsync(CodeFixContext context)
         /// </summary>
         /// <param name="document">The document to be changed.</param>
         /// <param name="diagnostic">The diagnostic to fix.</param>
-        /// <param name="newlineAtEndOfFile">A <see cref="EndOfFileHandling"/> value indicating the desired behavior.</param>
+        /// <param name="newlineAtEndOfFile">A <see cref="OptionSetting"/> value indicating the desired behavior.</param>
         /// <param name="cancellationToken">The cancellation token associated with the fix action.</param>
         /// <returns>The transformed document.</returns>
-        private static async Task<Document> FixEndOfFileAsync(Document document, Diagnostic diagnostic, EndOfFileHandling newlineAtEndOfFile, CancellationToken cancellationToken)
+        private static async Task<Document> FixEndOfFileAsync(Document document, Diagnostic diagnostic, OptionSetting newlineAtEndOfFile, CancellationToken cancellationToken)
         {
             var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
-            string replacement = newlineAtEndOfFile == EndOfFileHandling.Omit ? string.Empty : "\r\n";
+            string replacement = newlineAtEndOfFile == OptionSetting.Omit ? string.Empty : "\r\n";
             return document.WithText(text.WithChanges(new TextChange(diagnostic.Location.SourceSpan, replacement)));
         }