From d8d8193cec262b540eb1aab31c66ec33f0fceef3 Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Sun, 30 Mar 2025 12:39:38 +0200
Subject: [PATCH 01/38] Added ignoring of JetBrains Rider/Idea files

---
 .gitignore | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

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/

From 3afb7e8a822c0551e84552f377ac971317698014 Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Sun, 30 Mar 2025 13:50:30 +0200
Subject: [PATCH 02/38] Added forcing of 2 space indent for Analyzers.xml
 files. Disabled trimming of trailing white spaces

---
 .editorconfig | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/.editorconfig b/.editorconfig
index f9ecc06957..680563c619 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -10,6 +10,10 @@ indent_style = space
 [*.{cs,csx}]
 indent_size = 4
 
+[Analyzers.xml]
+indent_size = 2
+trim_trailing_whitespace = false
+
 # https://learn.microsoft.com/dotnet/fundamentals/code-analysis/style-rules/csharp-formatting-options
 
 # New-line options

From acc63033736da0b54eec748bf8a882d217538dfc Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Sun, 30 Mar 2025 13:51:12 +0200
Subject: [PATCH 03/38] Generated constants for RCS1269

---
 src/Analyzers.xml                             | 36 +++++++++++++++++++
 src/Common/DiagnosticIdentifiers.Generated.cs |  1 +
 src/Common/DiagnosticRules.Generated.cs       | 12 +++++++
 .../src/configurationFiles.generated.ts       |  3 ++
 4 files changed, 52 insertions(+)

diff --git a/src/Analyzers.xml b/src/Analyzers.xml
index 072001d577..e340d56cfb 100644
--- a/src/Analyzers.xml
+++ b/src/Analyzers.xml
@@ -7819,6 +7819,42 @@ 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>
+    <Summary>
+      This analyzer:
+        * adds new line after an opening bracket of method definition or call
+        * adds new line before a closing bracket of method definition or call
+        * 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/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/VisualStudioCode/package/src/configurationFiles.generated.ts b/src/VisualStudioCode/package/src/configurationFiles.generated.ts
index 538f74612f..8028596d79 100644
--- a/src/VisualStudioCode/package/src/configurationFiles.generated.ts
+++ b/src/VisualStudioCode/package/src/configurationFiles.generated.ts
@@ -923,6 +923,9 @@ 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
+
 # Use pattern matching
 #dotnet_diagnostic.rcs9001.severity = silent
 

From 48719da5b4211b40e85f01d22616fb80608b18c1 Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Sun, 30 Mar 2025 14:08:53 +0200
Subject: [PATCH 04/38] Adjusted indent size for *.xml files

---
 .editorconfig | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/.editorconfig b/.editorconfig
index 680563c619..aa35122b52 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -10,8 +10,10 @@ indent_style = space
 [*.{cs,csx}]
 indent_size = 4
 
-[Analyzers.xml]
+[*.xml]
 indent_size = 2
+
+[Analyzers.xml]
 trim_trailing_whitespace = false
 
 # https://learn.microsoft.com/dotnet/fundamentals/code-analysis/style-rules/csharp-formatting-options

From be55b98ff729effb3fe62d911b1784914f9252ca Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Sun, 30 Mar 2025 14:09:33 +0200
Subject: [PATCH 05/38] Added TargetBracesStyle

---
 .../CSharp/CodeStyle/TargetBracesStyle.cs     | 11 +++++++++
 .../CSharp/Extensions/CodeStyleExtensions.cs  | 23 +++++++++++++++++++
 src/Common/ConfigOptionKeys.Generated.cs      |  1 +
 src/Common/ConfigOptionValues.Generated.cs    |  4 ++++
 src/Common/ConfigOptions.Generated.cs         |  6 +++++
 src/ConfigOptions.xml                         |  9 ++++++++
 .../src/configurationFiles.generated.ts       |  3 +++
 7 files changed, 57 insertions(+)
 create mode 100644 src/Common/CSharp/CodeStyle/TargetBracesStyle.cs

diff --git a/src/Common/CSharp/CodeStyle/TargetBracesStyle.cs b/src/Common/CSharp/CodeStyle/TargetBracesStyle.cs
new file mode 100644
index 0000000000..d816fb0178
--- /dev/null
+++ b/src/Common/CSharp/CodeStyle/TargetBracesStyle.cs
@@ -0,0 +1,11 @@
+// Copyright (c) .NET Foundation and Contributors. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+namespace Roslynator.CSharp.CodeStyle;
+
+public enum TargetBracesStyle
+{
+    None,
+    Opening,
+    Closing,
+    Both
+}
\ No newline at end of file
diff --git a/src/Common/CSharp/Extensions/CodeStyleExtensions.cs b/src/Common/CSharp/Extensions/CodeStyleExtensions.cs
index 48fafdc967..4afb16cdf9 100644
--- a/src/Common/CSharp/Extensions/CodeStyleExtensions.cs
+++ b/src/Common/CSharp/Extensions/CodeStyleExtensions.cs
@@ -656,6 +656,29 @@ public static NewLinePosition GetNullConditionalOperatorNewLinePosition(this Syn
         return context.GetConfigOptions().GetNullConditionalOperatorNewLinePosition(defaultValue);
     }
 
+    public static TargetBracesStyle GetTargetBracesStyle(this SyntaxNodeAnalysisContext context)
+    {
+        AnalyzerConfigOptions configOptions = context.GetConfigOptions();
+
+        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/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/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/VisualStudioCode/package/src/configurationFiles.generated.ts b/src/VisualStudioCode/package/src/configurationFiles.generated.ts
index 8028596d79..e7ee73b347 100644
--- a/src/VisualStudioCode/package/src/configurationFiles.generated.ts
+++ b/src/VisualStudioCode/package/src/configurationFiles.generated.ts
@@ -124,6 +124,9 @@ roslynator_analyzers.enabled_by_default = true|false
 # Default: 4
 # Applicable to: rcs0056
 
+#roslynator_target_braces_style = both|closing|none|opening
+# Default: none
+
 #roslynator_trailing_comma_style = include|omit|omit_when_single_line
 # Applicable to: rcs1260
 

From 8e7c26436f4fefb3d892b0857c756b7929bd0fe0 Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Sun, 30 Mar 2025 19:23:05 +0200
Subject: [PATCH 06/38] Implementing

---
 src/Analyzers.xml                             |    3 +
 ...xBracketFormattingOfListCodeFixProvider.cs |  173 ++
 .../FixBracketFormattingOfListAnalyzer.cs     |  501 ++++++
 .../RCS1269FixBracketFormattingOfListTests.cs | 1461 +++++++++++++++++
 .../src/configurationFiles.generated.ts       |    2 +
 5 files changed, 2140 insertions(+)
 create mode 100644 src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs
 create mode 100644 src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs
 create mode 100644 src/Tests/Formatting.Analyzers.Tests/RCS1269FixBracketFormattingOfListTests.cs

diff --git a/src/Analyzers.xml b/src/Analyzers.xml
index e340d56cfb..ddc91d8d9e 100644
--- a/src/Analyzers.xml
+++ b/src/Analyzers.xml
@@ -7826,6 +7826,9 @@ string s = """
     <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 method definition or call
diff --git a/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs b/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs
new file mode 100644
index 0000000000..fa09b6075a
--- /dev/null
+++ b/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs
@@ -0,0 +1,173 @@
+using System;
+using System.Collections.Immutable;
+using System.Composition;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace Roslynator.Formatting.CodeFixes.CSharp;
+
+[ExportCodeFixProvider(LanguageNames.CSharp, Name = nameof(FixBracketFormattingOfListCodeFixProvider))]
+[Shared]
+public sealed class FixBracketFormattingOfListCodeFixProvider : BaseCodeFixProvider
+{
+    private const string Title = "Fix formatting";
+
+    public override ImmutableArray<string> FixableDiagnosticIds =>
+        ImmutableArray.Create(DiagnosticIdentifiers.FixFormattingOfList);
+
+    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.BaseList:
+                        case SyntaxKind.TupleType:
+                        case SyntaxKind.TupleExpression:
+                        case SyntaxKind.ArrayInitializerExpression:
+                        case SyntaxKind.CollectionInitializerExpression:
+                        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 => CodeFixHelpers.FixListAsync(document, parameterList, ListFixMode.Fix, ct),
+                        GetEquivalenceKey(diagnostic)
+                    );
+                }
+                case BracketedParameterListSyntax bracketedParameterList:
+                {
+                    return CodeAction.Create(
+                        Title,
+                        ct => CodeFixHelpers.FixListAsync(document, bracketedParameterList, ListFixMode.Fix, ct),
+                        GetEquivalenceKey(diagnostic)
+                    );
+                }
+                case TypeParameterListSyntax typeParameterList:
+                {
+                    return CodeAction.Create(
+                        Title,
+                        ct => CodeFixHelpers.FixListAsync(document, typeParameterList, ListFixMode.Fix, ct),
+                        GetEquivalenceKey(diagnostic)
+                    );
+                }
+                case ArgumentListSyntax argumentList:
+                {
+                    return CodeAction.Create(
+                        Title,
+                        ct => CodeFixHelpers.FixListAsync(document, argumentList, ListFixMode.Fix, ct),
+                        GetEquivalenceKey(diagnostic)
+                    );
+                }
+                case BracketedArgumentListSyntax bracketedArgumentList:
+                {
+                    return CodeAction.Create(
+                        Title,
+                        ct => CodeFixHelpers.FixListAsync(document, bracketedArgumentList, ListFixMode.Fix, ct),
+                        GetEquivalenceKey(diagnostic)
+                    );
+                }
+                case AttributeArgumentListSyntax attributeArgumentList:
+                {
+                    return CodeAction.Create(
+                        Title,
+                        ct => CodeFixHelpers.FixListAsync(document, attributeArgumentList, ListFixMode.Fix, ct),
+                        GetEquivalenceKey(diagnostic)
+                    );
+                }
+                case TypeArgumentListSyntax typeArgumentList:
+                {
+                    return CodeAction.Create(
+                        Title,
+                        ct => CodeFixHelpers.FixListAsync(document, typeArgumentList, ListFixMode.Fix, ct),
+                        GetEquivalenceKey(diagnostic)
+                    );
+                }
+                case AttributeListSyntax attributeList:
+                {
+                    return CodeAction.Create(
+                        Title,
+                        ct => CodeFixHelpers.FixListAsync(document, attributeList, ListFixMode.Fix, ct),
+                        GetEquivalenceKey(diagnostic)
+                    );
+                }
+                case BaseListSyntax baseList:
+                {
+                    return CodeAction.Create(
+                        Title,
+                        ct => CodeFixHelpers.FixListAsync(document, baseList, ListFixMode.Fix, ct),
+                        GetEquivalenceKey(diagnostic)
+                    );
+                }
+                case TupleTypeSyntax tupleType:
+                {
+                    return CodeAction.Create(
+                        Title,
+                        ct => CodeFixHelpers.FixListAsync(document, tupleType, ListFixMode.Fix, ct),
+                        GetEquivalenceKey(diagnostic)
+                    );
+                }
+                case TupleExpressionSyntax tupleExpression:
+                {
+                    return CodeAction.Create(
+                        Title,
+                        ct => CodeFixHelpers.FixListAsync(document, tupleExpression, ListFixMode.Fix, ct),
+                        GetEquivalenceKey(diagnostic)
+                    );
+                }
+                case InitializerExpressionSyntax initializerExpression:
+                {
+                    return CodeAction.Create(
+                        Title,
+                        ct => CodeFixHelpers.FixListAsync(document, initializerExpression, ListFixMode.Fix, ct),
+                        GetEquivalenceKey(diagnostic)
+                    );
+                }
+                default:
+                {
+                    throw new InvalidOperationException();
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs b/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs
new file mode 100644
index 0000000000..d2f487b8e2
--- /dev/null
+++ b/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs
@@ -0,0 +1,501 @@
+using System;
+using System.Collections.Immutable;
+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 => AnalyzeBaseList(f), SyntaxKind.BaseList);
+        context.RegisterSyntaxNodeAction(f => AnalyzeTupleType(f), SyntaxKind.TupleType);
+        context.RegisterSyntaxNodeAction(f => AnalyzeTupleExpression(f), SyntaxKind.TupleExpression);
+
+        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.Parameters);
+    }
+
+    private static void AnalyzeBracketedParameterList(SyntaxNodeAnalysisContext context)
+    {
+        var parameterList = (BracketedParameterListSyntax)context.Node;
+
+        Analyze(context, parameterList.OpenBracketToken, parameterList.Parameters);
+    }
+
+    private static void AnalyzeTypeParameterList(SyntaxNodeAnalysisContext context)
+    {
+        var parameterList = (TypeParameterListSyntax)context.Node;
+
+        Analyze(context, parameterList.LessThanToken, parameterList.Parameters);
+    }
+
+    private static void AnalyzeArgumentList(SyntaxNodeAnalysisContext context)
+    {
+        var argumentList = (ArgumentListSyntax)context.Node;
+
+        Analyze(context, argumentList.OpenParenToken, argumentList.Arguments);
+    }
+
+    private static void AnalyzeBracketedArgumentList(SyntaxNodeAnalysisContext context)
+    {
+        var argumentList = (BracketedArgumentListSyntax)context.Node;
+
+        Analyze(context, argumentList.OpenBracketToken, argumentList.Arguments);
+    }
+
+    private static void AnalyzeAttributeArgumentList(SyntaxNodeAnalysisContext context)
+    {
+        var argumentList = (AttributeArgumentListSyntax)context.Node;
+
+        Analyze(context, argumentList.OpenParenToken, argumentList.Arguments);
+    }
+
+    private static void AnalyzeTypeArgumentList(SyntaxNodeAnalysisContext context)
+    {
+        var argumentList = (TypeArgumentListSyntax)context.Node;
+
+        Analyze(context, argumentList.LessThanToken, argumentList.Arguments);
+    }
+
+    private static void AnalyzeAttributeList(SyntaxNodeAnalysisContext context)
+    {
+        var attributeList = (AttributeListSyntax)context.Node;
+
+        Analyze(context, attributeList.OpenBracketToken, attributeList.Attributes);
+    }
+
+    private static void AnalyzeBaseList(SyntaxNodeAnalysisContext context)
+    {
+        var baseList = (BaseListSyntax)context.Node;
+
+        Analyze(context, baseList.ColonToken, baseList.Types);
+    }
+
+    private static void AnalyzeTupleType(SyntaxNodeAnalysisContext context)
+    {
+        var tupleType = (TupleTypeSyntax)context.Node;
+
+        Analyze(context, tupleType.OpenParenToken, tupleType.Elements);
+    }
+
+    private static void AnalyzeTupleExpression(SyntaxNodeAnalysisContext context)
+    {
+        var tupleExpression = (TupleExpressionSyntax)context.Node;
+
+        Analyze(context, tupleExpression.OpenParenToken, tupleExpression.Arguments);
+    }
+
+    private static void AnalyzeInitializerExpression(SyntaxNodeAnalysisContext context)
+    {
+        var initializerExpression = (InitializerExpressionSyntax)context.Node;
+
+        Analyze(context, initializerExpression.OpenBraceToken, initializerExpression.Expressions);
+    }
+
+    private static void Analyze<TNode>(
+        SyntaxNodeAnalysisContext context,
+        SyntaxNodeOrToken openNodeOrToken,
+        SeparatedSyntaxList<TNode> nodes
+    )
+        where TNode : SyntaxNode
+    {
+        TargetBracesStyle style = context.GetTargetBracesStyle();
+
+        if (style == TargetBracesStyle.None)
+        {
+            return;
+        }
+
+        TNode first = nodes.FirstOrDefault();
+
+        if (first is null)
+            return;
+
+        TextSpan span = nodes.GetSpan(includeExteriorTrivia: false);
+
+        if (span.IsSingleLine(first.SyntaxTree))
+        {
+            if (!TriviaBlock.FromTrailing(openNodeOrToken).IsWrapped)
+                return;
+
+            int indentationLength = IndentationAnalysis.Create(openNodeOrToken.Parent, context.GetConfigOptions()).IncreasedIndentationLength;
+
+            if (indentationLength == 0)
+                return;
+
+            if (ShouldFixIndentation(first.GetLeadingTrivia(), indentationLength))
+                ReportDiagnostic();
+        }
+        else
+        {
+            TextLineCollection lines = null;
+            IndentationAnalysis indentationAnalysis = IndentationAnalysis.Create(openNodeOrToken.Parent, context.GetConfigOptions());
+            int indentationLength = indentationAnalysis.IncreasedIndentationLength;
+
+            if (indentationLength == 0)
+                return;
+
+            for (int i = nodes.Count - 1; i >= 0; i--)
+            {
+                context.CancellationToken.ThrowIfCancellationRequested();
+
+                SyntaxNodeOrToken nodeOrToken = (i == 0)
+                    ? openNodeOrToken
+                    : nodes.GetSeparator(i - 1);
+
+                if (TriviaBlock.FromTrailing(nodeOrToken).IsWrapped)
+                {
+                    if (AnalyzeBlock(nodes, indentationAnalysis, SyntaxKind.OpenBracketToken, SyntaxKind.CloseBracketToken))
+                        return;
+
+                    if (ShouldFixIndentation(nodes[i].GetLeadingTrivia(), indentationLength))
+                    {
+                        ReportDiagnostic();
+                        return;
+                    }
+                }
+                else
+                {
+                    if (nodes.Count > 1
+                        && ShouldWrapAndIndent(context.Node, i))
+                    {
+                        ReportDiagnostic();
+                        return;
+                    }
+
+                    if (AnalyzeBlock(nodes, indentationAnalysis, SyntaxKind.OpenBraceToken, SyntaxKind.CloseBraceToken))
+                        return;
+
+                    lines ??= first.SyntaxTree.GetText().Lines;
+
+                    int lineIndex = lines.IndexOf(span.Start);
+                    if (lineIndex < lines.Count - 1)
+                    {
+                        int lineStartIndex = lines[lineIndex + 1].Start;
+
+                        if (first.Span.Contains(lineStartIndex))
+                        {
+                            SyntaxToken token = first.FindToken(lineStartIndex);
+
+                            if (!token.IsKind(SyntaxKind.None))
+                            {
+                                SyntaxTriviaList leading = token.LeadingTrivia;
+
+                                if (leading.Any())
+                                {
+                                    if (leading.FullSpan.Contains(lineStartIndex))
+                                    {
+                                        SyntaxTrivia trivia = leading.Last();
+
+                                        if (trivia.IsWhitespaceTrivia()
+                                            && trivia.SpanStart == lineStartIndex
+                                            && trivia.Span.Length != indentationLength)
+                                        {
+                                            ReportDiagnostic();
+                                            return;
+                                        }
+                                    }
+                                }
+                                else if (lineStartIndex == token.SpanStart)
+                                {
+                                    ReportDiagnostic();
+                                    return;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        void ReportDiagnostic()
+        {
+            DiagnosticHelpers.ReportDiagnostic(
+                context,
+                DiagnosticRules.FixBracketFormattingOfList,
+                Location.Create(first.SyntaxTree, nodes.Span),
+                GetTitle()
+            );
+        }
+
+        static bool ShouldFixIndentation(SyntaxTriviaList leading, int indentationLength)
+        {
+            SyntaxTriviaList.Reversed.Enumerator en = leading.Reverse().GetEnumerator();
+
+            if (!en.MoveNext())
+                return true;
+
+            switch (en.Current.Kind())
+            {
+                case SyntaxKind.WhitespaceTrivia:
+                {
+                    if (en.Current.Span.Length != indentationLength)
+                    {
+                        if (!en.MoveNext()
+                            || en.Current.IsEndOfLineTrivia())
+                        {
+                            return true;
+                        }
+                    }
+
+                    break;
+                }
+                case SyntaxKind.EndOfLineTrivia:
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        string GetTitle()
+        {
+            switch (context.Node.Kind())
+            {
+                case SyntaxKind.ParameterList:
+                case SyntaxKind.BracketedParameterList:
+                case SyntaxKind.TypeParameterList:
+                    return "parameters";
+                case SyntaxKind.ArgumentList:
+                case SyntaxKind.BracketedArgumentList:
+                case SyntaxKind.AttributeArgumentList:
+                case SyntaxKind.TypeArgumentList:
+                    return "arguments";
+                case SyntaxKind.AttributeList:
+                    return "attributes";
+                case SyntaxKind.BaseList:
+                    return "base types";
+                case SyntaxKind.TupleType:
+                case SyntaxKind.TupleExpression:
+                    return "a tuple";
+                case SyntaxKind.ArrayInitializerExpression:
+                case SyntaxKind.CollectionInitializerExpression:
+                case SyntaxKind.ComplexElementInitializerExpression:
+                case SyntaxKind.ObjectInitializerExpression:
+                    return "an initializer";
+                default:
+                    throw new InvalidOperationException();
+            }
+        }
+
+        bool AnalyzeBlock(
+            SeparatedSyntaxList<TNode> nodes,
+            IndentationAnalysis indentationAnalysis,
+            SyntaxKind kind1,
+            SyntaxKind kind2)
+        {
+            if (nodes.Count == 1
+                && nodes[0].IsKind(SyntaxKind.Argument))
+            {
+                BracesBlock block = GetBracesBlock(nodes[0]);
+
+                if (block.Token.IsKind(kind1, kind2))
+                {
+                    SyntaxToken token = block.Token;
+                    SyntaxTriviaList leading = token.LeadingTrivia;
+
+                    if (leading.Any())
+                    {
+                        SyntaxTrivia trivia = leading.Last();
+
+                        if (trivia.IsWhitespaceTrivia()
+                            && trivia.SpanStart == block.LineStartIndex
+                            && trivia.Span.Length != indentationAnalysis.IndentationLength)
+                        {
+                            ReportDiagnostic();
+                        }
+                    }
+                    else if (block.LineStartIndex == token.SpanStart)
+                    {
+                        ReportDiagnostic();
+                    }
+                    return true;
+                }
+            }
+
+            return false;
+        }
+    }
+
+    internal static BracesBlock GetBracesBlock(SyntaxNode node)
+    {
+        TextLineCollection lines = node.SyntaxTree.GetText().Lines;
+        TextLine line = lines.GetLineFromPosition(node.SpanStart);
+
+        int startIndex = line.End;
+
+        if (!node.FullSpan.Contains(startIndex))
+            return default;
+
+        SyntaxToken openToken = node.FindToken(startIndex);
+        SyntaxNode block = null;
+        var isOpenBraceAtEndOfLine = false;
+
+        if (AnalyzeToken(openToken, isOpen: true))
+        {
+            SyntaxTriviaList trailing = openToken.TrailingTrivia;
+
+            if (trailing.Any()
+                && trailing.Span.Contains(startIndex))
+            {
+                block = openToken.Parent;
+                isOpenBraceAtEndOfLine = true;
+            }
+        }
+
+        if (block is null)
+        {
+            startIndex = line.EndIncludingLineBreak;
+            openToken = node.FindToken(startIndex);
+
+            if (AnalyzeToken(openToken, isOpen: true))
+            {
+                SyntaxTriviaList leading = openToken.LeadingTrivia;
+
+                if ((leading.Any() && leading.Span.Contains(startIndex))
+                    || (!leading.Any() && openToken.SpanStart == startIndex))
+                {
+                    block = openToken.Parent;
+                }
+            }
+        }
+
+        if (block is not null)
+        {
+            int endIndex = lines.GetLineFromPosition(node.Span.End).Start;
+            SyntaxToken closeToken = node.FindToken(endIndex);
+
+            if (AnalyzeToken(closeToken, isOpen: false)
+                && object.ReferenceEquals(block, closeToken.Parent))
+            {
+                SyntaxTriviaList leading = closeToken.LeadingTrivia;
+
+                if ((leading.Any() && leading.Span.Contains(endIndex))
+                    || (!leading.Any() && closeToken.SpanStart == endIndex))
+                {
+                    return new BracesBlock(
+                        (isOpenBraceAtEndOfLine) ? closeToken : openToken,
+                        (isOpenBraceAtEndOfLine) ? endIndex : startIndex);
+                }
+            }
+        }
+
+        return default;
+
+        static bool AnalyzeToken(SyntaxToken token, bool isOpen)
+        {
+            if (token.IsKind((isOpen) ? SyntaxKind.OpenBraceToken : SyntaxKind.CloseBraceToken))
+            {
+                if (token.IsParentKind(SyntaxKind.Block)
+                    && (CSharpFacts.IsAnonymousFunctionExpression(token.Parent.Parent.Kind())))
+                {
+                    return true;
+                }
+
+                if (token.IsParentKind(SyntaxKind.SwitchExpression))
+                    return true;
+
+                if (token.IsParentKind(SyntaxKind.ObjectInitializerExpression)
+                    && token.Parent.Parent.IsKind(
+                        SyntaxKind.ObjectCreationExpression,
+                        SyntaxKind.AnonymousObjectCreationExpression,
+                        SyntaxKind.ImplicitObjectCreationExpression))
+                {
+                    return true;
+                }
+
+                if (token.IsParentKind(SyntaxKind.ArrayInitializerExpression)
+                    && token.Parent.Parent.IsKind(
+                        SyntaxKind.ArrayCreationExpression,
+                        SyntaxKind.ImplicitArrayCreationExpression))
+                {
+                    return true;
+                }
+            }
+#if ROSLYN_4_7
+            return token.IsKind((isOpen) ? SyntaxKind.OpenBracketToken : SyntaxKind.CloseBracketToken)
+                   && token.IsParentKind(SyntaxKind.CollectionExpression);
+#else
+            return false;
+#endif
+        }
+    }
+
+    internal static bool ShouldWrapAndIndent(SyntaxNode node, int index)
+    {
+        if (index == 0)
+        {
+            if (node.IsKind(SyntaxKind.AttributeList))
+            {
+                return false;
+            }
+            else if (node.IsKind(SyntaxKind.TupleExpression)
+                     && node.Parent is AssignmentExpressionSyntax assignmentExpression
+                     && object.ReferenceEquals(node, assignmentExpression.Left))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    internal readonly struct BracesBlock
+    {
+        public BracesBlock(SyntaxToken token, int lineStartIndex)
+        {
+            Token = token;
+            LineStartIndex = lineStartIndex;
+        }
+
+        public SyntaxToken Token { get; }
+
+        public int LineStartIndex { get; }
+    }
+}
\ No newline at end of file
diff --git a/src/Tests/Formatting.Analyzers.Tests/RCS1269FixBracketFormattingOfListTests.cs b/src/Tests/Formatting.Analyzers.Tests/RCS1269FixBracketFormattingOfListTests.cs
new file mode 100644
index 0000000000..262d271401
--- /dev/null
+++ b/src/Tests/Formatting.Analyzers.Tests/RCS1269FixBracketFormattingOfListTests.cs
@@ -0,0 +1,1461 @@
+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_NoIndentation()
+    {
+        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_EmptyLine()
+    {
+        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_TwoParametersOnSameLine2()
+    {
+        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_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_OpeMultilineLambdaParameter()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+using System;
+
+class C
+{
+    void M(Func<string, string> x)
+    {
+        M([|f =>
+{
+    return null;
+});|]
+    }
+}
+", @"
+using System;
+
+class C
+{
+    void M(Func<string, string> x)
+    {
+        M(
+            f =>
+{
+    return null;
+}
+        );
+    }
+}
+");
+    }
+
+    [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_FirstParameterIsMultilineLambda2()
+    {
+        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_SecondParameterIsMultilineLambdaWithBlockBody()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+using System;
+
+class C
+{
+    void M(object x, Func<string, string> y)
+    {
+        M([|x, f =>
+        {
+            return f
+                .ToString()
+                .ToString();
+        });|]
+    }
+}
+", @"
+using System;
+
+class C
+{
+    void M(object x, Func<string, string> y)
+    {
+        M(
+            x, f =>
+        {
+            return f
+                .ToString()
+                .ToString();
+        }
+        );
+    }
+}
+");
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Multiline_SecondParameterIsMultilineLambdaWithBlockBody2()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+using System;
+
+class C
+{
+    void M(object x, Func<string, string> y)
+    {
+        M([|x, f => {
+            return f
+                .ToString()
+                .ToString();
+        });|]
+    }
+}
+", @"
+using System;
+
+class C
+{
+    void M(object x, Func<string, string> y)
+    {
+        M(
+            x, f => {
+            return f
+                .ToString()
+                .ToString();
+        }
+        );
+    }
+}
+");
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Multiline_MultilineLambda()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+using System;
+
+class C
+{
+    void M(Func<string, string> x, string y)
+    {
+        M([|f =>
+        {
+            string s = null;
+
+            //x
+            return null;
+        }, y);|]
+    }
+}
+", @"
+using System;
+
+class C
+{
+    void M(Func<string, string> x, string y)
+    {
+        M(
+            f =>
+        {
+            string s = null;
+
+            //x
+            return null;
+        }, y
+        );
+    }
+}
+");
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Multiline_MultilineLambda2()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+using System;
+
+class C
+{
+    void M(Func<string, string> x)
+    {
+        M([|f =>
+            {
+                return null;
+            });|]
+    }
+}
+", @"
+using System;
+
+class C
+{
+    void M(Func<string, string> x)
+    {
+        M(
+            f =>
+            {
+                return null;
+            }
+        );
+    }
+}
+");
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Multiline_IndentationsDiffer()
+    {
+        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()
+        );
+    }
+}
+");
+    }
+
+    [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_SecondParameterIsAlreadyIndented()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+using System.Linq;
+using System.Collections.Generic;
+
+class C
+{
+    void M(string x, IEnumerable<string> y)
+    {
+        M([|x,
+            Enumerable.Empty<string>()
+                .OrderBy(f => f)
+                .Select(f => f)|]
+        );
+    }
+}
+", @"
+using System.Linq;
+using System.Collections.Generic;
+
+class C
+{
+    void M(string x, IEnumerable<string> y)
+    {
+        M(
+            x,
+            Enumerable.Empty<string>()
+                .OrderBy(f => f)
+                .Select(f => f)
+        );
+    }
+}
+");
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Multiline_ConditionalExpression()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                void M(string x, string y)
+                {
+                    M([|x, (y != null)
+                        ? y
+                        : "");|]
+                }
+            }
+            """,
+            """
+            class C
+            {
+                void M(string x, string y)
+                {
+                    M(
+                        x, (y != null)
+                        ? y
+                        : ""
+                    );
+                }
+            }
+            """
+        );
+    }
+
+    [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()
+                {
+                    return ([|null, null,
+                        null|]);
+                }
+            }
+
+            """,
+            """
+            class C
+            {
+                private (
+                    string x, string y,
+                    string z
+                ) M()
+                {
+                    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);
+            """
+        );
+    }
+
+    [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(
+                        ""
+                    )
+                }
+            );
+            """,
+            options: Options.WithCompilationOptions(Options.CompilationOptions.WithOutputKind(OutputKind.ConsoleApplication))
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task TestNoDiagnostic_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 TestNoDiagnostic_Multiline_CollectionExpression()
+    {
+        await VerifyNoDiagnosticAsync(
+            """
+            class C
+            {
+                public C P { get; set; }
+
+                public string M1(string[] values)
+                {
+                    string x =
+                        P
+                            .M1(
+                            [
+                                // x
+                                null,
+                            ])
+                            .ToString();
+
+                    return x;
+                }
+
+                public string M2(string value, string[] values)
+                {
+                    string x =
+                        P
+                            .M2(
+                                "",
+                                [
+                                    // x
+                                    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()
+                    }
+                    );
+            }
+            """
+        );
+    }
+}
\ No newline at end of file
diff --git a/src/VisualStudioCode/package/src/configurationFiles.generated.ts b/src/VisualStudioCode/package/src/configurationFiles.generated.ts
index e7ee73b347..88e531facf 100644
--- a/src/VisualStudioCode/package/src/configurationFiles.generated.ts
+++ b/src/VisualStudioCode/package/src/configurationFiles.generated.ts
@@ -126,6 +126,7 @@ roslynator_analyzers.enabled_by_default = true|false
 
 #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
