diff --git a/.editorconfig b/.editorconfig
index f9ecc06957..8e329bae64 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -6,6 +6,12 @@ root = true
 [*]
 indent_style = space
 
+[*.xml]
+indent_size = 2
+
+[Analyzers.xml]
+trim_trailing_whitespace = false
+
 # Code files
 [*.{cs,csx}]
 indent_size = 4
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index f3c90a08ef..ae7e800a61 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -71,7 +71,7 @@ jobs:
             ../wordb/data/tech.acronyms.txt
 
   build_core_and_testing:
-    if: github.ref_type != 'tag' || startsWith(github.ref_name, 'v') 
+    if: github.ref_type != 'tag' || startsWith(github.ref_name, 'v')
     needs: pre_build
     runs-on: ubuntu-24.04
     env:
@@ -90,7 +90,7 @@ jobs:
           path: src/_nupkg/*nupkg
 
   build_analyzers:
-    if: github.ref_type != 'tag' || startsWith(github.ref_name, 'v') 
+    if: github.ref_type != 'tag' || startsWith(github.ref_name, 'v')
     needs: pre_build
     runs-on: ubuntu-24.04
     env:
@@ -123,7 +123,7 @@ jobs:
           path: src/${{ matrix.component.name }}.CodeFixes/bin/Release/*.*nupkg
 
   build_refactorings:
-    if: github.ref_type != 'tag' || startsWith(github.ref_name, 'v') 
+    if: github.ref_type != 'tag' || startsWith(github.ref_name, 'v')
     needs: pre_build
     runs-on: ubuntu-24.04
     env:
@@ -144,7 +144,7 @@ jobs:
           path: src/Refactorings/bin/Release/*.*nupkg
 
   build_code_fixes:
-    if: github.ref_type != 'tag' || startsWith(github.ref_name, 'v') 
+    if: github.ref_type != 'tag' || startsWith(github.ref_name, 'v')
     needs: pre_build
     runs-on: ubuntu-24.04
     env:
@@ -165,7 +165,7 @@ jobs:
           path: src/CodeFixes/bin/Release/*.*nupkg
 
   build_vs_extension:
-    if: github.ref_type != 'tag' || startsWith(github.ref_name, 'v') 
+    if: github.ref_type != 'tag' || startsWith(github.ref_name, 'v')
     needs: pre_build
     runs-on: windows-latest
     env:
@@ -199,7 +199,7 @@ jobs:
           delete-merged: true
 
   build_vs_code_extension:
-    if: github.ref_type != 'tag' || startsWith(github.ref_name, 'v') 
+    if: github.ref_type != 'tag' || startsWith(github.ref_name, 'v')
     needs: [ pre_build, build_analyzers ]
     runs-on: ubuntu-24.04
     env:
@@ -209,6 +209,9 @@ jobs:
         working-directory: src/VisualStudioCode
     steps:
       - uses: actions/checkout@v4
+      - uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: 9.0.301
       - run: dotnet restore
       - run: dotnet build --no-restore
       - run: |
@@ -263,7 +266,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: 9.0.101
+          dotnet-version: 9.0.301
       - run: dotnet restore
       - run: dotnet build --no-restore
       - run: dotnet pack --no-build
diff --git a/.gitignore b/.gitignore
index aa3419f5f5..a5ec2da68c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -140,7 +140,7 @@ publish/
 *.[Pp]ublish.xml
 *.azurePubxml
 
-# TODO: Un-comment the next line if you do not want to checkin 
+# TODO: Un-comment the next line if you do not want to checkin
 # your web deploy settings because they may include unencrypted
 # passwords
 #*.pubxml
@@ -244,4 +244,7 @@ ModelManifest.xml
 # FAKE - F# Make
 .fake/
 
-.DS_Store
\ No newline at end of file
+.DS_Store
+
+# JetBrains Rider setting files
+.idea/
diff --git a/src/Analyzers.xml b/src/Analyzers.xml
index 072001d577..f2ff360b3e 100644
--- a/src/Analyzers.xml
+++ b/src/Analyzers.xml
@@ -7819,6 +7819,46 @@ string s = """
       </Sample>
     </Samples>
   </Analyzer>
+  <Analyzer>
+    <Id>RCS1269</Id>
+    <Identifier>FixBracketFormattingOfList</Identifier>
+    <Title>Fix bracket formatting of a list</Title>
+    <MessageFormat>Fix bracket formatting of {0}</MessageFormat>
+    <DefaultSeverity>Info</DefaultSeverity>
+    <IsEnabledByDefault>false</IsEnabledByDefault>
+    <ConfigOptions>
+      <Option Key="target_braces_style" />
+    </ConfigOptions>
+    <Summary>
+      This analyzer:
+        * adds new line after an opening bracket of argument/parameter lists and similar lists
+        * adds new line before a closing bracket of argument/parameter lists and similar lists
+        * aligns the closing bracket with the block containing its opening bracket
+      The analyzer works only for multi-line declarations.
+    </Summary>
+    <Samples>
+      <Sample>
+        <Before><![CDATA[void M(object x,
+        object y)
+{
+}]]></Before>
+        <After><![CDATA[void M(
+    object x,
+    object y
+)
+{
+}]]></After>
+      </Sample>
+      <Sample>
+        <Before><![CDATA[Method(xParameter,
+    yParameter);]]></Before>
+        <After><![CDATA[Method(
+    xParameter,
+    yParameter
+);]]></After>
+      </Sample>
+    </Samples>
+  </Analyzer>
   <Analyzer>
     <Id>RCS9001</Id>
     <Identifier>UsePatternMatching</Identifier>
diff --git a/src/CSharp/DetermineParameterTypeHelper.cs b/src/CSharp/DetermineParameterTypeHelper.cs
index 85ed539cf6..dabed05fee 100644
--- a/src/CSharp/DetermineParameterTypeHelper.cs
+++ b/src/CSharp/DetermineParameterTypeHelper.cs
@@ -45,7 +45,7 @@ public static ImmutableArray<ITypeSymbol> DetermineParameterTypes(
 
                         if (typeSymbol?.IsErrorType() == false)
                         {
-                            (typeSymbols ??= new HashSet<ITypeSymbol>()).Add(typeSymbol);
+                            (typeSymbols ??= new HashSet<ITypeSymbol>(SymbolEqualityComparer.Default)).Add(typeSymbol);
                         }
                     }
 
diff --git a/src/Common/CSharp/CodeStyle/TargetBracesStyle.cs b/src/Common/CSharp/CodeStyle/TargetBracesStyle.cs
new file mode 100644
index 0000000000..5c6ee146b9
--- /dev/null
+++ b/src/Common/CSharp/CodeStyle/TargetBracesStyle.cs
@@ -0,0 +1,14 @@
+// Copyright (c) .NET Foundation and Contributors. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+
+namespace Roslynator.CSharp.CodeStyle;
+
+[Flags]
+public enum TargetBracesStyle
+{
+    None,
+    Opening,
+    Closing,
+    Both = Opening | Closing,
+}
diff --git a/src/Common/CSharp/Extensions/CodeStyleExtensions.cs b/src/Common/CSharp/Extensions/CodeStyleExtensions.cs
index 48fafdc967..eb853672f2 100644
--- a/src/Common/CSharp/Extensions/CodeStyleExtensions.cs
+++ b/src/Common/CSharp/Extensions/CodeStyleExtensions.cs
@@ -656,6 +656,30 @@ public static NewLinePosition GetNullConditionalOperatorNewLinePosition(this Syn
         return context.GetConfigOptions().GetNullConditionalOperatorNewLinePosition(defaultValue);
     }
 
+    public static TargetBracesStyle GetTargetBracesStyle(this SyntaxNodeAnalysisContext context)
+        => context.GetConfigOptions().GetTargetBracesStyle();
+
+    public static TargetBracesStyle GetTargetBracesStyle(this AnalyzerConfigOptions configOptions)
+    {
+        if (ConfigOptions.TryGetValue(configOptions, ConfigOptions.TargetBracesStyle, out string rawValue))
+        {
+            if (string.Equals(rawValue, ConfigOptionValues.TargetBracesStyle_Both, StringComparison.OrdinalIgnoreCase))
+            {
+                return TargetBracesStyle.Both;
+            }
+            else if (string.Equals(rawValue, ConfigOptionValues.TargetBracesStyle_Closing, StringComparison.OrdinalIgnoreCase))
+            {
+                return TargetBracesStyle.Closing;
+            }
+            else if (string.Equals(rawValue, ConfigOptionValues.TargetBracesStyle_Opening, StringComparison.OrdinalIgnoreCase))
+            {
+                return TargetBracesStyle.Opening;
+            }
+        }
+
+        return TargetBracesStyle.None;
+    }
+
     private static bool TryGetNewLinePosition(
         AnalyzerConfigOptions configOptions,
         ConfigOptionDescriptor option,
diff --git a/src/Common/CSharp/SyntaxTriviaAnalysis.cs b/src/Common/CSharp/SyntaxTriviaAnalysis.cs
index e995ce2e8b..5bc1fedd42 100644
--- a/src/Common/CSharp/SyntaxTriviaAnalysis.cs
+++ b/src/Common/CSharp/SyntaxTriviaAnalysis.cs
@@ -111,6 +111,9 @@ public static IndentationAnalysis AnalyzeIndentation(SyntaxNode node, AnalyzerCo
     }
 
     public static SyntaxTrivia DetermineIndentation(SyntaxNodeOrToken nodeOrToken, CancellationToken cancellationToken = default)
+        => DetermineIndentation(nodeOrToken, true, cancellationToken);
+
+    public static SyntaxTrivia DetermineIndentation(SyntaxNodeOrToken nodeOrToken, bool searchInAccessors, CancellationToken cancellationToken = default)
     {
         SyntaxTree tree = nodeOrToken.SyntaxTree;
 
@@ -171,7 +174,7 @@ public static SyntaxTrivia DetermineIndentation(SyntaxNodeOrToken nodeOrToken, C
             }
         }
 
-        if (!IsMemberDeclarationOrStatementOrAccessorDeclaration(node))
+        if (searchInAccessors && !IsMemberDeclarationOrStatementOrAccessorDeclaration(node))
         {
             node = node.Parent;
 
diff --git a/src/Common/ConfigOptionKeys.Generated.cs b/src/Common/ConfigOptionKeys.Generated.cs
index d03c51daff..b5b25046a3 100644
--- a/src/Common/ConfigOptionKeys.Generated.cs
+++ b/src/Common/ConfigOptionKeys.Generated.cs
@@ -37,6 +37,7 @@ internal static partial class ConfigOptionKeys
         public const string PrefixFieldIdentifierWithUnderscore               = "roslynator_prefix_field_identifier_with_underscore";
         public const string SuppressUnityScriptMethods                        = "roslynator_suppress_unity_script_methods";
         public const string TabLength                                         = "roslynator_tab_length";
+        public const string TargetBracesStyle                                 = "roslynator_target_braces_style";
         public const string TrailingCommaStyle                                = "roslynator_trailing_comma_style";
         public const string UnityCodeAnalysisEnabled                          = "roslynator_unity_code_analysis.enabled";
         public const string UseAnonymousFunctionOrMethodGroup                 = "roslynator_use_anonymous_function_or_method_group";
diff --git a/src/Common/ConfigOptionValues.Generated.cs b/src/Common/ConfigOptionValues.Generated.cs
index 06ae33fb45..ee449d1350 100644
--- a/src/Common/ConfigOptionValues.Generated.cs
+++ b/src/Common/ConfigOptionValues.Generated.cs
@@ -52,6 +52,10 @@ internal static partial class ConfigOptionValues
         public const string ObjectCreationTypeStyle_Explicit                                            = "explicit";
         public const string ObjectCreationTypeStyle_Implicit                                            = "implicit";
         public const string ObjectCreationTypeStyle_ImplicitWhenTypeIsObvious                           = "implicit_when_type_is_obvious";
+        public const string TargetBracesStyle_None                                                      = "none";
+        public const string TargetBracesStyle_Opening                                                   = "opening";
+        public const string TargetBracesStyle_Closing                                                   = "closing";
+        public const string TargetBracesStyle_Both                                                      = "both";
         public const string TrailingCommaStyle_Include                                                  = "include";
         public const string TrailingCommaStyle_Omit                                                     = "omit";
         public const string TrailingCommaStyle_OmitWhenSingleLine                                       = "omit_when_single_line";
diff --git a/src/Common/ConfigOptions.Generated.cs b/src/Common/ConfigOptions.Generated.cs
index 556a34bd13..95e6066949 100644
--- a/src/Common/ConfigOptions.Generated.cs
+++ b/src/Common/ConfigOptions.Generated.cs
@@ -196,6 +196,12 @@ public static partial class ConfigOptions
             defaultValuePlaceholder: "<NUM>", 
             description:             "A number of spaces that are equivalent to a tab character");
 
+        public static readonly ConfigOptionDescriptor TargetBracesStyle = new(
+            key:                     ConfigOptionKeys.TargetBracesStyle, 
+            defaultValue:            "none", 
+            defaultValuePlaceholder: "both|closing|none|opening", 
+            description:             "Define which braces should be used as a target of the code fix");
+
         public static readonly ConfigOptionDescriptor TrailingCommaStyle = new(
             key:                     ConfigOptionKeys.TrailingCommaStyle, 
             defaultValue:            null, 
diff --git a/src/Common/DiagnosticIdentifiers.Generated.cs b/src/Common/DiagnosticIdentifiers.Generated.cs
index 7d6e59085e..3f811ce922 100644
--- a/src/Common/DiagnosticIdentifiers.Generated.cs
+++ b/src/Common/DiagnosticIdentifiers.Generated.cs
@@ -280,5 +280,6 @@ public static partial class DiagnosticIdentifiers
         public const string UseRawStringLiteral = "RCS1266";
         public const string UseStringInterpolationInsteadOfStringConcat = "RCS1267";
         public const string SimplifyNumericComparison = "RCS1268";
+        public const string FixBracketFormattingOfList = "RCS1269";
     }
 }
\ No newline at end of file
diff --git a/src/Common/DiagnosticRules.Generated.cs b/src/Common/DiagnosticRules.Generated.cs
index 0b631ac6fb..e9f72ec0e6 100644
--- a/src/Common/DiagnosticRules.Generated.cs
+++ b/src/Common/DiagnosticRules.Generated.cs
@@ -3323,5 +3323,17 @@ public static partial class DiagnosticRules
             helpLinkUri:        DiagnosticIdentifiers.SimplifyNumericComparison, 
             customTags:         []);
 
+        /// <summary>RCS1269</summary>
+        public static readonly DiagnosticDescriptor FixBracketFormattingOfList = DiagnosticDescriptorFactory.Create(
+            id:                 DiagnosticIdentifiers.FixBracketFormattingOfList, 
+            title:              "Fix bracket formatting of a list", 
+            messageFormat:      "Fix bracket formatting of {0}", 
+            category:           DiagnosticCategories.Roslynator, 
+            defaultSeverity:    DiagnosticSeverity.Info, 
+            isEnabledByDefault: false, 
+            description:        null, 
+            helpLinkUri:        DiagnosticIdentifiers.FixBracketFormattingOfList, 
+            customTags:         []);
+
     }
 }
\ No newline at end of file
diff --git a/src/ConfigOptions.xml b/src/ConfigOptions.xml
index 7e43508098..cb70170eee 100644
--- a/src/ConfigOptions.xml
+++ b/src/ConfigOptions.xml
@@ -237,6 +237,15 @@
       <Value>when_type_is_obvious</Value>
     </Values>
   </Option>
+  <Option Id="TargetBracesStyle">
+    <Description>Define which braces should be used as a target of the code fix</Description>
+    <Values>
+      <Value IsDefault="true">none</Value>
+      <Value>opening</Value>
+      <Value>closing</Value>
+      <Value>both</Value>
+    </Values>
+  </Option>
   <!--
   <Option Id="">
     <Key></Key>
diff --git a/src/Documentation/DocumentationModel.cs b/src/Documentation/DocumentationModel.cs
index f44e3707ad..c9fda2e289 100644
--- a/src/Documentation/DocumentationModel.cs
+++ b/src/Documentation/DocumentationModel.cs
@@ -36,8 +36,8 @@ internal DocumentationModel(
         Assemblies = ImmutableArray.CreateRange(assemblies);
         Filter = filter;
 
-        _symbolData = new Dictionary<ISymbol, SymbolDocumentationData>();
-        _xmlDocumentations = new Dictionary<IAssemblySymbol, XmlDocumentation>();
+        _symbolData = new Dictionary<ISymbol, SymbolDocumentationData>(SymbolEqualityComparer.Default);
+        _xmlDocumentations = new Dictionary<IAssemblySymbol, XmlDocumentation>(SymbolEqualityComparer.Default);
 
         if (additionalXmlDocumentationPaths is not null)
             _additionalXmlDocumentationPaths = additionalXmlDocumentationPaths.ToImmutableArray();
@@ -52,8 +52,8 @@ internal DocumentationModel(
         Assemblies = compilations.Select(f => f.Assembly).ToImmutableArray();
         Filter = filter;
 
-        _symbolData = new Dictionary<ISymbol, SymbolDocumentationData>();
-        _xmlDocumentations = new Dictionary<IAssemblySymbol, XmlDocumentation>();
+        _symbolData = new Dictionary<ISymbol, SymbolDocumentationData>(SymbolEqualityComparer.Default);
+        _xmlDocumentations = new Dictionary<IAssemblySymbol, XmlDocumentation>(SymbolEqualityComparer.Default);
 
         if (additionalXmlDocumentationPaths is not null)
             _additionalXmlDocumentationPaths = additionalXmlDocumentationPaths.ToImmutableArray();
@@ -155,7 +155,7 @@ public IEnumerable<IMethodSymbol> GetExtensionMethods(INamedTypeSymbol typeSymbo
 
     public IEnumerable<INamedTypeSymbol> GetExtendedExternalTypes()
     {
-        return Iterator().Distinct();
+        return Iterator().Distinct<INamedTypeSymbol>(SymbolEqualityComparer.Default);
 
         IEnumerable<INamedTypeSymbol> Iterator()
         {
@@ -433,7 +433,17 @@ private Compilation FindCompilation(IAssemblySymbol assembly)
             return Compilations[0];
 
         if (_compilationMap is null)
-            Interlocked.CompareExchange(ref _compilationMap, Compilations.ToImmutableDictionary(f => f.Assembly, f => f), null);
+        {
+            Interlocked.CompareExchange(
+                ref _compilationMap,
+                Compilations.ToImmutableDictionary<Compilation, IAssemblySymbol, Compilation>(
+                    f => f.Assembly,
+                    f => f,
+                    SymbolEqualityComparer.Default
+                ),
+                null
+            );
+        }
 
         return _compilationMap[assembly];
     }
diff --git a/src/Documentation/DocumentationWriter.cs b/src/Documentation/DocumentationWriter.cs
index c6df7d2ee9..07c131d236 100644
--- a/src/Documentation/DocumentationWriter.cs
+++ b/src/Documentation/DocumentationWriter.cs
@@ -1733,7 +1733,7 @@ private ImmutableHashSet<INamedTypeSymbol> GetSymbolDisplayDuplicates(IEnumerabl
                 }
             })
             .SelectMany(grouping => grouping)
-            .ToImmutableHashSet();
+            .ToImmutableHashSet<INamedTypeSymbol>(SymbolEqualityComparer.Default);
 
         bool IncludesContainingNamespace(INamedTypeSymbol symbol)
         {
diff --git a/src/Documentation/Extensions/SymbolExtensions.cs b/src/Documentation/Extensions/SymbolExtensions.cs
index 7267418d01..010a0e361a 100644
--- a/src/Documentation/Extensions/SymbolExtensions.cs
+++ b/src/Documentation/Extensions/SymbolExtensions.cs
@@ -69,7 +69,7 @@ ImmutableArray<ISymbol> GetMembersIncludingInherited()
 
                 if (overriddenSymbol is not null)
                 {
-                    (overriddenSymbols ??= new HashSet<ISymbol>()).Add(overriddenSymbol);
+                    (overriddenSymbols ??= new HashSet<ISymbol>(SymbolEqualityComparer.Default)).Add(overriddenSymbol);
                 }
 
                 symbols.Add(symbol);
@@ -95,7 +95,7 @@ ImmutableArray<ISymbol> GetMembersIncludingInherited()
 
                         if (overriddenSymbol is not null)
                         {
-                            (overriddenSymbols ??= new HashSet<ISymbol>()).Add(overriddenSymbol);
+                            (overriddenSymbols ??= new HashSet<ISymbol>(SymbolEqualityComparer.Default)).Add(overriddenSymbol);
                         }
                     }
                 }
diff --git a/src/Documentation/SymbolDefinitionWriter.cs b/src/Documentation/SymbolDefinitionWriter.cs
index 6f03fcc30c..669825fe44 100644
--- a/src/Documentation/SymbolDefinitionWriter.cs
+++ b/src/Documentation/SymbolDefinitionWriter.cs
@@ -253,7 +253,9 @@ protected virtual SymbolDisplayFormat CreateDefinitionFormat(SymbolDisplayFormat
 
     public virtual void WriteDocument(IEnumerable<IAssemblySymbol> assemblies, CancellationToken cancellationToken = default)
     {
-        TypeSymbols = assemblies.SelectMany(a => a.GetTypes(f => Filter.IsMatch(f))).ToImmutableHashSet();
+        TypeSymbols =
+            assemblies.SelectMany(a => a.GetTypes(f => Filter.IsMatch(f)))
+                .ToImmutableHashSet<INamedTypeSymbol>(SymbolEqualityComparer.Default);
 
         WriteStartDocument();
 
@@ -335,7 +337,11 @@ private void WriteNamespaces(in OneOrMany<IAssemblySymbol> assemblies, Cancellat
             typesByNamespace = assemblies
                 .SelectMany(a => a.GetNamespaces(n => !n.IsGlobalNamespace && Filter.IsMatch(n)))
                 .Distinct(MetadataNameEqualityComparer<INamespaceSymbol>.Instance)
-                .ToDictionary(f => f, _ => ImmutableArray<INamedTypeSymbol>.Empty.AsEnumerable());
+                .ToDictionary<INamespaceSymbol, INamespaceSymbol, IEnumerable<INamedTypeSymbol>>(
+                    f => f,
+                    _ => ImmutableArray<INamedTypeSymbol>.Empty.AsEnumerable(),
+                    SymbolEqualityComparer.Default
+                );
         }
         else
         {
@@ -344,7 +350,11 @@ private void WriteNamespaces(in OneOrMany<IAssemblySymbol> assemblies, Cancellat
                 .GroupBy(t => t.ContainingNamespace, MetadataNameEqualityComparer<INamespaceSymbol>.Instance)
                 .Where(g => Filter.IsMatch(g.Key))
                 .OrderBy(g => g.Key, Comparer.NamespaceComparer)
-                .ToDictionary(f => f.Key, f => f.AsEnumerable());
+                .ToDictionary<IGrouping<INamespaceSymbol, INamedTypeSymbol>, INamespaceSymbol, IEnumerable<INamedTypeSymbol>>(
+                    f => f.Key,
+                    f => f.AsEnumerable(),
+                    SymbolEqualityComparer.Default
+                );
         }
 
         WriteStartNamespaces();
diff --git a/src/Documentation/SymbolDocumentationProvider.cs b/src/Documentation/SymbolDocumentationProvider.cs
index c8fda60264..2f75a67ae9 100644
--- a/src/Documentation/SymbolDocumentationProvider.cs
+++ b/src/Documentation/SymbolDocumentationProvider.cs
@@ -32,8 +32,8 @@ internal SymbolDocumentationProvider(
         Compilations = compilations.ToImmutableArray();
         Assemblies = compilations.Select(f => f.Assembly).ToImmutableArray();
 
-        _symbolData = new Dictionary<ISymbol, SymbolDocumentationData>();
-        _xmlDocumentations = new Dictionary<IAssemblySymbol, XmlDocumentation>();
+        _symbolData = new Dictionary<ISymbol, SymbolDocumentationData>(SymbolEqualityComparer.Default);
+        _xmlDocumentations = new Dictionary<IAssemblySymbol, XmlDocumentation>(SymbolEqualityComparer.Default);
 
         if (additionalXmlDocumentationPaths is not null)
             _additionalXmlDocumentationPaths = additionalXmlDocumentationPaths.ToImmutableArray();
@@ -196,7 +196,17 @@ private XmlDocumentation GetXmlDocumentation(IAssemblySymbol assembly, string pr
     private MetadataReference FindMetadataReference(IAssemblySymbol assembly)
     {
         if (_assemblyToReferenceMap is null)
-            Interlocked.CompareExchange(ref _assemblyToReferenceMap, Compilations.ToImmutableDictionary(f => f.Assembly, f => f.GetMetadataReference(f.Assembly)), null);
+        {
+            Interlocked.CompareExchange(
+                ref _assemblyToReferenceMap,
+                Compilations.ToImmutableDictionary<Compilation, IAssemblySymbol, MetadataReference>(
+                    f => f.Assembly,
+                    f => f.GetMetadataReference(f.Assembly),
+                    keyComparer: SymbolEqualityComparer.Default
+                ),
+                null
+            );
+        }
 
         if (_assemblyToReferenceMap.TryGetValue(assembly, out MetadataReference metadataReference))
             return metadataReference;
diff --git a/src/Documentation/TypeDocumentationModel.cs b/src/Documentation/TypeDocumentationModel.cs
index 2a53e80021..929df93058 100644
--- a/src/Documentation/TypeDocumentationModel.cs
+++ b/src/Documentation/TypeDocumentationModel.cs
@@ -407,7 +407,7 @@ bool IsEnabled(TypeDocumentationParts part)
 
     public bool Equals(TypeDocumentationModel other)
     {
-        return Symbol.Equals(other);
+        return SymbolEqualityComparer.Default.Equals(Symbol, other?.Symbol);
     }
 
     public override bool Equals(object obj)
@@ -418,6 +418,6 @@ public override bool Equals(object obj)
 
     public override int GetHashCode()
     {
-        return Symbol.GetHashCode();
+        return SymbolEqualityComparer.Default.GetHashCode(Symbol);
     }
 }
diff --git a/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs b/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs
new file mode 100644
index 0000000000..877b801f8a
--- /dev/null
+++ b/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs
@@ -0,0 +1,267 @@
+// Copyright (c) .NET Foundation and Contributors. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Composition;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Text;
+using Roslynator.CSharp;
+using Roslynator.CSharp.CodeStyle;
+
+namespace Roslynator.Formatting.CodeFixes.CSharp;
+
+[ExportCodeFixProvider(LanguageNames.CSharp, Name = nameof(FixBracketFormattingOfListCodeFixProvider))]
+[Shared]
+public sealed class FixBracketFormattingOfListCodeFixProvider : BaseCodeFixProvider
+{
+    private const string Title = "Fix bracket formatting";
+
+    public override ImmutableArray<string> FixableDiagnosticIds
+        => ImmutableArray.Create(DiagnosticIdentifiers.FixBracketFormattingOfList);
+
+    public override async Task RegisterCodeFixesAsync(CodeFixContext context)
+    {
+        SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
+
+        if (
+            !TryFindFirstAncestorOrSelf(
+                root,
+                context.Span,
+                out SyntaxNode node,
+                predicate: f =>
+                {
+                    switch (f.Kind())
+                    {
+                        case SyntaxKind.ParameterList:
+                        case SyntaxKind.BracketedParameterList:
+                        case SyntaxKind.TypeParameterList:
+                        case SyntaxKind.ArgumentList:
+                        case SyntaxKind.BracketedArgumentList:
+                        case SyntaxKind.AttributeArgumentList:
+                        case SyntaxKind.TypeArgumentList:
+                        case SyntaxKind.AttributeList:
+                        case SyntaxKind.TupleType:
+                        case SyntaxKind.TupleExpression:
+                        case SyntaxKind.ArrayInitializerExpression:
+                        case SyntaxKind.CollectionInitializerExpression:
+#if ROSLYN_4_7
+                        case SyntaxKind.CollectionExpression:
+#endif
+                        case SyntaxKind.ComplexElementInitializerExpression:
+                        case SyntaxKind.ObjectInitializerExpression:
+                            return true;
+                        default:
+                            return false;
+                    }
+                }
+            )
+        )
+        {
+            return;
+        }
+
+        Document document = context.Document;
+        Diagnostic diagnostic = context.Diagnostics[0];
+        CodeAction codeAction = CreateCodeAction();
+
+        context.RegisterCodeFix(codeAction, diagnostic);
+
+        CodeAction CreateCodeAction()
+        {
+            switch (node)
+            {
+                case ParameterListSyntax parameterList:
+                {
+                    return CodeAction.Create(
+                        Title,
+                        ct => Fix(parameterList, parameterList.OpenParenToken, parameterList.CloseParenToken, ct),
+                        GetEquivalenceKey(diagnostic)
+                    );
+                }
+                case BracketedParameterListSyntax bracketedParameterList:
+                {
+                    return CodeAction.Create(
+                        Title,
+                        ct => Fix(bracketedParameterList, bracketedParameterList.OpenBracketToken, bracketedParameterList.CloseBracketToken, ct),
+                        GetEquivalenceKey(diagnostic)
+                    );
+                }
+                case TypeParameterListSyntax typeParameterList:
+                {
+                    return CodeAction.Create(
+                        Title,
+                        ct => Fix(typeParameterList, typeParameterList.LessThanToken, typeParameterList.GreaterThanToken, ct),
+                        GetEquivalenceKey(diagnostic)
+                    );
+                }
+                case ArgumentListSyntax argumentList:
+                {
+                    return CodeAction.Create(
+                        Title,
+                        ct => Fix(argumentList, argumentList.OpenParenToken, argumentList.CloseParenToken, ct),
+                        GetEquivalenceKey(diagnostic)
+                    );
+                }
+                case BracketedArgumentListSyntax bracketedArgumentList:
+                {
+                    return CodeAction.Create(
+                        Title,
+                        ct => Fix(bracketedArgumentList, bracketedArgumentList.OpenBracketToken, bracketedArgumentList.CloseBracketToken, ct),
+                        GetEquivalenceKey(diagnostic)
+                    );
+                }
+                case AttributeArgumentListSyntax attributeArgumentList:
+                {
+                    return CodeAction.Create(
+                        Title,
+                        ct => Fix(attributeArgumentList, attributeArgumentList.OpenParenToken, attributeArgumentList.CloseParenToken, ct),
+                        GetEquivalenceKey(diagnostic)
+                    );
+                }
+                case TypeArgumentListSyntax typeArgumentList:
+                {
+                    return CodeAction.Create(
+                        Title,
+                        ct => Fix(typeArgumentList, typeArgumentList.LessThanToken, typeArgumentList.GreaterThanToken, ct),
+                        GetEquivalenceKey(diagnostic)
+                    );
+                }
+                case AttributeListSyntax attributeList:
+                {
+                    return CodeAction.Create(
+                        Title,
+                        ct => Fix(attributeList, attributeList.OpenBracketToken, attributeList.CloseBracketToken, ct),
+                        GetEquivalenceKey(diagnostic)
+                    );
+                }
+                case TupleTypeSyntax tupleType:
+                {
+                    return CodeAction.Create(
+                        Title,
+                        ct => Fix(tupleType, tupleType.OpenParenToken, tupleType.CloseParenToken, ct),
+                        GetEquivalenceKey(diagnostic)
+                    );
+                }
+                case TupleExpressionSyntax tupleExpression:
+                {
+                    return CodeAction.Create(
+                        Title,
+                        ct => Fix(tupleExpression, tupleExpression.OpenParenToken, tupleExpression.CloseParenToken, ct),
+                        GetEquivalenceKey(diagnostic)
+                    );
+                }
+                case InitializerExpressionSyntax initializerExpression:
+                {
+                    return CodeAction.Create(
+                        Title,
+                        ct => Fix(initializerExpression, initializerExpression.OpenBraceToken, initializerExpression.CloseBraceToken, ct),
+                        GetEquivalenceKey(diagnostic)
+                    );
+                }
+#if ROSLYN_4_7
+                case CollectionExpressionSyntax collectionExpression:
+                {
+                    return CodeAction.Create(
+                        Title,
+                        ct => Fix(collectionExpression, collectionExpression.OpenBracketToken, collectionExpression.CloseBracketToken, ct),
+                        GetEquivalenceKey(diagnostic)
+                    );
+                }
+#endif
+                default:
+                {
+                    throw new InvalidOperationException();
+                }
+            }
+        }
+
+        async Task<Document> Fix(
+            SyntaxNode listNode,
+            SyntaxToken openNodeOrToken,
+            SyntaxToken closeNodeOrToken,
+            CancellationToken cancellationToken
+        )
+        {
+            AnalyzerConfigOptions configOptions = document.GetConfigOptions(listNode.SyntaxTree);
+            TargetBracesStyle bracesStyle = configOptions.GetTargetBracesStyle();
+
+            if (bracesStyle == TargetBracesStyle.None)
+            {
+                return document;
+            }
+
+            string endOfLine = SyntaxTriviaAnalysis.DetermineEndOfLine(node).ToString();
+
+            var textChanges = new List<TextChange>();
+
+            if ((bracesStyle & TargetBracesStyle.Opening) != 0)
+            {
+                SyntaxToken nextToken = openNodeOrToken.GetNextToken();
+
+                int bracketLine = openNodeOrToken.GetSpanStartLine(cancellationToken);
+                int nextTokenLine = nextToken.GetSpanStartLine(cancellationToken);
+
+                if (bracketLine == nextTokenLine)
+                {
+                    string indentation = SyntaxTriviaAnalysis.GetIncreasedIndentation(listNode, configOptions, cancellationToken);
+
+                    textChanges.Add(
+                        new TextChange(
+                            TextSpan.FromBounds(openNodeOrToken.Span.End, nextToken.SpanStart),
+                            endOfLine + indentation
+                        )
+                    );
+                }
+            }
+
+            if ((bracesStyle & TargetBracesStyle.Closing) != 0)
+            {
+                SyntaxToken previousToken = closeNodeOrToken.GetPreviousToken();
+
+                int bracketLine = closeNodeOrToken.GetSpanStartLine(cancellationToken);
+                int previousTokenLine = previousToken.GetSpanEndLine(cancellationToken);
+
+                if (bracketLine == previousTokenLine)
+                {
+                    string indentation = SyntaxTriviaAnalysis.DetermineIndentation(listNode, searchInAccessors: false, cancellationToken).ToString();
+
+                    textChanges.Add(
+                        new TextChange(
+                            closeNodeOrToken.Span,
+                            endOfLine + indentation + closeNodeOrToken
+                        )
+                    );
+                }
+                else
+                {
+                    SyntaxTrivia listNodeIndent = SyntaxTriviaAnalysis.DetermineIndentation(listNode, searchInAccessors: false, cancellationToken);
+                    SyntaxTrivia bracketIndent = SyntaxTriviaAnalysis.DetermineIndentation(closeNodeOrToken, searchInAccessors: false, cancellationToken);
+                    if (listNodeIndent.Span.Length != bracketIndent.Span.Length)
+                    {
+                        TextSpan span =
+                            (bracketIndent.Span.Length == 0) // there is no indentation
+                                ? new TextSpan(closeNodeOrToken.Span.Start, 0)
+                                : bracketIndent.Span;
+
+                        textChanges.Add(
+                            new TextChange(
+                                span,
+                                listNodeIndent.ToString()
+                            )
+                        );
+                    }
+                }
+            }
+
+            return await document.WithTextChangesAsync(textChanges, cancellationToken).ConfigureAwait(false);
+        }
+    }
+}
diff --git a/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs b/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs
new file mode 100644
index 0000000000..44b5dd8240
--- /dev/null
+++ b/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs
@@ -0,0 +1,260 @@
+// Copyright (c) .NET Foundation and Contributors. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Immutable;
+using System.Threading;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Text;
+using Roslynator.CSharp;
+using Roslynator.CSharp.CodeStyle;
+
+namespace Roslynator.Formatting.CSharp;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public sealed class FixBracketFormattingOfListAnalyzer : BaseDiagnosticAnalyzer
+{
+    private static ImmutableArray<DiagnosticDescriptor> _supportedDiagnostics;
+
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
+    {
+        get
+        {
+            if (_supportedDiagnostics.IsDefault)
+                Immutable.InterlockedInitialize(ref _supportedDiagnostics, DiagnosticRules.FixBracketFormattingOfList);
+
+            return _supportedDiagnostics;
+        }
+    }
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+
+        context.RegisterSyntaxNodeAction(f => AnalyzeParameterList(f), SyntaxKind.ParameterList);
+        context.RegisterSyntaxNodeAction(f => AnalyzeBracketedParameterList(f), SyntaxKind.BracketedParameterList);
+        context.RegisterSyntaxNodeAction(f => AnalyzeTypeParameterList(f), SyntaxKind.TypeParameterList);
+
+        context.RegisterSyntaxNodeAction(f => AnalyzeArgumentList(f), SyntaxKind.ArgumentList);
+        context.RegisterSyntaxNodeAction(f => AnalyzeBracketedArgumentList(f), SyntaxKind.BracketedArgumentList);
+        context.RegisterSyntaxNodeAction(f => AnalyzeAttributeArgumentList(f), SyntaxKind.AttributeArgumentList);
+        context.RegisterSyntaxNodeAction(f => AnalyzeTypeArgumentList(f), SyntaxKind.TypeArgumentList);
+
+        context.RegisterSyntaxNodeAction(f => AnalyzeAttributeList(f), SyntaxKind.AttributeList);
+        context.RegisterSyntaxNodeAction(f => AnalyzeTupleType(f), SyntaxKind.TupleType);
+        context.RegisterSyntaxNodeAction(f => AnalyzeTupleExpression(f), SyntaxKind.TupleExpression);
+#if ROSLYN_4_7
+        context.RegisterSyntaxNodeAction(f => AnalyzeCollectionExpression(f), SyntaxKind.CollectionExpression);
+#endif
+
+        context.RegisterSyntaxNodeAction(
+            f => AnalyzeInitializerExpression(f),
+            SyntaxKind.ArrayInitializerExpression,
+            SyntaxKind.CollectionInitializerExpression,
+            SyntaxKind.ComplexElementInitializerExpression,
+            SyntaxKind.ObjectInitializerExpression
+        );
+    }
+
+    private static void AnalyzeParameterList(SyntaxNodeAnalysisContext context)
+    {
+        var parameterList = (ParameterListSyntax)context.Node;
+
+        Analyze(context, parameterList.OpenParenToken, parameterList.CloseParenToken, parameterList.Parameters);
+    }
+
+    private static void AnalyzeBracketedParameterList(SyntaxNodeAnalysisContext context)
+    {
+        var parameterList = (BracketedParameterListSyntax)context.Node;
+
+        Analyze(context, parameterList.OpenBracketToken, parameterList.CloseBracketToken, parameterList.Parameters);
+    }
+
+    private static void AnalyzeTypeParameterList(SyntaxNodeAnalysisContext context)
+    {
+        var parameterList = (TypeParameterListSyntax)context.Node;
+
+        Analyze(context, parameterList.LessThanToken, parameterList.GreaterThanToken, parameterList.Parameters);
+    }
+
+    private static void AnalyzeArgumentList(SyntaxNodeAnalysisContext context)
+    {
+        var argumentList = (ArgumentListSyntax)context.Node;
+
+        Analyze(context, argumentList.OpenParenToken, argumentList.CloseParenToken, argumentList.Arguments);
+    }
+
+    private static void AnalyzeBracketedArgumentList(SyntaxNodeAnalysisContext context)
+    {
+        var argumentList = (BracketedArgumentListSyntax)context.Node;
+
+        Analyze(context, argumentList.OpenBracketToken, argumentList.CloseBracketToken, argumentList.Arguments);
+    }
+
+    private static void AnalyzeAttributeArgumentList(SyntaxNodeAnalysisContext context)
+    {
+        var argumentList = (AttributeArgumentListSyntax)context.Node;
+
+        Analyze(context, argumentList.OpenParenToken, argumentList.CloseParenToken, argumentList.Arguments);
+    }
+
+    private static void AnalyzeTypeArgumentList(SyntaxNodeAnalysisContext context)
+    {
+        var argumentList = (TypeArgumentListSyntax)context.Node;
+
+        Analyze(context, argumentList.LessThanToken, argumentList.GreaterThanToken, argumentList.Arguments);
+    }
+
+    private static void AnalyzeAttributeList(SyntaxNodeAnalysisContext context)
+    {
+        var attributeList = (AttributeListSyntax)context.Node;
+
+        Analyze(context, attributeList.OpenBracketToken, attributeList.CloseBracketToken, attributeList.Attributes);
+    }
+
+    private static void AnalyzeTupleType(SyntaxNodeAnalysisContext context)
+    {
+        var tupleType = (TupleTypeSyntax)context.Node;
+
+        Analyze(context, tupleType.OpenParenToken, tupleType.CloseParenToken, tupleType.Elements);
+    }
+
+    private static void AnalyzeTupleExpression(SyntaxNodeAnalysisContext context)
+    {
+        var tupleExpression = (TupleExpressionSyntax)context.Node;
+
+        Analyze(context, tupleExpression.OpenParenToken, tupleExpression.CloseParenToken, tupleExpression.Arguments);
+    }
+
+    private static void AnalyzeInitializerExpression(SyntaxNodeAnalysisContext context)
+    {
+        var initializerExpression = (InitializerExpressionSyntax)context.Node;
+
+        Analyze(context, initializerExpression.OpenBraceToken, initializerExpression.CloseBraceToken, initializerExpression.Expressions);
+    }
+
+#if ROSLYN_4_7
+    private static void AnalyzeCollectionExpression(SyntaxNodeAnalysisContext context)
+    {
+        var collectionExpression = (CollectionExpressionSyntax)context.Node;
+
+        Analyze(context, collectionExpression.OpenBracketToken, collectionExpression.CloseBracketToken, collectionExpression.Elements);
+    }
+#endif
+
+    private static void Analyze<TNode>(
+        SyntaxNodeAnalysisContext context,
+        SyntaxToken openNodeOrToken,
+        SyntaxToken closeNodeOrToken,
+        SeparatedSyntaxList<TNode> nodes
+    )
+        where TNode : SyntaxNode
+    {
+        TargetBracesStyle bracesStyle = context.GetTargetBracesStyle();
+
+        if (bracesStyle == TargetBracesStyle.None)
+        {
+            return;
+        }
+
+        CancellationToken cancellationToken = context.CancellationToken;
+
+        TNode first = nodes.FirstOrDefault();
+
+        if (first is null)
+            return;
+
+        SyntaxNode listNode = context.Node;
+        TextSpan listSpan = listNode.GetSpan(includeExteriorTrivia: false);
+
+        if (listSpan.IsSingleLine(listNode.SyntaxTree))
+        {
+            return;
+        }
+
+        TNode last = nodes.Last();
+
+        if (ShouldFixOpeningBracket(bracesStyle, openNodeOrToken, first, cancellationToken)
+            || ShouldFixClosingBracket(bracesStyle, listNode, closeNodeOrToken, last, cancellationToken)
+        )
+        {
+            DiagnosticHelpers.ReportDiagnostic(
+                context,
+                DiagnosticRules.FixBracketFormattingOfList,
+                Location.Create(listNode.SyntaxTree, listSpan),
+                GetTitle(listNode)
+            );
+        }
+    }
+
+    private static string GetTitle(SyntaxNode listNode)
+    {
+        return listNode.Kind() switch
+        {
+            SyntaxKind.ParameterList
+                or SyntaxKind.BracketedParameterList
+                or SyntaxKind.TypeParameterList
+                => "parameters",
+
+            SyntaxKind.ArgumentList
+                or SyntaxKind.BracketedArgumentList
+                or SyntaxKind.AttributeArgumentList
+                or SyntaxKind.TypeArgumentList
+                => "arguments",
+
+            SyntaxKind.AttributeList => "attributes",
+
+            SyntaxKind.TupleType or SyntaxKind.TupleExpression => "a tuple",
+#if ROSLYN_4_7
+            SyntaxKind.CollectionExpression => "a collection expression",
+#endif
+            SyntaxKind.ArrayInitializerExpression
+                or SyntaxKind.CollectionInitializerExpression
+                or SyntaxKind.ComplexElementInitializerExpression
+                or SyntaxKind.ObjectInitializerExpression
+                => "an initializer",
+
+            _ => throw new InvalidOperationException()
+        };
+    }
+
+    private static bool ShouldFixOpeningBracket(
+        TargetBracesStyle bracesStyle,
+        SyntaxToken leftBracket,
+        SyntaxNode first,
+        CancellationToken cancellationToken
+    )
+    {
+        if ((bracesStyle & TargetBracesStyle.Opening) == 0)
+        {
+            return false;
+        }
+
+        return leftBracket.GetSpanStartLine(cancellationToken) == first.GetSpanStartLine(cancellationToken);
+    }
+
+    private static bool ShouldFixClosingBracket(
+        TargetBracesStyle bracesStyle,
+        SyntaxNode listNode,
+        SyntaxToken rightBracket,
+        SyntaxNode last,
+        CancellationToken cancellationToken
+    )
+    {
+        if ((bracesStyle & TargetBracesStyle.Closing) == 0)
+        {
+            return false;
+        }
+
+        if (rightBracket.GetSpanEndLine(cancellationToken) == last.GetSpanEndLine(cancellationToken))
+        {
+            return true;
+        }
+
+        SyntaxTrivia listNodeIndent = SyntaxTriviaAnalysis.DetermineIndentation(listNode, searchInAccessors: false, cancellationToken);
+        SyntaxTrivia bracketIndent = SyntaxTriviaAnalysis.DetermineIndentation(rightBracket, searchInAccessors: false, cancellationToken);
+        return listNodeIndent.Span.Length != bracketIndent.Span.Length;
+    }
+}
diff --git a/src/Tests/Formatting.Analyzers.Tests/RCS1269FixBracketFormattingOfListTests.cs b/src/Tests/Formatting.Analyzers.Tests/RCS1269FixBracketFormattingOfListTests.cs
new file mode 100644
index 0000000000..99a342476a
--- /dev/null
+++ b/src/Tests/Formatting.Analyzers.Tests/RCS1269FixBracketFormattingOfListTests.cs
@@ -0,0 +1,1327 @@
+// Copyright (c) .NET Foundation and Contributors. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Roslynator.Formatting.CodeFixes.CSharp;
+using Roslynator.Testing.CSharp;
+using Xunit;
+
+namespace Roslynator.Formatting.CSharp.Tests;
+
+public sealed class RCS1269FixBracketFormattingOfListTests :
+    AbstractCSharpDiagnosticVerifier<FixBracketFormattingOfListAnalyzer, FixBracketFormattingOfListCodeFixProvider>
+{
+    public override DiagnosticDescriptor Descriptor { get; } = DiagnosticRules.FixBracketFormattingOfList;
+
+    public override CSharpTestOptions Options
+        => base.Options.AddConfigOption(ConfigOptionKeys.TargetBracesStyle, "both");
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Singleline_AlignedToParenthesis()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                void M[|(
+                       object x, object y)|] 
+                {
+                }
+            }
+            """,
+            """
+            class C
+            {
+                void M(
+                       object x, object y
+                ) 
+                {
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Singleline_Unindented()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                void M[|(
+            object x, object y)|] 
+                {
+                }
+            }
+            """,
+            """
+            class C
+            {
+                void M(
+            object x, object y
+                ) 
+                {
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Singleline_Comment()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                void M[|( // x
+                object x, object y)|] 
+                {
+                }
+            }
+            """,
+            """
+            class C
+            {
+                void M( // x
+                object x, object y
+                ) 
+                {
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Singleline_EmptyLine_Comment()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                void M[|(
+            // x
+            object x, object y)|] 
+                {
+                }
+            }
+            """,
+            """
+            class C
+            {
+                void M(
+            // x
+            object x, object y
+                ) 
+                {
+                }
+            }
+            """);
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Multiline_AlignedToParenthesis()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            using System;
+
+            class C
+            {
+                void M()
+                {
+                }
+            
+                [Obsolete]
+                void M2[|(
+                        object x,
+                        object y)|] 
+                {
+                }
+            }
+            """,
+            """
+            using System;
+
+            class C
+            {
+                void M()
+                {
+                }
+            
+                [Obsolete]
+                void M2(
+                        object x,
+                        object y
+                ) 
+                {
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Multiline_AlignedToParenthesis_WhitespaceAfterParenthesis()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                void M[|( object x,
+                       object y)|] 
+                {
+                }
+            }
+            """,
+            """
+            class C
+            {
+                void M(
+                    object x,
+                       object y
+                ) 
+                {
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Multiline_FirstParameterNotWrapped()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            namespace N
+            {
+                class C
+                {
+                    void M[|(object x,
+                        object y)|] 
+                    {
+                    }
+                }
+            }
+            """,
+            """
+            namespace N
+            {
+                class C
+                {
+                    void M(
+                        object x,
+                        object y
+                    ) 
+                    {
+                    }
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Multiline_TwoParametersOnSameLine()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                void M[|(
+                    object x,
+                    object y,object z)|] 
+                {
+                }
+            }
+            """,
+            """
+            class C
+            {
+                void M(
+                    object x,
+                    object y,object z
+                ) 
+                {
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Multiline_ClosingBracket_Indent_Required()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                void M[|(
+                    object x,
+                    object y, object z,
+                    object p4
+                    )|] 
+                {
+                }
+            }
+            """,
+            """
+            class C
+            {
+                void M(
+                    object x,
+                    object y, object z,
+                    object p4
+                ) 
+                {
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Multiline_ClosingBracket_Indent_Required2()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                void M[|(
+                    object x,
+                    object y, object z,
+                    object p4
+              )|] 
+                {
+                }
+            }
+            """,
+            """
+            class C
+            {
+                void M(
+                    object x,
+                    object y, object z,
+                    object p4
+                ) 
+                {
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Multiline_ClosingBracket_Indent_Required3()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                void M[|(
+                    object x,
+                    object y, object z,
+                    object p4
+            )|] 
+                {
+                }
+            }
+            """,
+            """
+            class C
+            {
+                void M(
+                    object x,
+                    object y, object z,
+                    object p4
+                ) 
+                {
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Multiline_ClosingBracket_Indent_Required_with_comment()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                void M[|(
+                    object x,
+                    object y, object z,
+                    object p4
+                    // comment
+                    )|] 
+                {
+                }
+            }
+            """,
+            """
+            class C
+            {
+                void M(
+                    object x,
+                    object y, object z,
+                    object p4
+                    // comment
+                ) 
+                {
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Multiline_Comment()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                void M[|( // x
+             // x
+                object x, // xx
+                object y)|]
+                {
+                }
+            }
+            """,
+            """
+            class C
+            {
+                void M( // x
+             // x
+                object x, // xx
+                object y
+                )
+                {
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Multiline_FirstParameterIsMultilineLambda()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            using System;
+
+            class C
+            {
+                void M(Func<string, string> x, object y)
+                {
+                    M[|(f =>
+            {
+                return null;
+            },
+            y)|];
+                }
+            }
+            """,
+            """
+            using System;
+
+            class C
+            {
+                void M(Func<string, string> x, object y)
+                {
+                    M(
+                        f =>
+            {
+                return null;
+            },
+            y
+                    );
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Multiline_SecondParameterIsMultilineLambdaWithExpressionBody()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            using System;
+
+            class C
+            {
+                void M(object x, Func<string, string> y)
+                {
+                    M[|(x, f => f
+                        .ToString()
+                        .ToString())|];
+                }
+            }
+            """,
+            """
+            using System;
+
+            class C
+            {
+                void M(object x, Func<string, string> y)
+                {
+                    M(
+                        x, f => f
+                        .ToString()
+                        .ToString()
+                    );
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Multiline_IndentationsDiffer_Tab()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+            	void M(object x, string y)
+            	{
+            		M[|(x, y.ToString()
+            			.ToString())|];
+            	}
+            }
+            """,
+            """
+            class C
+            {
+            	void M(object x, string y)
+            	{
+            		M(
+            			x, y.ToString()
+            			.ToString()
+            		);
+            	}
+            }
+            """,
+            options: Options.SetConfigOption("indent_style", "tab")
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Multiline_SingleMultilineParameter_WrongIndentation()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                void M(string x)
+                {
+                    M[|((x != null)
+                ? x
+                : "")|];
+                }
+            }
+            """,
+            """
+            class C
+            {
+                void M(string x)
+                {
+                    M(
+                        (x != null)
+                ? x
+                : ""
+                    );
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Multiline_SingleMultilineParameter_WrongIndentation2()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                void M(string x)
+                {
+                    M[|(M2[|(
+                            x,
+                            x)|])|];
+                }
+            
+                string M2(string x, string y) => null;
+            }
+            """,
+            """
+            class C
+            {
+                void M(string x)
+                {
+                    M(
+                        M2(
+                            x,
+                            x
+                        )
+                    );
+                }
+            
+                string M2(string x, string y) => null;
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Multiline_SingleMultilineParameter_NoIndentation()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                void M(string x)
+                {
+                    M[|((x != null)
+            ? x
+            : "")|];
+                }
+            }
+            """,
+            """
+            class C
+            {
+                void M(string x)
+                {
+                    M(
+                        (x != null)
+            ? x
+            : ""
+                    );
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Multiline_BaseConstructorArguments()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C : B
+            {
+                public C(string x, string y) : base[|(x, (y != null)
+                    ? y
+                    : "")|]
+                {
+                }
+            }
+
+            class B
+            {
+                public B(string x, string y)
+                {
+                }
+            }
+            """,
+            """
+            class C : B
+            {
+                public C(string x, string y) : base(
+                    x, (y != null)
+                    ? y
+                    : ""
+                )
+                {
+                }
+            }
+
+            class B
+            {
+                public B(string x, string y)
+                {
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Multiline_BaseConstructorArguments2()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C : B
+            {
+                public C(string x, string y)
+                    : base[|(x, (y != null)
+                        ? y
+                        : "")|]
+                {
+                }
+            }
+
+            class B
+            {
+                public B(string x, string y)
+                {
+                }
+            }
+            """,
+            """
+            class C : B
+            {
+                public C(string x, string y)
+                    : base(
+                        x, (y != null)
+                        ? y
+                        : ""
+                    )
+                {
+                }
+            }
+
+            class B
+            {
+                public B(string x, string y)
+                {
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Multiline_StringLiteral()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                void M(string x, string y)
+                {
+                    M[|(x, @"
+            a
+            b
+            c
+            ")|];
+                }
+            }
+            """,
+            """
+            class C
+            {
+                void M(string x, string y)
+                {
+                    M(
+                        x, @"
+            a
+            b
+            c
+            "
+                    );
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Multiline_AttributeList()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            using System;
+
+            class C
+            {
+                [|[Flags, Obsolete[|(
+                    "",
+                    true)|]]|]
+                enum E
+                {
+                }
+            }
+            """,
+            """
+            using System;
+
+            class C
+            {
+                [
+                    Flags, Obsolete(
+                    "",
+                    true
+                    )
+                ]
+                enum E
+                {
+                }
+            }
+            """);
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Multiline_AttributeList_NotIndented()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            using System;
+
+            class C
+            {
+                [|[Flags, Obsolete[|(
+            "",
+            true)|]]|]
+                enum E
+                {
+                }
+            }
+            """,
+            """
+            using System;
+
+            class C
+            {
+                [
+                    Flags, Obsolete(
+            "",
+            true
+                    )
+                ]
+                enum E
+                {
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Multiline_OneOfParametersIsMultiline()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                void M[|(string x, string y
+                    = default(string), string z = default)|]
+                {
+                }
+            }
+            """,
+            """
+            class C
+            {
+                void M(
+                    string x, string y
+                    = default(string), string z = default
+                )
+                {
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Multiline_TupleType()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                private [|(string x, string y,
+                    string z)|] M[|([|(string a,
+                        string b)|] p)|]
+                {
+                    return [|(null, null,
+                        null)|];
+                }
+            }
+            """,
+            """
+            class C
+            {
+                private (
+                    string x, string y,
+                    string z
+                ) M(
+                    (
+                        string a,
+                        string b
+                    ) p
+                )
+                {
+                    return (
+                        null, null,
+                        null
+                    );
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Multiline_TupleExpression()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                void M[|([|(string x, string y,
+                    string z)|] p)|]
+                {
+                }
+            }
+            """,
+            """
+            class C
+            {
+                void M(
+                    (
+                        string x, string y,
+                    string z
+                    ) p
+                )
+                {
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Multiline_TupleExpression_LocalDeclaration()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                void M()
+                {
+                    [|(string x,
+                        string y, string z)|] = default((string, string, string));
+                }
+            }
+            """,
+            """
+            class C
+            {
+                void M()
+                {
+                    (
+                        string x,
+                        string y, string z
+                    ) = default((string, string, string));
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Multiline_ArrayInitializer()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                void M()
+                {
+                    var x = new string[] [|{ "", default, new string[|(
+                        ' ',
+                        1)|] }|];
+                }
+            }
+            """,
+            """
+            class C
+            {
+                void M()
+                {
+                    var x = new string[] {
+                        "", default, new string(
+                        ' ',
+                        1
+                        ) 
+                    };
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Multiline_PreprocessorDirectives()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            #define FOO
+            using System.Collections.Generic;
+
+            class C
+            {
+                void M()
+                {
+                    var x = new List<string>[|(new string[]
+                        {
+                            "",
+                            "",
+            #if FOO
+                            "",
+            #endif
+                        })|];
+                }
+            }
+            """,
+            """
+            #define FOO
+            using System.Collections.Generic;
+
+            class C
+            {
+                void M()
+                {
+                    var x = new List<string>(
+                        new string[]
+                        {
+                            "",
+                            "",
+            #if FOO
+                            "",
+            #endif
+                        }
+                    );
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_SingleParameterIsMultilineLambdaWithExpressionBody()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            using System.Linq;
+
+            class C
+            {
+                void M()
+                {
+                    string s = string.Concat[|(Enumerable.Empty<string>().Select[|(f => {
+                        return f;
+                    })|])|];
+                }
+            }
+            """,
+            """
+            using System.Linq;
+
+            class C
+            {
+                void M()
+                {
+                    string s = string.Concat(
+                        Enumerable.Empty<string>().Select(
+                            f => {
+                        return f;
+                    }
+                        )
+                    );
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task TestNoDiagnostic_Singleline()
+    {
+        await VerifyNoDiagnosticAsync(
+            """
+            class C
+            {
+                void M(object x, object y, object z) 
+                {
+                }
+
+                void M2(object x, object y, object z) 
+                {
+                }
+            }
+            """);
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task TestNoDiagnostic_ArrayInitializerWithMultilineComment()
+    {
+        await VerifyNoDiagnosticAsync(
+            """
+            class C
+            {
+                void M()
+                {
+                    var x = new string[]
+                    {
+                        /* x */ ""
+                    };
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_LambdaBlockBodyInGlobalStatement()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            using System.Linq;
+
+            foreach (var item in Enumerable.Range(0, 10))
+            {
+                var s = "";
+            }
+
+            var items = Enumerable.Range(0, 10)
+                .Select[|(f =>
+                {
+                    return f;
+                })|]
+                .Select(f => f);
+            """,
+            """
+            using System.Linq;
+
+            foreach (var item in Enumerable.Range(0, 10))
+            {
+                var s = "";
+            }
+
+            var items = Enumerable.Range(0, 10)
+                .Select(
+                    f =>
+                {
+                    return f;
+                }
+                )
+                .Select(f => f);
+            """,
+            options: Options.WithCompilationOptions(Options.CompilationOptions.WithOutputKind(OutputKind.ConsoleApplication))
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_ArrayInitializerInGlobalStatement()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            Foo.Method[|(
+                foo: new Foo[]
+                {
+                    new Foo[|(
+                        "")|]
+                })|];
+            """,
+            """
+            Foo.Method(
+                foo: new Foo[]
+                {
+                    new Foo(
+                        ""
+                    )
+                }
+            );
+            """,
+            additionalFiles:
+                new (string source, string expectedSource)[]
+                {
+                    (
+                        source:
+                            """
+                            public class Foo
+                            {
+                                public Foo(string v1)
+                                {
+                                }
+                            
+                                internal static void Method(Foo[] foo)
+                                {
+                                }
+                            }
+                            """,
+                        expectedSource: null
+                    ),
+                },
+            options: Options.WithCompilationOptions(Options.CompilationOptions.WithOutputKind(OutputKind.ConsoleApplication))
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Multiline_ObjectInitializer()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                public C() { }
+
+                public C(C value) { }
+            
+                public string P { get; set; }
+
+                C M()
+                {
+                    return new C[|(new C
+                    {
+                        P = ""
+                    })|];
+                }
+            }
+            """,
+            """
+            class C
+            {
+                public C() { }
+
+                public C(C value) { }
+            
+                public string P { get; set; }
+
+                C M()
+                {
+                    return new C(
+                        new C
+                    {
+                        P = ""
+                    }
+                    );
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Multiline_CollectionExpression()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                public C P { get; set; }
+
+                public string M1(string[] values)
+                {
+                    string x =
+                        P
+                            .M1[|([|[null,
+                                // x
+                                null,
+                            ]|])|]
+                            .ToString();
+
+                    return x;
+                }
+
+                public string M2(string value, string[] values)
+                {
+                    string x =
+                        P
+                            .M2[|(
+                                "", [|[ null,
+                                    // y
+                                    null,]|])|]
+                                .ToString();
+
+                    return x;
+                }
+            }
+            """,
+            """
+            class C
+            {
+                public C P { get; set; }
+
+                public string M1(string[] values)
+                {
+                    string x =
+                        P
+                            .M1(
+                                [
+                                    null,
+                                // x
+                                null,
+                                ]
+                            )
+                            .ToString();
+
+                    return x;
+                }
+
+                public string M2(string value, string[] values)
+                {
+                    string x =
+                        P
+                            .M2(
+                                "", [
+                                    null,
+                                    // y
+                                    null,
+                                ]
+                            )
+                                .ToString();
+
+                    return x;
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Multiline_SwitchExpression()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            using System;
+
+            class C
+            {
+                string M(string value) =>
+                    M[|(value switch
+                    {
+                        "a" => "a",
+                        "b" => "b",
+                        _ => throw new Exception()
+                    })|];
+            }
+            """,
+            """
+            using System;
+
+            class C
+            {
+                string M(string value) =>
+                    M(
+                        value switch
+                    {
+                        "a" => "a",
+                        "b" => "b",
+                        _ => throw new Exception()
+                    }
+                    );
+            }
+            """
+        );
+    }
+}
diff --git a/src/VisualStudioCode/package/CHANGELOG.md b/src/VisualStudioCode/package/CHANGELOG.md
index 0dd4c5eedb..69c6e93495 100644
--- a/src/VisualStudioCode/package/CHANGELOG.md
+++ b/src/VisualStudioCode/package/CHANGELOG.md
@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- Analyzer and fixer for bracket formatting  [RCS1269](https://josefpihrt.github.io/docs/roslynator/analyzers/RCS1269) ([PR](https://github.com/dotnet/roslynator/pull/1643))
+
 ## [4.13.1] - 2025-02-23
 
 ### Added
diff --git a/src/VisualStudioCode/package/src/configurationFiles.generated.ts b/src/VisualStudioCode/package/src/configurationFiles.generated.ts
index 538f74612f..88e531facf 100644
--- a/src/VisualStudioCode/package/src/configurationFiles.generated.ts
+++ b/src/VisualStudioCode/package/src/configurationFiles.generated.ts
@@ -124,6 +124,10 @@ roslynator_analyzers.enabled_by_default = true|false
 # Default: 4
 # Applicable to: rcs0056
 
+#roslynator_target_braces_style = both|closing|none|opening
+# Default: none
+# Applicable to: rcs1269
+
 #roslynator_trailing_comma_style = include|omit|omit_when_single_line
 # Applicable to: rcs1260
 
@@ -923,6 +927,10 @@ roslynator_analyzers.enabled_by_default = true|false
 # Simplify numeric comparison
 #dotnet_diagnostic.rcs1268.severity = suggestion
 
+# Fix bracket formatting of a list
+#dotnet_diagnostic.rcs1269.severity = none
+# Options: roslynator_target_braces_style
+
 # Use pattern matching
 #dotnet_diagnostic.rcs9001.severity = silent