Transfer leading trivia in ChangeSignature

src/EditorFeatures/CSharpTest/ChangeSignature/ChangeSignature_Delegates.cs

@@ -535,7 +535,7 @@ void M()
 /// <summary>
 /// This is <see cref=""MyDelegate""/>, which has these methods:
 ///     <see cref=""MyDelegate.MyDelegate(object, IntPtr)""/>
-///     <see cref=""MyDelegate.Invoke( bool, string)""/>
+///     <see cref=""MyDelegate.Invoke(bool, string)""/>
 ///     <see cref=""MyDelegate.EndInvoke(IAsyncResult)""/>
 ///     <see cref=""MyDelegate.BeginInvoke(int, string, bool, AsyncCallback, object)""/>
 /// </summary>

src/EditorFeatures/CSharpTest/ChangeSignature/ChangeSignature_Formatting.cs

@@ -41,6 +41,72 @@ class C
             await TestChangeSignatureViaCommandAsync(LanguageNames.CSharp, markup, updatedSignature: updatedSignature, expectedUpdatedInvocationDocumentCode: expectedUpdatedCode);
         }
 
+        [WpfFact, Trait(Traits.Feature, Traits.Features.ChangeSignature)]
+        [WorkItem(28156, "https://github.com/dotnet/roslyn/issues/28156")]
+        public async Task ChangeSignature_Formatting_KeepTrivia()
+        {
+            var markup = @"
+class C
+{
+    void $$Method(
+        int a, int b, int c,
+        int d, int e,
+        int f)
+    {
+        Method(
+            1, 2, 3,
+            4, 5, 6);
+    }
+}";
+            var updatedSignature = new[] { 1, 2, 3, 4, 5 };
+            var expectedUpdatedCode = @"
+class C
+{
+    void Method(
+        int b, int c, int d,
+        int e, int f)
+    {
+        Method(
+            2, 3, 4,
+            5, 6);
+    }
+}";
+            await TestChangeSignatureViaCommandAsync(LanguageNames.CSharp, markup, updatedSignature: updatedSignature, expectedUpdatedInvocationDocumentCode: expectedUpdatedCode);
+        }
+
+        [WpfFact, Trait(Traits.Feature, Traits.Features.ChangeSignature)]
+        [WorkItem(28156, "https://github.com/dotnet/roslyn/issues/28156")]
+        public async Task ChangeSignature_Formatting_KeepTrivia_WithArgumentNames()
+        {
+            var markup = @"
+class C
+{
+    void $$Method(
+        int a, int b, int c,
+        int d, int e,
+        int f)
+    {
+        Method(
+            a: 1, b: 2, c: 3,
+            d: 4, e: 5, f: 6);
+    }
+}";
+            var updatedSignature = new[] { 1, 2, 3, 4, 5 };
+            var expectedUpdatedCode = @"
+class C
+{
+    void Method(
+        int b, int c, int d,
+        int e, int f)
+    {
+        Method(
+            b: 2, c: 3, d: 4,
+            e: 5, f: 6);
+    }
+}";
+            await TestChangeSignatureViaCommandAsync(LanguageNames.CSharp, markup, updatedSignature: updatedSignature, expectedUpdatedInvocationDocumentCode: expectedUpdatedCode);
+        }
+
         [WpfFact, Trait(Traits.Feature, Traits.Features.ChangeSignature)]
         public async Task ChangeSignature_Formatting_Method()
         {
@@ -258,6 +324,28 @@ class CustomAttribute : System.Attribute
             await TestChangeSignatureViaCommandAsync(LanguageNames.CSharp, markup, updatedSignature: updatedSignature, expectedUpdatedInvocationDocumentCode: expectedUpdatedCode);
         }
 
