Combined the brace rules

Combined the rules around open and close braces into a single rule.  The
logic here is extremely similar, makes sense to keep it in one place.

Also expanded upon the unit tests here to capture a couple of new
scenarios.

Author: jaredpar

src/Microsoft.DotNet.CodeFormatting.Tests/Microsoft.DotNet.CodeFormatting.Tests.csproj

@@ -105,13 +105,12 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="CodeFormattingTestBase.cs" />
+    <Compile Include="Rules\BracesRuleTests.cs" />
     <Compile Include="Rules\ExplicitThisRuleTests.cs" />
     <Compile Include="Rules\ExplicitVisibilityRuleTests.cs" />
     <Compile Include="Rules\HasNewLineBeforeFirstNamespaceFormattingRuleTests.cs" />
     <Compile Include="Rules\HasNoIllegalHeadersFormattingRuleTests.cs" />
     <Compile Include="Rules\HasNewLineBeforeFirstUsingFormattingRuleTests.cs" />
-    <Compile Include="Rules\HasNoNewLineAfterOpenBraceFormattingRuleTests.cs" />
-    <Compile Include="Rules\HasNoNewLineBeforeEndBraceFormattingRuleTests.cs" />
     <Compile Include="Rules\PrivateFieldNamingRuleTests.cs" />
     <Compile Include="Rules\NonAsciiCharactersAreEscapedInLiteralsRuleTests.cs" />
     <Compile Include="Rules\UsesXunitForTestsFormattingRuleTests.cs" />

src/Microsoft.DotNet.CodeFormatting.Tests/Rules/HasNoNewLineBeforeEndBraceFormattingRuleTests.cs renamed to src/Microsoft.DotNet.CodeFormatting.Tests/Rules/BracesRuleTests.cs

@@ -5,8 +5,13 @@
 
 namespace Microsoft.DotNet.CodeFormatting.Tests
 {
-    public class HasNoNewLineBeforeEndBraceFormattingRuleTests : CodeFormattingTestBase
+    public class BraceNewLineTests : CodeFormattingTestBase
     {
+        internal override IFormattingRule GetFormattingRule()
+        {
+            return new Rules.BraceNewLineRule();
+        }
+
         [Fact]
         public void TestNoNewLineBeforeEndBrace01()
         {
@@ -131,9 +136,140 @@ class S
             Verify(text, expected);
         }
 
-        internal override IFormattingRule GetFormattingRule()
+        [Fact]
+        public void TestRemoveNewLinesBetweenPragmaAndCloseBrace()
+        {
+            var text = @"
+class U
+{
+
+// some comment
+
+
+#pragma warning disable 1591
+
+}
+";
+            var expected = @"
+class U
+{
+    // some comment
+
+
+#pragma warning disable 1591
+}
+";
+
+            Verify(text, expected);
+        }
+
+        [Fact]
+        public void TestBracesWithJustCommentBody()
         {
-            return new Rules.HasNoNewLineBeforeEndBraceFormattingRule();
+            var text = @"
+class U
+{
+// some comment
+}
+";
+            var expected = @"
+class U
+{
+    // some comment
+}
+";
+
+            Verify(text, expected);
+        }
+
+        [Fact]
+        public void MethodWithSingleLine()
+        {
+            var text = @"
+class U
+{
+    void M()
+    {
+        N();
+    }
+}
+";
+            var expected = @"
+class U
+{
+    void M()
+    {
+        N();
+    }
+}
+";
+
+            Verify(text, expected);
+
+        }
+
+        [Fact]
+        public void NewLineBeforeCloseBraceOnClass()
+        {
+            var text = @"
+class C { 
+}
+";
+            var expected = @"
+class C
+{
+}
+";
+            Verify(text, expected);
+        }
+
+        [Fact]
+        public void TestNoNewLineAfterOpenBrace01()
+        {
+            var text = @"
+using System;
+class T
+{
+   
+}
+class K { }
+class S {
+
+}
+class R 
+{
+
+    // some comment
+}
+class U
+{
+
+#pragma warning disable 1591
+}
+class L {
+}";
+            var expected = @"
+using System;
+class T
+{
+}
+class K { }
+class S
+{
+}
+class R
+{
+    // some comment
+}
+class U
+{
+#pragma warning disable 1591
+}
+class L
+{
+}";
+
+            Verify(text, expected);
         }
     }
 }

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

@@ -81,13 +81,12 @@
     <Compile Include="RuleOrderAttribute.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="IOrderMetadata.cs" />
+    <Compile Include="Rules\BraceNewLineRule.cs" />
     <Compile Include="Rules\ExplicitVisibilityRule.cs" />
     <Compile Include="Rules\HasCopyrightHeaderFormattingRule.cs" />
     <Compile Include="Rules\HasNewLineBeforeFirstNamespaceFormattingRule.cs" />
     <Compile Include="Rules\HasNewLineBeforeFirstUsingFormattingRule.cs" />
     <Compile Include="Rules\HasNoIllegalHeadersFormattingRule.cs" />
