Merge pull request #3178 from vweijsters/fix-3171

SA1119: Added support for typecast followed by switch expression

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/MaintainabilityRules/SA1119CodeFixProvider.cs

@@ -74,7 +74,8 @@ private static SyntaxNode GetReplacement(ParenthesizedExpressionSyntax oldNode)
             if (!leadingTrivia.Any())
             {
                 var previousToken = oldNode.OpenParenToken.GetPreviousToken();
-                if (!previousToken.IsKind(SyntaxKind.OpenParenToken) && (TriviaHelper.IndexOfTrailingWhitespace(previousToken.TrailingTrivia) == -1))
+                if (!(previousToken.IsKind(SyntaxKind.OpenParenToken) || previousToken.IsKind(SyntaxKind.CloseParenToken))
+                    && (TriviaHelper.IndexOfTrailingWhitespace(previousToken.TrailingTrivia) == -1))
                 {
                     leadingTrivia = SyntaxFactory.TriviaList(SyntaxFactory.Space);
                 }

StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp8/MaintainabilityRules/SA1119CSharp8UnitTests.cs

@@ -3,9 +3,118 @@
 
 namespace StyleCop.Analyzers.Test.CSharp8.MaintainabilityRules
 {
+    using System.Threading;
+    using System.Threading.Tasks;
+
+    using Microsoft.CodeAnalysis.CSharp;
+    using Microsoft.CodeAnalysis.Testing;
+
+    using StyleCop.Analyzers.Lightup;
     using StyleCop.Analyzers.Test.CSharp7.MaintainabilityRules;
 
+    using Xunit;
+
+    using static StyleCop.Analyzers.Test.Verifiers.StyleCopCodeFixVerifier<
+        StyleCop.Analyzers.MaintainabilityRules.SA1119StatementMustNotUseUnnecessaryParenthesis,
+        StyleCop.Analyzers.MaintainabilityRules.SA1119CodeFixProvider>;
+
     public class SA1119CSharp8UnitTests : SA1119CSharp7UnitTests
     {
+        /// <summary>
+        /// Verifies that a type cast followed by a switch expression is handled correctly.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+        [Fact]
+        [WorkItem(3171, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3171")]
+        public async Task TestTypeCastFollowedBySwitchExpressionIsHandledCorrectlyAsync()
+        {
+            const string testCode = @"
+public class Foo
+{
+    public string TestMethod(int n, object a, object b)
+    {
+        return (string)(n switch { 1 => a, 2 => b });
+    }
+}
+";
+
+            await VerifyCSharpDiagnosticAsync(LanguageVersion.CSharp8, testCode, DiagnosticResult.EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Verifies that a type cast followed by a switch expression with unnecessary parenthesis is handled correctly.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+        [Fact]
+        [WorkItem(3171, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3171")]
+        public async Task TestTypeCastFollowedBySwitchExpressionWithUnnecessaryParenthesisIsHandledCorrectlyAsync()
+        {
+            const string testCode = @"
+public class Foo
+{
+    public string TestMethod(int n, object a, object b)
+    {
+        return (string)((n switch { 1 => a, 2 => b }));
+    }
+}
+";
+
+            const string fixedCode = @"
+public class Foo
+{
+    public string TestMethod(int n, object a, object b)
+    {
+        return (string)(n switch { 1 => a, 2 => b });
+    }
+}
+";
+
+            DiagnosticResult[] expected =
+            {
+                Diagnostic(DiagnosticId).WithSpan(6, 24, 6, 55),
+                Diagnostic(ParenthesesDiagnosticId).WithLocation(6, 24),
+                Diagnostic(ParenthesesDiagnosticId).WithLocation(6, 54),
+            };
+
+            await VerifyCSharpFixAsync(LanguageVersion.CSharp8, testCode, expected, fixedCode, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Verifies that a switch expression with unnecessary parenthesis is handled correcly.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+        [Fact]
+        [WorkItem(3171, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3171")]
+        public async Task TestSwitchExpressionWithUnnecessaryParenthesisAsync()
+        {
+            const string testCode = @"
+public class Foo
+{
+    public void TestMethod(int n, object a, object b)
+    {
+        var test = (n switch { 1 => a, 2 => b });
+    }
+}
+";
+
+            const string fixedCode = @"
+public class Foo
+{
+    public void TestMethod(int n, object a, object b)
+    {
+        var test = n switch { 1 => a, 2 => b };
+    }
+}
+";
+
+            DiagnosticResult[] expected =
+            {
+                Diagnostic(DiagnosticId).WithSpan(6, 20, 6, 49),
+                Diagnostic(ParenthesesDiagnosticId).WithLocation(6, 20),
+                Diagnostic(ParenthesesDiagnosticId).WithLocation(6, 48),
+            };
+
+            await VerifyCSharpFixAsync(LanguageVersion.CSharp8, testCode, expected, fixedCode, CancellationToken.None).ConfigureAwait(false);
+        }
     }
 }

StyleCop.Analyzers/StyleCop.Analyzers/MaintainabilityRules/SA1119StatementMustNotUseUnnecessaryParenthesis.cs

@@ -125,6 +125,11 @@ private static void HandleParenthesizedExpression(SyntaxNodeAnalysisContext cont
                         return;
                     }
 
+                    if (IsSwitchExpressionPrecededByTypeCast(node))
+                    {
+                        return;
+                    }
+
                     ReportDiagnostic(context, node);
                 }
                 else
@@ -197,6 +202,23 @@ private static bool IsConditionalAccessInInterpolation(ExpressionSyntax node)
             return false;
         }
 
+        private static bool IsSwitchExpressionPrecededByTypeCast(ParenthesizedExpressionSyntax node)
+        {
+            if (!node.Expression.IsKind(SyntaxKindEx.SwitchExpression))
+            {
+                return false;
+            }
+
+            var previousToken = node.OpenParenToken.GetPreviousToken();
+
+            while (previousToken.IsKind(SyntaxKind.OpenParenToken) && previousToken.Parent.IsKind(SyntaxKind.ParenthesizedExpression))
+            {
+                previousToken = previousToken.GetPreviousToken();
+            }
+
+            return previousToken.IsKind(SyntaxKind.CloseParenToken) && previousToken.Parent.IsKind(SyntaxKind.CastExpression);
+        }
+
         private static void ReportDiagnostic(SyntaxNodeAnalysisContext context, ParenthesizedExpressionSyntax node)
         {
             context.ReportDiagnostic(Diagnostic.Create(Descriptor, node.GetLocation()));