SA1516 no longer counts attributes when determining if a declaration is multiline

Author: vweijsters

StyleCop.Analyzers/StyleCop.Analyzers.Test/LayoutRules/SA1516UnitTests.cs

@@ -523,6 +523,26 @@ public event System.EventHandler FooProperty
             await this.VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
         }
 
+        /// <summary>
+        /// Verifies that private fields with attributes are handled properly.
+        /// This is a regression test for #1595
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+        [Fact]
+        public async Task VerifyThatPrivateFieldsAreHandledProperlyAsync()
+        {
+            string testCode = @"using System;
+
+public class TestClass
+{
+    [Obsolete]
+    private int test1;
+    private bool test2;
+}";
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
         protected override IEnumerable<DiagnosticAnalyzer> GetCSharpDiagnosticAnalyzers()
         {
             yield return new SA1516ElementsMustBeSeparatedByBlankLine();

StyleCop.Analyzers/StyleCop.Analyzers/LayoutRules/SA1516ElementsMustBeSeparatedByBlankLine.cs

@@ -196,9 +196,9 @@ private static void HandleMemberList(SyntaxNodeAnalysisContext context, SyntaxLi
                     // or the previous declaration is of different type
                     // or the current declaration has documentation
                     // or the current declaration is not a field declaration,
-                    if (IsMultiline(members[i - 1])
-                        || !members[i - 1].IsKind(members[i].Kind())
-                        || !members[i].IsKind(SyntaxKind.FieldDeclaration))
+                    if (!members[i - 1].IsKind(members[i].Kind())
+                        || !members[i].IsKind(SyntaxKind.FieldDeclaration)
+                        || IsMultiline(members[i - 1]))
                     {
                         ReportIfThereIsNoBlankLine(context, members[i - 1], members[i]);
                     }
@@ -209,8 +209,21 @@ private static void HandleMemberList(SyntaxNodeAnalysisContext context, SyntaxLi
         private static bool IsMultiline(SyntaxNode node)
         {
             var lineSpan = node.GetLineSpan();
+            var attributes = GetAttributes(node);
+            int startLine;
 
-            return lineSpan.StartLinePosition.Line != lineSpan.EndLinePosition.Line;
+            // Exclude attributes when determining if a node spans multiple lines
+            if (attributes.Count > 0)
+            {
+                var lastAttributeSpan = node.SyntaxTree.GetLineSpan(attributes.Last().FullSpan);
+                startLine = lastAttributeSpan.EndLinePosition.Line;
+            }
+            else
+            {
+                startLine = lineSpan.StartLinePosition.Line;
+            }
+
+            return startLine != lineSpan.EndLinePosition.Line;
         }
 
         private static void ReportIfThereIsNoBlankLine(SyntaxNodeAnalysisContext context, SyntaxNode firstNode, SyntaxNode secondNode)
@@ -270,5 +283,52 @@ private static bool HasEmptyLine(IEnumerable<SyntaxTrivia> allTrivia)
 
             return false;
         }
+
+        // copied from Roslyn code, as its inaccessible there
+        // (from Microsoft.CodeAnalysis.CSharp.Extensions.MemberDeclarationSyntaxExtensions)
+        private static SyntaxList<AttributeListSyntax> GetAttributes(SyntaxNode node)
+        {
+            var memberDeclaration = node as MemberDeclarationSyntax;
+            if (memberDeclaration != null)
+            {
+                switch (memberDeclaration.Kind())
+                {
+                    case SyntaxKind.EnumDeclaration:
+                        return ((EnumDeclarationSyntax)memberDeclaration).AttributeLists;
+                    case SyntaxKind.EnumMemberDeclaration:
+                        return ((EnumMemberDeclarationSyntax)memberDeclaration).AttributeLists;
+                    case SyntaxKind.ClassDeclaration:
+                    case SyntaxKind.InterfaceDeclaration:
+                    case SyntaxKind.StructDeclaration:
+                        return ((TypeDeclarationSyntax)memberDeclaration).AttributeLists;
+                    case SyntaxKind.DelegateDeclaration:
+                        return ((DelegateDeclarationSyntax)memberDeclaration).AttributeLists;
+                    case SyntaxKind.FieldDeclaration:
+                        return ((FieldDeclarationSyntax)memberDeclaration).AttributeLists;
+                    case SyntaxKind.EventFieldDeclaration:
+                        return ((EventFieldDeclarationSyntax)memberDeclaration).AttributeLists;
+                    case SyntaxKind.ConstructorDeclaration:
+                        return ((ConstructorDeclarationSyntax)memberDeclaration).AttributeLists;
+                    case SyntaxKind.DestructorDeclaration:
+                        return ((DestructorDeclarationSyntax)memberDeclaration).AttributeLists;
+                    case SyntaxKind.PropertyDeclaration:
+                        return ((PropertyDeclarationSyntax)memberDeclaration).AttributeLists;
+                    case SyntaxKind.EventDeclaration:
+                        return ((EventDeclarationSyntax)memberDeclaration).AttributeLists;
+                    case SyntaxKind.IndexerDeclaration:
+                        return ((IndexerDeclarationSyntax)memberDeclaration).AttributeLists;
+                    case SyntaxKind.OperatorDeclaration:
+                        return ((OperatorDeclarationSyntax)memberDeclaration).AttributeLists;
+                    case SyntaxKind.ConversionOperatorDeclaration:
+                        return ((ConversionOperatorDeclarationSyntax)memberDeclaration).AttributeLists;
+                    case SyntaxKind.MethodDeclaration:
+                        return ((MethodDeclarationSyntax)memberDeclaration).AttributeLists;
+                    case SyntaxKind.IncompleteMember:
+                        return ((IncompleteMemberSyntax)memberDeclaration).AttributeLists;
+                }
+            }
+
+            return SyntaxFactory.List<AttributeListSyntax>();
+        }
     }
 }