-    <Compile Include="Rules\HasNoNewLineAfterOpenBraceFormattingRule.cs" />
-    <Compile Include="Rules\HasNoNewLineBeforeEndBraceFormattingRule.cs" />
     <Compile Include="Rules\HasNoCustomCopyrightHeaderFormattingRule.cs" />
     <Compile Include="Rules\PrivateFieldNamingRule.cs" />
     <Compile Include="Rules\HasUsingsOutsideOfNamespaceFormattingRule.cs" />

src/Microsoft.DotNet.CodeFormatting/Microsoft.DotNet.CodeFormatting.csproj

@@ -1,28 +1,62 @@
 // Copyright (c) Microsoft. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
 using System;
 using System.Collections.Generic;
-using System.ComponentModel.Composition;
 using System.Linq;
+using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-
 namespace Microsoft.DotNet.CodeFormatting.Rules
 {
-    [RuleOrder(RuleOrder.HasNoNewLineBeforeEndBraceFormattingRule)]
-    internal sealed class HasNoNewLineBeforeEndBraceFormattingRule : IFormattingRule
+    [RuleOrder(RuleOrder.BraceNewLineRule)]
+    internal sealed class BraceNewLineRule : IFormattingRule
     {
         public async Task<Document> ProcessAsync(Document document, CancellationToken cancellationToken)
         {
-            var syntaxRoot = await document.GetSyntaxRootAsync(cancellationToken) as CSharpSyntaxNode;
-            if (syntaxRoot == null)
+            var syntaxNode = await document.GetSyntaxRootAsync(cancellationToken);
+            if (syntaxNode == null)
+            {
                 return document;
+            }
+
+            syntaxNode = FixOpenBraces(syntaxNode);
+            syntaxNode = FixCloseBraces(syntaxNode);
+            return document.WithSyntaxRoot(syntaxNode);
+        }
 
-            var closeBraceTokens = syntaxRoot.DescendantTokens().Where((token) => token.CSharpKind() == SyntaxKind.CloseBraceToken);
+        private static SyntaxNode FixOpenBraces(SyntaxNode syntaxNode)
+        {
+            var openBraceTokens = syntaxNode.DescendantTokens().Where((token) => token.CSharpKind() == SyntaxKind.OpenBraceToken);
+            Func<SyntaxToken, SyntaxToken, SyntaxToken> replacementForTokens = (token, dummy) =>
+            {
+                int elementsToRemove = 1;
+                if (token.LeadingTrivia.Count > 1)
+                {
+                    while (elementsToRemove < token.LeadingTrivia.Count &&
+                            token.LeadingTrivia.ElementAt(elementsToRemove).CSharpKind() == SyntaxKind.EndOfLineTrivia)
+                        elementsToRemove++;
+                }
+
+                var newToken = token.WithLeadingTrivia(token.LeadingTrivia.Skip(elementsToRemove));
+                return newToken;
+            };
+
+            var tokensToReplace = openBraceTokens.Where((token) =>
+            {
+                var nextToken = token.GetNextToken();
+                return (nextToken.HasLeadingTrivia && nextToken.LeadingTrivia.First().CSharpKind() == SyntaxKind.EndOfLineTrivia);
+            }).Select((token) => token.GetNextToken());
+
+            return syntaxNode.ReplaceTokens(tokensToReplace, replacementForTokens);
+        }
+
+        private static SyntaxNode FixCloseBraces(SyntaxNode syntaxNode)
+        {
+            var closeBraceTokens = syntaxNode.DescendantTokens().Where((token) => token.CSharpKind() == SyntaxKind.CloseBraceToken);
             Func<SyntaxToken, SyntaxToken, SyntaxToken> replaceTriviaInTokens = (token, dummy) =>
             {
                 var newTrivia = RemoveNewLinesFromTop(token.LeadingTrivia);
@@ -35,7 +69,7 @@ public async Task<Document> ProcessAsync(Document document, CancellationToken ca
                                     token.LeadingTrivia.Last().CSharpKind() == SyntaxKind.EndOfLineTrivia ||
                                     token.LeadingTrivia.Last().CSharpKind() == SyntaxKind.WhitespaceTrivia));
 
-            return document.WithSyntaxRoot(syntaxRoot.ReplaceTokens(tokensToReplace, replaceTriviaInTokens));
+            return syntaxNode.ReplaceTokens(tokensToReplace, replaceTriviaInTokens);
         }
 
         private static IEnumerable<SyntaxTrivia> RemoveNewLinesFromTop(IEnumerable<SyntaxTrivia> trivia)