@@ -928,6 +929,7 @@ roslynator_analyzers.enabled_by_default = true|false
 
 # Fix bracket formatting of a list
 #dotnet_diagnostic.rcs1269.severity = none
+# Options: roslynator_target_braces_style
 
 # Use pattern matching
 #dotnet_diagnostic.rcs9001.severity = silent

From dc86f5ff70a2b6a945adb80840abdabe70789c10 Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Sun, 6 Apr 2025 19:59:00 +0200
Subject: [PATCH 07/38] Implementing

---
 .../CSharp/CodeStyle/TargetBracesStyle.cs     |    5 +-
 .../CSharp/Extensions/CodeStyleExtensions.cs  |    7 +-
 src/Common/CSharp/SyntaxTriviaAnalysis.cs     |   13 +-
 ...xBracketFormattingOfListCodeFixProvider.cs |  122 +-
 .../FixBracketFormattingOfListAnalyzer.cs     |  415 ++-----
 .../RCS1269FixBracketFormattingOfListTests.cs | 1045 +++++++----------
 6 files changed, 624 insertions(+), 983 deletions(-)

diff --git a/src/Common/CSharp/CodeStyle/TargetBracesStyle.cs b/src/Common/CSharp/CodeStyle/TargetBracesStyle.cs
index d816fb0178..5efb5c49d5 100644
--- a/src/Common/CSharp/CodeStyle/TargetBracesStyle.cs
+++ b/src/Common/CSharp/CodeStyle/TargetBracesStyle.cs
@@ -1,11 +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
+    Both = Opening | Closing,
 }
\ No newline at end of file
diff --git a/src/Common/CSharp/Extensions/CodeStyleExtensions.cs b/src/Common/CSharp/Extensions/CodeStyleExtensions.cs
index 4afb16cdf9..5d8c62f4a3 100644
--- a/src/Common/CSharp/Extensions/CodeStyleExtensions.cs
+++ b/src/Common/CSharp/Extensions/CodeStyleExtensions.cs
@@ -656,10 +656,11 @@ public static NewLinePosition GetNullConditionalOperatorNewLinePosition(this Syn
         return context.GetConfigOptions().GetNullConditionalOperatorNewLinePosition(defaultValue);
     }
 
-    public static TargetBracesStyle GetTargetBracesStyle(this SyntaxNodeAnalysisContext context)
-    {
-        AnalyzerConfigOptions configOptions = context.GetConfigOptions();
+    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))
diff --git a/src/Common/CSharp/SyntaxTriviaAnalysis.cs b/src/Common/CSharp/SyntaxTriviaAnalysis.cs
index e995ce2e8b..af4ad4256e 100644
--- a/src/Common/CSharp/SyntaxTriviaAnalysis.cs
+++ b/src/Common/CSharp/SyntaxTriviaAnalysis.cs
@@ -118,8 +118,18 @@ public static SyntaxTrivia DetermineIndentation(SyntaxNodeOrToken nodeOrToken, C
             return CSharpFactory.EmptyWhitespace();
 
         TextSpan span = nodeOrToken.Span;
+        FileLinePositionSpan linePositionSpan = tree.GetLineSpan(span, cancellationToken);
 
-        int lineStartIndex = span.Start - tree.GetLineSpan(span, cancellationToken).StartLinePosition.Character;
+        SourceText sourceText = tree.GetText(cancellationToken);
+        int lineStartPosition = sourceText.Lines.GetPosition(new LinePosition(linePositionSpan.StartLinePosition.Line, 0));
+
+        // Span starts at the beginning of the line = no indentation
+        if (span.Start == lineStartPosition)
+        {
+            return CSharpFactory.EmptyWhitespace();
+        }
+
+        int lineStartIndex = span.Start - linePositionSpan.StartLinePosition.Character;
 
         SyntaxTriviaList leading = nodeOrToken.GetLeadingTrivia();
 
@@ -206,6 +216,7 @@ static bool IsMemberDeclarationOrStatementOrAccessorDeclaration(SyntaxNode node)
         }
     }
 
+
     public static string GetIncreasedIndentation(SyntaxNode node, AnalyzerConfigOptions configOptions, CancellationToken cancellationToken = default)
     {
         return AnalyzeIndentation(node, configOptions, cancellationToken).GetIncreasedIndentation();
diff --git a/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs b/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs
index fa09b6075a..a277a1978d 100644
--- a/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs
+++ b/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs
@@ -1,12 +1,18 @@
 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;
 
@@ -14,10 +20,10 @@ namespace Roslynator.Formatting.CodeFixes.CSharp;
 [Shared]
 public sealed class FixBracketFormattingOfListCodeFixProvider : BaseCodeFixProvider
 {
-    private const string Title = "Fix formatting";
+    private const string Title = "Fix bracket formatting";
 
     public override ImmutableArray<string> FixableDiagnosticIds =>
-        ImmutableArray.Create(DiagnosticIdentifiers.FixFormattingOfList);
+        ImmutableArray.Create(DiagnosticIdentifiers.FixBracketFormattingOfList);
 
     public override async Task RegisterCodeFixesAsync(CodeFixContext context)
     {
@@ -39,7 +45,6 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
                         case SyntaxKind.AttributeArgumentList:
                         case SyntaxKind.TypeArgumentList:
                         case SyntaxKind.AttributeList:
-                        case SyntaxKind.BaseList:
                         case SyntaxKind.TupleType:
                         case SyntaxKind.TupleExpression:
                         case SyntaxKind.ArrayInitializerExpression:
@@ -71,7 +76,7 @@ CodeAction CreateCodeAction()
                 {
                     return CodeAction.Create(
                         Title,
-                        ct => CodeFixHelpers.FixListAsync(document, parameterList, ListFixMode.Fix, ct),
+                        ct => Fix(parameterList, parameterList.OpenParenToken, parameterList.CloseParenToken, ct),
                         GetEquivalenceKey(diagnostic)
                     );
                 }
@@ -79,7 +84,7 @@ CodeAction CreateCodeAction()
                 {
                     return CodeAction.Create(
                         Title,
-                        ct => CodeFixHelpers.FixListAsync(document, bracketedParameterList, ListFixMode.Fix, ct),
+                        ct => Fix(bracketedParameterList, bracketedParameterList.OpenBracketToken, bracketedParameterList.CloseBracketToken, ct),
                         GetEquivalenceKey(diagnostic)
                     );
                 }
@@ -87,7 +92,7 @@ CodeAction CreateCodeAction()
                 {
                     return CodeAction.Create(
                         Title,
-                        ct => CodeFixHelpers.FixListAsync(document, typeParameterList, ListFixMode.Fix, ct),
+                        ct => Fix(typeParameterList, typeParameterList.LessThanToken, typeParameterList.GreaterThanToken, ct),
                         GetEquivalenceKey(diagnostic)
                     );
                 }
@@ -95,7 +100,7 @@ CodeAction CreateCodeAction()
                 {
                     return CodeAction.Create(
                         Title,
-                        ct => CodeFixHelpers.FixListAsync(document, argumentList, ListFixMode.Fix, ct),
+                        ct => Fix(argumentList, argumentList.OpenParenToken, argumentList.CloseParenToken, ct),
                         GetEquivalenceKey(diagnostic)
                     );
                 }
@@ -103,7 +108,7 @@ CodeAction CreateCodeAction()
                 {
                     return CodeAction.Create(
                         Title,
-                        ct => CodeFixHelpers.FixListAsync(document, bracketedArgumentList, ListFixMode.Fix, ct),
+                        ct => Fix(bracketedArgumentList, bracketedArgumentList.OpenBracketToken, bracketedArgumentList.CloseBracketToken, ct),
                         GetEquivalenceKey(diagnostic)
                     );
                 }
@@ -111,7 +116,7 @@ CodeAction CreateCodeAction()
                 {
                     return CodeAction.Create(
                         Title,
-                        ct => CodeFixHelpers.FixListAsync(document, attributeArgumentList, ListFixMode.Fix, ct),
+                        ct => Fix(attributeArgumentList, attributeArgumentList.OpenParenToken, attributeArgumentList.CloseParenToken, ct),
                         GetEquivalenceKey(diagnostic)
                     );
                 }
@@ -119,7 +124,7 @@ CodeAction CreateCodeAction()
                 {
                     return CodeAction.Create(
                         Title,
-                        ct => CodeFixHelpers.FixListAsync(document, typeArgumentList, ListFixMode.Fix, ct),
+                        ct => Fix(typeArgumentList, typeArgumentList.LessThanToken, typeArgumentList.GreaterThanToken, ct),
                         GetEquivalenceKey(diagnostic)
                     );
                 }
@@ -127,15 +132,7 @@ CodeAction CreateCodeAction()
                 {
                     return CodeAction.Create(
                         Title,
-                        ct => CodeFixHelpers.FixListAsync(document, attributeList, ListFixMode.Fix, ct),
-                        GetEquivalenceKey(diagnostic)
-                    );
-                }
-                case BaseListSyntax baseList:
-                {
-                    return CodeAction.Create(
-                        Title,
-                        ct => CodeFixHelpers.FixListAsync(document, baseList, ListFixMode.Fix, ct),
+                        ct => Fix(attributeList, attributeList.OpenBracketToken, attributeList.CloseBracketToken, ct),
                         GetEquivalenceKey(diagnostic)
                     );
                 }
@@ -143,7 +140,7 @@ CodeAction CreateCodeAction()
                 {
                     return CodeAction.Create(
                         Title,
-                        ct => CodeFixHelpers.FixListAsync(document, tupleType, ListFixMode.Fix, ct),
+                        ct => Fix(tupleType, tupleType.OpenParenToken, tupleType.CloseParenToken, ct),
                         GetEquivalenceKey(diagnostic)
                     );
                 }
@@ -151,7 +148,7 @@ CodeAction CreateCodeAction()
                 {
                     return CodeAction.Create(
                         Title,
-                        ct => CodeFixHelpers.FixListAsync(document, tupleExpression, ListFixMode.Fix, ct),
+                        ct => Fix(tupleExpression, tupleExpression.OpenParenToken, tupleExpression.CloseParenToken, ct),
                         GetEquivalenceKey(diagnostic)
                     );
                 }
@@ -159,7 +156,7 @@ CodeAction CreateCodeAction()
                 {
                     return CodeAction.Create(
                         Title,
-                        ct => CodeFixHelpers.FixListAsync(document, initializerExpression, ListFixMode.Fix, ct),
+                        ct => Fix(initializerExpression, initializerExpression.OpenBraceToken, initializerExpression.CloseBraceToken, ct),
                         GetEquivalenceKey(diagnostic)
                     );
                 }
@@ -169,5 +166,86 @@ CodeAction CreateCodeAction()
                 }
             }
         }
