Fixed issue code-cracker#537 by creating multiple variable declaratio…

…ns rather than a single declaration.

src/CSharp/CodeCracker/Style/AlwaysUseVarCodeFixProvider.cs

@@ -1,4 +1,5 @@
-using Microsoft.CodeAnalysis;
+using System.Collections.Generic;
+using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.CSharp;
@@ -30,15 +31,49 @@ public sealed override Task RegisterCodeFixesAsync(CodeFixContext context)
         private async static Task<Document> UseVarAsync(Document document, Diagnostic diagnostic, CancellationToken cancellationToken)
         {
             var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+
             var diagnosticSpan = diagnostic.Location.SourceSpan;
             var localDeclaration = root.FindToken(diagnosticSpan.Start).Parent.AncestorsAndSelf().OfType<LocalDeclarationStatementSyntax>().First();
-            var variableDeclaration = localDeclaration.ChildNodes()
-                .OfType<VariableDeclarationSyntax>()
-                .FirstOrDefault();
-            var @var = SyntaxFactory.IdentifierName("var")
-                .WithLeadingTrivia(variableDeclaration.Type.GetLeadingTrivia())
-                .WithTrailingTrivia(variableDeclaration.Type.GetTrailingTrivia());
-            var newRoot = root.ReplaceNode(variableDeclaration.Type, @var);
+            var variableDeclaration = localDeclaration.Declaration;
+            var numVariables = variableDeclaration.Variables.Count;
+
+            var newVariableDeclarations = new VariableDeclarationSyntax[numVariables];
+
+            var varSyntax = SyntaxFactory.IdentifierName("var");
+
+            //Create a new var declaration for each variable.
+            for (var i = 0; i < numVariables; i++)
+            {
+                var originalVariable = variableDeclaration.Variables[i];
+                var newLeadingTrivia = originalVariable.GetLeadingTrivia();
+
+                //Get the trivia from the separator as well
+                if (i != 0)
+                {
+                    newLeadingTrivia = newLeadingTrivia.InsertRange(0,
+                        variableDeclaration.Variables.GetSeparator(i-1).GetAllTrivia());
+                }
+
+                newVariableDeclarations[i] = SyntaxFactory.VariableDeclaration(varSyntax)
+                    .AddVariables(originalVariable.WithLeadingTrivia(newLeadingTrivia));
+            }
+
+            //ensure trivia for leading type node is preserved
+            var originalTypeSyntax = variableDeclaration.Type;
+            newVariableDeclarations[0] = newVariableDeclarations[0]
+                .WithType((TypeSyntax) varSyntax.WithSameTriviaAs(originalTypeSyntax));
+
+            var newLocalDeclarationStatements = newVariableDeclarations.Select(SyntaxFactory.LocalDeclarationStatement).ToList();
+
+
+            //Preserve the trivia for the entire statement at the start and at the end
+            newLocalDeclarationStatements[0] =
+                newLocalDeclarationStatements[0].WithLeadingTrivia(variableDeclaration.GetLeadingTrivia());
+            var lastIndex = numVariables -1;
+            newLocalDeclarationStatements[lastIndex] =
+                newLocalDeclarationStatements[lastIndex].WithTrailingTrivia(localDeclaration.GetTrailingTrivia());
+
+            var newRoot = root.ReplaceNode(localDeclaration, newLocalDeclarationStatements);
             var newDocument = document.WithSyntaxRoot(newRoot);
             return newDocument;
         }

test/CSharp/CodeCracker.Test/Style/AlwaysUseVarTests.cs

@@ -215,5 +215,83 @@ public void Foo()
     }";
             await VerifyCSharpFixAllAsync(new[] { source1, source2 }, new[] { fixtest1, fixtest2 });
         }
+
+
+        [Fact]
+        public async Task FixReplacesMultipleDeclarationWithMultipleVars()
+        {
+            const string test = @"
+    using System;
+
+    namespace ConsoleApplication1
+    {
+        class TypeName
+        {
+            public async Task Foo()
+            {
+                int a = 10, b = 12;
+            }
+        }
+    }";
+
+            const string expected = @"
+    using System;
+
+    namespace ConsoleApplication1
+    {
+        class TypeName
+        {
+            public async Task Foo()
+            {
+                var a = 10;
+                var b = 12;
+            }
+        }
+    }";
+            await VerifyCSharpFixAsync(test, expected);
+        }
+
+
+
+        [Fact]
+        public async Task FixPreservesTriviaSensibly()
+        {
+            const string test = @"
+    using System;
+
+    namespace ConsoleApplication1
+    {
+        class TypeName
+        {
+            public async Task Foo()
+            {
+                int a = 10; //Blue
+
+                /*variables for use*/ string /*desc of b*/b = /* why not*/ ""12"", /*Formatter does this My next variable*/ c /* is quite nice and it */ = ""23"";
+            }
+        }
+    }";
+
+            const string expected = @"
+    using System;
+
+    namespace ConsoleApplication1
+    {
+        class TypeName
+        {
+            public async Task Foo()
+            {
+                var a = 10; //Blue
+
+                /*variables for use*/ var /*desc of b*/b = /* why not*/ ""12"";
+                var 
+/*Formatter does this My next variable*/ c /* is quite nice and it */ = ""23"";
+            }
+        }
+    }";
+            await VerifyCSharpFixAllAsync(test, expected);
+        }
     }
-}
+}
+
+