Merge pull request #16027 from CyrusNajmabadi/coalesceFormatting

Format the coalesce expression we produce.

Fixes #16025

src/EditorFeatures/CSharpTest/UseCoalesceExpression/UseCoalesceExpressionTests.cs

@@ -310,5 +310,34 @@ void M(string x, string y, string z)
     }
 }");
         }
+
+        [WorkItem(16025, "https://github.com/dotnet/roslyn/issues/16025")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseCoalesceExpression)]
+        public async Task TestTrivia1()
+        {
+            await TestAsync(
+@"using System;
+
+class Program
+{
+    public Program()
+    {
+        string x = "";
+
+        string y = [|x|] == null ? string.Empty : x;
+    }
+}",
+@"using System;
+
+class Program
+{
+    public Program()
+    {
+        string x = "";
+
+        string y = x ?? string.Empty;
+    }
+}", compareTokens: false);
+        }
     }
 }
\ No newline at end of file

src/Features/Core/Portable/UseCoalesceExpression/UseCoalesceExpressionCodeFixProvider.cs

@@ -10,6 +10,7 @@
 using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Editing;
+using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Roslyn.Utilities;
@@ -38,32 +39,51 @@ public override Task RegisterCodeFixesAsync(CodeFixContext context)
             SyntaxEditor editor, CancellationToken cancellationToken)
         {
             var syntaxFacts = document.GetLanguageService<ISyntaxFactsService>();
-            var generator = editor.Generator;
-            var root = editor.OriginalRoot;
 
             foreach (var diagnostic in diagnostics)
             {
-                var conditionalExpression = root.FindNode(diagnostic.AdditionalLocations[0].SourceSpan, getInnermostNodeForTie: true);
-                var conditionalPartHigh = root.FindNode(diagnostic.AdditionalLocations[1].SourceSpan);
-                var whenPart = root.FindNode(diagnostic.AdditionalLocations[2].SourceSpan);
-                syntaxFacts.GetPartsOfConditionalExpression(
-                    conditionalExpression, out var condition, out var whenTrue, out var whenFalse);
-
-                var conditionalPartLow = syntaxFacts.WalkDownParentheses(conditionalPartHigh);
-                editor.ReplaceNode(conditionalExpression,
-                    (c, g) => {
-                        syntaxFacts.GetPartsOfConditionalExpression(
-                            c, out var currentCondition, out var currentWhenTrue, out var currentWhenFalse);
-
-                        return whenPart == whenTrue
-                            ? g.CoalesceExpression(conditionalPartLow, syntaxFacts.WalkDownParentheses(currentWhenTrue))
-                            : g.CoalesceExpression(conditionalPartLow, syntaxFacts.WalkDownParentheses(currentWhenFalse));
-                    });
+                cancellationToken.ThrowIfCancellationRequested();
+                ApplyEdit(editor, syntaxFacts, diagnostic);
             }
 
             return SpecializedTasks.EmptyTask;
         }
 
+        private static void ApplyEdit(SyntaxEditor editor, ISyntaxFactsService syntaxFacts, Diagnostic diagnostic)
+        {
+            var root = editor.OriginalRoot;
+            var conditionalExpression = root.FindNode(diagnostic.AdditionalLocations[0].SourceSpan, getInnermostNodeForTie: true);
+            var conditionalPartHigh = root.FindNode(diagnostic.AdditionalLocations[1].SourceSpan);
+            var whenPart = root.FindNode(diagnostic.AdditionalLocations[2].SourceSpan);
+            syntaxFacts.GetPartsOfConditionalExpression(
+                conditionalExpression, out var condition, out var whenTrue, out var whenFalse);
+
+            var conditionalPartLow = syntaxFacts.WalkDownParentheses(conditionalPartHigh);
+            editor.ReplaceNode(conditionalExpression,
+                (c, g) =>
+                {
+                    syntaxFacts.GetPartsOfConditionalExpression(
+                        c, out var currentCondition, out var currentWhenTrue, out var currentWhenFalse);
+
+                    var coalesceExpression = GetCoalesceExpression(
+                        syntaxFacts, g, whenPart, whenTrue, conditionalPartLow, 
+                        currentWhenTrue, currentWhenFalse);
+
+                    return coalesceExpression.WithAdditionalAnnotations(Formatter.Annotation);
+                });
+        }
+
+        private static SyntaxNode GetCoalesceExpression(
+            ISyntaxFactsService syntaxFacts, SyntaxGenerator generator, 
+            SyntaxNode whenPart, SyntaxNode whenTrue, 
+            SyntaxNode conditionalPartLow, 
+            SyntaxNode currentWhenTrue, SyntaxNode currentWhenFalse)
+        {
+            return whenPart == whenTrue
+                ? generator.CoalesceExpression(conditionalPartLow, syntaxFacts.WalkDownParentheses(currentWhenTrue))
+                : generator.CoalesceExpression(conditionalPartLow, syntaxFacts.WalkDownParentheses(currentWhenFalse));
+        }
+
         private class MyCodeAction : CodeAction.DocumentChangeAction
         {
             public MyCodeAction(Func<CancellationToken, Task<Document>> createChangedDocument)