Merge pull request #3462 from sharwell/await-switch

Support awaiting a parenthesized 'switch' or 'with' expression

Author: sharwell

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

@@ -79,6 +79,71 @@ public string TestMethod(int n, object a, object b)
             await VerifyCSharpFixAsync(LanguageVersion.CSharp8, testCode, expected, fixedCode, CancellationToken.None).ConfigureAwait(false);
         }
 
+        /// <summary>
+        /// Verifies that <see langword="await"/> followed by a switch expression is handled correctly.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+        [Fact]
+        [WorkItem(3460, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3460")]
+        public async Task TestAwaitFollowedBySwitchExpressionIsHandledCorrectlyAsync()
+        {
+            const string testCode = @"
+using System.Threading.Tasks;
+
+public class Foo
+{
+    public async Task<string> TestMethod(int n, Task<string> a, Task<string> b)
+    {
+        return await (n switch { 1 => a, 2 => b });
+    }
+}
+";
+
+            await VerifyCSharpDiagnosticAsync(LanguageVersion.CSharp8, testCode, DiagnosticResult.EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Verifies that <see langword="await"/> 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(3460, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3460")]
+        public async Task TestAwaitFollowedBySwitchExpressionWithUnnecessaryParenthesisIsHandledCorrectlyAsync()
+        {
+            const string testCode = @"
+using System.Threading.Tasks;
+
+public class Foo
+{
+    public async Task<string> TestMethod(int n, Task<string> a, Task<string> b)
+    {
+        return await {|#0:{|#1:(|}(n switch { 1 => a, 2 => b }){|#2:)|}|};
+    }
+}
+";
+
+            const string fixedCode = @"
+using System.Threading.Tasks;
+
+public class Foo
+{
+    public async Task<string> TestMethod(int n, Task<string> a, Task<string> b)
+    {
+        return await (n switch { 1 => a, 2 => b });
+    }
+}
+";
+
+            DiagnosticResult[] expected =
+            {
+                Diagnostic(DiagnosticId).WithLocation(0),
+                Diagnostic(ParenthesesDiagnosticId).WithLocation(1),
+                Diagnostic(ParenthesesDiagnosticId).WithLocation(2),
+            };
+
+            await VerifyCSharpFixAsync(LanguageVersion.CSharp8, testCode, expected, fixedCode, CancellationToken.None).ConfigureAwait(false);
+        }
+
         /// <summary>
         /// Verifies that a switch expression with unnecessary parenthesis is handled correcly.
         /// </summary>

StyleCop.Analyzers/StyleCop.Analyzers/Helpers/ExpressionSyntaxHelpers.cs

@@ -1,8 +1,6 @@
 // Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
 // Licensed under the MIT License. See LICENSE in the project root for license information.
 
-#nullable disable
-
 namespace StyleCop.Analyzers.Helpers
 {
     using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -19,5 +17,16 @@ public static ExpressionSyntax WalkDownParentheses(this ExpressionSyntax express
 
             return result;
         }
+
+        public static ExpressionSyntax WalkUpParentheses(this ExpressionSyntax expression)
+        {
+            var result = expression;
+            while (result.Parent is ParenthesizedExpressionSyntax parenthesizedExpression)
+            {
+                result = parenthesizedExpression;
+            }
+
+            return result;
+        }
     }
 }

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

@@ -130,12 +130,7 @@ private static void HandleParenthesizedExpression(SyntaxNodeAnalysisContext cont
                         return;
                     }
 
-                    if (IsSwitchOrWithExpressionPrecededByTypeCast(node))
-                    {
-                        return;
-                    }
-
-                    if (IsSwitchOrWithExpressionExpressionOfMemberAccess(node))
+                    if (IsSwitchOrWithExpressionWithRequiredParentheses(node))
                     {
                         return;
                     }
@@ -219,37 +214,22 @@ private static bool IsConditionalAccessInInterpolation(ExpressionSyntax node)
             return false;
         }
 
-        private static bool IsSwitchOrWithExpressionPrecededByTypeCast(ParenthesizedExpressionSyntax node)
-        {
-            if (!node.Expression.IsKind(SyntaxKindEx.SwitchExpression)
-                && !node.Expression.IsKind(SyntaxKindEx.WithExpression))
-            {
-                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 bool IsSwitchOrWithExpressionExpressionOfMemberAccess(ParenthesizedExpressionSyntax node)
+        private static bool IsSwitchOrWithExpressionWithRequiredParentheses(ParenthesizedExpressionSyntax node)
         {
             if (!node.Expression.IsKind(SyntaxKindEx.SwitchExpression)
                 && !node.Expression.IsKind(SyntaxKindEx.WithExpression))
             {
                 return false;
             }
 
-            return node.Parent switch
+            var outerExpression = node.WalkUpParentheses();
+            return outerExpression.Parent switch
             {
-                MemberAccessExpressionSyntax memberAccessExpression => memberAccessExpression.Expression == node,
-                ConditionalAccessExpressionSyntax conditionalAccessExpression => conditionalAccessExpression.Expression == node,
-                ElementAccessExpressionSyntax elementAccessExpression => elementAccessExpression.Expression == node,
+                AwaitExpressionSyntax awaitExpression => awaitExpression.Expression == outerExpression,
+                CastExpressionSyntax castExpression => castExpression.Expression == outerExpression,
+                MemberAccessExpressionSyntax memberAccessExpression => memberAccessExpression.Expression == outerExpression,
+                ConditionalAccessExpressionSyntax conditionalAccessExpression => conditionalAccessExpression.Expression == outerExpression,
+                ElementAccessExpressionSyntax elementAccessExpression => elementAccessExpression.Expression == outerExpression,
                 _ => false,
             };
         }