Allow no preceding whitespace on negative and positive signs that follow opening braces of interpolated strings

Author: ninety7

StyleCop.Analyzers/StyleCop.Analyzers.Test/SpacingRules/NumberSignSpacingTestBase.cs

@@ -424,6 +424,68 @@ void Foo()
             await this.VerifyCSharpFixAsync(test, fixedTest, cancellationToken: CancellationToken.None).ConfigureAwait(false);
         }
 
+        [Fact]
+        public async Task TestPrefixUnaryOperatorInInterpolationBracesAsync()
+        {
+            string testFormat = @"namespace Namespace
+{{
+    class Type
+    {{
+        void Foo()
+        {{
+            string x = $""{{{0}}}"";
+        }}
+    }}
+}}
+";
+
+            // in all cases the final output should be the following
+            string fixedTest = @"namespace Namespace
+{
+    class Type
+    {
+        void Foo()
+        {
+            string x = $""{" + this.Sign + @"0}"";
+        }
+    }
+}
+";
+
+            await this.VerifyCSharpDiagnosticAsync(fixedTest, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+
+            string test = string.Format(testFormat, this.Sign + "0");
+            await this.VerifyCSharpDiagnosticAsync(test, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpFixAsync(test, fixedTest, numberOfFixAllIterations: 0, cancellationToken: CancellationToken.None).ConfigureAwait(false);
+
+            test = string.Format(testFormat, " " + this.Sign + "0");
+            DiagnosticResult[] expected =
+                {
+                    this.CSharpDiagnostic().WithArguments(" not", "preceded").WithLocation(7, 28),
+                };
+            await this.VerifyCSharpDiagnosticAsync(test, expected, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpFixAsync(test, fixedTest, cancellationToken: CancellationToken.None).ConfigureAwait(false);
+
+            test = string.Format(testFormat, this.Sign + " 0");
+            expected =
+                new[]
+                {
+                    this.CSharpDiagnostic().WithArguments(" not", "followed").WithLocation(7, 27),
+                };
+            await this.VerifyCSharpDiagnosticAsync(test, expected, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpFixAsync(test, fixedTest, cancellationToken: CancellationToken.None).ConfigureAwait(false);
+
+            test = string.Format(testFormat, " " + this.Sign + " 0");
+            expected =
+                new[]
+                {
+                    this.CSharpDiagnostic().WithArguments(" not", "preceded").WithLocation(7, 28),
+                    this.CSharpDiagnostic().WithArguments(" not", "followed").WithLocation(7, 28),
+                };
+            await this.VerifyCSharpDiagnosticAsync(test, expected, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpFixAsync(test, fixedTest, cancellationToken: CancellationToken.None).ConfigureAwait(false);
+        }
+
         protected override abstract CodeFixProvider GetCSharpCodeFixProvider();
     }
 }

StyleCop.Analyzers/StyleCop.Analyzers/Helpers/TokenHelper.cs

@@ -56,6 +56,30 @@ internal static bool IsFirstInLine(this SyntaxToken token, bool allowNonWhitespa
             return firstInLine;
         }
 
+        /// <summary>
+        /// Gets a value indicating whether the <paramref name="token"/> is an interpolated
+        /// unary expression.
+        /// </summary>
+        /// <param name="token">The token to process.</param>
+        /// <returns>
+        /// <see langword="true"/> if <paramref name="token"/> is an interpolated unary expression;
+        /// otherwise, <see langword="false"/>.
+        /// </returns>
+        internal static bool IsInterpolatedUnaryExpression(this SyntaxToken token)
+        {
+            SyntaxNode parentNode = (token.Parent.IsKind(SyntaxKind.UnaryMinusExpression)
+                    || token.Parent.IsKind(SyntaxKind.UnaryPlusExpression))
+                ? token.Parent.Parent
+                : token.Parent;
+
+            if (parentNode.IsKind(SyntaxKind.Interpolation))
+            {
+                return true;
+            }
+
+            return false;
+        }
+
         /// <summary>
         /// Gets a value indicating whether the <paramref name="token"/> is last in line.
         /// </summary>

StyleCop.Analyzers/StyleCop.Analyzers/SpacingRules/SA1021NegativeSignsMustBeSpacedCorrectly.cs

@@ -86,6 +86,7 @@ private static void HandleMinusToken(SyntaxTreeAnalysisContext context, SyntaxTo
             bool followsSpecialCharacter = false;
 
             bool followedBySpace = token.IsFollowedByWhitespace();
+            bool interpolatedUnaryExpression = token.IsInterpolatedUnaryExpression();
             bool lastInLine = token.IsLastInLine();
 
             if (!firstInLine)
@@ -96,7 +97,8 @@ private static void HandleMinusToken(SyntaxTreeAnalysisContext context, SyntaxTo
                 followsSpecialCharacter =
                     precedingToken.IsKind(SyntaxKind.OpenBracketToken)
                     || precedingToken.IsKind(SyntaxKind.OpenParenToken)
-                    || precedingToken.IsKind(SyntaxKind.CloseParenToken);
+                    || precedingToken.IsKind(SyntaxKind.CloseParenToken)
+                    || (precedingToken.IsKind(SyntaxKind.OpenBraceToken) && interpolatedUnaryExpression);
             }
 
             if (!firstInLine)

StyleCop.Analyzers/StyleCop.Analyzers/SpacingRules/SA1022PositiveSignsMustBeSpacedCorrectly.cs

@@ -86,6 +86,7 @@ private static void HandlePlusToken(SyntaxTreeAnalysisContext context, SyntaxTok
             bool followsSpecialCharacter = false;
 
             bool followedBySpace = token.IsFollowedByWhitespace();
+            bool interpolatedUnaryExpression = token.IsInterpolatedUnaryExpression();
             bool lastInLine = token.IsLastInLine();
 
             if (!firstInLine)
@@ -96,7 +97,8 @@ private static void HandlePlusToken(SyntaxTreeAnalysisContext context, SyntaxTok
                 followsSpecialCharacter =
                     precedingToken.IsKind(SyntaxKind.OpenBracketToken)
                     || precedingToken.IsKind(SyntaxKind.OpenParenToken)
-                    || precedingToken.IsKind(SyntaxKind.CloseParenToken);
+                    || precedingToken.IsKind(SyntaxKind.CloseParenToken)
+                    || (precedingToken.IsKind(SyntaxKind.OpenBraceToken) && interpolatedUnaryExpression);
             }
 
             if (!firstInLine)

documentation/SA1021.md

@@ -23,7 +23,7 @@ A negative sign within a C# element is not spaced correctly.
 
 A violation of this rule occurs when the spacing around a negative sign is not correct.
 
-A negative sign should always be preceded by a single space, unless it comes after an opening square bracket, a parenthesis, or is the first character on the line.
+A negative sign should always be preceded by a single space, unless it comes after an opening square bracket, a parenthesis, a brace of an interpolated string, or is the first character on the line.
 
 A negative sign should never be followed by whitespace, and should never be the last character on a line.
 

documentation/SA1022.md

@@ -23,7 +23,7 @@ A positive sign within a C# element is not spaced correctly.
 
 A violation of this rule occurs when the spacing around a positive sign is not correct.
 
-A positive sign should always be preceded by a single space, unless it comes after an opening square bracket, a parenthesis, or is the first character on the line.
+A positive sign should always be preceded by a single space, unless it comes after an opening square bracket, a parenthesis, a brace of an interpolated string, or is the first character on the line.
 
 A positive sign should never be followed by whitespace, and should never be the last character on a line.