Added enum member, operator, and conversion operator declaration checks (and tests)

Author: nbarbettini

StyleCop.Analyzers/StyleCop.Analyzers.Test/LayoutRules/SA1506UnitTests.cs

@@ -617,6 +617,135 @@ public void TestMethod3() { }
             await this.VerifyCSharpFixAsync(testCode, fixedCode).ConfigureAwait(false);
         }
 
+        /// <summary>
+        /// Verifies that enum member declarations with invalid documentation will produce the expected diagnostics.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+        [Fact]
+        public async Task TestInvalidEnumMemberDeclarationsAsync()
+        {
+            var testCode = @"namespace TestNamespace
+{
+    public enum TestEnum
+    {
+        /// <summary>
+        /// This is an enum member.
+        /// </summary>
+
+        Foo = 0
+    }
+}
+";
+
+            var fixedTestCode = @"namespace TestNamespace
+{
+    public enum TestEnum
+    {
+        /// <summary>
+        /// This is an enum member.
+        /// </summary>
+        Foo = 0
+    }
+}
+";
+
+            var expectedDiagnostic = this.CSharpDiagnostic().WithLocation(8, 1);
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, expectedDiagnostic, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpDiagnosticAsync(fixedTestCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpFixAsync(testCode, fixedTestCode).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Verifies that operator declarations with invalid documentation will produce the expected diagnostics.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+        [Fact]
+        public async Task TestInvalidOperatorDeclarationsAsync()
+        {
+            var testCode = @"namespace TestNamespace
+{
+    public struct Foo
+    {
+        /// <summary>
+        /// This is an operator declaration.
+        /// </summary>
+
+        public static Foo operator +(Foo x, Foo y)
+        {
+            return new Foo();
+        }
+    }
+}
+";
+
+            var fixedTestCode = @"namespace TestNamespace
+{
+    public struct Foo
+    {
+        /// <summary>
+        /// This is an operator declaration.
+        /// </summary>
+        public static Foo operator +(Foo x, Foo y)
+        {
+            return new Foo();
+        }
+    }
+}
+";
+
+            var expectedDiagnostic = this.CSharpDiagnostic().WithLocation(8, 1);
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, expectedDiagnostic, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpDiagnosticAsync(fixedTestCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpFixAsync(testCode, fixedTestCode).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Verifies that conversion operator declarations with invalid documentation will produce the expected diagnostics.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+        [Fact]
+        public async Task TestInvalidConversionOperatorDeclarationsAsync()
+        {
+            var testCode = @"namespace TestNamespace
+{
+    public struct Foo
+    {
+        /// <summary>
+        /// This is a conversion operator declaration.
+        /// </summary>
+
+        public static explicit operator Foo(string s)
+        {
+            return new Foo();
+        }
+    }
+}
+";
+
+            var fixedTestCode = @"namespace TestNamespace
+{
+    public struct Foo
+    {
+        /// <summary>
+        /// This is a conversion operator declaration.
+        /// </summary>
+        public static explicit operator Foo(string s)
+        {
+            return new Foo();
+        }
+    }
+}
+";
+
+            var expectedDiagnostic = this.CSharpDiagnostic().WithLocation(8, 1);
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, expectedDiagnostic, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpDiagnosticAsync(fixedTestCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpFixAsync(testCode, fixedTestCode).ConfigureAwait(false);
+        }
+
         protected override IEnumerable<DiagnosticAnalyzer> GetCSharpDiagnosticAnalyzers()
         {
             yield return new SA1506ElementDocumentationHeadersMustNotBeFollowedByBlankLine();

StyleCop.Analyzers/StyleCop.Analyzers/LayoutRules/SA1506ElementDocumentationHeadersMustNotBeFollowedByBlankLine.cs

@@ -56,6 +56,7 @@ internal class SA1506ElementDocumentationHeadersMustNotBeFollowedByBlankLine : D
                 SyntaxKind.StructDeclaration,
                 SyntaxKind.InterfaceDeclaration,
                 SyntaxKind.EnumDeclaration,
+                SyntaxKind.EnumMemberDeclaration,
                 SyntaxKind.MethodDeclaration,
                 SyntaxKind.ConstructorDeclaration,
                 SyntaxKind.DestructorDeclaration,
@@ -64,7 +65,9 @@ internal class SA1506ElementDocumentationHeadersMustNotBeFollowedByBlankLine : D
                 SyntaxKind.FieldDeclaration,
                 SyntaxKind.DelegateDeclaration,
                 SyntaxKind.EventDeclaration,
-                SyntaxKind.EventFieldDeclaration);
+                SyntaxKind.EventFieldDeclaration,
+                SyntaxKind.OperatorDeclaration,
+                SyntaxKind.ConversionOperatorDeclaration);
 
         private static readonly Action<CompilationStartAnalysisContext> CompilationStartAction = HandleCompilationStart;
         private static readonly Action<SyntaxNodeAnalysisContext> DeclarationAction = HandleDeclaration;
@@ -93,25 +96,25 @@ private static void HandleDeclaration(SyntaxNodeAnalysisContext context)
             {
                 switch (triviaList[i].Kind())
                 {
-                case SyntaxKind.WhitespaceTrivia:
-                    break;
-                case SyntaxKind.EndOfLineTrivia:
-                    eolCount++;
-                    break;
-                case SyntaxKind.SingleLineCommentTrivia:
-                case SyntaxKind.MultiLineCommentTrivia:
-                    eolCount--;
-                    break;
-                case SyntaxKind.SingleLineDocumentationCommentTrivia:
-                    if (eolCount > 0)
-                    {
-                        context.ReportDiagnostic(Diagnostic.Create(Descriptor, triviaList[i + 1].GetLocation()));
-                    }
+                    case SyntaxKind.WhitespaceTrivia:
+                        break;
+                    case SyntaxKind.EndOfLineTrivia:
+                        eolCount++;
+                        break;
+                    case SyntaxKind.SingleLineCommentTrivia:
+                    case SyntaxKind.MultiLineCommentTrivia:
+                        eolCount--;
+                        break;
+                    case SyntaxKind.SingleLineDocumentationCommentTrivia:
+                        if (eolCount > 0)
+                        {
+                            context.ReportDiagnostic(Diagnostic.Create(Descriptor, triviaList[i + 1].GetLocation()));
+                        }
 
-                    return;
-                default:
-                    // no documentation found
-                    return;
+                        return;
+                    default:
+                        // no documentation found
+                        return;
                 }
             }
         }