Added suggested unit test and fixed code

Author: vweijsters

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

@@ -42,7 +42,45 @@ public string TestMethod(int n, object a, object b)
         }
 
         /// <summary>
-        /// Verifies that a swith expression with unnecessary parenthesis is handled correcly.
+        /// 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]

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

@@ -210,6 +210,12 @@ private static bool IsSwitchExpressionPrecededByTypeCast(ParenthesizedExpression
             }
 
             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);
         }