+
+        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();
+
+            List<TextChange> textChanges = new ();
+
+            if (bracesStyle.HasFlag(TargetBracesStyle.Opening))
+            {
+                SyntaxToken nextToken = openNodeOrToken.GetNextToken();
+
+                int bracketLine = openNodeOrToken.GetSpanStartLine();
+                int nextTokenLine = nextToken.GetSpanStartLine();
+
+                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.HasFlag(TargetBracesStyle.Closing))
+            {
+                SyntaxToken previousToken = closeNodeOrToken.GetPreviousToken();
+
+                int bracketLine = closeNodeOrToken.GetSpanStartLine();
+                int previousTokenLine = previousToken.GetSpanStartLine();
+
+                if (bracketLine == previousTokenLine)
+                {
+                    string indentation = SyntaxTriviaAnalysis.DetermineIndentation(listNode, cancellationToken).ToString();
+
+                    textChanges.Add(
+                        new TextChange(
+                            closeNodeOrToken.Span,
+                            endOfLine + indentation + closeNodeOrToken
+                        )
+                    );
+                }
+                else
+                {
+                    SyntaxTrivia listNodeIndent = SyntaxTriviaAnalysis.DetermineIndentation(listNode);
+                    SyntaxTrivia bracketIndent = SyntaxTriviaAnalysis.DetermineIndentation(closeNodeOrToken);
+                    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);
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs b/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs
index d2f487b8e2..d413056153 100644
--- a/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs
+++ b/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs
@@ -30,6 +30,8 @@ public override void Initialize(AnalysisContext context)
     {
         base.Initialize(context);
 
+        // Add if statement
+
         context.RegisterSyntaxNodeAction(f => AnalyzeParameterList(f), SyntaxKind.ParameterList);
         context.RegisterSyntaxNodeAction(f => AnalyzeBracketedParameterList(f), SyntaxKind.BracketedParameterList);
         context.RegisterSyntaxNodeAction(f => AnalyzeTypeParameterList(f), SyntaxKind.TypeParameterList);
@@ -40,7 +42,6 @@ public override void Initialize(AnalysisContext context)
         context.RegisterSyntaxNodeAction(f => AnalyzeTypeArgumentList(f), SyntaxKind.TypeArgumentList);
 
         context.RegisterSyntaxNodeAction(f => AnalyzeAttributeList(f), SyntaxKind.AttributeList);
-        context.RegisterSyntaxNodeAction(f => AnalyzeBaseList(f), SyntaxKind.BaseList);
         context.RegisterSyntaxNodeAction(f => AnalyzeTupleType(f), SyntaxKind.TupleType);
         context.RegisterSyntaxNodeAction(f => AnalyzeTupleExpression(f), SyntaxKind.TupleExpression);
 
@@ -57,96 +58,90 @@ private static void AnalyzeParameterList(SyntaxNodeAnalysisContext context)
     {
         var parameterList = (ParameterListSyntax)context.Node;
 
-        Analyze(context, parameterList.OpenParenToken, parameterList.Parameters);
+        Analyze(context, parameterList.OpenParenToken, parameterList.CloseParenToken, parameterList.Parameters);
     }
 
     private static void AnalyzeBracketedParameterList(SyntaxNodeAnalysisContext context)
     {
         var parameterList = (BracketedParameterListSyntax)context.Node;
 
-        Analyze(context, parameterList.OpenBracketToken, parameterList.Parameters);
+        Analyze(context, parameterList.OpenBracketToken, parameterList.CloseBracketToken, parameterList.Parameters);
     }
 
     private static void AnalyzeTypeParameterList(SyntaxNodeAnalysisContext context)
     {
         var parameterList = (TypeParameterListSyntax)context.Node;
 
-        Analyze(context, parameterList.LessThanToken, parameterList.Parameters);
+        Analyze(context, parameterList.LessThanToken, parameterList.GreaterThanToken, parameterList.Parameters);
     }
 
     private static void AnalyzeArgumentList(SyntaxNodeAnalysisContext context)
     {
         var argumentList = (ArgumentListSyntax)context.Node;
 
-        Analyze(context, argumentList.OpenParenToken, argumentList.Arguments);
+        Analyze(context, argumentList.OpenParenToken, argumentList.CloseParenToken, argumentList.Arguments);
     }
 
     private static void AnalyzeBracketedArgumentList(SyntaxNodeAnalysisContext context)
     {
         var argumentList = (BracketedArgumentListSyntax)context.Node;
 
-        Analyze(context, argumentList.OpenBracketToken, argumentList.Arguments);
+        Analyze(context, argumentList.OpenBracketToken, argumentList.CloseBracketToken, argumentList.Arguments);
     }
 
     private static void AnalyzeAttributeArgumentList(SyntaxNodeAnalysisContext context)
     {
         var argumentList = (AttributeArgumentListSyntax)context.Node;
 
-        Analyze(context, argumentList.OpenParenToken, argumentList.Arguments);
+        Analyze(context, argumentList.OpenParenToken, argumentList.CloseParenToken, argumentList.Arguments);
     }
 
     private static void AnalyzeTypeArgumentList(SyntaxNodeAnalysisContext context)
     {
         var argumentList = (TypeArgumentListSyntax)context.Node;
 
-        Analyze(context, argumentList.LessThanToken, argumentList.Arguments);
+        Analyze(context, argumentList.LessThanToken, argumentList.GreaterThanToken, argumentList.Arguments);
     }
 
     private static void AnalyzeAttributeList(SyntaxNodeAnalysisContext context)
     {
         var attributeList = (AttributeListSyntax)context.Node;
 
-        Analyze(context, attributeList.OpenBracketToken, attributeList.Attributes);
-    }
-
-    private static void AnalyzeBaseList(SyntaxNodeAnalysisContext context)
-    {
-        var baseList = (BaseListSyntax)context.Node;
-
-        Analyze(context, baseList.ColonToken, baseList.Types);
+        Analyze(context, attributeList.OpenBracketToken, attributeList.CloseBracketToken, attributeList.Attributes);
     }
 
     private static void AnalyzeTupleType(SyntaxNodeAnalysisContext context)
     {
         var tupleType = (TupleTypeSyntax)context.Node;
 
-        Analyze(context, tupleType.OpenParenToken, tupleType.Elements);
+        Analyze(context, tupleType.OpenParenToken, tupleType.CloseParenToken, tupleType.Elements);
     }
 
     private static void AnalyzeTupleExpression(SyntaxNodeAnalysisContext context)
     {
         var tupleExpression = (TupleExpressionSyntax)context.Node;
 
-        Analyze(context, tupleExpression.OpenParenToken, tupleExpression.Arguments);
+        Analyze(context, tupleExpression.OpenParenToken, tupleExpression.CloseParenToken, tupleExpression.Arguments);
     }
 
     private static void AnalyzeInitializerExpression(SyntaxNodeAnalysisContext context)
     {
         var initializerExpression = (InitializerExpressionSyntax)context.Node;
 
-        Analyze(context, initializerExpression.OpenBraceToken, initializerExpression.Expressions);
+        Analyze(context, initializerExpression.OpenBraceToken, initializerExpression.CloseBraceToken, initializerExpression.Expressions);
     }
 
     private static void Analyze<TNode>(
         SyntaxNodeAnalysisContext context,
-        SyntaxNodeOrToken openNodeOrToken,
+        SyntaxToken openNodeOrToken,
+        SyntaxToken closeNodeOrToken,
         SeparatedSyntaxList<TNode> nodes
     )
         where TNode : SyntaxNode
     {
-        TargetBracesStyle style = context.GetTargetBracesStyle();
+        TargetBracesStyle bracesStyle = context.GetTargetBracesStyle();
 
-        if (style == TargetBracesStyle.None)
+        if (bracesStyle == TargetBracesStyle.None)
         {
             return;
         }
@@ -156,346 +151,90 @@ SeparatedSyntaxList<TNode> nodes
         if (first is null)
             return;
 
-        TextSpan span = nodes.GetSpan(includeExteriorTrivia: false);
-
-        if (span.IsSingleLine(first.SyntaxTree))
-        {
-            if (!TriviaBlock.FromTrailing(openNodeOrToken).IsWrapped)
-                return;
-
-            int indentationLength = IndentationAnalysis.Create(openNodeOrToken.Parent, context.GetConfigOptions()).IncreasedIndentationLength;
-
-            if (indentationLength == 0)
-                return;
+        SyntaxNode listNode = context.Node;
+        TextSpan listSpan = listNode.GetSpan(includeExteriorTrivia: false);
 
-            if (ShouldFixIndentation(first.GetLeadingTrivia(), indentationLength))
-                ReportDiagnostic();
-        }
-        else
+        if (listSpan.IsSingleLine(listNode.SyntaxTree))
         {
-            TextLineCollection lines = null;
-            IndentationAnalysis indentationAnalysis = IndentationAnalysis.Create(openNodeOrToken.Parent, context.GetConfigOptions());
-            int indentationLength = indentationAnalysis.IncreasedIndentationLength;
-
-            if (indentationLength == 0)
-                return;
-
-            for (int i = nodes.Count - 1; i >= 0; i--)
-            {
-                context.CancellationToken.ThrowIfCancellationRequested();
-
-                SyntaxNodeOrToken nodeOrToken = (i == 0)
-                    ? openNodeOrToken
-                    : nodes.GetSeparator(i - 1);
-
-                if (TriviaBlock.FromTrailing(nodeOrToken).IsWrapped)
-                {
-                    if (AnalyzeBlock(nodes, indentationAnalysis, SyntaxKind.OpenBracketToken, SyntaxKind.CloseBracketToken))
-                        return;
-
-                    if (ShouldFixIndentation(nodes[i].GetLeadingTrivia(), indentationLength))
-                    {
-                        ReportDiagnostic();
-                        return;
-                    }
-                }
-                else
-                {
-                    if (nodes.Count > 1
-                        && ShouldWrapAndIndent(context.Node, i))
-                    {
-                        ReportDiagnostic();
-                        return;
-                    }
-
-                    if (AnalyzeBlock(nodes, indentationAnalysis, SyntaxKind.OpenBraceToken, SyntaxKind.CloseBraceToken))
-                        return;
-
-                    lines ??= first.SyntaxTree.GetText().Lines;
-
-                    int lineIndex = lines.IndexOf(span.Start);
-                    if (lineIndex < lines.Count - 1)
-                    {
-                        int lineStartIndex = lines[lineIndex + 1].Start;
-
-                        if (first.Span.Contains(lineStartIndex))
-                        {
-                            SyntaxToken token = first.FindToken(lineStartIndex);
-
-                            if (!token.IsKind(SyntaxKind.None))
-                            {
-                                SyntaxTriviaList leading = token.LeadingTrivia;
-
-                                if (leading.Any())
-                                {
-                                    if (leading.FullSpan.Contains(lineStartIndex))
-                                    {
-                                        SyntaxTrivia trivia = leading.Last();
-
-                                        if (trivia.IsWhitespaceTrivia()
-                                            && trivia.SpanStart == lineStartIndex
-                                            && trivia.Span.Length != indentationLength)
-                                        {
-                                            ReportDiagnostic();
-                                            return;
-                                        }
-                                    }
-                                }
-                                else if (lineStartIndex == token.SpanStart)
-                                {
-                                    ReportDiagnostic();
-                                    return;
-                                }
-                            }
-                        }
-                    }
-                }
-            }
+            return;
         }
 
-        void ReportDiagnostic()
+        TNode last = nodes.Last();
+
+        if (
+            ShouldFixOpeningBracket(bracesStyle, openNodeOrToken, first)
+            || ShouldFixClosingBracket(bracesStyle, listNode, closeNodeOrToken, last)
+        )
         {
             DiagnosticHelpers.ReportDiagnostic(
                 context,
                 DiagnosticRules.FixBracketFormattingOfList,
-                Location.Create(first.SyntaxTree, nodes.Span),
-                GetTitle()
+                Location.Create(listNode.SyntaxTree, listSpan),
+                GetTitle(listNode)
             );
         }
-
-        static bool ShouldFixIndentation(SyntaxTriviaList leading, int indentationLength)
-        {
-            SyntaxTriviaList.Reversed.Enumerator en = leading.Reverse().GetEnumerator();
-
-            if (!en.MoveNext())
-                return true;
-
-            switch (en.Current.Kind())
-            {
-                case SyntaxKind.WhitespaceTrivia:
-                {
-                    if (en.Current.Span.Length != indentationLength)
-                    {
-                        if (!en.MoveNext()
-                            || en.Current.IsEndOfLineTrivia())
-                        {
-                            return true;
-                        }
-                    }
-
-                    break;
-                }
-                case SyntaxKind.EndOfLineTrivia:
-                {
-                    return true;
-                }
-            }
-
-            return false;
-        }
-
-        string GetTitle()
-        {
-            switch (context.Node.Kind())
-            {
-                case SyntaxKind.ParameterList:
-                case SyntaxKind.BracketedParameterList:
-                case SyntaxKind.TypeParameterList:
-                    return "parameters";
-                case SyntaxKind.ArgumentList:
-                case SyntaxKind.BracketedArgumentList:
-                case SyntaxKind.AttributeArgumentList:
-                case SyntaxKind.TypeArgumentList:
-                    return "arguments";
-                case SyntaxKind.AttributeList:
-                    return "attributes";
-                case SyntaxKind.BaseList:
-                    return "base types";
-                case SyntaxKind.TupleType:
-                case SyntaxKind.TupleExpression:
-                    return "a tuple";
-                case SyntaxKind.ArrayInitializerExpression:
-                case SyntaxKind.CollectionInitializerExpression:
-                case SyntaxKind.ComplexElementInitializerExpression:
-                case SyntaxKind.ObjectInitializerExpression:
-                    return "an initializer";
-                default:
-                    throw new InvalidOperationException();
-            }
-        }
-
-        bool AnalyzeBlock(
-            SeparatedSyntaxList<TNode> nodes,
-            IndentationAnalysis indentationAnalysis,
-            SyntaxKind kind1,
-            SyntaxKind kind2)
-        {
-            if (nodes.Count == 1
-                && nodes[0].IsKind(SyntaxKind.Argument))
-            {
-                BracesBlock block = GetBracesBlock(nodes[0]);
-
-                if (block.Token.IsKind(kind1, kind2))
-                {
-                    SyntaxToken token = block.Token;
-                    SyntaxTriviaList leading = token.LeadingTrivia;
-
-                    if (leading.Any())
-                    {
-                        SyntaxTrivia trivia = leading.Last();
-
-                        if (trivia.IsWhitespaceTrivia()
-                            && trivia.SpanStart == block.LineStartIndex
-                            && trivia.Span.Length != indentationAnalysis.IndentationLength)
-                        {
-                            ReportDiagnostic();
-                        }
-                    }
-                    else if (block.LineStartIndex == token.SpanStart)
-                    {
-                        ReportDiagnostic();
-                    }
-                    return true;
-                }
-            }
-
-            return false;
-        }
     }
 
-    internal static BracesBlock GetBracesBlock(SyntaxNode node)
-    {
-        TextLineCollection lines = node.SyntaxTree.GetText().Lines;
-        TextLine line = lines.GetLineFromPosition(node.SpanStart);
-
-        int startIndex = line.End;
-
-        if (!node.FullSpan.Contains(startIndex))
-            return default;
-
-        SyntaxToken openToken = node.FindToken(startIndex);
-        SyntaxNode block = null;
-        var isOpenBraceAtEndOfLine = false;
-
-        if (AnalyzeToken(openToken, isOpen: true))
-        {
-            SyntaxTriviaList trailing = openToken.TrailingTrivia;
-
-            if (trailing.Any()
-                && trailing.Span.Contains(startIndex))
-            {
-                block = openToken.Parent;
-                isOpenBraceAtEndOfLine = true;
-            }
-        }
-
-        if (block is null)
-        {
-            startIndex = line.EndIncludingLineBreak;
-            openToken = node.FindToken(startIndex);
-
-            if (AnalyzeToken(openToken, isOpen: true))
-            {
-                SyntaxTriviaList leading = openToken.LeadingTrivia;
-
-                if ((leading.Any() && leading.Span.Contains(startIndex))
-                    || (!leading.Any() && openToken.SpanStart == startIndex))
-                {
-                    block = openToken.Parent;
-                }
-            }
-        }
-
-        if (block is not null)
+    private static string GetTitle(SyntaxNode listNode) =>
+        listNode.Kind() switch
         {
-            int endIndex = lines.GetLineFromPosition(node.Span.End).Start;
-            SyntaxToken closeToken = node.FindToken(endIndex);
-
-            if (AnalyzeToken(closeToken, isOpen: false)
-                && object.ReferenceEquals(block, closeToken.Parent))
-            {
-                SyntaxTriviaList leading = closeToken.LeadingTrivia;
-
-                if ((leading.Any() && leading.Span.Contains(endIndex))
-                    || (!leading.Any() && closeToken.SpanStart == endIndex))
-                {
-                    return new BracesBlock(
-                        (isOpenBraceAtEndOfLine) ? closeToken : openToken,
-                        (isOpenBraceAtEndOfLine) ? endIndex : startIndex);
-                }
-            }
-        }
-
-        return default;
-
-        static bool AnalyzeToken(SyntaxToken token, bool isOpen)
+            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",
+
+            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
+    )
+    {
+        if (!bracesStyle.HasFlag(TargetBracesStyle.Opening))
         {
-            if (token.IsKind((isOpen) ? SyntaxKind.OpenBraceToken : SyntaxKind.CloseBraceToken))
-            {
-                if (token.IsParentKind(SyntaxKind.Block)
-                    && (CSharpFacts.IsAnonymousFunctionExpression(token.Parent.Parent.Kind())))
-                {
-                    return true;
-                }
-
-                if (token.IsParentKind(SyntaxKind.SwitchExpression))
-                    return true;
-
-                if (token.IsParentKind(SyntaxKind.ObjectInitializerExpression)
-                    && token.Parent.Parent.IsKind(
-                        SyntaxKind.ObjectCreationExpression,
-                        SyntaxKind.AnonymousObjectCreationExpression,
-                        SyntaxKind.ImplicitObjectCreationExpression))
-                {
-                    return true;
-                }
-
-                if (token.IsParentKind(SyntaxKind.ArrayInitializerExpression)
-                    && token.Parent.Parent.IsKind(
-                        SyntaxKind.ArrayCreationExpression,
-                        SyntaxKind.ImplicitArrayCreationExpression))
-                {
-                    return true;
-                }
-            }
-#if ROSLYN_4_7
-            return token.IsKind((isOpen) ? SyntaxKind.OpenBracketToken : SyntaxKind.CloseBracketToken)
-                   && token.IsParentKind(SyntaxKind.CollectionExpression);
-#else
             return false;
-#endif
         }
+
+        return leftBracket.GetSpanStartLine() == first.GetSpanStartLine();
     }
 
-    internal static bool ShouldWrapAndIndent(SyntaxNode node, int index)
+    private static bool ShouldFixClosingBracket(
+        TargetBracesStyle bracesStyle,
+        SyntaxNode listNode,
+        SyntaxToken rightBracket,
+        SyntaxNode last
+    )
     {
-        if (index == 0)
+        if (!bracesStyle.HasFlag(TargetBracesStyle.Closing))
         {
-            if (node.IsKind(SyntaxKind.AttributeList))
-            {
-                return false;
-            }
-            else if (node.IsKind(SyntaxKind.TupleExpression)
-                     && node.Parent is AssignmentExpressionSyntax assignmentExpression
-                     && object.ReferenceEquals(node, assignmentExpression.Left))
-            {
-                return false;
-            }
+            return false;
         }
 
-        return true;
-    }
-
-    internal readonly struct BracesBlock
-    {
-        public BracesBlock(SyntaxToken token, int lineStartIndex)
+        if (rightBracket.GetSpanEndLine() == last.GetSpanEndLine())
         {
-            Token = token;
-            LineStartIndex = lineStartIndex;
+            return true;
         }
 
-        public SyntaxToken Token { get; }
-
-        public int LineStartIndex { get; }
+        SyntaxTrivia listNodeIndent = SyntaxTriviaAnalysis.DetermineIndentation(listNode);
+        SyntaxTrivia bracketIndent = SyntaxTriviaAnalysis.DetermineIndentation(rightBracket);
+        return listNodeIndent.Span.Length != bracketIndent.Span.Length;
     }
 }
\ No newline at end of file
diff --git a/src/Tests/Formatting.Analyzers.Tests/RCS1269FixBracketFormattingOfListTests.cs b/src/Tests/Formatting.Analyzers.Tests/RCS1269FixBracketFormattingOfListTests.cs
index 262d271401..76d11d4140 100644
--- a/src/Tests/Formatting.Analyzers.Tests/RCS1269FixBracketFormattingOfListTests.cs
+++ b/src/Tests/Formatting.Analyzers.Tests/RCS1269FixBracketFormattingOfListTests.cs
@@ -18,58 +18,38 @@ public sealed class RCS1269FixBracketFormattingOfListTests :
     [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_NoIndentation()
-    {
-        await VerifyDiagnosticAndFixAsync(@"
-class C
-{
-    void M[|(
-object x, object y)|] 
-    {
-    }
-}
-", @"
-class C
-{
-    void M(
-        object x, object y
-    ) 
-    {
-    }
-}
-");
+        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_EmptyLine()
+    public async Task Test_Singleline_Unindentated()
     {
         await VerifyDiagnosticAndFixAsync(
             """
             class C
             {
                 void M[|(
-            object x, object y) |]
+            object x, object y)|] 
                 {
                 }
             }
@@ -78,7 +58,7 @@ class C
             class C
             {
                 void M(
-                    object x, object y
+            object x, object y
                 ) 
                 {
                 }
@@ -90,620 +70,409 @@ void M(
     [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
-    ) 
-    {
-    }
-}
-");
+        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
-    ) 
-    {
-    }
-}
-");
+        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_TwoParametersOnSameLine2()
-    {
-        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_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_OpeMultilineLambdaParameter()
-    {
-        await VerifyDiagnosticAndFixAsync(@"
-using System;
-
-class C
-{
-    void M(Func<string, string> x)
-    {
-        M([|f =>
-{
-    return null;
-});|]
-    }
-}
-", @"
-using System;
-
-class C
-{
-    void M(Func<string, string> x)
-    {
-        M(
-            f =>
-{
-    return null;
-}
-        );
-    }
-}
-");
-    }
-
-    [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_FirstParameterIsMultilineLambda2()
-    {
-        await VerifyDiagnosticAndFixAsync(@"
-using System;
+        await VerifyDiagnosticAndFixAsync(
+            """
+            using System;
 
-class C
-{
-    void M(Func<string, string> x, object y)
-    {
-        M([|f =>
+            class C
             {
-                return null;
-            },
-y);|]
-    }
-}
-", @"
-using System;
+                void M()
+                {
+                }
+            
+                [Obsolete]
+                void M2[|(
+                        object x,
+                        object y)|] 
+                {
+                }
+            }
+            """,
+            """
+            using System;
 
-class C
-{
-    void M(Func<string, string> x, object y)
-    {
-        M(
-            f =>
+            class C
             {
-                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()
+                void M()
+                {
+                }
+            
+                [Obsolete]
+                void M2(
+                        object x,
+                        object y
+                ) 
+                {
+                }
+            }
+            """
         );
     }
-}
-");
-    }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
-    public async Task Test_Multiline_SecondParameterIsMultilineLambdaWithBlockBody()
-    {
-        await VerifyDiagnosticAndFixAsync(@"
-using System;
-
-class C
-{
-    void M(object x, Func<string, string> y)
-    {
-        M([|x, f =>
-        {
-            return f
-                .ToString()
-                .ToString();
-        });|]
-    }
-}
-", @"
-using System;
-
-class C
-{
-    void M(object x, Func<string, string> y)
+    public async Task Test_Multiline_AlignedToParenthesis_WhitespaceAfterParenthesis()
     {
-        M(
-            x, f =>
-        {
-            return f
-                .ToString()
-                .ToString();
-        }
+        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_SecondParameterIsMultilineLambdaWithBlockBody2()
-    {
-        await VerifyDiagnosticAndFixAsync(@"
-using System;
-
-class C
-{
-    void M(object x, Func<string, string> y)
-    {
-        M([|x, f => {
-            return f
-                .ToString()
-                .ToString();
-        });|]
-    }
-}
-", @"
-using System;
-
-class C
-{
-    void M(object x, Func<string, string> y)
+    public async Task Test_Multiline_FirstParameterNotWrapped()
     {
-        M(
-            x, f => {
-            return f
-                .ToString()
-                .ToString();
-        }
+        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_MultilineLambda()
-    {
-        await VerifyDiagnosticAndFixAsync(@"
-using System;
-
-class C
-{
-    void M(Func<string, string> x, string y)
+    public async Task Test_Multiline_TwoParametersOnSameLine()
     {
-        M([|f =>
-        {
-            string s = null;
-
-            //x
-            return null;
-        }, y);|]
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                void M[|(
+                    object x,
+                    object y,object z)|] 
+                {
+                }
+            }
+            """,
+            """
+            class C
+            {
+                void M(
+                    object x,
+                    object y,object z
+                ) 
+                {
+                }
+            }
+            """
+        );
     }
-}
-", @"
-using System;
 
-class C
-{
-    void M(Func<string, string> x, string y)
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Multiline_ClosingBracket_Indent_Required()
     {
-        M(
-            f =>
-        {
-            string s = null;
-
-            //x
-            return null;
-        }, y
+        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_MultilineLambda2()
-    {
-        await VerifyDiagnosticAndFixAsync(@"
-using System;
-
-class C
-{
-    void M(Func<string, string> x)
+    public async Task Test_Multiline_ClosingBracket_Indent_Required2()
     {
-        M([|f =>
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
             {
-                return null;
-            });|]
+                void M[|(
+                    object x,
+                    object y, object z,
+                    object p4
+              )|] 
+                {
+                }
+            }
+            """,
+            """
+            class C
+            {
+                void M(
+                    object x,
+                    object y, object z,
+                    object p4
+                ) 
+                {
+                }
+            }
+            """
+        );
     }
-}
-", @"
-using System;
 
-class C
-{
-    void M(Func<string, string> x)
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
+    public async Task Test_Multiline_ClosingBracket_Indent_Required3()
     {
-        M(
-            f =>
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
             {
-                return null;
+                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_IndentationsDiffer()
+    public async Task Test_Multiline_ClosingBracket_Indent_Required_with_prio_comment()
     {
-        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()
+        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_IndentationsDiffer_Tab()
+    public async Task Test_Multiline_Comment()
     {
-        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"));
+        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_SecondParameterIsAlreadyIndented()
+    public async Task Test_Multiline_FirstParameterIsMultilineLambda()
     {
-        await VerifyDiagnosticAndFixAsync(@"
-using System.Linq;
-using System.Collections.Generic;
+        await VerifyDiagnosticAndFixAsync(
+            """
+            using System;
 
-class C
-{
-    void M(string x, IEnumerable<string> y)
-    {
-        M([|x,
-            Enumerable.Empty<string>()
-                .OrderBy(f => f)
-                .Select(f => f)|]
-        );
-    }
-}
-", @"
-using System.Linq;
-using System.Collections.Generic;
+            class C
+            {
+                void M(Func<string, string> x, object y)
+                {
+                    M[|(f =>
+            {
+                return null;
+            },
+            y)|];
+                }
+            }
+            """,
+            """
+            using System;
 
-class C
-{
-    void M(string x, IEnumerable<string> y)
-    {
-        M(
-            x,
-            Enumerable.Empty<string>()
-                .OrderBy(f => f)
-                .Select(f => f)
+            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_ConditionalExpression()
+    public async Task Test_Multiline_SecondParameterIsMultilineLambdaWithExpressionBody()
     {
         await VerifyDiagnosticAndFixAsync(
             """
+            using System;
+
             class C
             {
-                void M(string x, string y)
+                void M(object x, Func<string, string> y)
                 {
-                    M([|x, (y != null)
-                        ? y
-                        : "");|]
+                    M[|(x, f => f
+                        .ToString()
+                        .ToString())|];
                 }
             }
             """,
             """
+            using System;
+
             class C
             {
-                void M(string x, string y)
+                void M(object x, Func<string, string> y)
                 {
                     M(
-                        x, (y != null)
-                        ? y
-                        : ""
+                        x, f => f
+                        .ToString()
+                        .ToString()
                     );
                 }
             }
@@ -711,6 +480,36 @@ void M(string x, string y)
         );
     }
 
+    [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()
     {
@@ -720,9 +519,9 @@ class C
             {
                 void M(string x)
                 {
-                    M([|(x != null)
+                    M[|((x != null)
                 ? x
-                : "");|]
+                : "")|];
                 }
             }
             """,
@@ -751,9 +550,9 @@ class C
             {
                 void M(string x)
                 {
-                    M([|M2(
-                            [|x,
-                            x)|]);|]
+                    M[|(M2[|(
+                            x,
+                            x)|])|];
                 }
             
                 string M2(string x, string y) => null;
@@ -787,9 +586,9 @@ class C
             {
                 void M(string x)
                 {
-                    M([|(x != null)
+                    M[|((x != null)
             ? x
-            : "");|]
+            : "")|];
                 }
             }
             """,
@@ -816,7 +615,7 @@ await VerifyDiagnosticAndFixAsync(
             """
             class C : B
             {
-                public C(string x, string y) : base([|x, (y != null)
+                public C(string x, string y) : base[|(x, (y != null)
                     ? y
                     : "")|]
                 {
@@ -860,7 +659,7 @@ await VerifyDiagnosticAndFixAsync(
             class C : B
             {
                 public C(string x, string y)
-                    : base([|x, (y != null)
+                    : base[|(x, (y != null)
                         ? y
                         : "")|]
                 {
@@ -906,11 +705,11 @@ class C
             {
                 void M(string x, string y)
                 {
-                    M([|x, @"
+                    M[|(x, @"
             a
             b
             c
-            ");|]
+            ")|];
                 }
             }
             """,
@@ -941,9 +740,9 @@ await VerifyDiagnosticAndFixAsync(
 
             class C
             {
-                [Flags, Obsolete(
+                [|[Flags, Obsolete[|(
                     "",
-                    true)]|]
+                    true)|]]|]
                 enum E
                 {
                 }
@@ -954,10 +753,12 @@ enum E
 
             class C
             {
-                [Flags, Obsolete(
+                [
+                    Flags, Obsolete(
                     "",
                     true
-                )]
+                    )
+                ]
                 enum E
                 {
                 }
@@ -974,9 +775,9 @@ await VerifyDiagnosticAndFixAsync(
 
             class C
             {
-                [[|Flags, Obsolete(
+                [|[Flags, Obsolete(
             "",
-            true)]|]
+            true)|]]|]
                 enum E
                 {
                 }
@@ -987,10 +788,12 @@ enum E
 
             class C
             {
-                [Flags, Obsolete(
+                [
+                    Flags, Obsolete(
             "",
             true
-                )]
+                    )
+                ]
                 enum E
                 {
                 }
@@ -1006,7 +809,7 @@ await VerifyDiagnosticAndFixAsync(
             """
             class C
             {
-                void M([|string x, string y
+                void M[|(string x, string y
                     = default(string), string z = default)|]
                 {
                 }
@@ -1033,11 +836,11 @@ await VerifyDiagnosticAndFixAsync(
             """
             class C
             {
-                private ([|string x, string y,
-                    string z|]) M()
+                private [|(string x, string y,
+                    string z)|] M()
                 {
-                    return ([|null, null,
-                        null|]);
+                    return [|(null, null,
+                        null)|];
                 }
             }
 
@@ -1067,8 +870,8 @@ await VerifyDiagnosticAndFixAsync(
             """
             class C
             {
-                void M([|(string x, string y,
-                    string z) p)|]
+                void M[|([|(string x, string y,
+                    string z)|] p)|]
                 {
                 }
             }
@@ -1079,7 +882,7 @@ class C
                 void M(
                     (
                         string x, string y,
-                        string z
+                    string z
                     ) p
                 )
                 {
@@ -1098,7 +901,7 @@ class C
             {
                 void M()
                 {
-                    ([|string x,
+                    [|(string x,
                         string y, string z)|] = default((string, string, string));
                 }
             }
@@ -1127,9 +930,9 @@ class C
             {
                 void M()
                 {
-                    var x = new string[] { [|"", default, new string(
+                    var x = new string[] [|{ "", default, new string[|(
                         ' ',
-                        1) };|]
+                        1)|] }|];
                 }
             }
             """,
@@ -1141,7 +944,8 @@ void M()
                     var x = new string[] { 
                         "", default, new string(
                         ' ',
-                        1) 
+                        1
+                        )
                     };
                 }
             }
@@ -1161,14 +965,14 @@ class C
             {
                 void M()
                 {
-                    var x = new List<string>([|new string[]
+                    var x = new List<string>[|(new string[]
                         {
                             "",
                             "",
             #if FOO
                             "",
             #endif
-                        }|]);
+                        })|];
                 }
             }
             """,
@@ -1207,9 +1011,9 @@ class C
             {
                 void M()
                 {
-                    string s = string.Concat([|Enumerable.Empty<string>().Select([|f => {
+                    string s = string.Concat[|(Enumerable.Empty<string>().Select[|(f => {
                         return f;
-                    })|]);|]
+                    })|])|];
                 }
             }
             """,
@@ -1229,7 +1033,6 @@ void M()
                     );
                 }
             }
-
             """
         );
     }
@@ -1458,4 +1261,10 @@ string M(string value) =>
             """
         );
     }
-}
\ No newline at end of file
+}
+
+// Wrapped parentness in method or tuple definition
+// (int a,
+//     int b) Method
+//     (int a,
+//         int b)
\ No newline at end of file

From bcdeff0ed25f08724fd49deaa76cbfe8aaf0dd20 Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Fri, 11 Apr 2025 12:49:10 +0200
Subject: [PATCH 08/38] Implementing

---
 ...xBracketFormattingOfListCodeFixProvider.cs |  11 +-
 .../FixBracketFormattingOfListAnalyzer.cs     |  10 ++
 .../RCS1269FixBracketFormattingOfListTests.cs | 138 +++++++++++++-----
 3 files changed, 120 insertions(+), 39 deletions(-)

diff --git a/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs b/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs
index a277a1978d..68bacd02f9 100644
--- a/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs
+++ b/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs
@@ -49,6 +49,7 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
                         case SyntaxKind.TupleExpression:
                         case SyntaxKind.ArrayInitializerExpression:
                         case SyntaxKind.CollectionInitializerExpression:
+                        case SyntaxKind.CollectionExpression:
                         case SyntaxKind.ComplexElementInitializerExpression:
                         case SyntaxKind.ObjectInitializerExpression:
                             return true;
@@ -160,6 +161,14 @@ CodeAction CreateCodeAction()
                         GetEquivalenceKey(diagnostic)
                     );
                 }
+                case CollectionExpressionSyntax collectionExpression:
+                {
+                    return CodeAction.Create(
+                        Title,
+                        ct => Fix(collectionExpression, collectionExpression.OpenBracketToken, collectionExpression.CloseBracketToken, ct),
+                        GetEquivalenceKey(diagnostic)
+                    );
+                }
                 default:
                 {
                     throw new InvalidOperationException();
@@ -211,7 +220,7 @@ CancellationToken cancellationToken
                 SyntaxToken previousToken = closeNodeOrToken.GetPreviousToken();
 
                 int bracketLine = closeNodeOrToken.GetSpanStartLine();
-                int previousTokenLine = previousToken.GetSpanStartLine();
+                int previousTokenLine = previousToken.GetSpanEndLine();
 
                 if (bracketLine == previousTokenLine)
                 {
diff --git a/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs b/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs
index d413056153..b4617855a3 100644
--- a/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs
+++ b/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs
@@ -44,6 +44,7 @@ public override void Initialize(AnalysisContext context)
         context.RegisterSyntaxNodeAction(f => AnalyzeAttributeList(f), SyntaxKind.AttributeList);
         context.RegisterSyntaxNodeAction(f => AnalyzeTupleType(f), SyntaxKind.TupleType);
         context.RegisterSyntaxNodeAction(f => AnalyzeTupleExpression(f), SyntaxKind.TupleExpression);
+        context.RegisterSyntaxNodeAction(f => AnalyzeCollectionExpression(f), SyntaxKind.CollectionExpression);
 
         context.RegisterSyntaxNodeAction(
             f => AnalyzeInitializerExpression(f),
@@ -131,6 +132,13 @@ private static void AnalyzeInitializerExpression(SyntaxNodeAnalysisContext conte
         Analyze(context, initializerExpression.OpenBraceToken, initializerExpression.CloseBraceToken, initializerExpression.Expressions);
     }
 
+    private static void AnalyzeCollectionExpression(SyntaxNodeAnalysisContext context)
+    {
+        var collectionExpression = (CollectionExpressionSyntax)context.Node;
+
+        Analyze(context, collectionExpression.OpenBracketToken, collectionExpression.CloseBracketToken, collectionExpression.Elements);
+    }
+
     private static void Analyze<TNode>(
         SyntaxNodeAnalysisContext context,
         SyntaxToken openNodeOrToken,
@@ -193,6 +201,8 @@ or SyntaxKind.TypeArgumentList
 
             SyntaxKind.TupleType or SyntaxKind.TupleExpression => "a tuple",
 
+            SyntaxKind.CollectionExpression => "a collection expression",
+
             SyntaxKind.ArrayInitializerExpression
             or SyntaxKind.CollectionInitializerExpression
             or SyntaxKind.ComplexElementInitializerExpression
diff --git a/src/Tests/Formatting.Analyzers.Tests/RCS1269FixBracketFormattingOfListTests.cs b/src/Tests/Formatting.Analyzers.Tests/RCS1269FixBracketFormattingOfListTests.cs
index 76d11d4140..a73e803eaf 100644
--- a/src/Tests/Formatting.Analyzers.Tests/RCS1269FixBracketFormattingOfListTests.cs
+++ b/src/Tests/Formatting.Analyzers.Tests/RCS1269FixBracketFormattingOfListTests.cs
@@ -775,7 +775,7 @@ await VerifyDiagnosticAndFixAsync(
 
             class C
             {
-                [|[Flags, Obsolete(
+                [|[Flags, Obsolete[|(
             "",
             true)|]]|]
                 enum E
@@ -837,13 +837,13 @@ await VerifyDiagnosticAndFixAsync(
             class C
             {
                 private [|(string x, string y,
-                    string z)|] M()
+                    string z)|] M[|([|(string a,
+                        string b)|] p)|]
                 {
                     return [|(null, null,
                         null)|];
                 }
             }
-
             """,
             """
             class C
@@ -851,7 +851,12 @@ class C
                 private (
                     string x, string y,
                     string z
-                ) M()
+                ) M(
+                    (
+                        string a,
+                        string b
+                    ) p
+                )
                 {
                     return (
                         null, null,
@@ -941,11 +946,11 @@ class C
             {
                 void M()
                 {
-                    var x = new string[] { 
+                    var x = new string[] {
                         "", default, new string(
                         ' ',
                         1
-                        )
+                        ) 
                     };
                 }
             }
@@ -1040,18 +1045,19 @@ void M()
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
     public async Task TestNoDiagnostic_Singleline()
     {
-        await VerifyNoDiagnosticAsync(@"
-class C
-{
-    void M(object x, object y, object z) 
-    {
-    }
+        await VerifyNoDiagnosticAsync(
+            """
+            class C
+            {
+                void M(object x, object y, object z) 
+                {
+                }
 
-    void M2(object x, object y, object z) 
-    {
-    }
-}
-");
+                void M2(object x, object y, object z) 
+                {
+                }
+            }
+            """);
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
@@ -1086,10 +1092,10 @@ await VerifyDiagnosticAndFixAsync(
             }
 
             var items = Enumerable.Range(0, 10)
-                .Select([|f =>
+                .Select[|(f =>
                 {
                     return f;
-                }|])
+                })|]
                 .Select(f => f);
             """,
             """
@@ -1108,7 +1114,8 @@ await VerifyDiagnosticAndFixAsync(
                 }
                 )
                 .Select(f => f);
-            """
+            """,
+            options: Options.WithCompilationOptions(Options.CompilationOptions.WithOutputKind(OutputKind.ConsoleApplication))
         );
     }
 
@@ -1117,12 +1124,12 @@ public async Task Test_ArrayInitializerInGlobalStatement()
     {
         await VerifyDiagnosticAndFixAsync(
             """
-            Foo.Method(
-                [|foo: new Foo[]
+            Foo.Method[|(
+                foo: new Foo[]
                 {
-                    new Foo(
-                        [|"")|]
-                }|]);
+                    new Foo[|(
+                        "")|]
+                })|];
             """,
             """
             Foo.Method(
@@ -1134,12 +1141,32 @@ await VerifyDiagnosticAndFixAsync(
                 }
             );
             """,
+            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 TestNoDiagnostic_Multiline_ObjectInitializer()
+    public async Task Test_Multiline_ObjectInitializer()
     {
         await VerifyDiagnosticAndFixAsync(
             """
@@ -1153,10 +1180,10 @@ public C(C value) { }
 
                 C M()
                 {
-                    return new C([|new C
+                    return new C[|(new C
                     {
                         P = ""
-                    });|]
+                    })|];
                 }
             }
             """,
@@ -1184,9 +1211,41 @@ C M()
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
-    public async Task TestNoDiagnostic_Multiline_CollectionExpression()
+    public async Task Test_Multiline_CollectionExpression()
     {
-        await VerifyNoDiagnosticAsync(
+        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
             {
@@ -1197,10 +1256,12 @@ public string M1(string[] values)
                     string x =
                         P
                             .M1(
-                            [
+                                [
+                                    null,
                                 // x
                                 null,
-                            ])
+                                ]
+                            )
                             .ToString();
 
                     return x;
@@ -1211,11 +1272,12 @@ public string M2(string value, string[] values)
                     string x =
                         P
                             .M2(
-                                "",
-                                [
-                                    // x
+                                "", [
+                                    null,
+                                    // y
                                     null,
-                                ])
+                                ]
+                            )
                                 .ToString();
 
                     return x;
@@ -1235,12 +1297,12 @@ await VerifyDiagnosticAndFixAsync(
             class C
             {
                 string M(string value) =>
-                    M([|value switch
+                    M[|(value switch
                     {
                         "a" => "a",
                         "b" => "b",
                         _ => throw new Exception()
-                    });|]
+                    })|];
             }
             """,
             """

From 308625bbe0dff2d499a4bf0511de6225a057854e Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Fri, 11 Apr 2025 13:02:34 +0200
Subject: [PATCH 09/38] Fixed analyzer description

---
 src/Analyzers.xml | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/Analyzers.xml b/src/Analyzers.xml
index ddc91d8d9e..f2ff360b3e 100644
--- a/src/Analyzers.xml
+++ b/src/Analyzers.xml
@@ -7831,8 +7831,8 @@ string s = """
     </ConfigOptions>
     <Summary>
       This analyzer:
-        * adds new line after an opening bracket of method definition or call
-        * adds new line before a closing bracket of method definition or call
+        * 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>
@@ -7852,9 +7852,10 @@ string s = """
       <Sample>
         <Before><![CDATA[Method(xParameter,
     yParameter);]]></Before>
-        <After><![CDATA[Method(xParameter,
-            yParameter
-        );]]></After>
+        <After><![CDATA[Method(
+    xParameter,
+    yParameter
+);]]></After>
       </Sample>
     </Samples>
   </Analyzer>

From 683523fbde357138db5504507b3f596704e7052b Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Fri, 11 Apr 2025 13:08:34 +0200
Subject: [PATCH 10/38] Cleanup

---
 .../CSharp/FixBracketFormattingOfListAnalyzer.cs            | 2 --
 .../RCS1269FixBracketFormattingOfListTests.cs               | 6 ------
 2 files changed, 8 deletions(-)

diff --git a/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs b/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs
index b4617855a3..765e8d58f8 100644
--- a/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs
+++ b/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs
@@ -30,8 +30,6 @@ public override void Initialize(AnalysisContext context)
     {
         base.Initialize(context);
 
-        // Add if statement
-
         context.RegisterSyntaxNodeAction(f => AnalyzeParameterList(f), SyntaxKind.ParameterList);
         context.RegisterSyntaxNodeAction(f => AnalyzeBracketedParameterList(f), SyntaxKind.BracketedParameterList);
         context.RegisterSyntaxNodeAction(f => AnalyzeTypeParameterList(f), SyntaxKind.TypeParameterList);
diff --git a/src/Tests/Formatting.Analyzers.Tests/RCS1269FixBracketFormattingOfListTests.cs b/src/Tests/Formatting.Analyzers.Tests/RCS1269FixBracketFormattingOfListTests.cs
index a73e803eaf..2d7efb9b17 100644
--- a/src/Tests/Formatting.Analyzers.Tests/RCS1269FixBracketFormattingOfListTests.cs
+++ b/src/Tests/Formatting.Analyzers.Tests/RCS1269FixBracketFormattingOfListTests.cs
@@ -1324,9 +1324,3 @@ string M(string value) =>
         );
     }
 }
-
-// Wrapped parentness in method or tuple definition
-// (int a,
-//     int b) Method
-//     (int a,
-//         int b)
\ No newline at end of file

From 1e6a8ddb0c2e1ca0ebfe5974a646b74ba686d448 Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Sat, 12 Apr 2025 11:39:48 +0200
Subject: [PATCH 11/38] Fixed tests. Added missed cancellation tokens

---
 src/Common/CSharp/SyntaxTriviaAnalysis.cs     | 19 ++++++-----------
 ...xBracketFormattingOfListCodeFixProvider.cs | 14 ++++++-------
 .../FixBracketFormattingOfListAnalyzer.cs     | 21 ++++++++++++-------
 3 files changed, 26 insertions(+), 28 deletions(-)

diff --git a/src/Common/CSharp/SyntaxTriviaAnalysis.cs b/src/Common/CSharp/SyntaxTriviaAnalysis.cs
index af4ad4256e..20c8580a98 100644
--- a/src/Common/CSharp/SyntaxTriviaAnalysis.cs
+++ b/src/Common/CSharp/SyntaxTriviaAnalysis.cs
@@ -110,7 +110,10 @@ public static IndentationAnalysis AnalyzeIndentation(SyntaxNode node, AnalyzerCo
         return IndentationAnalysis.Create(node, configOptions, cancellationToken);
     }
 
-    public static SyntaxTrivia DetermineIndentation(SyntaxNodeOrToken nodeOrToken, CancellationToken cancellationToken = default)
+    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;
 
@@ -118,18 +121,8 @@ public static SyntaxTrivia DetermineIndentation(SyntaxNodeOrToken nodeOrToken, C
             return CSharpFactory.EmptyWhitespace();
 
         TextSpan span = nodeOrToken.Span;
-        FileLinePositionSpan linePositionSpan = tree.GetLineSpan(span, cancellationToken);
-
-        SourceText sourceText = tree.GetText(cancellationToken);
-        int lineStartPosition = sourceText.Lines.GetPosition(new LinePosition(linePositionSpan.StartLinePosition.Line, 0));
-
-        // Span starts at the beginning of the line = no indentation
-        if (span.Start == lineStartPosition)
-        {
-            return CSharpFactory.EmptyWhitespace();
-        }
 
-        int lineStartIndex = span.Start - linePositionSpan.StartLinePosition.Character;
+        int lineStartIndex = span.Start - tree.GetLineSpan(span, cancellationToken).StartLinePosition.Character;
 
         SyntaxTriviaList leading = nodeOrToken.GetLeadingTrivia();
 
@@ -181,7 +174,7 @@ public static SyntaxTrivia DetermineIndentation(SyntaxNodeOrToken nodeOrToken, C
             }
         }
 
-        if (!IsMemberDeclarationOrStatementOrAccessorDeclaration(node))
+        if (searchInAccessors &&!IsMemberDeclarationOrStatementOrAccessorDeclaration(node))
         {
             node = node.Parent;
 
diff --git a/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs b/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs
index 68bacd02f9..f90d8436e9 100644
--- a/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs
+++ b/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs
@@ -199,8 +199,8 @@ CancellationToken cancellationToken
             {
                 SyntaxToken nextToken = openNodeOrToken.GetNextToken();
 
-                int bracketLine = openNodeOrToken.GetSpanStartLine();
-                int nextTokenLine = nextToken.GetSpanStartLine();
+                int bracketLine = openNodeOrToken.GetSpanStartLine(cancellationToken);
+                int nextTokenLine = nextToken.GetSpanStartLine(cancellationToken);
 
                 if (bracketLine == nextTokenLine)
                 {
@@ -219,12 +219,12 @@ CancellationToken cancellationToken
             {
                 SyntaxToken previousToken = closeNodeOrToken.GetPreviousToken();
 
-                int bracketLine = closeNodeOrToken.GetSpanStartLine();
-                int previousTokenLine = previousToken.GetSpanEndLine();
+                int bracketLine = closeNodeOrToken.GetSpanStartLine(cancellationToken);
+                int previousTokenLine = previousToken.GetSpanEndLine(cancellationToken);
 
                 if (bracketLine == previousTokenLine)
                 {
-                    string indentation = SyntaxTriviaAnalysis.DetermineIndentation(listNode, cancellationToken).ToString();
+                    string indentation = SyntaxTriviaAnalysis.DetermineIndentation(listNode, searchInAccessors: false, cancellationToken).ToString();
 
                     textChanges.Add(
                         new TextChange(
@@ -235,8 +235,8 @@ CancellationToken cancellationToken
                 }
                 else
                 {
-                    SyntaxTrivia listNodeIndent = SyntaxTriviaAnalysis.DetermineIndentation(listNode);
-                    SyntaxTrivia bracketIndent = SyntaxTriviaAnalysis.DetermineIndentation(closeNodeOrToken);
+                    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 =
diff --git a/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs b/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs
index 765e8d58f8..c842330c4b 100644
--- a/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs
+++ b/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Immutable;
+using System.Threading;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -152,6 +153,8 @@ SeparatedSyntaxList<TNode> nodes
             return;
         }
 
+        CancellationToken cancellationToken = context.CancellationToken;
+
         TNode first = nodes.FirstOrDefault();
 
         if (first is null)
@@ -168,8 +171,8 @@ SeparatedSyntaxList<TNode> nodes
         TNode last = nodes.Last();
 
         if (
-            ShouldFixOpeningBracket(bracesStyle, openNodeOrToken, first)
-            || ShouldFixClosingBracket(bracesStyle, listNode, closeNodeOrToken, last)
+            ShouldFixOpeningBracket(bracesStyle, openNodeOrToken, first, cancellationToken)
+            || ShouldFixClosingBracket(bracesStyle, listNode, closeNodeOrToken, last, cancellationToken)
         )
         {
             DiagnosticHelpers.ReportDiagnostic(
@@ -213,7 +216,8 @@ or SyntaxKind.ObjectInitializerExpression
     private static bool ShouldFixOpeningBracket(
         TargetBracesStyle bracesStyle,
         SyntaxToken leftBracket,
-        SyntaxNode first
+        SyntaxNode first,
+        CancellationToken cancellationToken
     )
     {
         if (!bracesStyle.HasFlag(TargetBracesStyle.Opening))
@@ -221,14 +225,15 @@ SyntaxNode first
             return false;
         }
 
-        return leftBracket.GetSpanStartLine() == first.GetSpanStartLine();
+        return leftBracket.GetSpanStartLine(cancellationToken) == first.GetSpanStartLine(cancellationToken);
     }
 
     private static bool ShouldFixClosingBracket(
         TargetBracesStyle bracesStyle,
         SyntaxNode listNode,
         SyntaxToken rightBracket,
-        SyntaxNode last
+        SyntaxNode last,
+        CancellationToken cancellationToken
     )
     {
         if (!bracesStyle.HasFlag(TargetBracesStyle.Closing))
@@ -236,13 +241,13 @@ SyntaxNode last
             return false;
         }
 
-        if (rightBracket.GetSpanEndLine() == last.GetSpanEndLine())
+        if (rightBracket.GetSpanEndLine(cancellationToken) == last.GetSpanEndLine(cancellationToken))
         {
             return true;
         }
 
-        SyntaxTrivia listNodeIndent = SyntaxTriviaAnalysis.DetermineIndentation(listNode);
-        SyntaxTrivia bracketIndent = SyntaxTriviaAnalysis.DetermineIndentation(rightBracket);
+        SyntaxTrivia listNodeIndent = SyntaxTriviaAnalysis.DetermineIndentation(listNode, searchInAccessors: false, cancellationToken);
+        SyntaxTrivia bracketIndent = SyntaxTriviaAnalysis.DetermineIndentation(rightBracket, searchInAccessors: false, cancellationToken);
         return listNodeIndent.Span.Length != bracketIndent.Span.Length;
     }
 }
\ No newline at end of file

From ed88447cf1fcd881d8760ba5fc354ca2c525cb5f Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Mon, 21 Apr 2025 12:53:06 +0200
Subject: [PATCH 12/38] Added missed license headers

---
 .../CSharp/FixBracketFormattingOfListCodeFixProvider.cs       | 4 +++-
 .../CSharp/FixBracketFormattingOfListAnalyzer.cs              | 4 +++-
 .../RCS1269FixBracketFormattingOfListTests.cs                 | 4 +++-
 3 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs b/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs
index f90d8436e9..1711a1d117 100644
--- a/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs
+++ b/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs
@@ -1,4 +1,6 @@
-using System;
+// 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;
diff --git a/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs b/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs
index c842330c4b..bd90267ae9 100644
--- a/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs
+++ b/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs
@@ -1,4 +1,6 @@
-using System;
+// 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;
diff --git a/src/Tests/Formatting.Analyzers.Tests/RCS1269FixBracketFormattingOfListTests.cs b/src/Tests/Formatting.Analyzers.Tests/RCS1269FixBracketFormattingOfListTests.cs
index 2d7efb9b17..ff098795bd 100644
--- a/src/Tests/Formatting.Analyzers.Tests/RCS1269FixBracketFormattingOfListTests.cs
+++ b/src/Tests/Formatting.Analyzers.Tests/RCS1269FixBracketFormattingOfListTests.cs
@@ -1,4 +1,6 @@
-using System.Threading.Tasks;
+// 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;

From b4a3c9c3c91f2c689659543ea698a89d01b64ebe Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Mon, 21 Apr 2025 12:51:01 +0200
Subject: [PATCH 13/38] Declared new analyzer and formatter

---
 src/Analyzers.xml                             | 34 +++++++++++++++++++
 src/Common/DiagnosticIdentifiers.Generated.cs |  1 +
 src/Common/DiagnosticRules.Generated.cs       | 12 +++++++
 .../src/configurationFiles.generated.ts       |  6 +++-
 4 files changed, 52 insertions(+), 1 deletion(-)

diff --git a/src/Analyzers.xml b/src/Analyzers.xml
index f2ff360b3e..2b73d5c17d 100644
--- a/src/Analyzers.xml
+++ b/src/Analyzers.xml
@@ -7859,6 +7859,40 @@ string s = """
       </Sample>
     </Samples>
   </Analyzer>
+  <Analyzer>
+    <Id>RCS1270</Id>
+    <Identifier>FixBracketFormattingOfBinaryExpression</Identifier>
+    <Title>Fix bracket formatting of a binary expression</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 binary expressions
+        * adds new line before a closing bracket of binary expressions
+        * aligns the closing bracket with the block containing its opening bracket
+      The analyzer works only for multi-line declarations.
+    </Summary>
+    <Samples>
+      <Sample>
+        <Before><![CDATA[if (x &&
+    y &&
+    z)
+{
+}]]></Before>
+        <After><![CDATA[if (
+    x
+    && y
+    && z
+)
+{
+}]]></After>
+      </Sample>
+    </Samples>
+  </Analyzer>
   <Analyzer>
     <Id>RCS9001</Id>
     <Identifier>UsePatternMatching</Identifier>
diff --git a/src/Common/DiagnosticIdentifiers.Generated.cs b/src/Common/DiagnosticIdentifiers.Generated.cs
index 3f811ce922..80b384bc43 100644
--- a/src/Common/DiagnosticIdentifiers.Generated.cs
+++ b/src/Common/DiagnosticIdentifiers.Generated.cs
@@ -281,5 +281,6 @@ public static partial class DiagnosticIdentifiers
         public const string UseStringInterpolationInsteadOfStringConcat = "RCS1267";
         public const string SimplifyNumericComparison = "RCS1268";
         public const string FixBracketFormattingOfList = "RCS1269";
+        public const string FixBracketFormattingOfBinaryExpression = "RCS1270";
     }
 }
\ No newline at end of file
diff --git a/src/Common/DiagnosticRules.Generated.cs b/src/Common/DiagnosticRules.Generated.cs
index e9f72ec0e6..15065cf798 100644
--- a/src/Common/DiagnosticRules.Generated.cs
+++ b/src/Common/DiagnosticRules.Generated.cs
@@ -3335,5 +3335,17 @@ public static partial class DiagnosticRules
             helpLinkUri:        DiagnosticIdentifiers.FixBracketFormattingOfList, 
             customTags:         []);
 
+        /// <summary>RCS1270</summary>
+        public static readonly DiagnosticDescriptor FixBracketFormattingOfBinaryExpression = DiagnosticDescriptorFactory.Create(
+            id:                 DiagnosticIdentifiers.FixBracketFormattingOfBinaryExpression, 
+            title:              "Fix bracket formatting of a binary expression", 
+            messageFormat:      "Fix bracket formatting of {0}", 
+            category:           DiagnosticCategories.Roslynator, 
+            defaultSeverity:    DiagnosticSeverity.Info, 
+            isEnabledByDefault: false, 
+            description:        null, 
+            helpLinkUri:        DiagnosticIdentifiers.FixBracketFormattingOfBinaryExpression, 
+            customTags:         []);
+
     }
 }
\ No newline at end of file
diff --git a/src/VisualStudioCode/package/src/configurationFiles.generated.ts b/src/VisualStudioCode/package/src/configurationFiles.generated.ts
index 88e531facf..336f749371 100644
--- a/src/VisualStudioCode/package/src/configurationFiles.generated.ts
+++ b/src/VisualStudioCode/package/src/configurationFiles.generated.ts
@@ -126,7 +126,7 @@ roslynator_analyzers.enabled_by_default = true|false
 
 #roslynator_target_braces_style = both|closing|none|opening
 # Default: none
-# Applicable to: rcs1269
+# Applicable to: rcs1269, rcs1270
 
 #roslynator_trailing_comma_style = include|omit|omit_when_single_line
 # Applicable to: rcs1260
@@ -931,6 +931,10 @@ roslynator_analyzers.enabled_by_default = true|false
 #dotnet_diagnostic.rcs1269.severity = none
 # Options: roslynator_target_braces_style
 
+# Fix bracket formatting of a binary expression
+#dotnet_diagnostic.rcs1270.severity = none
+# Options: roslynator_target_braces_style
+
 # Use pattern matching
 #dotnet_diagnostic.rcs9001.severity = silent
 

From e1b49874e5cde06da3a4ae8326658a8e16b1a0e9 Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Mon, 21 Apr 2025 13:22:04 +0200
Subject: [PATCH 14/38] Added test description

---
 ...racketFormattingOfBinaryExpressionTests.cs | 250 ++++++++++++++++++
 1 file changed, 250 insertions(+)
 create mode 100644 src/Tests/Formatting.Analyzers.Tests/RCS1270FixBracketFormattingOfBinaryExpressionTests.cs

diff --git a/src/Tests/Formatting.Analyzers.Tests/RCS1270FixBracketFormattingOfBinaryExpressionTests.cs b/src/Tests/Formatting.Analyzers.Tests/RCS1270FixBracketFormattingOfBinaryExpressionTests.cs
new file mode 100644
index 0000000000..ed7a8bee85
--- /dev/null
+++ b/src/Tests/Formatting.Analyzers.Tests/RCS1270FixBracketFormattingOfBinaryExpressionTests.cs
@@ -0,0 +1,250 @@
+// 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 class RCS1270FixBracketFormattingOfBinaryExpressionTests 
+    : AbstractCSharpDiagnosticVerifier<PlaceNewLineAfterOrBeforeBinaryOperatorAnalyzer, BinaryExpressionCodeFixProvider>
+{
+    public override DiagnosticDescriptor Descriptor { get; } = DiagnosticRules.FixBracketFormattingOfBinaryExpression;
+
+    public override CSharpTestOptions Options =>
+        base.Options.AddConfigOption(ConfigOptionKeys.TargetBracesStyle, "both");
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfBinaryExpression)]
+    public async Task Inserts_new_line_Before_and_After_binary_expression()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                void M()
+                {
+                    bool x = false;
+                    bool y = false;
+                    bool z = false;
+
+                    if [|(x &&
+                        y &&
+                        z)|]
+                    {
+                    }
+                }
+            }
+            """,
+            """
+            class C
+            {
+                void M()
+                {
+                    bool x = false;
+                    bool y = false;
+                    bool z = false;
+
+                    if (
+                        x &&
+                        y &&
+                        z
+                    )
+                    {
+                    }
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfBinaryExpression)]
+    public async Task Inserts_new_line_Before_and_After_binary_expression_2()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                void M()
+                {
+                    bool x = false;
+                    bool y = false;
+                    bool z = false;
+
+                    if [|(x
+                        && y
+                        && z)|]
+                    {
+                    }
+                }
+            }
+            """,
+            """
+            class C
+            {
+                void M()
+                {
+                    bool x = false;
+                    bool y = false;
+                    bool z = false;
+
+                    if (
+                        x
+                        && y
+                        && z
+                    )
+                    {
+                    }
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfBinaryExpression)]
+    public async Task TestNoDiagnostic()
+    {
+        await VerifyNoDiagnosticAsync(
+            """
+            class C
+            {
+                void M()
+                {
+                    bool x = false;
+                    bool y = false;
+                    bool z = false;
+
+                    if (
+                        x
+                        && y
+                        && z
+                    )
+                    {
+                    }
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfBinaryExpression)]
+    public async Task TestNoDiagnostic_SingleLine()
+    {
+        await VerifyNoDiagnosticAsync(
+            """
+            class C
+            {
+                void M()
+                {
+                    bool x = false;
+                    bool y = false;
+                    bool z = false;
+
+                    if (x && y && z)
+                    {
+                    }
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfBinaryExpression)]
+    public async Task Inserts_new_line_Before_and_After_binary_expression_for_nested()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                void M()
+                {
+                    bool x = false;
+                    bool y = false;
+                    bool z = false;
+                    bool w = false;
+                    bool v = false;
+
+                    if [|(x
+                        && [|(y
+                            || w)|]
+                        && (z || v))|]
+                    {
+                    }
+                }
+            }
+            """,
+            """
+            class C
+            {
+                void M()
+                {
+                    bool x = false;
+                    bool y = false;
+                    bool z = false;
+                    bool w = false;
+                    bool v = false;
+
+                    if (
+                        x
+                        && (
+                            y
+                            || w
+                        )
+                        && (z || v)
+                    )
+                    {
+                    }
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfBinaryExpression)]
+    public async Task Inserts_new_line_Before_and_After_binary_expression_not_if_case()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                void M()
+                {
+                    bool x = false;
+                    bool y = false;
+                    bool z = false;
+                    bool w = false;
+                    bool v = false;
+
+                    bool result = (x
+                        && [|(y
+                            || w)|]
+                        && (z || v))|];
+                }
+            }
+            """,
+            """
+            class C
+            {
+                void M()
+                {
+                    bool x = false;
+                    bool y = false;
+                    bool z = false;
+                    bool w = false;
+                    bool v = false;
+
+                    bool result = (
+                        x
+                        && (
+                            y
+                            || w
+                        )
+                        && (z || v)
+                    );
+                }
+            }
+            """
+        );
+    }
+}
\ No newline at end of file

From d2dd01350d4fc401719c40dd5f91171f727722e4 Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Mon, 21 Apr 2025 14:23:35 +0200
Subject: [PATCH 15/38] Analyzer created from copy

---
 ...ketFormattingOfBinaryExpressionAnalyzer.cs | 85 +++++++++++++++++++
 ...racketFormattingOfBinaryExpressionTests.cs |  2 +-
 2 files changed, 86 insertions(+), 1 deletion(-)
 create mode 100644 src/Formatting.Analyzers/CSharp/FixBracketFormattingOfBinaryExpressionAnalyzer.cs

diff --git a/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfBinaryExpressionAnalyzer.cs b/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfBinaryExpressionAnalyzer.cs
new file mode 100644
index 0000000000..3e00136408
--- /dev/null
+++ b/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfBinaryExpressionAnalyzer.cs
@@ -0,0 +1,85 @@
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Roslynator.CSharp;
+using Roslynator.CSharp.CodeStyle;
+
+namespace Roslynator.Formatting.CSharp;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public sealed class FixBracketFormattingOfBinaryExpressionAnalyzer : BaseDiagnosticAnalyzer
+{
+    private static ImmutableArray<DiagnosticDescriptor> _supportedDiagnostics;
+
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
+    {
+        get
+        {
+            if (_supportedDiagnostics.IsDefault)
+            {
+                Immutable.InterlockedInitialize(ref _supportedDiagnostics, DiagnosticRules.FixBracketFormattingOfBinaryExpression);
+            }
+
+            return _supportedDiagnostics;
+        }
+    }
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+
+        context.RegisterSyntaxNodeAction(
+            f => AnalyzeBinaryExpression(f),
+            SyntaxKind.AddExpression,
+            SyntaxKind.SubtractExpression,
+            SyntaxKind.MultiplyExpression,
+            SyntaxKind.DivideExpression,
+            SyntaxKind.ModuloExpression,
+            SyntaxKind.LeftShiftExpression,
+            SyntaxKind.RightShiftExpression,
+            SyntaxKind.LogicalOrExpression,
+            SyntaxKind.LogicalAndExpression,
+            SyntaxKind.BitwiseOrExpression,
+            SyntaxKind.BitwiseAndExpression,
+            SyntaxKind.ExclusiveOrExpression,
+            SyntaxKind.EqualsExpression,
+            SyntaxKind.NotEqualsExpression,
+            SyntaxKind.LessThanExpression,
+            SyntaxKind.LessThanOrEqualExpression,
+            SyntaxKind.GreaterThanExpression,
+            SyntaxKind.GreaterThanOrEqualExpression,
+            SyntaxKind.IsExpression,
+            SyntaxKind.AsExpression
+        );
+    }
+
+    private static void AnalyzeBinaryExpression(SyntaxNodeAnalysisContext context)
+    {
+        var binaryExpression = (BinaryExpressionSyntax)context.Node;
+
+        ExpressionSyntax left = binaryExpression.Left;
+
+        if (left.IsMissing)
+            return;
+
+        ExpressionSyntax right = binaryExpression.Right;
+
+        if (right.IsMissing)
+            return;
+
+        NewLinePosition newLinePosition = context.GetBinaryExpressionNewLinePosition();
+
+        TriviaBlock block = TriviaBlock.FromSurrounding(binaryExpression.OperatorToken, right, newLinePosition);
+
+        if (block.Success)
+        {
+            DiagnosticHelpers.ReportDiagnostic(
+                context,
+                DiagnosticRules.FixBracketFormattingOfBinaryExpression,
+                block.GetLocation(),
+                (block.First.IsToken) ? "before" : "after");
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Tests/Formatting.Analyzers.Tests/RCS1270FixBracketFormattingOfBinaryExpressionTests.cs b/src/Tests/Formatting.Analyzers.Tests/RCS1270FixBracketFormattingOfBinaryExpressionTests.cs
index ed7a8bee85..37c08a9e7b 100644
--- a/src/Tests/Formatting.Analyzers.Tests/RCS1270FixBracketFormattingOfBinaryExpressionTests.cs
+++ b/src/Tests/Formatting.Analyzers.Tests/RCS1270FixBracketFormattingOfBinaryExpressionTests.cs
@@ -9,7 +9,7 @@
 namespace Roslynator.Formatting.CSharp.Tests;
 
 public class RCS1270FixBracketFormattingOfBinaryExpressionTests 
-    : AbstractCSharpDiagnosticVerifier<PlaceNewLineAfterOrBeforeBinaryOperatorAnalyzer, BinaryExpressionCodeFixProvider>
+    : AbstractCSharpDiagnosticVerifier<FixBracketFormattingOfBinaryExpressionAnalyzer, BinaryExpressionCodeFixProvider>
 {
     public override DiagnosticDescriptor Descriptor { get; } = DiagnosticRules.FixBracketFormattingOfBinaryExpression;
 

From 5e618f749093ae1f7d4a95a3be702199ece7eb6f Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Thu, 1 May 2025 16:40:51 +0200
Subject: [PATCH 16/38] Potential fix for the build

---
 src/CSharp/DetermineParameterTypeHelper.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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);
                         }
                     }
 

From 040a7a681871af350b331f1abdad881e4d6d8f90 Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Fri, 2 May 2025 09:36:01 +0200
Subject: [PATCH 17/38] Potential fix for the build

---
 src/Documentation/DocumentationModel.cs       | 20 +++++++++++++------
 src/Documentation/DocumentationWriter.cs      |  2 +-
 .../Extensions/SymbolExtensions.cs            |  4 ++--
 src/Documentation/SymbolDefinitionWriter.cs   | 16 ++++++++++++---
 .../SymbolDocumentationProvider.cs            | 14 ++++++++++---
 src/Documentation/TypeDocumentationModel.cs   |  4 ++--
 6 files changed, 43 insertions(+), 17 deletions(-)

diff --git a/src/Documentation/DocumentationModel.cs b/src/Documentation/DocumentationModel.cs
index f44e3707ad..6372b3cf32 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,15 @@ 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..d8bd7b89ca 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,15 @@ 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);
     }
 }

From 8d5fe0cbbfee47867b37e69826b42eb8937bdf9d Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Sat, 3 May 2025 15:27:24 +0200
Subject: [PATCH 18/38] Implementing

---
 ...ketFormattingOfBinaryExpressionAnalyzer.cs | 119 ++++++++++++++++--
 .../FixBracketFormattingOfListAnalyzer.cs     |   2 +
 ...racketFormattingOfBinaryExpressionTests.cs | 104 ++++++++++++++-
 3 files changed, 214 insertions(+), 11 deletions(-)

diff --git a/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfBinaryExpressionAnalyzer.cs b/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfBinaryExpressionAnalyzer.cs
index 3e00136408..5ecf9f346d 100644
--- a/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfBinaryExpressionAnalyzer.cs
+++ b/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfBinaryExpressionAnalyzer.cs
@@ -1,8 +1,13 @@
-using System.Collections.Immutable;
+#nullable enable
+
+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;
 
@@ -57,29 +62,127 @@ public override void Initialize(AnalysisContext context)
 
     private static void AnalyzeBinaryExpression(SyntaxNodeAnalysisContext context)
     {
-        var binaryExpression = (BinaryExpressionSyntax)context.Node;
+        TargetBracesStyle bracesStyle = context.GetTargetBracesStyle();
+
+        if (bracesStyle == TargetBracesStyle.None)
+        {
+            return;
+        }
+
+        CancellationToken cancellationToken = context.CancellationToken;
+
+        BinaryExpressionSyntax binaryExpression = (BinaryExpressionSyntax)context.Node;
 
         ExpressionSyntax left = binaryExpression.Left;
 
         if (left.IsMissing)
+        {
             return;
+        }
 
         ExpressionSyntax right = binaryExpression.Right;
 
         if (right.IsMissing)
+        {
             return;
+        }
 
-        NewLinePosition newLinePosition = context.GetBinaryExpressionNewLinePosition();
+        SyntaxToken? openBracket;
+        SyntaxToken? closeBracket;
+        SyntaxNode? parent = FindBrackets(right, out openBracket, out closeBracket);
 
-        TriviaBlock block = TriviaBlock.FromSurrounding(binaryExpression.OperatorToken, right, newLinePosition);
+        if (parent == null || parent.IsSingleLine() || openBracket is null || closeBracket is null)
+        {
+            return;
+        }
 
-        if (block.Success)
+        if (
+            ShouldFixOpeningBracket(bracesStyle, openBracket.Value, left, cancellationToken)
+            || ShouldFixClosingBracket(bracesStyle, parent, closeBracket.Value, right, cancellationToken)
+        )
         {
-            DiagnosticHelpers.ReportDiagnostic(
+            DiagnosticHelpers.ReportDiagnosticIfEffective(
                 context,
                 DiagnosticRules.FixBracketFormattingOfBinaryExpression,
-                block.GetLocation(),
-                (block.First.IsToken) ? "before" : "after");
+                Location.Create(
+                    parent.SyntaxTree,
+                    TextSpan.FromBounds(openBracket.Value.SpanStart, closeBracket.Value.Span.End)
+                ),
+                GetTitle(parent)
+            );
+        }
+    }
+
+    private static SyntaxNode? FindBrackets(
+        SyntaxNode syntaxNode,
+        out SyntaxToken? openBracket,
+        out SyntaxToken? closeBracket
+    )
+    {
+        SyntaxNode? parent = syntaxNode.FirstAncestor<SyntaxNode>();
+        while (parent != null)
+        {
+            parent = parent.FirstAncestor<SyntaxNode>();
+            switch (parent)
+            {
+                case IfStatementSyntax ifStatement:
+                    openBracket = ifStatement.OpenParenToken;
+                    closeBracket = ifStatement.CloseParenToken;
+                    return parent;
+            }
+        }
+
+        openBracket = null;
+        closeBracket = null;
+        return null;
+    }
+
+    private static string GetTitle(SyntaxNode listNode) =>
+        listNode.Kind() switch
+        {
+            SyntaxKind.IfStatement
+                => "an 'if' statement",
+
+            _ => throw new InvalidOperationException()
+        };
+
+    private static bool ShouldFixOpeningBracket(
+        TargetBracesStyle bracesStyle,
+        SyntaxToken leftBracket,
+        SyntaxNode first,
+        CancellationToken cancellationToken
+    )
+    {
+        if (!bracesStyle.HasFlag(TargetBracesStyle.Opening))
+        {
+            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.HasFlag(TargetBracesStyle.Closing))
+        {
+            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;
     }
 }
\ No newline at end of file
diff --git a/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs b/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs
index c842330c4b..eaaccfcc21 100644
--- a/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs
+++ b/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs
@@ -158,7 +158,9 @@ SeparatedSyntaxList<TNode> nodes
         TNode first = nodes.FirstOrDefault();
 
         if (first is null)
+        {
             return;
+        }
 
         SyntaxNode listNode = context.Node;
         TextSpan listSpan = listNode.GetSpan(includeExteriorTrivia: false);
diff --git a/src/Tests/Formatting.Analyzers.Tests/RCS1270FixBracketFormattingOfBinaryExpressionTests.cs b/src/Tests/Formatting.Analyzers.Tests/RCS1270FixBracketFormattingOfBinaryExpressionTests.cs
index 37c08a9e7b..2d17c4526e 100644
--- a/src/Tests/Formatting.Analyzers.Tests/RCS1270FixBracketFormattingOfBinaryExpressionTests.cs
+++ b/src/Tests/Formatting.Analyzers.Tests/RCS1270FixBracketFormattingOfBinaryExpressionTests.cs
@@ -8,7 +8,7 @@
 
 namespace Roslynator.Formatting.CSharp.Tests;
 
-public class RCS1270FixBracketFormattingOfBinaryExpressionTests 
+public class RCS1270FixBracketFormattingOfBinaryExpressionTests
     : AbstractCSharpDiagnosticVerifier<FixBracketFormattingOfBinaryExpressionAnalyzer, BinaryExpressionCodeFixProvider>
 {
     public override DiagnosticDescriptor Descriptor { get; } = DiagnosticRules.FixBracketFormattingOfBinaryExpression;
@@ -22,7 +22,7 @@ public async Task Inserts_new_line_Before_and_After_binary_expression()
         await VerifyDiagnosticAndFixAsync(
             """
             class C
-            {
+            { 
                 void M()
                 {
                     bool x = false;
@@ -102,6 +102,55 @@ void M()
         );
     }
 
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfBinaryExpression)]
+    public async Task Inserts_new_line_Before_and_After_binary_expression_3()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                void M()
+                {
+                    bool x = false;
+                    bool y = false;
+                    bool z = false;
+
+                    if (x && y)
+                    {
+                    }
+                    else if [|(x
+                        && y
+                        && z)|]
+                    {
+                    }
+                }
+            }
+            """,
+            """
+            class C
+            {
+                void M()
+                {
+                    bool x = false;
+                    bool y = false;
+                    bool z = false;
+
+                    if (x && y)
+                    {
+                    }
+                    else if (
+                        x
+                        && y
+                        && z
+                    )
+                    {
+                    }
+                }
+            }
+            """
+        );
+    }
+
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfBinaryExpression)]
     public async Task TestNoDiagnostic()
     {
@@ -216,7 +265,7 @@ void M()
                     bool w = false;
                     bool v = false;
 
-                    bool result = (x
+                    bool result = [|(x
                         && [|(y
                             || w)|]
                         && (z || v))|];
@@ -247,4 +296,53 @@ void M()
             """
         );
     }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfBinaryExpression)]
+    public async Task Inserts_new_line_Before_and_After_binary_expression_not_if_case2()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                void M()
+                {
+                    bool x = false;
+                    bool y = false;
+                    bool z = false;
+                    bool w = false;
+                    bool v = false;
+
+                    bool result = 
+                        [|(x
+                            && [|(y
+                                || w)|]
+                            && (z || v))|];
+                }
+            }
+            """,
+            """
+            class C
+            {
+                void M()
+                {
+                    bool x = false;
+                    bool y = false;
+                    bool z = false;
+                    bool w = false;
+                    bool v = false;
+
+                    bool result = 
+                        (
+                            x
+                            && (
+                                y
+                                || w
+                            )
+                            && (z || v)
+                        );
+                }
+            }
+            """
+        );
+    }
 }
\ No newline at end of file

From 65480de8ba21dc545167e75bbc07bbea3e0cd870 Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Sat, 3 May 2025 20:19:36 +0200
Subject: [PATCH 19/38] Implementing

---
 ...ketFormattingOfBinaryExpressionAnalyzer.cs |  6 ++-
 ...racketFormattingOfBinaryExpressionTests.cs | 43 +++++++++++++++++++
 2 files changed, 47 insertions(+), 2 deletions(-)

diff --git a/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfBinaryExpressionAnalyzer.cs b/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfBinaryExpressionAnalyzer.cs
index 5ecf9f346d..70488fced8 100644
--- a/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfBinaryExpressionAnalyzer.cs
+++ b/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfBinaryExpressionAnalyzer.cs
@@ -96,12 +96,14 @@ private static void AnalyzeBinaryExpression(SyntaxNodeAnalysisContext context)
             return;
         }
 
+        var anyFirstDescendant = parent.DescendantNodesAndTokens();
+
         if (
             ShouldFixOpeningBracket(bracesStyle, openBracket.Value, left, cancellationToken)
             || ShouldFixClosingBracket(bracesStyle, parent, closeBracket.Value, right, cancellationToken)
         )
         {
-            DiagnosticHelpers.ReportDiagnosticIfEffective(
+            DiagnosticHelpers.ReportDiagnostic(
                 context,
                 DiagnosticRules.FixBracketFormattingOfBinaryExpression,
                 Location.Create(
@@ -120,7 +122,7 @@ out SyntaxToken? closeBracket
     )
     {
         SyntaxNode? parent = syntaxNode.FirstAncestor<SyntaxNode>();
-        while (parent != null)
+        //while (parent != null)
         {
             parent = parent.FirstAncestor<SyntaxNode>();
             switch (parent)
diff --git a/src/Tests/Formatting.Analyzers.Tests/RCS1270FixBracketFormattingOfBinaryExpressionTests.cs b/src/Tests/Formatting.Analyzers.Tests/RCS1270FixBracketFormattingOfBinaryExpressionTests.cs
index 2d17c4526e..8c0c39db36 100644
--- a/src/Tests/Formatting.Analyzers.Tests/RCS1270FixBracketFormattingOfBinaryExpressionTests.cs
+++ b/src/Tests/Formatting.Analyzers.Tests/RCS1270FixBracketFormattingOfBinaryExpressionTests.cs
@@ -151,6 +151,49 @@ void M()
         );
     }
 
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfBinaryExpression)]
+    public async Task Inserts_new_line_Before_and_After_binary_expression_4()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                void M()
+                {
+                    bool x = false;
+                    bool y = false;
+                    bool z = false;
+
+                    if [|(x
+                        || y
+                        || z)|]
+                    {
+                    }
+                }
+            }
+            """,
+            """
+            class C
+            {
+                void M()
+                {
+                    bool x = false;
+                    bool y = false;
+                    bool z = false;
+
+                    if (
+                        x
+                        && y
+                        && z
+                    )
+                    {
+                    }
+                }
+            }
+            """
+        );
+    }
+
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfBinaryExpression)]
     public async Task TestNoDiagnostic()
     {

From 2fd3896e7d4d6f5f52f476a912fa8e2b800e7a26 Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Sat, 3 May 2025 22:07:10 +0200
Subject: [PATCH 20/38] Added additional tests

---
 ...racketFormattingOfBinaryExpressionTests.cs | 277 ++++++++++++++++++
 1 file changed, 277 insertions(+)

diff --git a/src/Tests/Formatting.Analyzers.Tests/RCS1270FixBracketFormattingOfBinaryExpressionTests.cs b/src/Tests/Formatting.Analyzers.Tests/RCS1270FixBracketFormattingOfBinaryExpressionTests.cs
index 8c0c39db36..8bee513e3e 100644
--- a/src/Tests/Formatting.Analyzers.Tests/RCS1270FixBracketFormattingOfBinaryExpressionTests.cs
+++ b/src/Tests/Formatting.Analyzers.Tests/RCS1270FixBracketFormattingOfBinaryExpressionTests.cs
@@ -194,6 +194,160 @@ void M()
         );
     }
 
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfBinaryExpression)]
+    public async Task Inserts_new_line_Before_and_After_binary_expression_5()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                void M()
+                {
+                    bool x = false;
+                    bool y = false;
+                    bool z = false;
+
+                    if [|(F()
+                        || F()
+                        || F())|]
+                    {
+                    }
+                }
+
+                bool F() => true;
+            }
+            """,
+            """
+            class C
+            {
+                void M()
+                {
+                    bool x = false;
+                    bool y = false;
+                    bool z = false;
+
+                    if (
+                        F()
+                        && F()
+                        && F()
+                    )
+                    {
+                    }
+                }
+
+                bool F() => true;
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfBinaryExpression)]
+    public async Task Inserts_new_line_Before_and_After_binary_expression_6()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                void M()
+                {
+                    bool x = false;
+                    bool y = false;
+                    bool z = false;
+
+                    while [|(x
+                        || y
+                        || z)|]
+                    {
+                    }
+                }
+            }
+            """,
+            """
+            class C
+            {
+                void M()
+                {
+                    bool x = false;
+                    bool y = false;
+                    bool z = false;
+
+                    while (
+                        x
+                        && y
+                        && z
+                    )
+                    {
+                    }
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfBinaryExpression)]
+    public async Task Inserts_new_line_Before_and_After_binary_expression_7()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                void M()
+                {
+                    bool x = false;
+                    bool y = false;
+                    bool z = false;
+
+                    do {}
+                    while [|(x
+                        || y
+                        || z)|];
+                }
+            }
+            """,
+            """
+            class C
+            {
+                void M()
+                {
+                    bool x = false;
+                    bool y = false;
+                    bool z = false;
+
+                    do {}
+                    while (
+                        x
+                        || y
+                        || z
+                    );
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfBinaryExpression)]
+    public async Task NoDiagnostic_inside_for()
+    {
+        await VerifyNoDiagnosticAsync(
+            """
+            class C
+            {
+                void M()
+                {
+                    bool x = false;
+                    bool y = false;
+                    bool z = false;
+
+                    for (int i = 0; 
+                        x || y || z; i++)
+                    {
+                    }
+                }
+            }
+            """
+        );
+    }
+
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfBinaryExpression)]
     public async Task TestNoDiagnostic()
     {
@@ -242,6 +396,129 @@ void M()
         );
     }
 
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfBinaryExpression)]
+    public async Task Test_Expression_in_unnecessary_parentheses()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                void M()
+                {
+                    bool x = false;
+                    bool y = false;
+                    bool z = false;
+
+                    if [|([|(x
+                        || y)|])|]
+                    {
+                    }
+                }
+            }
+            """,
+            """
+            class C
+            {
+                void M()
+                {
+                    bool x = false;
+                    bool y = false;
+                    bool z = false;
+
+                    if (
+                        (
+                            x
+                            || y
+                        )
+                    )
+                    {
+                    }
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfBinaryExpression)]
+    public async Task Test_Expression_in_unnecessary_parentheses2()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                void M()
+                {
+                    bool x = false;
+                    bool y = false;
+                    bool z = false;
+
+                    if [|(
+                        (x || y))|]
+                    {
+                    }
+                }
+            }
+            """,
+            """
+            class C
+            {
+                void M()
+                {
+                    bool x = false;
+                    bool y = false;
+                    bool z = false;
+
+                    if (
+                        (x || y)
+                    )
+                    {
+                    }
+                }
+            }
+            """
+        );
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfBinaryExpression)]
+    public async Task Test_Expression_in_unnecessary_parentheses3()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                void M()
+                {
+                    bool x = false;
+                    bool y = false;
+                    bool z = false;
+
+                    if [|(
+                        (((x || y))))|]
+                    {
+                    }
+                }
+            }
+            """,
+            """
+            class C
+            {
+                void M()
+                {
+                    bool x = false;
+                    bool y = false;
+                    bool z = false;
+
+                    if (
+                        (((x || y)))
+                    )
+                    {
+                    }
+                }
+            }
+            """
+        );
+    }
+
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfBinaryExpression)]
     public async Task Inserts_new_line_Before_and_After_binary_expression_for_nested()
     {

From df09b0150bc7e4c4cf8e672962a55f713652da8b Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Sun, 4 May 2025 13:44:17 +0200
Subject: [PATCH 21/38] Implemented fixer

---
 ...FormattingOfBinaryExpressionFixProvider.cs | 186 ++++++++++++++++++
 ...ketFormattingOfBinaryExpressionAnalyzer.cs | 158 +++++++++++----
 ...racketFormattingOfBinaryExpressionTests.cs |  42 +++-
 3 files changed, 337 insertions(+), 49 deletions(-)
 create mode 100644 src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfBinaryExpressionFixProvider.cs

diff --git a/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfBinaryExpressionFixProvider.cs b/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfBinaryExpressionFixProvider.cs
new file mode 100644
index 0000000000..99d4b63cfb
--- /dev/null
+++ b/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfBinaryExpressionFixProvider.cs
@@ -0,0 +1,186 @@
+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(FixBracketFormattingOfBinaryExpressionFixProvider))]
+[Shared]
+public sealed class FixBracketFormattingOfBinaryExpressionFixProvider : BaseCodeFixProvider
+{
+    private const string Title = "Fix bracket formatting";
+
+    public override ImmutableArray<string> FixableDiagnosticIds =>
+        ImmutableArray.Create(DiagnosticIdentifiers.FixBracketFormattingOfBinaryExpression);
+
+    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.ParenthesizedExpression:
+                        case SyntaxKind.IfStatement:
+                        case SyntaxKind.WhileStatement:
+                        case SyntaxKind.DoStatement:
+                            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 ParenthesizedExpressionSyntax parenthesizedExpression:
+                {
+                    return CodeAction.Create(
+                        Title,
+                        ct => Fix(parenthesizedExpression, parenthesizedExpression.OpenParenToken, parenthesizedExpression.CloseParenToken, ct),
+                        GetEquivalenceKey(diagnostic)
+                    );
+                }
+                case IfStatementSyntax ifStatement:
+                {
+                    return CodeAction.Create(
+                        Title,
+                        ct => Fix(ifStatement, ifStatement.OpenParenToken, ifStatement.CloseParenToken, ct),
+                        GetEquivalenceKey(diagnostic)
+                    );
+                }
+                case WhileStatementSyntax whileStatement:
+                {
+                    return CodeAction.Create(
+                        Title,
+                        ct => Fix(whileStatement, whileStatement.OpenParenToken, whileStatement.CloseParenToken, ct),
+                        GetEquivalenceKey(diagnostic)
+                    );
+                }
+                case DoStatementSyntax doStatement:
+                {
+                    return CodeAction.Create(
+                        Title,
+                        ct => Fix(doStatement, doStatement.OpenParenToken, doStatement.CloseParenToken, ct),
+                        GetEquivalenceKey(diagnostic)
+                    );
+                }
+                default:
+                {
+                    throw new InvalidOperationException();
+                }
+            }
+        }
+
+        async Task<Document> Fix(
+            SyntaxNode targetNode,
+            SyntaxToken openNodeOrToken,
+            SyntaxToken closeNodeOrToken,
+            CancellationToken cancellationToken
+        )
+        {
+            AnalyzerConfigOptions configOptions = document.GetConfigOptions(targetNode.SyntaxTree);
+            TargetBracesStyle bracesStyle = configOptions.GetTargetBracesStyle();
+
+            if (bracesStyle == TargetBracesStyle.None)
+            {
+                return document;
+            }
+
+            string endOfLine = SyntaxTriviaAnalysis.DetermineEndOfLine(node).ToString();
+
+            List<TextChange> textChanges = new ();
+
+            if (bracesStyle.HasFlag(TargetBracesStyle.Opening))
+            {
+                SyntaxToken nextToken = openNodeOrToken.GetNextToken();
+
+                int bracketLine = openNodeOrToken.GetSpanStartLine(cancellationToken);
+                int nextTokenLine = nextToken.GetSpanStartLine(cancellationToken);
+
+                if (bracketLine == nextTokenLine)
+                {
+                    string indentation = SyntaxTriviaAnalysis.GetIncreasedIndentation(targetNode, configOptions, cancellationToken);
+
+                    textChanges.Add(
+                        new TextChange(
+                            TextSpan.FromBounds(openNodeOrToken.Span.End, nextToken.SpanStart),
+                            endOfLine + indentation
+                        )
+                    );
+                }
+            }
+
+            if (bracesStyle.HasFlag(TargetBracesStyle.Closing))
+            {
+                SyntaxToken previousToken = closeNodeOrToken.GetPreviousToken();
+
+                int bracketLine = closeNodeOrToken.GetSpanStartLine(cancellationToken);
+                int previousTokenLine = previousToken.GetSpanEndLine(cancellationToken);
+
+                if (bracketLine == previousTokenLine)
+                {
+                    string indentation = SyntaxTriviaAnalysis.DetermineIndentation(targetNode, searchInAccessors: false, cancellationToken).ToString();
+
+                    textChanges.Add(
+                        new TextChange(
+                            closeNodeOrToken.Span,
+                            endOfLine + indentation + closeNodeOrToken
+                        )
+                    );
+                }
+                else
+                {
+                    SyntaxTrivia listNodeIndent = SyntaxTriviaAnalysis.DetermineIndentation(targetNode, 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);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfBinaryExpressionAnalyzer.cs b/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfBinaryExpressionAnalyzer.cs
index 70488fced8..a8748df4e0 100644
--- a/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfBinaryExpressionAnalyzer.cs
+++ b/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfBinaryExpressionAnalyzer.cs
@@ -1,6 +1,7 @@
 #nullable enable
 
 using System;
+using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Threading;
 using Microsoft.CodeAnalysis;
@@ -87,71 +88,147 @@ private static void AnalyzeBinaryExpression(SyntaxNodeAnalysisContext context)
             return;
         }
 
-        SyntaxToken? openBracket;
-        SyntaxToken? closeBracket;
-        SyntaxNode? parent = FindBrackets(right, out openBracket, out closeBracket);
+        SyntaxToken firstToken = binaryExpression.GetFirstToken();
+        SyntaxToken lastToken = binaryExpression.GetLastToken();
 
-        if (parent == null || parent.IsSingleLine() || openBracket is null || closeBracket is null)
-        {
-            return;
-        }
+        IEnumerable<(SyntaxNode Parent, SyntaxToken OpenBracket, SyntaxToken CloseBracket)> nodesWithBrackets =
+            FindNodesWithBrackets(binaryExpression);
 
-        var anyFirstDescendant = parent.DescendantNodesAndTokens();
+        SemanticModel semanticModel = context.SemanticModel;
 
-        if (
-            ShouldFixOpeningBracket(bracesStyle, openBracket.Value, left, cancellationToken)
-            || ShouldFixClosingBracket(bracesStyle, parent, closeBracket.Value, right, cancellationToken)
-        )
+        foreach ((SyntaxNode parent, SyntaxToken openBracket, SyntaxToken closeBracket) in nodesWithBrackets)
         {
-            DiagnosticHelpers.ReportDiagnostic(
-                context,
-                DiagnosticRules.FixBracketFormattingOfBinaryExpression,
-                Location.Create(
-                    parent.SyntaxTree,
-                    TextSpan.FromBounds(openBracket.Value.SpanStart, closeBracket.Value.Span.End)
-                ),
-                GetTitle(parent)
-            );
+            if (openBracket.GetSpanStartLine(cancellationToken) == closeBracket.GetSpanEndLine(cancellationToken))
+            {
+                continue;
+            }
+
+            if (
+                ShouldFixOpeningBracket(bracesStyle, openBracket, firstToken, cancellationToken)
+                || ShouldFixClosingBracket(bracesStyle, parent, closeBracket, lastToken, cancellationToken)
+            )
+            {
+                TextSpan span = TextSpan.FromBounds(openBracket.SpanStart, closeBracket.Span.End);
+
+                Diagnostic? existingDiagnostic =
+                    semanticModel.GetDiagnostic(
+                        DiagnosticIdentifiers.FixBracketFormattingOfBinaryExpression,
+                        span,
+                        cancellationToken
+                    );
+
+                if (existingDiagnostic is not null)
+                {
+                    continue;
+                }
+
+                DiagnosticHelpers.ReportDiagnostic(
+                    context,
+                    DiagnosticRules.FixBracketFormattingOfBinaryExpression,
+                    Location.Create(
+                        parent.SyntaxTree,
+                        span
+                    ),
+                    GetTitle(parent)
+                );
+            }
         }
     }
 
-    private static SyntaxNode? FindBrackets(
-        SyntaxNode syntaxNode,
-        out SyntaxToken? openBracket,
-        out SyntaxToken? closeBracket
-    )
+    private static IEnumerable<(SyntaxNode Parent, SyntaxToken OpenBracket, SyntaxToken CloseBracket)>
+        FindNodesWithBrackets(SyntaxNode syntaxNode)
     {
-        SyntaxNode? parent = syntaxNode.FirstAncestor<SyntaxNode>();
-        //while (parent != null)
+        // Braced nodes can be in braces and in braces and ...
+        // if the node itself is not ParenthesizedExpressionSyntax or the first parent doesn't have parentheses
+        // then further processing should be stopped, otherwise multiple diagnostics for the same place will be reported
+
+        SyntaxNode? parent = syntaxNode;
+        int depth = 0;
+        while (parent != null)
         {
-            parent = parent.FirstAncestor<SyntaxNode>();
+            bool stop = false;
+
             switch (parent)
             {
+                case ParenthesizedExpressionSyntax parenthesizedExpressionSyntax:
+                    yield return (
+                        parent,
+                        parenthesizedExpressionSyntax.OpenParenToken,
+                        parenthesizedExpressionSyntax.CloseParenToken
+                    );
+                    break;
+
                 case IfStatementSyntax ifStatement:
-                    openBracket = ifStatement.OpenParenToken;
-                    closeBracket = ifStatement.CloseParenToken;
-                    return parent;
+                    yield return (
+                        parent,
+                        ifStatement.OpenParenToken,
+                        ifStatement.CloseParenToken
+                    );
+                    // If-statement is considered as a final node.
+                    stop = true;
+                    break;
+
+                case WhileStatementSyntax whileStatement:
+                    yield return (
+                        parent,
+                        whileStatement.OpenParenToken,
+                        whileStatement.CloseParenToken
+                    );
+                    // While-statement is considered as a final node.
+                    stop = true;
+                    break;
+
+                case DoStatementSyntax doWhileStatement:
+                    yield return (
+                        parent,
+                        doWhileStatement.OpenParenToken,
+                        doWhileStatement.CloseParenToken
+                    );
+                    // Do-while-statement is considered as a final node.
+                    stop = true;
+                    break;
+
+                default:
+                    if (depth > 0)
+                    {
+                        stop = true;
+                    }
+                    break;
             }
-        }
 
-        openBracket = null;
-        closeBracket = null;
-        return null;
+            depth++;
+
+            if (stop)
+            {
+                break;
+            }
+
+            parent = parent.FirstAncestor<SyntaxNode>();
+        }
     }
 
