Merge pull request #1703 from nbarbettini/fix-1681

Update SA1506 to support enum member and (conversion) operator declarations

Author: sharwell

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

@@ -617,6 +617,212 @@ public void TestMethod3() { }
             await this.VerifyCSharpFixAsync(testCode, fixedCode).ConfigureAwait(false);
         }
 
+        /// <summary>
+        /// Verifies that enum member declarations with valid (or no) documentation will not produce diagnostics.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+        [Fact]
+        public async Task TestValidEnumMemberDeclarationsAsync()
+        {
+            var testCode = @"namespace TestNamespace
+{
+    public enum TestEnum
+    {
+        /// <summary>
+        /// This is an enum member.
+        /// </summary>
+        Foo = 0,
+        Bar = 1
+    }
+}
+";
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).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 valid (or no) documentation will not produce diagnostics.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+        [Fact]
+        public async Task TestValidOperatorDeclarationsAsync()
+        {
+            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();
+        }
+
+        private int testField1;
+    }
+}
+";
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).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 valid (or no) documentation will not produce diagnostics.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+        [Fact]
+        public async Task TestValidConversionOperatorDeclarationsAsync()
+        {
+            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();
+        }
+
+        private int testField1;
+    }
+}
+";
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).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;