Fix SA1127 handling of multi-line declarations

Fixes #1476

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.Test/ReadabilityRules/SA1127UnitTests.cs

@@ -70,6 +70,64 @@ private void Method<T>()
             await this.VerifyCSharpFixAsync(testCode, fixedCode, cancellationToken: CancellationToken.None).ConfigureAwait(false);
         }
 
+        /// <summary>
+        /// This is a regression test for DotNetAnalyzers/StyleCopAnalyzers#1476:
+        /// https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/1476
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+        [Fact]
+        public async Task TestViolationWithObsoleteMethodDeclarationAsync()
+        {
+            var testCode = @"
+class Foo
+{
+    [System.Obsolete]
+    private void Method<T>() where T : class { }
+}";
+            var fixedCode = @"
+class Foo
+{
+    [System.Obsolete]
+    private void Method<T>()
+        where T : class
+    { }
+}";
+            var expected = this.CSharpDiagnostic().WithLocation(5, 30);
+            await this.VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpDiagnosticAsync(fixedCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpFixAsync(testCode, fixedCode, cancellationToken: CancellationToken.None).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// This is a regression test for DotNetAnalyzers/StyleCopAnalyzers#1476:
+        /// https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/1476
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+        [Fact]
+        public async Task TestViolationWithMethodDeclarationMultiLineParametersAsync()
+        {
+            var testCode = @"
+class Foo
+{
+    private void Method<T>(
+        int a,
+        int b) where T : class { }
+}";
+            var fixedCode = @"
+class Foo
+{
+    private void Method<T>(
+        int a,
+        int b)
+        where T : class
+    { }
+}";
+            var expected = this.CSharpDiagnostic().WithLocation(6, 16);
+            await this.VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpDiagnosticAsync(fixedCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpFixAsync(testCode, fixedCode, cancellationToken: CancellationToken.None).ConfigureAwait(false);
+        }
+
         [Fact]
         public async Task TestViolationWithExpressionBodiedMethodDeclarationAsync()
         {

StyleCop.Analyzers/StyleCop.Analyzers/ReadabilityRules/SA1127GenericTypeConstraintsMustBeOnOwnLine.cs

@@ -52,49 +52,15 @@ public override void Initialize(AnalysisContext context)
 
         private static void HandleCompilationStart(CompilationStartAnalysisContext context)
         {
-            context.RegisterSyntaxNodeActionHonorExclusions(HandleMethodDeclaration, SyntaxKind.MethodDeclaration);
-            context.RegisterSyntaxNodeActionHonorExclusions(HandleTypeDeclaration, SyntaxKind.ClassDeclaration);
-            context.RegisterSyntaxNodeActionHonorExclusions(HandleTypeDeclaration, SyntaxKind.StructDeclaration);
-            context.RegisterSyntaxNodeActionHonorExclusions(HandleTypeDeclaration, SyntaxKind.InterfaceDeclaration);
+            context.RegisterSyntaxNodeActionHonorExclusions(HandleTypeParameterConstraintClause, SyntaxKind.TypeParameterConstraintClause);
         }
 
-        private static void HandleMethodDeclaration(SyntaxNodeAnalysisContext context)
+        private static void HandleTypeParameterConstraintClause(SyntaxNodeAnalysisContext context)
         {
-            var declaration = (MethodDeclarationSyntax)context.Node;
-            var declarationLineSpan = declaration.GetLineSpan();
-
-            if (declaration.TypeParameterList?.Parameters.Count > 0)
-            {
-                Analyze(context, declarationLineSpan, declaration.ConstraintClauses);
-            }
-        }
-
-        private static void HandleTypeDeclaration(SyntaxNodeAnalysisContext context)
-        {
-            var declaration = (TypeDeclarationSyntax)context.Node;
-            var declarationLineSpan = declaration.GetLineSpan();
-
-            if (declaration.TypeParameterList?.Parameters.Count > 0)
+            var syntax = (TypeParameterConstraintClauseSyntax)context.Node;
+            if (!syntax.WhereKeyword.IsFirstInLine())
             {
-                Analyze(context, declarationLineSpan, declaration.ConstraintClauses);
-            }
-        }
-
-        private static void Analyze(
-            SyntaxNodeAnalysisContext context,
-            FileLinePositionSpan declarationLineSpan,
-            SyntaxList<TypeParameterConstraintClauseSyntax> constraintClauses)
-        {
-            int currentLine = declarationLineSpan.StartLinePosition.Line;
-            foreach (var constraint in constraintClauses)
-            {
-                int constraintLine = constraint.GetLineSpan().StartLinePosition.Line;
-                if (currentLine == constraintLine)
-                {
-                    context.ReportDiagnostic(Diagnostic.Create(Descriptor, constraint.GetLocation()));
-                }
-
-                currentLine = constraintLine;
+                context.ReportDiagnostic(Diagnostic.Create(Descriptor, syntax.GetLocation()));
             }
         }
     }