-    private static string GetTitle(SyntaxNode listNode) =>
-        listNode.Kind() switch
+    private static string GetTitle(SyntaxNode node) =>
+        node.Kind() switch
         {
             SyntaxKind.IfStatement
                 => "an 'if' statement",
 
+            SyntaxKind.ParenthesizedExpression
+                => "a parenthesized expression",
+
+            SyntaxKind.WhileStatement
+                => "a 'while' statement",
+
+            SyntaxKind.DoStatement
+                => "a 'do-while' statement",
+
             _ => throw new InvalidOperationException()
         };
 
     private static bool ShouldFixOpeningBracket(
         TargetBracesStyle bracesStyle,
         SyntaxToken leftBracket,
-        SyntaxNode first,
+        SyntaxToken first,
         CancellationToken cancellationToken
     )
     {
@@ -167,7 +244,7 @@ private static bool ShouldFixClosingBracket(
         TargetBracesStyle bracesStyle,
         SyntaxNode listNode,
         SyntaxToken rightBracket,
-        SyntaxNode last,
+        SyntaxToken last,
         CancellationToken cancellationToken
     )
     {
@@ -185,6 +262,7 @@ CancellationToken cancellationToken
             SyntaxTriviaAnalysis.DetermineIndentation(listNode, searchInAccessors: false, cancellationToken);
         SyntaxTrivia bracketIndent =
             SyntaxTriviaAnalysis.DetermineIndentation(rightBracket, searchInAccessors: false, cancellationToken);
+
         return listNodeIndent.Span.Length != bracketIndent.Span.Length;
     }
 }
