Do not offer 'remove unnecessary parens' when it would change a collection initializer

Author: CyrusNajmabadi

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

@@ -3552,4 +3552,32 @@ public void M()
             }
             """);
     }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/78331")]
+    public async Task TestCollectionExpressionInInitializer()
+    {
+        await TestMissingInRegularAndScriptAsync("""
+            class C
+            {
+                public void M()
+                {
+                    var v = new List<int[]>() { $$([]) };
+                }
+            }
+            """);
+    }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/78331")]
+    public async Task TestAttributedLambdaExpressionInInitializer()
+    {
+        await TestMissingInRegularAndScriptAsync("""
+            class C
+            {
+                public void M()
+                {
+                    var v = new List<Action>() { $$([X] () => { }) };
+                }
+            }
+            """);
+    }
 }

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

@@ -110,15 +110,29 @@ public static bool CanRemoveParentheses(
         if (expression.IsKind(SyntaxKind.TupleExpression))
             return true;
 
+        // Cases:
+        //   {(x)} -> {x}
+        if (nodeParent is InitializerExpressionSyntax)
+        {
+            // `{ ([]) }` can't become `{ [] }` as `[` in an initializer will be parsed as an index assignment.
+            if (tokenAfterParen.Kind() == SyntaxKind.OpenBracketToken)
+                return false;
+
+            // Assignment expressions and collection expressions are not allowed in initializers
+            // as they are not parsed as expressions, but as more complex constructs
+            if (expression is AssignmentExpressionSyntax)
+                return false;
+
+            return true;
+        }
+
         // ([...]) -> [...]
         if (expression.IsKind(SyntaxKind.CollectionExpression))
             return true;
 
         // int Prop => (x); -> int Prop => x;
         if (nodeParent is ArrowExpressionClauseSyntax arrowExpressionClause && arrowExpressionClause.Expression == node)
-        {
             return true;
-        }
 
         // Easy statement-level cases:
         //   var y = (x);           -> var y = x;
@@ -181,15 +195,6 @@ public static bool CanRemoveParentheses(
         if (expression.IsKind(SyntaxKind.InterpolatedStringExpression))
             return true;
 
-        // Cases:
-        //   {(x)} -> {x}
-        if (nodeParent is InitializerExpressionSyntax)
-        {
-            // Assignment expressions and collection expressions are not allowed in initializers
-            // as they are not parsed as expressions, but as more complex constructs
-            return expression is not AssignmentExpressionSyntax and not CollectionExpressionSyntax;
-        }
-
         // Cases:
         //   new {(x)} -> {x}
         //   new { a = (x)} -> { a = x }