Fixed a newline case.

Author: jaredpar

src/Microsoft.DotNet.CodeFormatting.Tests/Rules/NewLineAboveRuleTests.cs

@@ -74,6 +74,46 @@ public void UsingWithOnlyBlankAbove()
             Verify(text, text);
         }
 
+        [Fact]
+        public void StandardCombination()
+        {
+            var text = @"// copyright
+using System;
+using System.Collections;
+namespace NS1
+{
+
+}";
+
+            var expected = @"// copyright
+
+using System;
+using System.Collections;
+
+namespace NS1
+{
+
+}";
+
+            Verify(text, expected);
+        }
+
+        [Fact]
+        public void StandardCombinationNoWork()
+        {
+            var text = @"// copyright
+
+using System;
+using System.Collections;
+
+namespace NS1
+{
+
+}";
+
+            Verify(text, text);
+        }
+
         [Fact]
         public void TestNewLineBeforeFirstUsing01()
         {

src/Microsoft.DotNet.CodeFormatting/Rules/NewLineAboveRule.cs

@@ -47,7 +47,25 @@ private SyntaxNode ProcessNamespace(SyntaxNode syntaxRoot)
                 return syntaxRoot;
             }
 
-            return ProcessCore(syntaxRoot, firstNamespace);
+            var list = firstNamespace.GetLeadingTrivia();
+            if (list.Count == 0)
+            {
+                var newLine = SyntaxUtil.GetBestNewLineTrivia(firstNamespace);
+                list = list.Add(newLine);
+                return syntaxRoot.ReplaceNode(firstNamespace, firstNamespace.WithLeadingTrivia(list));
+            }
+            else if (list.Count == 1 && list[0].IsKind(SyntaxKind.EndOfLineTrivia))
+            {
+                // The namespace node is typically preceeded by a using node.  In thate case the trivia will
+                // be split between the two nodes.  If the namespace already has a newline leading trivia then
+                // there is at least a single blank between the nodes as the using will have a trailing new
+                // line as well (in case of a single on it will be on the using).  
+                return syntaxRoot;
+            }
+            else
+            {
+                return ProcessCore(syntaxRoot, firstNamespace);
+            }
         }
 
         private SyntaxNode ProcessCore<TNode>(SyntaxNode syntaxRoot, TNode node) where TNode: SyntaxNode