\ No newline at end of file
diff --git a/src/Tests/Formatting.Analyzers.Tests/RCS1270FixBracketFormattingOfBinaryExpressionTests.cs b/src/Tests/Formatting.Analyzers.Tests/RCS1270FixBracketFormattingOfBinaryExpressionTests.cs
index 8bee513e3e..eac8392404 100644
--- a/src/Tests/Formatting.Analyzers.Tests/RCS1270FixBracketFormattingOfBinaryExpressionTests.cs
+++ b/src/Tests/Formatting.Analyzers.Tests/RCS1270FixBracketFormattingOfBinaryExpressionTests.cs
@@ -9,7 +9,7 @@
 namespace Roslynator.Formatting.CSharp.Tests;
 
 public class RCS1270FixBracketFormattingOfBinaryExpressionTests
-    : AbstractCSharpDiagnosticVerifier<FixBracketFormattingOfBinaryExpressionAnalyzer, BinaryExpressionCodeFixProvider>
+    : AbstractCSharpDiagnosticVerifier<FixBracketFormattingOfBinaryExpressionAnalyzer, FixBracketFormattingOfBinaryExpressionFixProvider>
 {
     public override DiagnosticDescriptor Descriptor { get; } = DiagnosticRules.FixBracketFormattingOfBinaryExpression;
 
@@ -22,7 +22,7 @@ public async Task Inserts_new_line_Before_and_After_binary_expression()
         await VerifyDiagnosticAndFixAsync(
             """
             class C
-            { 
+            {
                 void M()
                 {
                     bool x = false;
@@ -183,8 +183,8 @@ void M()
 
                     if (
                         x
-                        && y
-                        && z
+                        || y
+                        || z
                     )
                     {
                     }
@@ -228,8 +228,8 @@ void M()
 
                     if (
                         F()
-                        && F()
-                        && F()
+                        || F()
+                        || F()
                     )
                     {
                     }
@@ -273,8 +273,8 @@ void M()
 
                     while (
                         x
-                        && y
-                        && z
+                        || y
+                        || z
                     )
                     {
                     }
@@ -410,7 +410,7 @@ void M()
                     bool z = false;
 
                     if [|([|(x
-                        || y)|])|]
+                            || y)|])|]
                     {
                     }
                 }
@@ -519,6 +519,30 @@ void M()
         );
     }
 
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfBinaryExpression)]
+    public async Task Test_NoDiagnostic_in_case_of_unnecessary_parentheses()
+    {
+        await VerifyNoDiagnosticAsync(
+            """
+            class C
+            {
+                void M()
+                {
+                    bool x = false;
+                    bool y = false;
+                    bool z = false;
+
+                    if (
+                        (((x || y)))
+                    )
+                    {
+                    }
+                }
+            }
+            """
+        );
+    }
+
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfBinaryExpression)]
     public async Task Inserts_new_line_Before_and_After_binary_expression_for_nested()
     {

From 1eaae70781f5a4ee3033edad358413d391a6c17a Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Sun, 4 May 2025 13:52:26 +0200
Subject: [PATCH 22/38] Added additional test. Added license information in the
 header

---
 ...FormattingOfBinaryExpressionFixProvider.cs |  4 +-
 ...ketFormattingOfBinaryExpressionAnalyzer.cs |  4 +-
 ...racketFormattingOfBinaryExpressionTests.cs | 59 +++++++++++++++++++
 3 files changed, 65 insertions(+), 2 deletions(-)

diff --git a/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfBinaryExpressionFixProvider.cs b/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfBinaryExpressionFixProvider.cs
index 99d4b63cfb..f2f6b51adc 100644
--- a/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfBinaryExpressionFixProvider.cs
+++ b/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfBinaryExpressionFixProvider.cs
@@ -1,4 +1,6 @@
-using System;
+// 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;
diff --git a/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfBinaryExpressionAnalyzer.cs b/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfBinaryExpressionAnalyzer.cs
index a8748df4e0..78936e9c49 100644
--- a/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfBinaryExpressionAnalyzer.cs
+++ b/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfBinaryExpressionAnalyzer.cs
@@ -1,4 +1,6 @@
-#nullable enable
+// Copyright (c) .NET Foundation and Contributors. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+#nullable enable
 
 using System;
 using System.Collections.Generic;
diff --git a/src/Tests/Formatting.Analyzers.Tests/RCS1270FixBracketFormattingOfBinaryExpressionTests.cs b/src/Tests/Formatting.Analyzers.Tests/RCS1270FixBracketFormattingOfBinaryExpressionTests.cs
index eac8392404..4068cc1857 100644
--- a/src/Tests/Formatting.Analyzers.Tests/RCS1270FixBracketFormattingOfBinaryExpressionTests.cs
+++ b/src/Tests/Formatting.Analyzers.Tests/RCS1270FixBracketFormattingOfBinaryExpressionTests.cs
@@ -689,4 +689,63 @@ void M()
             """
         );
     }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfBinaryExpression)]
