Fixed exception with partial type with nested types

The code which queries for other partial members must use the original,
unmodified, SyntaxNode.  It is the only node which is guaranteed to be
in the original tree and hence valid for uses with the semantic model.

Author: jaredpar

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

@@ -340,5 +340,29 @@ public partial class C { }
 
             Verify(new[] { text1, text2 }, new[] { expected1, expected2 }, runFormatter: false);
         }
+
+        [Fact]
+        public void PartialTypesWithNestedClasses()
+        {
+            var text = @"
+partial class C {
+    class N1 { }
+    class N2 { }
+}
+
+public partial class C { }
+";
+
+            var expected = @"
+public partial class C {
+    private class N1 { }
+    private class N2 { }
+}
+
+public partial class C { }
+";
+
+            Verify(text, expected, runFormatter: false);
+        }
     }
 }

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

@@ -29,21 +29,21 @@ internal VisibilityRewriter(Document document, CancellationToken cancellationTok
                 _cancellationToken = cancellationToken;
             }
 
-            public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node)
+            public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax originalNode)
             {
-                node = (ClassDeclarationSyntax)base.VisitClassDeclaration(node);
-                return EnsureVisibility(node, node.Modifiers, (x, l) => x.WithModifiers(l), () => GetTypeDefaultVisibility(node));
+                var node = (ClassDeclarationSyntax)base.VisitClassDeclaration(originalNode);
+                return EnsureVisibility(node, node.Modifiers, (x, l) => x.WithModifiers(l), () => GetTypeDefaultVisibility(originalNode));
             }
 
             public override SyntaxNode VisitInterfaceDeclaration(InterfaceDeclarationSyntax node)
             {
                 return EnsureVisibility(node, node.Modifiers, (x, l) => x.WithModifiers(l), () => GetTypeDefaultVisibility(node));
             }
 
-            public override SyntaxNode VisitStructDeclaration(StructDeclarationSyntax node)
+            public override SyntaxNode VisitStructDeclaration(StructDeclarationSyntax originalNode)
             {
-                node = (StructDeclarationSyntax)base.VisitStructDeclaration(node);
-                return EnsureVisibility(node, node.Modifiers, (x, l) => x.WithModifiers(l), () => GetTypeDefaultVisibility(node));
+                var node = (StructDeclarationSyntax)base.VisitStructDeclaration(originalNode);
+                return EnsureVisibility(node, node.Modifiers, (x, l) => x.WithModifiers(l), () => GetTypeDefaultVisibility(originalNode));
             }
 
             public override SyntaxNode VisitDelegateDeclaration(DelegateDeclarationSyntax node)
@@ -106,27 +106,27 @@ public override SyntaxNode VisitFieldDeclaration(FieldDeclarationSyntax node)
                 return EnsureVisibility(node, node.Modifiers, (x, l) => x.WithModifiers(l), () => SyntaxKind.PrivateKeyword);
             }
 
-            private SyntaxKind GetTypeDefaultVisibility(BaseTypeDeclarationSyntax node)
+            private SyntaxKind GetTypeDefaultVisibility(BaseTypeDeclarationSyntax originalDeclarationSyntax)
             {
                 // In the case of partial types we need to use the existing visibility if it exists
-                if (node.Modifiers.Any(x => x.CSharpContextualKind() == SyntaxKind.PartialKeyword))
+                if (originalDeclarationSyntax.Modifiers.Any(x => x.CSharpContextualKind() == SyntaxKind.PartialKeyword))
                 {
-                    SyntaxKind? kind = GetExistingPartialVisibility(node);
+                    SyntaxKind? kind = GetExistingPartialVisibility(originalDeclarationSyntax);
                     if (kind.HasValue)
                     {
                         return kind.Value;
                     }
                 }
 
-                return GetDelegateTypeDefaultVisibility(node);
+                return GetDelegateTypeDefaultVisibility(originalDeclarationSyntax);
             }
 
             private SyntaxKind GetDelegateTypeDefaultVisibility(SyntaxNode node)
             {
                 return IsNestedDeclaration(node) ? SyntaxKind.PrivateKeyword : SyntaxKind.InternalKeyword;
             }
 
-            private SyntaxKind? GetExistingPartialVisibility(BaseTypeDeclarationSyntax declarationSyntax)
+            private SyntaxKind? GetExistingPartialVisibility(BaseTypeDeclarationSyntax originalDeclarationSyntax)
             {
                 // Getting the SemanticModel is a relatively expensive operation.  Can take a few seconds in 
                 // projects of significant size.  It is delay created to avoid this in files which already
@@ -136,7 +136,7 @@ private SyntaxKind GetDelegateTypeDefaultVisibility(SyntaxNode node)
                     _semanticModel = _document.GetSemanticModelAsync(_cancellationToken).Result;
                 }
 
-                var symbol = _semanticModel.GetDeclaredSymbol(declarationSyntax, _cancellationToken);
+                var symbol = _semanticModel.GetDeclaredSymbol(originalDeclarationSyntax, _cancellationToken);
                 if (symbol == null)
                 {
                     return null;