+        [WpfFact, Trait(Traits.Feature, Traits.Features.ChangeSignature)]
+        [WorkItem(28156, "https://github.com/dotnet/roslyn/issues/28156")]
+        public async Task ChangeSignature_Formatting_Attribute_KeepTrivia()
+        {
+            var markup = @"
+[Custom(
+    1, 2)]
+class CustomAttribute : System.Attribute
+{
+    public $$CustomAttribute(int x, int y) { }
+}";
+            var updatedSignature = new[] { 1 };
+            var expectedUpdatedCode = @"
+[Custom(
+    2)]
+class CustomAttribute : System.Attribute
+{
+    public CustomAttribute(int y) { }
+}";
+            await TestChangeSignatureViaCommandAsync(LanguageNames.CSharp, markup, updatedSignature: updatedSignature, expectedUpdatedInvocationDocumentCode: expectedUpdatedCode);
+        }
+
         [WorkItem(946220, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/946220")]
         [WpfFact, Trait(Traits.Feature, Traits.Features.ChangeSignature)]
         public async Task ChangeSignature_Formatting_LambdaAsArgument()

src/EditorFeatures/CSharpTest/ChangeSignature/ReorderParametersTests.cs

@@ -803,7 +803,7 @@ class C
 class C
 {
     /// <summary>
-    /// See <see cref=""M( string,int)""/> and <see cref=""M""/>
+    /// See <see cref=""M(string, int)""/> and <see cref=""M""/>
     /// </summary>
     void M(string y, int x)
     { }

src/Features/CSharp/Portable/ChangeSignature/CSharpChangeSignatureService.cs

@@ -406,17 +406,39 @@ private SyntaxNode GetNodeContainingTargetNode(SyntaxNode matchingNode)
             var reorderedParameters = updatedSignature.UpdatedConfiguration.ToListOfParameters();
 
             var newParameters = new List<T>();
+            int index = 0;
             foreach (var newParam in reorderedParameters)
             {
                 var pos = originalParameters.IndexOf(newParam);
                 var param = list[pos];
+
+                // copy whitespace trivia from original position
+                param = TransferLeadingWhitespaceTrivia(param, list[index]);
+
                 newParameters.Add(param);
+                index++;
             }
 
             var numSeparatorsToSkip = originalParameters.Count - reorderedParameters.Count;
             return SyntaxFactory.SeparatedList(newParameters, GetSeparators(list, numSeparatorsToSkip));
         }
 
+        private static T TransferLeadingWhitespaceTrivia<T>(T newArgument, SyntaxNode oldArgument) where T : SyntaxNode
+        {
+            var oldTrivia = oldArgument.GetLeadingTrivia();
+            var oldOnlyHasWhitespaceTrivia = oldTrivia.All(t => t.IsKind(SyntaxKind.WhitespaceTrivia));
+
+            var newTrivia = newArgument.GetLeadingTrivia();
+            var newOnlyHasWhitespaceTrivia = newTrivia.All(t => t.IsKind(SyntaxKind.WhitespaceTrivia));
+
+            if (oldOnlyHasWhitespaceTrivia && newOnlyHasWhitespaceTrivia)
+            {
+                return newArgument.WithLeadingTrivia(oldTrivia);
+            }
+
+            return newArgument;
+        }
+
         private static SeparatedSyntaxList<AttributeArgumentSyntax> PermuteAttributeArgumentList(
             Document document,
             ISymbol declarationSymbol,
@@ -425,7 +447,11 @@ private SyntaxNode GetNodeContainingTargetNode(SyntaxNode matchingNode)
         {
             var newArguments = PermuteArguments(document, declarationSymbol, arguments.Select(a => UnifiedArgumentSyntax.Create(a)).ToList(), updatedSignature);
             var numSeparatorsToSkip = arguments.Count - newArguments.Count;
-            return SyntaxFactory.SeparatedList(newArguments.Select(a => (AttributeArgumentSyntax)(UnifiedArgumentSyntax)a), GetSeparators(arguments, numSeparatorsToSkip));
+
+            // copy whitespace trivia from original position
+            var newArgumentsWithTrivia = TransferLeadingWhitespaceTrivia(newArguments.Select(a => (AttributeArgumentSyntax)(UnifiedArgumentSyntax)a), arguments);
+
+            return SyntaxFactory.SeparatedList(newArgumentsWithTrivia, GetSeparators(arguments, numSeparatorsToSkip));
         }
 
         private static SeparatedSyntaxList<ArgumentSyntax> PermuteArgumentList(
@@ -436,8 +462,26 @@ private SyntaxNode GetNodeContainingTargetNode(SyntaxNode matchingNode)
             bool isReducedExtensionMethod = false)
         {
             var newArguments = PermuteArguments(document, declarationSymbol, arguments.Select(a => UnifiedArgumentSyntax.Create(a)).ToList(), updatedSignature, isReducedExtensionMethod);
+
+            var newArgumentsWithTrivia = TransferLeadingWhitespaceTrivia(newArguments.Select(a => (ArgumentSyntax)(UnifiedArgumentSyntax)a), arguments); // copy whitespace trivia from original position
+
             var numSeparatorsToSkip = arguments.Count - newArguments.Count;
-            return SyntaxFactory.SeparatedList(newArguments.Select(a => (ArgumentSyntax)(UnifiedArgumentSyntax)a), GetSeparators(arguments, numSeparatorsToSkip));
+            return SyntaxFactory.SeparatedList(newArgumentsWithTrivia, GetSeparators(arguments, numSeparatorsToSkip));
+        }
+
+        private static List<T> TransferLeadingWhitespaceTrivia<T, U>(IEnumerable<T> newArguments, SeparatedSyntaxList<U> oldArguments)
+            where T : SyntaxNode
+            where U : SyntaxNode
+        {
+            var result = new List<T>();
+            int index = 0;
+            foreach (var newArgument in newArguments)
+            {
+                result.Add(TransferLeadingWhitespaceTrivia(newArgument, oldArguments[index]));
+                index++;
+            }
+
+            return result;
         }
 
         private List<SyntaxTrivia> UpdateParamTagsInLeadingTrivia(CSharpSyntaxNode node, ISymbol declarationSymbol, SignatureChange updatedSignature)