+    public async Task Inserts_new_line_Before_and_After_binary_expression_for_ternary_operator()
+    {
+        await VerifyDiagnosticAndFixAsync(
+            """
+            class C
+            {
+                void M()
+                {
+                    bool x = false;
+                    bool y = false;
+                    bool z = false;
+                    bool w = false;
+                    bool v = false;
+
+                    bool result = 
+                        [|(x
+                            && [|(y
+                                || w)|])|]
+                        ? [|(z 
+                            || v)|]
+                        : [|(x 
+                            && y)|];
+                }
+            }
+            """,
+            """
+            class C
+            {
+                void M()
+                {
+                    bool x = false;
+                    bool y = false;
+                    bool z = false;
+                    bool w = false;
+                    bool v = false;
+
+                    bool result = 
+                        (
+                            x
+                            && (
+                                y
+                                || w
+                            )
+                        )
+                        ? (
+                            z 
+                            || v
+                        )
+                        : (
+                            x 
+                            && y
+                        );
+                }
+            }
+            """
+        );
+    }
 }
\ No newline at end of file

From ba38e5e44bdd16e3e6f4e774f54fa8b02b57ffee Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Fri, 16 May 2025 10:51:13 +0200
Subject: [PATCH 23/38] RS1024,RS1025,RS1026 removed from treating as Errors
 during the build

