Remove unnecessary parentheses around collection expressions

src/Analyzers/CSharp/Tests/RemoveUnnecessaryParentheses/RemoveUnnecessaryExpressionParenthesesTests.cs

@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeFixes;
@@ -20,17 +21,16 @@
 namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.RemoveUnnecessaryParentheses;
 
 [Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryParentheses)]
-public partial class RemoveUnnecessaryExpressionParenthesesTests : AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest_NoEditor
+public sealed class RemoveUnnecessaryExpressionParenthesesTests(ITestOutputHelper logger)
+    : AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest_NoEditor(logger)
 {
-    public RemoveUnnecessaryExpressionParenthesesTests(ITestOutputHelper logger)
-      : base(logger)
-    {
-    }
-
     internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProviderAndFixer(Workspace workspace)
         => (new CSharpRemoveUnnecessaryExpressionParenthesesDiagnosticAnalyzer(), new CSharpRemoveUnnecessaryParenthesesCodeFixProvider());
 
-    private async Task TestAsync(string initial, string expected, bool offeredWhenRequireForClarityIsEnabled, int index = 0)
+    private async Task TestAsync(
+        [StringSyntax(PredefinedEmbeddedLanguageNames.CSharpTest)] string initial,
+        [StringSyntax(PredefinedEmbeddedLanguageNames.CSharpTest)] string expected,
+        bool offeredWhenRequireForClarityIsEnabled, int index = 0)
     {
         await TestInRegularAndScriptAsync(initial, expected, options: RemoveAllUnnecessaryParentheses, index: index);
 
@@ -3458,4 +3458,28 @@ public void M()
             }
             """);
     }
+
+    [Fact]
+    public async Task TestRemoveAroundCollectionExpression()
+    {
+        await TestInRegularAndScriptAsync(
+            """
+            class C
+            {
+                void M(bool b)
+                {
+                    int[] a = b ? $$([1]) : []; 
+                }
+            }
+            """,
+            """
+            class C
+            {
+                void M(bool b)
+                {
+                    int[] a = b ? [1] : []; 
+                }
+            }
+            """);
+    }
 }

src/Analyzers/CSharp/Tests/UseConditionalExpression/UseConditionalExpressionForReturnTests.cs

@@ -2308,4 +2308,35 @@ public static string Method(bool empty)
             }
             """);
     }
+
+    [Fact]
+    public async Task TestWithCollectionExpressions()
+    {
+        await TestInRegularAndScript1Async(
+            """
+            class C
+            {
+                int[] M()
+                {
+                    [||]if (true)
+                    {
+                        return [0];
+                    }
+                    else
+                    {
+                        return [1];
+                    }
+                }
+            }
+            """,
+            """
+            class C
+            {
+                int[] M()
+                {
+                    return true ? [0] : [1];
+                }
+            }
+            """);
+    }
 }

src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/ParenthesizedExpressionSyntaxExtensions.cs

@@ -111,6 +111,10 @@ public static bool CanRemoveParentheses(
         if (expression.IsKind(SyntaxKind.TupleExpression))
             return true;
 
+        // ([...]) -> [...]
+        if (expression.IsKind(SyntaxKind.CollectionExpression))
+            return true;
+
         // int Prop => (x); -> int Prop => x;
         if (nodeParent is ArrowExpressionClauseSyntax arrowExpressionClause && arrowExpressionClause.Expression == node)
         {