Responded to PR feedback

Author: jaredpar

src/CodeFormatter.sln

@@ -14,8 +14,6 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".nuget", ".nuget", "{34034F
 		.nuget\packages.config = .nuget\packages.config
 	EndProjectSection
 EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{297488BF-08A5-4D06-A0C3-B1623F49162A}"
-EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU

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

@@ -7,6 +7,11 @@ namespace Microsoft.DotNet.CodeFormatting.Tests
 {
     public class PrivateFieldNamingRuleTests : CodeFormattingTestBase
     {
+        internal override IFormattingRule GetFormattingRule()
+        {
+            return new Rules.PrivateFieldNamingRule();
+        }
+
         [Fact]
         public void TestUnderScoreInPrivateFields()
         {
@@ -43,9 +48,70 @@ class T
             Verify(text, expected);
         }
 
-        internal override IFormattingRule GetFormattingRule()
+        [Fact]
+        public void CornerCaseNames()
         {
-            return new Rules.PrivateFieldNamingRule();
+            var text = @"
+class C
+{
+    private int x_;
+    private int _;
+    private int __;
+    private int m_field1;
+    private int field2_;
+";
+
+            var expected = @"
+class C
+{
+    private int _x;
+    private int _;
+    private int __;
+    private int _field1;
+    private int _field2;
+";
+
+            Verify(text, expected, runFormatter: false);
+        }
+
+        [Fact]
+        public void MultipleDeclarators()
+        {
+            var text = @"
+class C1
+{
+    private int field1, field2, field3;
+}
+
+class C2
+{
+    private static int field1, field2, field3;
+}
+
+class C3
+{
+    internal int field1, field2, field3;
+}
+";
+
+            var expected = @"
+class C1
+{
+    private int _field1, _field2, _field3;
+}
+
+class C2
+{
+    private static int s_field1, s_field2, s_field3;
+}
+
+class C3
+{
+    internal int field1, field2, field3;
+}
+";
+
+            Verify(text, expected, runFormatter: true);
         }
     }
 }

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

@@ -21,6 +21,7 @@ private sealed class ExplicitThisRewriter : CSharpSyntaxRewriter
             internal ExplicitThisRewriter(SemanticModel semanticModel, CancellationToken cancellationToken)
             {
                 _semanticModel = semanticModel;
+                _cancellationToken = cancellationToken;
             }
 
             public override SyntaxNode VisitMemberAccessExpression(MemberAccessExpressionSyntax node)

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

@@ -23,7 +23,7 @@ internal sealed class PrivateFieldNamingRule : IFormattingRule
         /// <summary>
         /// This will add an annotation to any private field that needs to be renamed.
         /// </summary>
-        private sealed class PrivateFieldAnnotationsRewriter : CSharpSyntaxRewriter
+        internal sealed class PrivateFieldAnnotationsRewriter : CSharpSyntaxRewriter
         {
             internal readonly static SyntaxAnnotation Marker = new SyntaxAnnotation("PrivateFieldToRename");
 
@@ -47,19 +47,20 @@ internal static SyntaxNode AddAnnotations(SyntaxNode node, out int count)
 
             public override SyntaxNode VisitFieldDeclaration(FieldDeclarationSyntax node)
             {
-                if (NeedsRewrite(node))
+                bool isInstance;
+                if (NeedsRewrite(node, out isInstance))
                 {
                     var list = new List<VariableDeclaratorSyntax>(node.Declaration.Variables.Count);
                     foreach (var v in node.Declaration.Variables)
                     {
-                        if (IsBadName(v))
+                        if (IsGoodName(v, isInstance))
                         {
-                            list.Add(v.WithAdditionalAnnotations(Marker));
-                            _count++;
+                            list.Add(v);
                         }
                         else
                         {
-                            list.Add(v);
+                            list.Add(v.WithAdditionalAnnotations(Marker));
+                            _count++;
                         }
                     }
 
@@ -72,16 +73,16 @@ public override SyntaxNode VisitFieldDeclaration(FieldDeclarationSyntax node)
                 return node;
             }
 
-            private static bool NeedsRewrite(FieldDeclarationSyntax fieldSyntax)
+            private static bool NeedsRewrite(FieldDeclarationSyntax fieldSyntax, out bool isInstance)
             {
-                if (!IsPrivateField(fieldSyntax))
+                if (!IsPrivateField(fieldSyntax, out isInstance))
                 {
                     return false;
                 }
 
                 foreach (var v in fieldSyntax.Declaration.Variables)
                 {
-                    if (IsBadName(v))
+                    if (!IsGoodName(v, isInstance))
                     {
                         return true;
                     }
@@ -90,14 +91,22 @@ private static bool NeedsRewrite(FieldDeclarationSyntax fieldSyntax)
                 return false;
             }
 
-            private static bool IsBadName(VariableDeclaratorSyntax node)
+            private static bool IsGoodName(VariableDeclaratorSyntax node, bool isInstance)
             {
                 var name = node.Identifier.ValueText;
-                return name.Length > 0 && name[0] != '_';
+                if (isInstance)
+                {
+                    return name.Length > 0 && name[0] == '_';
+                }
+                else
+                {
+                    return name.Length > 1 && (name[0] == 's' || name[0] == 't') && name[1] == '_';
+                }
             }
 
-            private static bool IsPrivateField(FieldDeclarationSyntax fieldSyntax)
+            private static bool IsPrivateField(FieldDeclarationSyntax fieldSyntax, out bool isInstance)
             {
+                isInstance = true;
                 foreach (var modifier in fieldSyntax.Modifiers)
                 {
                     switch (modifier.CSharpKind())
@@ -107,6 +116,9 @@ private static bool IsPrivateField(FieldDeclarationSyntax fieldSyntax)
                         case SyntaxKind.InternalKeyword:
                         case SyntaxKind.ProtectedKeyword:
                             return false;
+                        case SyntaxKind.StaticKeyword:
+                            isInstance = false;
+                            break;
                     }
                 }
 
@@ -189,6 +201,13 @@ private static async Task<Solution> RenameFields(Solution solution, DocumentId d
                 var declaration = root.GetAnnotatedNodes(PrivateFieldAnnotationsRewriter.Marker).ElementAt(i);
                 var fieldSymbol = (IFieldSymbol)semanticModel.GetDeclaredSymbol(declaration, cancellationToken);
                 var newName = GetNewFieldName(fieldSymbol);
+
+                // Can happen with pathologically bad field names like _
+                if (newName == fieldSymbol.Name)
+                {
+                    continue;
+                }
+
                 solution = await Renamer.RenameSymbolAsync(solution, fieldSymbol, newName, solution.Workspace.Options, cancellationToken).ConfigureAwait(false);
             }
 
@@ -197,17 +216,15 @@ private static async Task<Solution> RenameFields(Solution solution, DocumentId d
 
         private static string GetNewFieldName(IFieldSymbol fieldSymbol)
         {
-            var name = fieldSymbol.Name;
-            if (name.Length > 1)
+            var name = fieldSymbol.Name.Trim('_');
+            if (name.Length > 2 && char.IsLetter(name[0]) && name[1] == '_')
             {
-                if (name[0] == '_')
-                {
-                    name = name.TrimStart('_');
-                }
-                else if (char.IsLetter(name[0]) && name[1] == '_')
-                {
-                    name = name.Substring(2);
-                }
+                name = name.Substring(2);
+            }
+
+            if (name.Length == 0)
+            {
+                return fieldSymbol.Name;
             }
 
             if (fieldSymbol.IsStatic)