---
 .github/workflows/build.yml | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index f3c90a08ef..6165635b22 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -10,7 +10,7 @@ on:
 env:
   Configuration: Release
   TreatWarningsAsErrors: true
-  WarningsNotAsErrors: 1573,1591,NU5128
+  WarningsNotAsErrors: 1573,1591,NU5128,RS1024,RS1025,RS1026
   Deterministic: true
   RunCodeAnalysis: false
 
@@ -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:

From 6433046d06b6765c447f580929002d35418b302e Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Sun, 25 May 2025 16:51:10 +0200
Subject: [PATCH 24/38] Fixed broken .editorconfig

---
 .editorconfig                                             | 8 ++++----
 src/Common/CSharp/SyntaxTriviaAnalysis.cs                 | 2 +-
 .../CSharp/FixBracketFormattingOfListCodeFixProvider.cs   | 2 +-
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/.editorconfig b/.editorconfig
index aa35122b52..8e329bae64 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -6,16 +6,16 @@ root = true
 [*]
 indent_style = space
 
-# Code files
-[*.{cs,csx}]
-indent_size = 4
-
 [*.xml]
 indent_size = 2
 
 [Analyzers.xml]
 trim_trailing_whitespace = false
 
+# Code files
+[*.{cs,csx}]
+indent_size = 4
+
 # https://learn.microsoft.com/dotnet/fundamentals/code-analysis/style-rules/csharp-formatting-options
 
 # New-line options
diff --git a/src/Common/CSharp/SyntaxTriviaAnalysis.cs b/src/Common/CSharp/SyntaxTriviaAnalysis.cs
index 20c8580a98..ab5727b02a 100644
--- a/src/Common/CSharp/SyntaxTriviaAnalysis.cs
+++ b/src/Common/CSharp/SyntaxTriviaAnalysis.cs
@@ -174,7 +174,7 @@ public static SyntaxTrivia DetermineIndentation(SyntaxNodeOrToken nodeOrToken, b
             }
         }
 
