Fix bugs

Author: Lakshmi Priya Sekar

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

@@ -107,6 +107,7 @@
     <Compile Include="Rules\HasNoNewLineAfterOpenBraceFormattingRuleTests.cs" />
     <Compile Include="Rules\HasNoNewLineBeforeEndBraceFormattingRuleTests.cs" />
     <Compile Include="Rules\HasPrivateAccessorOnFieldNamesFormattingRuleTests.cs" />
+    <Compile Include="Rules\HasUnderScoreInPrivateFieldNamesFormattingRuleTests.cs" />
   </ItemGroup>
   <ItemGroup>
     <Folder Include="Properties\" />

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

@@ -34,6 +34,11 @@ class O
 
 }
 class M {
+}
+class R
+{
+    // some comment
+
 }";
             var expected = @"
 using System;
@@ -57,6 +62,10 @@ class O
 }
 class M
 {
+}
+class R
+{
+    // some comment
 }";
             Verify(text, expected);
         }
@@ -84,6 +93,44 @@ class L
             Verify(text, expected);
         }
 
+        [Fact]
+        public void TestNoNewLineBeforeEndBrace03()
+        {
+            var text = @"
+class S 
+{
+
+
+    }    
+
+  
+";
+            var expected = @"
+class S
+{
+}
+
+
+";
+            Verify(text, expected);
+        }
+
+        [Fact]
+        public void TestNoNewLineBeforeEndBrace04()
+        {
+            var text = @"
+class S 
+{   
+    
+
+}";
+            var expected = @"
+class S
+{
+}";
+            Verify(text, expected);
+        }
+
         internal override IFormattingRule GetFormattingRule()
         {
             return new Rules.HasNoNewLineBeforeEndBraceFormattingRule();

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

@@ -0,0 +1,51 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Xunit;
+
+namespace Microsoft.DotNet.CodeFormatting.Tests
+{
+    public class HasUnderScoreInPrivateFieldNamesFormattingRuleTests : CodeFormattingTestBase
+    {
+        [Fact]
+        public void TestUnderScoreInPrivateFields()
+        {
+            var text = @"
+using System;
+class T
+{
+    private static int x;
+    private static int s_y;
+    // some trivia
+    private static int m_z;
+    // some trivia
+    private int k = 1, m_s = 2;
+    // some trivia
+    [ThreadStatic] static int r;
+    [ThreadStaticAttribute] static int b_r;
+}";
+            var expected = @"
+using System;
+class T
+{
+    private static int s_x;
+    private static int s_y;
+    // some trivia
+    private static int s_z;
+    // some trivia
+    private int _k = 1, _s = 2;
+    // some trivia
+    [ThreadStatic]
+    static int t_r;
+    [ThreadStaticAttribute]
+    static int t_r;
+}";
+            Verify(text, expected);
+        }
+
+        internal override IFormattingRule GetFormattingRule()
+        {
+            return new Rules.HasUnderScoreInPrivateFieldNamesFormattingRule();
+        }
+    }
+}

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

@@ -95,6 +95,7 @@
     <Compile Include="Rules\HasNoNewLineBeforeEndBraceFormattingRule.cs" />
     <Compile Include="Rules\HasNoCustomCopyrightHeaderFormattingRule.cs" />
     <Compile Include="Rules\HasPrivateAccessorOnFieldNamesFormattingRule.cs" />
+    <Compile Include="Rules\HasRightEncodingFormattingRule.cs" />
     <Compile Include="Rules\HasUnderScoreInPrivateFieldNamesFormattingRule.cs" />
     <Compile Include="Rules\HasUsingsOutsideOfNamespaceFormattingRule.cs" />
     <Compile Include="Rules\IsFormattedFormattingRule.cs" />

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

@@ -87,6 +87,9 @@ private static IEnumerable<SyntaxTrivia> RemoveNewLinesFromBottom(IEnumerable<Sy
 
             var newTrivia = trivia.Take(elementsToRemoveAtEnd + 1);
 
+            if (newTrivia.Any() && newTrivia.Last().CSharpKind().ToString().ToLower().Contains("comment"))
+                addNewLine = true;
+
             if (addWhitespace)
             {
                 if (newTrivia.Last().IsDirective)

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

@@ -0,0 +1,25 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Text;
+
+namespace Microsoft.DotNet.CodeFormatting.Rules
+{
+    [RuleOrder(int.MaxValue)]
+    internal sealed class HasRightEncodingFormattingRule : IFormattingRule
+    {
+        Encoding _desiredEncoding = new UTF8Encoding(false);
+        public async Task<Document> ProcessAsync(Document document, CancellationToken cancellationToken)
+        {
+            var text = await document.GetTextAsync();
+            var newText = SourceText.From(text.ToString(), _desiredEncoding);
+            return document.WithText(newText);
+        }
+    }
+}
+

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

@@ -6,6 +6,7 @@
 using System.Collections.Generic;
 using System.ComponentModel.Composition;
 using System.Linq;
+using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -87,11 +88,12 @@ private async Task<Solution> RenameFields(Solution solution, DocumentId document
         private static string GetNewSymbolName(ISymbol symbol)
         {
             var symbolName = symbol.Name.TrimStart('_');
-            if (symbolName.StartsWith("m_", StringComparison.OrdinalIgnoreCase)) symbolName = symbolName.Remove(0, 2);
+            Regex regex = new Regex("^(.)_");
+            if (regex.IsMatch(symbolName)) symbolName = symbolName.Remove(0, 2);
             if (symbol.IsStatic)
             {
                 // Check for ThreadStatic private fields.
-                if (symbol.GetAttributes().Any(a => a.AttributeClass.Name.Equals("ThreadStatic")))
+                if (symbol.GetAttributes().Any(a => a.AttributeClass.Name.Equals("ThreadStaticAttribute")))
                 {
                     if (!symbolName.StartsWith("t_", StringComparison.OrdinalIgnoreCase))
                         return "t_" + symbolName;