Merge pull request #3409 from bjornhellander/feature/Issue3386CastInRange

sharwell · web-flow · commit b5b91d7e8097 · 2021-12-09T08:41:50.000-08:00
Update SA1003 and SA1008 to not require space before a cast inside a range expression
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp8/SpacingRules/SA1003CSharp8UnitTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp8/SpacingRules/SA1003CSharp8UnitTests.cs
@@ -3,9 +3,67 @@
 
 namespace StyleCop.Analyzers.Test.CSharp8.SpacingRules
 {
+    using System.Threading;
+    using System.Threading.Tasks;
+    using Microsoft.CodeAnalysis.CSharp;
+    using Microsoft.CodeAnalysis.Testing;
     using StyleCop.Analyzers.Test.CSharp7.SpacingRules;
+    using Xunit;
+
+    using static StyleCop.Analyzers.SpacingRules.SA1003SymbolsMustBeSpacedCorrectly;
+    using static StyleCop.Analyzers.Test.Verifiers.StyleCopCodeFixVerifier<
+        StyleCop.Analyzers.SpacingRules.SA1003SymbolsMustBeSpacedCorrectly,
+        StyleCop.Analyzers.SpacingRules.SA1003CodeFixProvider>;
 
     public class SA1003CSharp8UnitTests : SA1003CSharp7UnitTests
     {
+        /// <summary>
+        /// Verifies that spacing around a range expression double dots isn't required.
+        /// </summary>
+        /// <remarks>
+        /// <para>Double dots of range expressions already provide enough spacing for readability so there is no
+        /// need to surround the range expression with spaces.</para>
+        /// </remarks>
+        /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+        [Fact]
+        [WorkItem(3386, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3386")]
+        public async Task TestRangeExpressionAsync()
+        {
+            var testCode = @"
+namespace TestNamespace
+{
+    using System;
+    public class TestClass
+    {
+        public void TestMethod()
+        {
+            var test1 = .. {|#0:(|}int)1;
+        }
+    }
+}
+";
+
+            var fixedCode = @"
+namespace TestNamespace
+{
+    using System;
+    public class TestClass
+    {
+        public void TestMethod()
+        {
+            var test1 = ..(int)1;
+        }
+    }
+}
+";
+
+            await new CSharpTest(LanguageVersion.CSharp8)
+            {
+                ReferenceAssemblies = ReferenceAssemblies.NetCore.NetCoreApp31,
+                TestCode = testCode,
+                ExpectedDiagnostics = { Diagnostic(DescriptorNotPrecededByWhitespace).WithLocation(0).WithArguments("(int)") },
+                FixedCode = fixedCode,
+            }.RunAsync(CancellationToken.None).ConfigureAwait(false);
+        }
     }
 }
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp8/SpacingRules/SA1008CSharp8UnitTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp8/SpacingRules/SA1008CSharp8UnitTests.cs
@@ -8,7 +8,6 @@ namespace StyleCop.Analyzers.Test.CSharp8.SpacingRules
     using Microsoft.CodeAnalysis.CSharp;
     using Microsoft.CodeAnalysis.Testing;
     using StyleCop.Analyzers.Test.CSharp7.SpacingRules;
-    using StyleCop.Analyzers.Test.Verifiers;
     using Xunit;
 
     using static StyleCop.Analyzers.SpacingRules.SA1008OpeningParenthesisMustBeSpacedCorrectly;
@@ -28,6 +27,7 @@ public class SA1008CSharp8UnitTests : SA1008CSharp7UnitTests
         /// </remarks>
         /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
         [Fact]
+        [WorkItem(3386, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3386")]
         public async Task TestAfterRangeExpressionAsync()
         {
             var testCode = @"
@@ -36,11 +36,12 @@ namespace TestNamespace
     using System;
     public class TestClass
     {
-        public string TestMethod()
+        public void TestMethod()
         {
             string str = ""test"";
             int finalLen = 4;
-            return str[.. {|#0:(|}finalLen - 1)];
+            var test1 = str[.. {|#0:(|}finalLen - 1)];
+            var test2 = .. {|#1:(|}int)finalLen;
         }
     }
 }
@@ -52,11 +53,12 @@ namespace TestNamespace
     using System;
     public class TestClass
     {
-        public string TestMethod()
+        public void TestMethod()
         {
             string str = ""test"";
             int finalLen = 4;
-            return str[..(finalLen - 1)];
+            var test1 = str[..(finalLen - 1)];
+            var test2 = ..(int)finalLen;
         }
     }
 }
@@ -66,7 +68,11 @@ public string TestMethod()
             {
                 ReferenceAssemblies = ReferenceAssemblies.NetCore.NetCoreApp31,
                 TestCode = testCode,
-                ExpectedDiagnostics = { Diagnostic(DescriptorNotPreceded).WithLocation(0) },
+                ExpectedDiagnostics =
+                {
+                    Diagnostic(DescriptorNotPreceded).WithLocation(0),
+                    Diagnostic(DescriptorNotPreceded).WithLocation(1),
+                },
                 FixedCode = fixedCode,
             }.RunAsync(CancellationToken.None).ConfigureAwait(false);
         }
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/SpacingRules/SA1003SymbolsMustBeSpacedCorrectly.cs b/StyleCop.Analyzers/StyleCop.Analyzers/SpacingRules/SA1003SymbolsMustBeSpacedCorrectly.cs
@@ -10,6 +10,7 @@ namespace StyleCop.Analyzers.SpacingRules
     using Microsoft.CodeAnalysis.CSharp.Syntax;
     using Microsoft.CodeAnalysis.Diagnostics;
     using StyleCop.Analyzers.Helpers;
+    using StyleCop.Analyzers.Lightup;
 
     /// <summary>
     /// The spacing around an operator symbol is incorrect, within a C# code file.
@@ -344,7 +345,8 @@ private static void HandleCastExpression(SyntaxNodeAnalysisContext context)
                 && !(castExpression.Parent is CastExpressionSyntax)
                 && !precedingToken.IsKind(SyntaxKind.OpenParenToken)
                 && !precedingToken.IsKind(SyntaxKind.OpenBracketToken)
-                && !(precedingToken.IsKind(SyntaxKind.OpenBraceToken) && (precedingToken.Parent is InterpolationSyntax));
+                && !(precedingToken.IsKind(SyntaxKind.OpenBraceToken) && (precedingToken.Parent is InterpolationSyntax))
+                && !precedingToken.IsKind(SyntaxKindEx.DotDotToken);
 
             var tokenString = castExpression.OpenParenToken.ToString() + castExpression.Type.ToString() + castExpression.CloseParenToken.ToString();
             CheckToken(context, castExpression.OpenParenToken, mustHaveLeadingWhitespace, false, false, tokenString);
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/SpacingRules/SA1008OpeningParenthesisMustBeSpacedCorrectly.cs b/StyleCop.Analyzers/StyleCop.Analyzers/SpacingRules/SA1008OpeningParenthesisMustBeSpacedCorrectly.cs
@@ -231,8 +231,9 @@ private static void HandleOpenParenToken(SyntaxTreeAnalysisContext context, Synt
                 startOfIndexer = prevToken.IsKind(SyntaxKind.OpenBracketToken);
                 var consecutiveCast = prevToken.IsKind(SyntaxKind.CloseParenToken) && prevToken.Parent.IsKind(SyntaxKind.CastExpression);
                 var partOfInterpolation = prevToken.IsKind(SyntaxKind.OpenBraceToken) && prevToken.Parent.IsKind(SyntaxKind.Interpolation);
+                var partOfRange = prevToken.IsKind(SyntaxKindEx.DotDotToken);
 
-                haveLeadingSpace = !partOfUnaryExpression && !startOfIndexer && !consecutiveCast && !partOfInterpolation;
+                haveLeadingSpace = !partOfUnaryExpression && !startOfIndexer && !consecutiveCast && !partOfInterpolation && !partOfRange;
                 break;
 
             case SyntaxKind.ParameterList:

Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,6 @@ namespace StyleCop.Analyzers.Test.CSharp8.SpacingRules`
`8`	`8`	`using Microsoft.CodeAnalysis.CSharp;`
`9`	`9`	`using Microsoft.CodeAnalysis.Testing;`
`10`	`10`	`using StyleCop.Analyzers.Test.CSharp7.SpacingRules;`
`11`		`- using StyleCop.Analyzers.Test.Verifiers;`
`12`	`11`	`using Xunit;`
`13`	`12`
`14`	`13`	`using static StyleCop.Analyzers.SpacingRules.SA1008OpeningParenthesisMustBeSpacedCorrectly;`
`@@ -28,6 +27,7 @@ public class SA1008CSharp8UnitTests : SA1008CSharp7UnitTests`
`28`	`27`	`/// </remarks>`
`29`	`28`	`/// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>`
`30`	`29`	`[Fact]`
	`30`	`+ [WorkItem(3386, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3386")]`
`31`	`31`	`public async Task TestAfterRangeExpressionAsync()`
`32`	`32`	`{`
`33`	`33`	`var testCode = @"`
`@@ -36,11 +36,12 @@ namespace TestNamespace`
`36`	`36`	`using System;`
`37`	`37`	`public class TestClass`
`38`	`38`	`{`
`39`		`- public string TestMethod()`
	`39`	`+ public void TestMethod()`
`40`	`40`	`{`
`41`	`41`	`string str = ""test"";`
`42`	`42`	`int finalLen = 4;`
`43`		`- return str[.. {\|#0:(\|}finalLen - 1)];`
	`43`	`+ var test1 = str[.. {\|#0:(\|}finalLen - 1)];`
	`44`	`+ var test2 = .. {\|#1:(\|}int)finalLen;`
`44`	`45`	`}`
`45`	`46`	`}`
`46`	`47`	`}`
`@@ -52,11 +53,12 @@ namespace TestNamespace`
`52`	`53`	`using System;`
`53`	`54`	`public class TestClass`
`54`	`55`	`{`
`55`		`- public string TestMethod()`
	`56`	`+ public void TestMethod()`
`56`	`57`	`{`
`57`	`58`	`string str = ""test"";`
`58`	`59`	`int finalLen = 4;`
`59`		`- return str[..(finalLen - 1)];`
	`60`	`+ var test1 = str[..(finalLen - 1)];`
	`61`	`+ var test2 = ..(int)finalLen;`
`60`	`62`	`}`
`61`	`63`	`}`
`62`	`64`	`}`
`@@ -66,7 +68,11 @@ public string TestMethod()`
`66`	`68`	`{`
`67`	`69`	`ReferenceAssemblies = ReferenceAssemblies.NetCore.NetCoreApp31,`
`68`	`70`	`TestCode = testCode,`
`69`		`- ExpectedDiagnostics = { Diagnostic(DescriptorNotPreceded).WithLocation(0) },`
	`71`	`+ ExpectedDiagnostics =`
	`72`	`+ {`
	`73`	`+ Diagnostic(DescriptorNotPreceded).WithLocation(0),`
	`74`	`+ Diagnostic(DescriptorNotPreceded).WithLocation(1),`
	`75`	`+ },`
`70`	`76`	`FixedCode = fixedCode,`
`71`	`77`	`}.RunAsync(CancellationToken.None).ConfigureAwait(false);`
`72`	`78`	`}`