-        if (searchInAccessors &&!IsMemberDeclarationOrStatementOrAccessorDeclaration(node))
+        if (searchInAccessors && !IsMemberDeclarationOrStatementOrAccessorDeclaration(node))
         {
             node = node.Parent;
 
diff --git a/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs b/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs
index 1711a1d117..907dd6bc14 100644
--- a/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs
+++ b/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs
@@ -195,7 +195,7 @@ CancellationToken cancellationToken
 
             string endOfLine = SyntaxTriviaAnalysis.DetermineEndOfLine(node).ToString();
 
-            List<TextChange> textChanges = new ();
+            List<TextChange> textChanges = new();
 
             if (bracesStyle.HasFlag(TargetBracesStyle.Opening))
             {

From db5d274db2df66d837bed6ebffb1e2117e8b537a Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Sun, 25 May 2025 16:57:35 +0200
Subject: [PATCH 25/38] Reverted introducing of RS1024,RS1025,RS1026 in the
 build pipeline

---
 .github/workflows/build.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 6165635b22..6de2e4167a 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -10,7 +10,7 @@ on:
 env:
   Configuration: Release
   TreatWarningsAsErrors: true
-  WarningsNotAsErrors: 1573,1591,NU5128,RS1024,RS1025,RS1026
+  WarningsNotAsErrors: 1573,1591,NU5128
   Deterministic: true
   RunCodeAnalysis: false
 

From 51809478773dfc32b9365036e8a65fdf56c6ea5f Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Sun, 25 May 2025 16:58:44 +0200
Subject: [PATCH 26/38] Fixed bitwise warning

---
 .../CSharp/FixBracketFormattingOfListCodeFixProvider.cs       | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs b/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs
index 907dd6bc14..a7d987f34c 100644
--- a/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs
+++ b/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs
@@ -197,7 +197,7 @@ CancellationToken cancellationToken
 
             List<TextChange> textChanges = new();
 
-            if (bracesStyle.HasFlag(TargetBracesStyle.Opening))
+            if ((bracesStyle & TargetBracesStyle.Opening) != 0)
             {
                 SyntaxToken nextToken = openNodeOrToken.GetNextToken();
 
@@ -217,7 +217,7 @@ CancellationToken cancellationToken
                 }
             }
 
-            if (bracesStyle.HasFlag(TargetBracesStyle.Closing))
+            if ((bracesStyle & TargetBracesStyle.Closing) != 0)
             {
                 SyntaxToken previousToken = closeNodeOrToken.GetPreviousToken();
 

From 9cd4e7ae2e30970b85dd09795052831cab10cf70 Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Sun, 25 May 2025 16:59:26 +0200
Subject: [PATCH 27/38] Fixed bitwise warning

---
 .../CSharp/FixBracketFormattingOfListAnalyzer.cs              | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs b/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs
index bd90267ae9..af3dba9fd4 100644
--- a/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs
+++ b/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs
@@ -222,7 +222,7 @@ private static bool ShouldFixOpeningBracket(
         CancellationToken cancellationToken
     )
     {
-        if (!bracesStyle.HasFlag(TargetBracesStyle.Opening))
+        if ((bracesStyle & TargetBracesStyle.Opening) == 0)
         {
             return false;
         }
@@ -238,7 +238,7 @@ private static bool ShouldFixClosingBracket(
         CancellationToken cancellationToken
     )
     {
-        if (!bracesStyle.HasFlag(TargetBracesStyle.Closing))
+        if ((bracesStyle & TargetBracesStyle.Closing) == 0)
         {
             return false;
         }

From 6e315e324858770183f5df38719984f843796e29 Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Sun, 25 May 2025 20:48:07 +0200
Subject: [PATCH 28/38] Applied dotnet format Roslynator.sln --severity info

---
 .../CSharp/CodeStyle/TargetBracesStyle.cs     |  2 +-
 .../CSharp/Extensions/CodeStyleExtensions.cs  |  4 +--
 src/Common/CSharp/SyntaxTriviaAnalysis.cs     |  5 ++--
 src/Documentation/DocumentationModel.cs       |  2 ++
 .../SymbolDocumentationProvider.cs            |  2 ++
 ...xBracketFormattingOfListCodeFixProvider.cs | 15 ++++++-----
 .../FixBracketFormattingOfListAnalyzer.cs     | 27 ++++++++++---------
 .../RCS1269FixBracketFormattingOfListTests.cs |  7 +++--
 8 files changed, 34 insertions(+), 30 deletions(-)

diff --git a/src/Common/CSharp/CodeStyle/TargetBracesStyle.cs b/src/Common/CSharp/CodeStyle/TargetBracesStyle.cs
index 5efb5c49d5..5c6ee146b9 100644
--- a/src/Common/CSharp/CodeStyle/TargetBracesStyle.cs
+++ b/src/Common/CSharp/CodeStyle/TargetBracesStyle.cs
@@ -11,4 +11,4 @@ public enum TargetBracesStyle
     Opening,
     Closing,
     Both = Opening | Closing,
-}
\ No newline at end of file
+}
diff --git a/src/Common/CSharp/Extensions/CodeStyleExtensions.cs b/src/Common/CSharp/Extensions/CodeStyleExtensions.cs
index 5d8c62f4a3..eb853672f2 100644
--- a/src/Common/CSharp/Extensions/CodeStyleExtensions.cs
+++ b/src/Common/CSharp/Extensions/CodeStyleExtensions.cs
@@ -656,8 +656,8 @@ 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 SyntaxNodeAnalysisContext context)
+        => context.GetConfigOptions().GetTargetBracesStyle();
 
     public static TargetBracesStyle GetTargetBracesStyle(this AnalyzerConfigOptions configOptions)
     {
diff --git a/src/Common/CSharp/SyntaxTriviaAnalysis.cs b/src/Common/CSharp/SyntaxTriviaAnalysis.cs
index ab5727b02a..5bc1fedd42 100644
--- a/src/Common/CSharp/SyntaxTriviaAnalysis.cs
+++ b/src/Common/CSharp/SyntaxTriviaAnalysis.cs
@@ -110,8 +110,8 @@ public static IndentationAnalysis AnalyzeIndentation(SyntaxNode node, AnalyzerCo
         return IndentationAnalysis.Create(node, configOptions, cancellationToken);
     }
 
-    public static SyntaxTrivia DetermineIndentation(SyntaxNodeOrToken nodeOrToken, CancellationToken cancellationToken = default) =>
-        DetermineIndentation(nodeOrToken, true, cancellationToken);
+    public static SyntaxTrivia DetermineIndentation(SyntaxNodeOrToken nodeOrToken, CancellationToken cancellationToken = default)
+        => DetermineIndentation(nodeOrToken, true, cancellationToken);
 
     public static SyntaxTrivia DetermineIndentation(SyntaxNodeOrToken nodeOrToken, bool searchInAccessors, CancellationToken cancellationToken = default)
     {
@@ -209,7 +209,6 @@ static bool IsMemberDeclarationOrStatementOrAccessorDeclaration(SyntaxNode node)
         }
     }
 
-
     public static string GetIncreasedIndentation(SyntaxNode node, AnalyzerConfigOptions configOptions, CancellationToken cancellationToken = default)
     {
         return AnalyzeIndentation(node, configOptions, cancellationToken).GetIncreasedIndentation();
diff --git a/src/Documentation/DocumentationModel.cs b/src/Documentation/DocumentationModel.cs
index 6372b3cf32..c9fda2e289 100644
--- a/src/Documentation/DocumentationModel.cs
+++ b/src/Documentation/DocumentationModel.cs
@@ -433,6 +433,7 @@ private Compilation FindCompilation(IAssemblySymbol assembly)
             return Compilations[0];
 
         if (_compilationMap is null)
+        {
             Interlocked.CompareExchange(
                 ref _compilationMap,
                 Compilations.ToImmutableDictionary<Compilation, IAssemblySymbol, Compilation>(
@@ -442,6 +443,7 @@ private Compilation FindCompilation(IAssemblySymbol assembly)
                 ),
                 null
             );
+        }
 
         return _compilationMap[assembly];
     }
diff --git a/src/Documentation/SymbolDocumentationProvider.cs b/src/Documentation/SymbolDocumentationProvider.cs
index d8bd7b89ca..2f75a67ae9 100644
--- a/src/Documentation/SymbolDocumentationProvider.cs
+++ b/src/Documentation/SymbolDocumentationProvider.cs
@@ -196,6 +196,7 @@ private XmlDocumentation GetXmlDocumentation(IAssemblySymbol assembly, string pr
     private MetadataReference FindMetadataReference(IAssemblySymbol assembly)
     {
         if (_assemblyToReferenceMap is null)
+        {
             Interlocked.CompareExchange(
                 ref _assemblyToReferenceMap,
                 Compilations.ToImmutableDictionary<Compilation, IAssemblySymbol, MetadataReference>(
@@ -205,6 +206,7 @@ private MetadataReference FindMetadataReference(IAssemblySymbol assembly)
                 ),
                 null
             );
+        }
 
         if (_assemblyToReferenceMap.TryGetValue(assembly, out MetadataReference metadataReference))
             return metadataReference;
diff --git a/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs b/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs
index a7d987f34c..cd3b66de14 100644
--- a/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs
+++ b/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs
@@ -24,14 +24,15 @@ public sealed class FixBracketFormattingOfListCodeFixProvider : BaseCodeFixProvi
 {
     private const string Title = "Fix bracket formatting";
 
-    public override ImmutableArray<string> FixableDiagnosticIds =>
-        ImmutableArray.Create(DiagnosticIdentifiers.FixBracketFormattingOfList);
+    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(
+        if (
+            !TryFindFirstAncestorOrSelf(
                 root,
                 context.Span,
                 out SyntaxNode node,
@@ -195,7 +196,7 @@ CancellationToken cancellationToken
 
             string endOfLine = SyntaxTriviaAnalysis.DetermineEndOfLine(node).ToString();
 
-            List<TextChange> textChanges = new();
+            List<TextChange> textChanges = [];
 
             if ((bracesStyle & TargetBracesStyle.Opening) != 0)
             {
@@ -242,7 +243,7 @@ CancellationToken cancellationToken
                     if (listNodeIndent.Span.Length != bracketIndent.Span.Length)
                     {
                         TextSpan span =
-                            bracketIndent.Span.Length == 0 // there is no indentation
+                            (bracketIndent.Span.Length == 0) // there is no indentation
                                 ? new TextSpan(closeNodeOrToken.Span.Start, 0)
                                 : bracketIndent.Span;
 
@@ -256,7 +257,7 @@ CancellationToken cancellationToken
                 }
             }
 
-            return await document.WithTextChangesAsync(textChanges, cancellationToken);
+            return await document.WithTextChangesAsync(textChanges, cancellationToken).ConfigureAwait(false);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs b/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs
index af3dba9fd4..db77d64b2a 100644
--- a/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs
+++ b/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs
@@ -172,8 +172,7 @@ SeparatedSyntaxList<TNode> nodes
 
         TNode last = nodes.Last();
 
-        if (
-            ShouldFixOpeningBracket(bracesStyle, openNodeOrToken, first, cancellationToken)
+        if (ShouldFixOpeningBracket(bracesStyle, openNodeOrToken, first, cancellationToken)
             || ShouldFixClosingBracket(bracesStyle, listNode, closeNodeOrToken, last, cancellationToken)
         )
         {
@@ -186,18 +185,19 @@ SeparatedSyntaxList<TNode> nodes
         }
     }
 
-    private static string GetTitle(SyntaxNode listNode) =>
-        listNode.Kind() switch
+    private static string GetTitle(SyntaxNode listNode)
+    {
+        return listNode.Kind() switch
         {
             SyntaxKind.ParameterList
-            or SyntaxKind.BracketedParameterList
-            or SyntaxKind.TypeParameterList
+                or SyntaxKind.BracketedParameterList
+                or SyntaxKind.TypeParameterList
                 => "parameters",
 
             SyntaxKind.ArgumentList
-            or SyntaxKind.BracketedArgumentList
-            or SyntaxKind.AttributeArgumentList
-            or SyntaxKind.TypeArgumentList
+                or SyntaxKind.BracketedArgumentList
+                or SyntaxKind.AttributeArgumentList
+                or SyntaxKind.TypeArgumentList
                 => "arguments",
 
             SyntaxKind.AttributeList => "attributes",
@@ -207,13 +207,14 @@ or SyntaxKind.TypeArgumentList
             SyntaxKind.CollectionExpression => "a collection expression",
 
             SyntaxKind.ArrayInitializerExpression
-            or SyntaxKind.CollectionInitializerExpression
-            or SyntaxKind.ComplexElementInitializerExpression
-            or SyntaxKind.ObjectInitializerExpression
+                or SyntaxKind.CollectionInitializerExpression
+                or SyntaxKind.ComplexElementInitializerExpression
+                or SyntaxKind.ObjectInitializerExpression
                 => "an initializer",
 
             _ => throw new InvalidOperationException()
         };
+    }
 
     private static bool ShouldFixOpeningBracket(
         TargetBracesStyle bracesStyle,
@@ -252,4 +253,4 @@ CancellationToken cancellationToken
         SyntaxTrivia bracketIndent = SyntaxTriviaAnalysis.DetermineIndentation(rightBracket, searchInAccessors: false, cancellationToken);
         return listNodeIndent.Span.Length != bracketIndent.Span.Length;
     }
-}
\ No newline at end of file
+}
diff --git a/src/Tests/Formatting.Analyzers.Tests/RCS1269FixBracketFormattingOfListTests.cs b/src/Tests/Formatting.Analyzers.Tests/RCS1269FixBracketFormattingOfListTests.cs
index ff098795bd..b01b18a6fb 100644
--- a/src/Tests/Formatting.Analyzers.Tests/RCS1269FixBracketFormattingOfListTests.cs
+++ b/src/Tests/Formatting.Analyzers.Tests/RCS1269FixBracketFormattingOfListTests.cs
@@ -13,9 +13,8 @@ public sealed class RCS1269FixBracketFormattingOfListTests :
 {
     public override DiagnosticDescriptor Descriptor { get; } = DiagnosticRules.FixBracketFormattingOfList;
 
-    public override CSharpTestOptions Options =>
-        base.Options.AddConfigOption(ConfigOptionKeys.TargetBracesStyle, "both");
-
+    public override CSharpTestOptions Options
+        => base.Options.AddConfigOption(ConfigOptionKeys.TargetBracesStyle, "both");
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
     public async Task Test_Singleline_AlignedToParenthesis()
@@ -1161,7 +1160,7 @@ internal static void Method(Foo[] foo)
                             }
                             """,
                         expectedSource: null
-                    )
+                    ),
                 },
             options: Options.WithCompilationOptions(Options.CompilationOptions.WithOutputKind(OutputKind.ConsoleApplication))
         );

From 6ffaf600f6c9dbf0e0c0dd659473d000659d4165 Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Sun, 25 May 2025 21:00:43 +0200
Subject: [PATCH 29/38] Fixed use specific type formatting issue

---
 .../CSharp/FixBracketFormattingOfListCodeFixProvider.cs         | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs b/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs
index cd3b66de14..4edc48a1c4 100644
--- a/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs
+++ b/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs
@@ -196,7 +196,7 @@ CancellationToken cancellationToken
 
             string endOfLine = SyntaxTriviaAnalysis.DetermineEndOfLine(node).ToString();
 
-            List<TextChange> textChanges = [];
+            var textChanges = new List<TextChange>();
 
             if ((bracesStyle & TargetBracesStyle.Opening) != 0)
             {

From 73f2724d47f0579d52323754761a722ac37a6551 Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Thu, 29 May 2025 14:56:20 +0200
Subject: [PATCH 30/38] Fixed typo complains from the  build

---
 .../RCS1269FixBracketFormattingOfListTests.cs                 | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Tests/Formatting.Analyzers.Tests/RCS1269FixBracketFormattingOfListTests.cs b/src/Tests/Formatting.Analyzers.Tests/RCS1269FixBracketFormattingOfListTests.cs
index b01b18a6fb..99a342476a 100644
--- a/src/Tests/Formatting.Analyzers.Tests/RCS1269FixBracketFormattingOfListTests.cs
+++ b/src/Tests/Formatting.Analyzers.Tests/RCS1269FixBracketFormattingOfListTests.cs
@@ -43,7 +43,7 @@ void M(
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
-    public async Task Test_Singleline_Unindentated()
+    public async Task Test_Singleline_Unindented()
     {
         await VerifyDiagnosticAndFixAsync(
             """
@@ -345,7 +345,7 @@ object p4
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfList)]
-    public async Task Test_Multiline_ClosingBracket_Indent_Required_with_prio_comment()
+    public async Task Test_Multiline_ClosingBracket_Indent_Required_with_comment()
     {
         await VerifyDiagnosticAndFixAsync(
             """

From da052e02cfe7ad3d9bd6e12d24ec8e362243e584 Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Thu, 29 May 2025 15:29:47 +0200
Subject: [PATCH 31/38] SyntaxKind.CollectionExpression excluded for earlier
 Roslyn versions

---
 .../CSharp/FixBracketFormattingOfListCodeFixProvider.cs     | 2 ++
 .../CSharp/FixBracketFormattingOfListAnalyzer.cs            | 6 ++++--
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs b/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs
index 4edc48a1c4..a3ed30c181 100644
--- a/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs
+++ b/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs
@@ -52,7 +52,9 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
                         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;
diff --git a/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs b/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs
index db77d64b2a..e2a0b84b17 100644
--- a/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs
+++ b/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs
@@ -45,7 +45,9 @@ public override void Initialize(AnalysisContext context)
         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),
@@ -203,9 +205,9 @@ or SyntaxKind.TypeArgumentList
             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

From 5d417fa60cd9f0c7282bf9424610346d9a2042c9 Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Thu, 29 May 2025 15:44:43 +0200
Subject: [PATCH 32/38] Updated change log

---
 src/VisualStudioCode/package/CHANGELOG.md | 4 ++++
 1 file changed, 4 insertions(+)

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

From b102a308f12a9de73d5c821ee148d02f0f69507f Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Thu, 29 May 2025 16:37:38 +0200
Subject: [PATCH 33/38] Added potential fix for the build

---
 .github/workflows/build.yml | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 6de2e4167a..d78bcd3243 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -209,6 +209,9 @@ jobs:
         working-directory: src/VisualStudioCode
     steps:
       - uses: actions/checkout@v4
+      - uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: 9.0.300
       - 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.300
       - run: dotnet restore
       - run: dotnet build --no-restore
       - run: dotnet pack --no-build

From d16da298c06b746f04ef1862c90509093c791f55 Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Tue, 3 Jun 2025 12:59:43 +0200
Subject: [PATCH 34/38] CollectionExpressionSyntax excluded for earlier Roslyn
 versions

---
 .../CSharp/FixBracketFormattingOfListCodeFixProvider.cs         | 2 ++
 .../CSharp/FixBracketFormattingOfListAnalyzer.cs                | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs b/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs
index a3ed30c181..877b801f8a 100644
--- a/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs
+++ b/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfListCodeFixProvider.cs
@@ -166,6 +166,7 @@ CodeAction CreateCodeAction()
                         GetEquivalenceKey(diagnostic)
                     );
                 }
+#if ROSLYN_4_7
                 case CollectionExpressionSyntax collectionExpression:
                 {
                     return CodeAction.Create(
@@ -174,6 +175,7 @@ CodeAction CreateCodeAction()
                         GetEquivalenceKey(diagnostic)
                     );
                 }
+#endif
                 default:
                 {
                     throw new InvalidOperationException();
diff --git a/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs b/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs
index e2a0b84b17..44b5dd8240 100644
--- a/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs
+++ b/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfListAnalyzer.cs
@@ -135,12 +135,14 @@ private static void AnalyzeInitializerExpression(SyntaxNodeAnalysisContext conte
         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,

From 8257badccbe19f7f189438246a4fb3e23de3a409 Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Sun, 8 Jun 2025 15:19:24 +0200
Subject: [PATCH 35/38] A try to fix the build

---
 .github/workflows/build.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index d78bcd3243..e51910ea9c 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -266,7 +266,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: 9.0.300
+          dotnet-version: 9.0.203
       - run: dotnet restore
       - run: dotnet build --no-restore
       - run: dotnet pack --no-build

From 12e521176ba8364bac7ea1edb0b26cb7073687a1 Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Wed, 25 Jun 2025 14:09:04 +0200
Subject: [PATCH 36/38] Revert "A try to fix the build"

This reverts commit 8257badccbe19f7f189438246a4fb3e23de3a409.
---
 .github/workflows/build.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index e51910ea9c..d78bcd3243 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -266,7 +266,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: 9.0.203
+          dotnet-version: 9.0.300
       - run: dotnet restore
       - run: dotnet build --no-restore
       - run: dotnet pack --no-build

From d4c06c12abb865b06cc1a5fa81718945c9b356cf Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Wed, 25 Jun 2025 14:10:39 +0200
Subject: [PATCH 37/38] Updated .net version for the installation

---
 .github/workflows/build.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index d78bcd3243..ae7e800a61 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -211,7 +211,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: 9.0.300
+          dotnet-version: 9.0.301
       - run: dotnet restore
       - run: dotnet build --no-restore
       - run: |
@@ -266,7 +266,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: 9.0.300
+          dotnet-version: 9.0.301
       - run: dotnet restore
       - run: dotnet build --no-restore
       - run: dotnet pack --no-build

From 1baac2e4c46de2c18e298963f0f87f2f1c1baf4a Mon Sep 17 00:00:00 2001
From: Andrei Shenets <shenets.andrei@gmail.com>
Date: Sat, 5 Jul 2025 14:27:49 +0200
Subject: [PATCH 38/38] Fixing formatting

---
 ...FormattingOfBinaryExpressionFixProvider.cs | 16 ++++++------
 ...ketFormattingOfBinaryExpressionAnalyzer.cs | 25 ++++++++-----------
 ...racketFormattingOfBinaryExpressionTests.cs | 10 ++++----
 src/VisualStudioCode/package/CHANGELOG.md     |  3 ++-
 4 files changed, 26 insertions(+), 28 deletions(-)

diff --git a/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfBinaryExpressionFixProvider.cs b/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfBinaryExpressionFixProvider.cs
index f2f6b51adc..21b019fcf4 100644
--- a/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfBinaryExpressionFixProvider.cs
+++ b/src/Formatting.Analyzers.CodeFixes/CSharp/FixBracketFormattingOfBinaryExpressionFixProvider.cs
@@ -24,8 +24,8 @@ public sealed class FixBracketFormattingOfBinaryExpressionFixProvider : BaseCode
 {
     private const string Title = "Fix bracket formatting";
 
-    public override ImmutableArray<string> FixableDiagnosticIds =>
-        ImmutableArray.Create(DiagnosticIdentifiers.FixBracketFormattingOfBinaryExpression);
+    public override ImmutableArray<string> FixableDiagnosticIds
+        => ImmutableArray.Create(DiagnosticIdentifiers.FixBracketFormattingOfBinaryExpression);
 
     public override async Task RegisterCodeFixesAsync(CodeFixContext context)
     {
@@ -121,9 +121,9 @@ CancellationToken cancellationToken
 
             string endOfLine = SyntaxTriviaAnalysis.DetermineEndOfLine(node).ToString();
 
-            List<TextChange> textChanges = new ();
+            List<TextChange> textChanges = [];
 
-            if (bracesStyle.HasFlag(TargetBracesStyle.Opening))
+            if ((bracesStyle & TargetBracesStyle.Opening) != 0)
             {
                 SyntaxToken nextToken = openNodeOrToken.GetNextToken();
 
@@ -143,7 +143,7 @@ CancellationToken cancellationToken
                 }
             }
 
-            if (bracesStyle.HasFlag(TargetBracesStyle.Closing))
+            if ((bracesStyle & TargetBracesStyle.Closing) != 0)
             {
                 SyntaxToken previousToken = closeNodeOrToken.GetPreviousToken();
 
@@ -168,7 +168,7 @@ CancellationToken cancellationToken
                     if (listNodeIndent.Span.Length != bracketIndent.Span.Length)
                     {
                         TextSpan span =
-                            bracketIndent.Span.Length == 0 // there is no indentation
+                            (bracketIndent.Span.Length == 0) // there is no indentation
                                 ? new TextSpan(closeNodeOrToken.Span.Start, 0)
                                 : bracketIndent.Span;
 
@@ -182,7 +182,7 @@ CancellationToken cancellationToken
                 }
             }
 
-            return await document.WithTextChangesAsync(textChanges, cancellationToken);
+            return await document.WithTextChangesAsync(textChanges, cancellationToken).ConfigureAwait(false);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfBinaryExpressionAnalyzer.cs b/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfBinaryExpressionAnalyzer.cs
index 78936e9c49..a86b83dc08 100644
--- a/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfBinaryExpressionAnalyzer.cs
+++ b/src/Formatting.Analyzers/CSharp/FixBracketFormattingOfBinaryExpressionAnalyzer.cs
@@ -74,7 +74,7 @@ private static void AnalyzeBinaryExpression(SyntaxNodeAnalysisContext context)
 
         CancellationToken cancellationToken = context.CancellationToken;
 
-        BinaryExpressionSyntax binaryExpression = (BinaryExpressionSyntax)context.Node;
+        var binaryExpression = (BinaryExpressionSyntax)context.Node;
 
         ExpressionSyntax left = binaryExpression.Left;
 
@@ -105,8 +105,7 @@ private static void AnalyzeBinaryExpression(SyntaxNodeAnalysisContext context)
                 continue;
             }
 
-            if (
-                ShouldFixOpeningBracket(bracesStyle, openBracket, firstToken, cancellationToken)
+            if (ShouldFixOpeningBracket(bracesStyle, openBracket, firstToken, cancellationToken)
                 || ShouldFixClosingBracket(bracesStyle, parent, closeBracket, lastToken, cancellationToken)
             )
             {
@@ -146,9 +145,9 @@ private static void AnalyzeBinaryExpression(SyntaxNodeAnalysisContext context)
 
         SyntaxNode? parent = syntaxNode;
         int depth = 0;
-        while (parent != null)
+        while (parent is not null)
         {
-            bool stop = false;
+            var stop = false;
 
             switch (parent)
             {
@@ -159,7 +158,6 @@ private static void AnalyzeBinaryExpression(SyntaxNodeAnalysisContext context)
                         parenthesizedExpressionSyntax.CloseParenToken
                     );
                     break;
-
                 case IfStatementSyntax ifStatement:
                     yield return (
                         parent,
@@ -169,7 +167,6 @@ private static void AnalyzeBinaryExpression(SyntaxNodeAnalysisContext context)
                     // If-statement is considered as a final node.
                     stop = true;
                     break;
-
                 case WhileStatementSyntax whileStatement:
                     yield return (
                         parent,
@@ -179,7 +176,6 @@ private static void AnalyzeBinaryExpression(SyntaxNodeAnalysisContext context)
                     // While-statement is considered as a final node.
                     stop = true;
                     break;
-
                 case DoStatementSyntax doWhileStatement:
                     yield return (
                         parent,
@@ -189,7 +185,6 @@ private static void AnalyzeBinaryExpression(SyntaxNodeAnalysisContext context)
                     // Do-while-statement is considered as a final node.
                     stop = true;
                     break;
-
                 default:
                     if (depth > 0)
                     {
@@ -209,8 +204,9 @@ private static void AnalyzeBinaryExpression(SyntaxNodeAnalysisContext context)
         }
     }
 
-    private static string GetTitle(SyntaxNode node) =>
-        node.Kind() switch
+    private static string GetTitle(SyntaxNode node)
+    {
+        return node.Kind() switch
         {
             SyntaxKind.IfStatement
                 => "an 'if' statement",
@@ -226,6 +222,7 @@ private static string GetTitle(SyntaxNode node) =>
 
             _ => throw new InvalidOperationException()
         };
+    }
 
     private static bool ShouldFixOpeningBracket(
         TargetBracesStyle bracesStyle,
@@ -234,7 +231,7 @@ private static bool ShouldFixOpeningBracket(
         CancellationToken cancellationToken
     )
     {
-        if (!bracesStyle.HasFlag(TargetBracesStyle.Opening))
+        if ((bracesStyle & TargetBracesStyle.Opening) == 0)
         {
             return false;
         }
@@ -250,7 +247,7 @@ private static bool ShouldFixClosingBracket(
         CancellationToken cancellationToken
     )
     {
-        if (!bracesStyle.HasFlag(TargetBracesStyle.Closing))
+        if ((bracesStyle & TargetBracesStyle.Closing) == 0)
         {
             return false;
         }
@@ -267,4 +264,4 @@ CancellationToken cancellationToken
 
         return listNodeIndent.Span.Length != bracketIndent.Span.Length;
     }
-}
\ No newline at end of file
+}
diff --git a/src/Tests/Formatting.Analyzers.Tests/RCS1270FixBracketFormattingOfBinaryExpressionTests.cs b/src/Tests/Formatting.Analyzers.Tests/RCS1270FixBracketFormattingOfBinaryExpressionTests.cs
index 4068cc1857..9b5e10707d 100644
--- a/src/Tests/Formatting.Analyzers.Tests/RCS1270FixBracketFormattingOfBinaryExpressionTests.cs
+++ b/src/Tests/Formatting.Analyzers.Tests/RCS1270FixBracketFormattingOfBinaryExpressionTests.cs
@@ -8,13 +8,13 @@
 
 namespace Roslynator.Formatting.CSharp.Tests;
 
-public class RCS1270FixBracketFormattingOfBinaryExpressionTests
-    : AbstractCSharpDiagnosticVerifier<FixBracketFormattingOfBinaryExpressionAnalyzer, FixBracketFormattingOfBinaryExpressionFixProvider>
+public class RCS1270FixBracketFormattingOfBinaryExpressionTests :
+    AbstractCSharpDiagnosticVerifier<FixBracketFormattingOfBinaryExpressionAnalyzer, FixBracketFormattingOfBinaryExpressionFixProvider>
 {
     public override DiagnosticDescriptor Descriptor { get; } = DiagnosticRules.FixBracketFormattingOfBinaryExpression;
 
-    public override CSharpTestOptions Options =>
-        base.Options.AddConfigOption(ConfigOptionKeys.TargetBracesStyle, "both");
+    public override CSharpTestOptions Options
+        => base.Options.AddConfigOption(ConfigOptionKeys.TargetBracesStyle, "both");
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixBracketFormattingOfBinaryExpression)]
     public async Task Inserts_new_line_Before_and_After_binary_expression()
@@ -748,4 +748,4 @@ void M()
             """
         );
     }
-}
\ No newline at end of file
+}
diff --git a/src/VisualStudioCode/package/CHANGELOG.md b/src/VisualStudioCode/package/CHANGELOG.md
index 69c6e93495..ba640d1e31 100644
--- a/src/VisualStudioCode/package/CHANGELOG.md
+++ b/src/VisualStudioCode/package/CHANGELOG.md
@@ -9,7 +9,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
-- Analyzer and fixer for bracket formatting  [RCS1269](https://josefpihrt.github.io/docs/roslynator/analyzers/RCS1269) ([PR](https://github.com/dotnet/roslynator/pull/1643))
+- Analyzer and fixer for bracket formatting for list expressions [RCS1269](https://josefpihrt.github.io/docs/roslynator/analyzers/RCS1269) ([PR](https://github.com/dotnet/roslynator/pull/1643))
+- Analyzer and fixed for bracket formatting for binary expressions [RCS1269](https://josefpihrt.github.io/docs/roslynator/analyzers/RCS1270) ([PR](https://github.com/dotnet/roslynator/pull/1650))
 
 ## [4.13.1] - 2025-02-23