Update SA1003 for null-forgiving operator at end of line when followed by member access

Author: EdwinEngelen

StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp8/SpacingRules/SA1003CSharp8UnitTests.cs

@@ -329,5 +329,39 @@ public void TestMethod(int[] values)
 
             await VerifyCSharpFixAsync(testCode, expected, fixedCode, CancellationToken.None).ConfigureAwait(false);
         }
+
+        [Fact]
+        public async Task TestNullForgivingOperatorAtEndOfLineBeforeMemberAccessAsync()
+        {
+            var testCode = @"
+namespace TestNamespace
+{
+    public class TestClass
+    {
+        public void TestOnParameter(string? maybeNullParameter)
+        {
+            var result = maybeNullParameter!
+                .ToString();
+        }
+
+        private string? _maybeNullProperty;
+        public void TestOnProperty()
+        {
+            var result = _maybeNullProperty!
+                .ToString();
+        }
+
+        private string? MaybeNullMethod() => null;
+        public void TestOnMethod()
+        {
+            var result = MaybeNullMethod()!
+                .ToString();
+        }
+    }
+}
+";
+
+            await VerifyCSharpDiagnosticAsync(testCode, DiagnosticResult.EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
     }
 }

StyleCop.Analyzers/StyleCop.Analyzers/SpacingRules/SA1003SymbolsMustBeSpacedCorrectly.cs

@@ -393,9 +393,22 @@ private static void HandlePostfixUnaryExpression(SyntaxNodeAnalysisContext conte
                 break;
             }
 
-            // If the next token is a close brace token we are in an anonymous object creation or an initialization.
-            // Then we allow a new line
-            bool allowEndOfLine = followingToken.IsKind(SyntaxKind.CloseBraceToken);
+            bool allowEndOfLine;
+            if (followingToken.IsKind(SyntaxKind.CloseBraceToken))
+            {
+                // If the next token is a close brace token we are in an anonymous object creation or an initialization.
+                // Then we allow a new line
+                allowEndOfLine = true;
+            }
+            else if (followingToken.IsKind(SyntaxKind.DotToken) && followingToken.IsFirstInLine())
+            {
+                // Allow null forgiving operator at end of line when followed by member access on the next line
+                allowEndOfLine = true;
+            }
+            else
+            {
+                allowEndOfLine = false;
+            }
 
             CheckToken(context, unaryExpression.OperatorToken, false, allowEndOfLine, mustHaveTrailingWhitespace);
         }