Merge pull request #1819 from sharwell/fix-1597

Allow invocation expressions to span multiple lines

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.Test/ReadabilityRules/SA1118UnitTests.cs

@@ -90,6 +90,31 @@ public void Bar()
             await this.VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
         }
 
+        [Fact]
+        public async Task TestMethodCallWithThreeParametersSecondSpansMultipleLinesThirdSpansMultipleLinesButIsInvocationExpressionAsync()
+        {
+            var testCode = @"
+class Foo
+{
+    public void Fun(int i, int j, int k)
+    {
+    }
+
+    public void Bar()
+    {
+        Fun(1,
+            System.Linq.Enumerable.Count(
+                new int[0]) + 4,
+            System.Linq.Enumerable.Count(
+                new int[0]));
+    }
+}";
+
+            DiagnosticResult expected = this.CSharpDiagnostic().WithLocation(11, 13);
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
+        }
+
         [Fact]
         public async Task TestMethodCallWithTwoParametersFirstIsMultilineSecondIsOneLineAsync()
         {
@@ -156,6 +181,31 @@ public void Bar()
             await this.VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
         }
 
+        [Fact]
+        public async Task TestAnonymousMethodCallSecondParameterSpansMultipleLinesThirdParameterIsInvocationAsync()
+        {
+            var testCode = @"
+class Foo
+{
+    public void Bar()
+    {
+        System.Action<int, int, int> d = delegate(int i, int j, int k)
+                                    {
+
+                                    };
+        d(1,
+          System.Linq.Enumerable.Count(
+                new int[0]) + 1,
+          System.Linq.Enumerable.Count(
+                new int[0]));
+    }
+}";
+
+            DiagnosticResult expected = this.CSharpDiagnostic().WithLocation(11, 11);
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
+        }
+
         [Fact]
         public async Task TestLambdaCallSecondParameterSpansTwoLinesAsync()
         {

StyleCop.Analyzers/StyleCop.Analyzers/ReadabilityRules/SA1118ParameterMustNotSpanMultipleLines.cs

@@ -80,7 +80,8 @@ internal class SA1118ParameterMustNotSpanMultipleLines : DiagnosticAnalyzer
         {
             SyntaxKind.AnonymousMethodExpression,
             SyntaxKind.ParenthesizedLambdaExpression,
-            SyntaxKind.SimpleLambdaExpression
+            SyntaxKind.SimpleLambdaExpression,
+            SyntaxKind.InvocationExpression
         };
 
         /// <inheritdoc/>

documentation/SA1118.md

@@ -21,7 +21,15 @@ A parameter to a C# method or indexer, other than the first parameter, spans acr
 
 ## Rule description
 
-To prevent method calls from becoming excessively complicated and unreadable, only the first parameter to a method or indexer call is allowed to span across multiple lines. The exception is an anonymous method passed as a parameter, which is always allowed to span multiple lines. A violation of this rule occurs whenever a parameter other than the first parameter spans across multiple lines, and the parameter does not contain an anonymous method.
+To prevent method calls from becoming excessively complicated and unreadable, individual parameters and arguments should
+be placed on a single line. When parameters other than the first parameter span across multiple lines, it can be
+difficult to tell how many parameters are passed to the method. In general, the code becomes difficult to read. A
+violation of this rule is reported when a parameter or argument spans multiple lines, except in the following specific
+cases:
+
+* The first parameter may span multiple lines
+* Anonymous methods (including lambda expressions) may span multiple lines
+* Invocation expressions may span multiple lines
 
 For example, the following code would violate this rule, since the second parameter spans across multiple lines:
 
@@ -32,9 +40,9 @@ return JoinStrings(
     " Doe");
 ```
 
-When parameters other than the first parameter span across multiple lines, it can be difficult to tell how many parameters are passed to the method. In general, the code becomes difficult to read.
-
-To fix the example above, ensure that the parameters after the first parameter do not span across multiple lines. If this will cause a parameter to be excessively long, store the value of the parameter within a temporary variable. For example:
+To fix the example above, ensure that the parameters after the first parameter do not span across multiple lines. If
+this will cause a parameter to be excessively long, store the value of the parameter within a temporary variable. For
+example:
 
 ```csharp
 string last = "Smith" + 
@@ -53,7 +61,8 @@ return JoinStrings("John", last);
 
 ## How to fix violations
 
-To fix a violation of this rule, ensure that the parameters after the first parameter do not span multiple lines, unless the parameter contains an anonymous method.
+To fix a violation of this rule, ensure that the parameters and arguments do not span multiple lines, except in the
+specific cases listed above.
 
 ## How to suppress violations