Added remaining visibility checks

This adds support for properties, fields, constructors and events.

Author: jaredpar

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

@@ -111,5 +111,130 @@ internal interface I
 
                 Verify(text, expected, runFormatter: false);
         }
+
+        [Fact]
+        public void TestExplicitInterfaceImplementation()
+        {
+            var text = @"
+interface I1
+{
+    int Prop { get; set; }
+    void M();
+}
+
+class C : I1
+{
+    int I1.Prop
+    {
+        get { return 0; }
+        set { }
+    }
+    void I1.M() { } 
+}
+";
+
+            var expected = @"
+internal interface I1
+{
+    int Prop { get; set; }
+    void M();
+}
+
+internal class C : I1
+{
+    int I1.Prop
+    {
+        get { return 0; }
+        set { }
+    }
+    void I1.M() { } 
+}
+";
+
+            Verify(text, expected, runFormatter: false);
+        }
+
+        [Fact]
+        public void TestFieldImplementation()
+        {
+            var text = @"
+class C
+{
+    const int Max;
+    int Field1;
+    public int Field2;
+    event EventHandler E1;
+    public event EventHandler E2;
+}
+
+struct C
+{
+    const int Max;
+    int Field1;
+    public int Field2;
+    event EventHandler E1;
+    public event EventHandler E2;
+}
+";
+
+            var expected = @"
+internal class C
+{
+    private const int Max;
+    private int Field1;
+    public int Field2;
+    private event EventHandler E1;
+    public event EventHandler E2;
+}
+
+internal struct C
+{
+    private const int Max;
+    private int Field1;
+    public int Field2;
+    private event EventHandler E1;
+    public event EventHandler E2;
+}
+";
+
+            Verify(text, expected, runFormatter: false);
+        }
+
+        [Fact]
+        public void TestConstructor()
+        {
+            var text = @"
+class C
+{
+    static C() { } 
+    C() { } 
+    internal C(int p) { } 
+}
+
+struct S
+{
+    static S() { } 
+    S(int p) { } 
+    internal S(int p1, int p2) { } 
+}
+";
+            var expected = @"
+internal class C
+{
+    static C() { } 
+    private C() { } 
+    internal C(int p) { } 
+}
+
+internal struct S
+{
+    static S() { } 
+    private S(int p) { } 
+    internal S(int p1, int p2) { } 
+}
+";
+
+            Verify(text, expected, runFormatter: false);
+        }
     }
 }

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

@@ -11,6 +11,7 @@
 
 namespace Microsoft.DotNet.CodeFormatting.Rules
 {
+    [RuleOrder(12)]
     internal sealed class ExplicitVisibilityRule : IFormattingRule
     {
         private sealed class VisibilityRewriter : CSharpSyntaxRewriter
@@ -47,9 +48,48 @@ public override SyntaxNode VisitEnumDeclaration(EnumDeclarationSyntax node)
                 return EnsureVisibility(node, node.Modifiers, (x, l) => x.WithModifiers(l), visibilityKind);
             }
 
+            public override SyntaxNode VisitConstructorDeclaration(ConstructorDeclarationSyntax node)
+            {
+                if (node.Modifiers.Any(x => x.CSharpKind() == SyntaxKind.StaticKeyword))
+                {
+                    return node;
+                }
+
+                return EnsureVisibility(node, node.Modifiers, (x, l) => x.WithModifiers(l), SyntaxKind.PrivateKeyword);
+            }
+
             public override SyntaxNode VisitMethodDeclaration(MethodDeclarationSyntax node)
             {
-                node = (MethodDeclarationSyntax)base.VisitMethodDeclaration(node);
+                if (node.ExplicitInterfaceSpecifier != null)
+                {
+                    return node;
+                }
+
+                return EnsureVisibility(node, node.Modifiers, (x, l) => x.WithModifiers(l), SyntaxKind.PrivateKeyword);
+            }
+
+            public override SyntaxNode VisitPropertyDeclaration(PropertyDeclarationSyntax node)
+            {
+                if (node.ExplicitInterfaceSpecifier != null)
+                {
+                    return node;
+                }
+
+                return EnsureVisibility(node, node.Modifiers, (x, l) => x.WithModifiers(l), SyntaxKind.PrivateKeyword);
+            }
+
+            public override SyntaxNode VisitEventDeclaration(EventDeclarationSyntax node)
+            {
+                return EnsureVisibility(node, node.Modifiers, (x, l) => x.WithModifiers(l), SyntaxKind.PrivateKeyword);
+            }
+
+            public override SyntaxNode VisitEventFieldDeclaration(EventFieldDeclarationSyntax node)
+            {
+                return EnsureVisibility(node, node.Modifiers, (x, l) => x.WithModifiers(l), SyntaxKind.PrivateKeyword);
+            }
+
+            public override SyntaxNode VisitFieldDeclaration(FieldDeclarationSyntax node)
+            {
                 return EnsureVisibility(node, node.Modifiers, (x, l) => x.WithModifiers(l), SyntaxKind.PrivateKeyword);
             }
 
@@ -74,6 +114,10 @@ private static bool IsNestedDeclaration(SyntaxNode node)
                 return false;
             }
 
+            /// <summary>
+            /// Return a node declaration that has a visibility modifier.  If one isn't present it will be added as the 
+            /// first modifier.  Any trivia before the node will be added as leading trivia to the added <see cref="SyntaxToken"/>.
+            /// </summary>
             private static MemberDeclarationSyntax EnsureVisibility<T>(T node, SyntaxTokenList originalModifiers, Func<T, SyntaxTokenList, T> withModifiers, SyntaxKind visibilityKind) where T : MemberDeclarationSyntax
             {
                 Debug.Assert(SyntaxFacts.IsAccessibilityModifier(visibilityKind));