Fix analyzer RCS1206 (#1685)

josefpihrt · web-flow · commit cf65e2b4b6c1 · 2025-08-31T16:06:11.000+02:00
diff --git a/ChangeLog.md b/ChangeLog.md
@@ -24,6 +24,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Fix analyzer [RCS1253](https://josefpihrt.github.io/docs/roslynator/analyzers/RCS1253) ([PR](https://github.com/dotnet/roslynator/pull/1687))
 - Fix refactoring [Check expression for null](https://josefpihrt.github.io/docs/roslynator/refactorings/RR0024) ([PR](https://github.com/dotnet/roslynator/pull/1682))
 
+### Changed
+
+- Change behavior of analyzer [RCS1206](https://josefpihrt.github.io/docs/roslynator/analyzers/RCS1206) ([PR](https://github.com/dotnet/roslynator/pull/1685))
+  - The condition for option `omit_when_single_line` will be that the braces/brackets are on the same line, not just the expression in the braces/brackets
+
 ## [4.14.0] - 2025-07-26
 
 ### Added
diff --git a/src/Analyzers/CSharp/Analysis/AddOrRemoveTrailingCommaAnalyzer.cs b/src/Analyzers/CSharp/Analysis/AddOrRemoveTrailingCommaAnalyzer.cs
@@ -69,7 +69,7 @@ private static void AnalyzeInitializerExpression(SyntaxNodeAnalysisContext conte
                 ReportRemove(context, expressions.GetSeparator(count - 1));
             }
             else if (style == TrailingCommaStyle.OmitWhenSingleLine
-                && expressions.IsSingleLine(cancellationToken: context.CancellationToken))
+                && initializer.IsSingleLine(cancellationToken: context.CancellationToken))
             {
                 ReportRemove(context, expressions.GetSeparator(count - 1));
             }
@@ -81,7 +81,7 @@ private static void AnalyzeInitializerExpression(SyntaxNodeAnalysisContext conte
                 ReportAdd(context, expressions.Last());
             }
             else if (style == TrailingCommaStyle.OmitWhenSingleLine
-                && !expressions.IsSingleLine(cancellationToken: context.CancellationToken))
+                && !initializer.IsSingleLine(cancellationToken: context.CancellationToken))
             {
                 ReportAdd(context, expressions.Last());
             }
@@ -104,6 +104,7 @@ private static void AnalyzeEnumDeclaration(SyntaxNodeAnalysisContext context)
 
         int count = members.Count;
         int separatorCount = members.SeparatorCount;
+        TextSpan bracesSpan = TextSpan.FromBounds(enumDeclaration.OpenBraceToken.SpanStart, enumDeclaration.CloseBraceToken.Span.End);
 
         if (count == separatorCount)
         {
@@ -112,7 +113,7 @@ private static void AnalyzeEnumDeclaration(SyntaxNodeAnalysisContext context)
                 ReportRemove(context, members.GetSeparator(count - 1));
             }
             else if (style == TrailingCommaStyle.OmitWhenSingleLine
-                && members.IsSingleLine(cancellationToken: context.CancellationToken))
+                && bracesSpan.IsSingleLine(enumDeclaration.SyntaxTree, cancellationToken: context.CancellationToken))
             {
                 ReportRemove(context, members.GetSeparator(count - 1));
             }
@@ -124,7 +125,7 @@ private static void AnalyzeEnumDeclaration(SyntaxNodeAnalysisContext context)
                 ReportAdd(context, members.Last());
             }
             else if (style == TrailingCommaStyle.OmitWhenSingleLine
-                && !members.IsSingleLine(cancellationToken: context.CancellationToken))
+                && !bracesSpan.IsSingleLine(enumDeclaration.SyntaxTree, cancellationToken: context.CancellationToken))
             {
                 ReportAdd(context, members.Last());
             }
@@ -147,6 +148,7 @@ private static void AnalyzeAnonymousObjectCreationExpression(SyntaxNodeAnalysisC
 
         int count = initializers.Count;
         int separatorCount = initializers.SeparatorCount;
+        TextSpan bracesSpan = TextSpan.FromBounds(objectCreation.OpenBraceToken.SpanStart, objectCreation.CloseBraceToken.Span.End);
 
         if (count == separatorCount)
         {
@@ -155,7 +157,7 @@ private static void AnalyzeAnonymousObjectCreationExpression(SyntaxNodeAnalysisC
                 ReportRemove(context, initializers.GetSeparator(count - 1));
             }
             else if (style == TrailingCommaStyle.OmitWhenSingleLine
-                && initializers.IsSingleLine(cancellationToken: context.CancellationToken))
+                && bracesSpan.IsSingleLine(objectCreation.SyntaxTree, cancellationToken: context.CancellationToken))
             {
                 ReportRemove(context, initializers.GetSeparator(count - 1));
             }
@@ -167,7 +169,7 @@ private static void AnalyzeAnonymousObjectCreationExpression(SyntaxNodeAnalysisC
                 ReportAdd(context, initializers.Last());
             }
             else if (style == TrailingCommaStyle.OmitWhenSingleLine
-                && !initializers.IsSingleLine(cancellationToken: context.CancellationToken))
+                && !bracesSpan.IsSingleLine(objectCreation.SyntaxTree, cancellationToken: context.CancellationToken))
             {
                 ReportAdd(context, initializers.Last());
             }
@@ -181,15 +183,16 @@ private static void AnalyzeSwitchExpression(SyntaxNodeAnalysisContext context)
         if (style == TrailingCommaStyle.None)
             return;
 
-        var objectCreation = (SwitchExpressionSyntax)context.Node;
+        var switchExpression = (SwitchExpressionSyntax)context.Node;
 
-        SeparatedSyntaxList<SwitchExpressionArmSyntax> arms = objectCreation.Arms;
+        SeparatedSyntaxList<SwitchExpressionArmSyntax> arms = switchExpression.Arms;
 
         if (!arms.Any())
             return;
 
         int count = arms.Count;
         int separatorCount = arms.SeparatorCount;
+        TextSpan bracesSpan = TextSpan.FromBounds(switchExpression.OpenBraceToken.SpanStart, switchExpression.CloseBraceToken.Span.End);
 
         if (count == separatorCount)
         {
@@ -198,7 +201,7 @@ private static void AnalyzeSwitchExpression(SyntaxNodeAnalysisContext context)
                 ReportRemove(context, arms.GetSeparator(count - 1));
             }
             else if (style == TrailingCommaStyle.OmitWhenSingleLine
-                && arms.IsSingleLine(cancellationToken: context.CancellationToken))
+                && bracesSpan.IsSingleLine(switchExpression.SyntaxTree, cancellationToken: context.CancellationToken))
             {
                 ReportRemove(context, arms.GetSeparator(count - 1));
             }
@@ -210,7 +213,7 @@ private static void AnalyzeSwitchExpression(SyntaxNodeAnalysisContext context)
                 ReportAdd(context, arms.Last());
             }
             else if (style == TrailingCommaStyle.OmitWhenSingleLine
-                && !arms.IsSingleLine(cancellationToken: context.CancellationToken))
+                && !bracesSpan.IsSingleLine(switchExpression.SyntaxTree, cancellationToken: context.CancellationToken))
             {
                 ReportAdd(context, arms.Last());
             }
@@ -224,15 +227,16 @@ private static void AnalyzePropertyPatternClause(SyntaxNodeAnalysisContext conte
         if (style == TrailingCommaStyle.None)
             return;
 
-        var objectCreation = (PropertyPatternClauseSyntax)context.Node;
+        var patternClause = (PropertyPatternClauseSyntax)context.Node;
 
-        SeparatedSyntaxList<SubpatternSyntax> subpatterns = objectCreation.Subpatterns;
+        SeparatedSyntaxList<SubpatternSyntax> subpatterns = patternClause.Subpatterns;
 
         if (!subpatterns.Any())
             return;
 
         int count = subpatterns.Count;
         int separatorCount = subpatterns.SeparatorCount;
+        TextSpan bracesSpan = TextSpan.FromBounds(patternClause.OpenBraceToken.SpanStart, patternClause.CloseBraceToken.Span.End);
 
         if (count == separatorCount)
         {
@@ -241,7 +245,7 @@ private static void AnalyzePropertyPatternClause(SyntaxNodeAnalysisContext conte
                 ReportRemove(context, subpatterns.GetSeparator(count - 1));
             }
             else if (style == TrailingCommaStyle.OmitWhenSingleLine
-                && subpatterns.IsSingleLine(cancellationToken: context.CancellationToken))
+                && bracesSpan.IsSingleLine(patternClause.SyntaxTree, cancellationToken: context.CancellationToken))
             {
                 ReportRemove(context, subpatterns.GetSeparator(count - 1));
             }
@@ -253,7 +257,7 @@ private static void AnalyzePropertyPatternClause(SyntaxNodeAnalysisContext conte
                 ReportAdd(context, subpatterns.Last());
             }
             else if (style == TrailingCommaStyle.OmitWhenSingleLine
-                && !subpatterns.IsSingleLine(cancellationToken: context.CancellationToken))
+                && !bracesSpan.IsSingleLine(patternClause.SyntaxTree, cancellationToken: context.CancellationToken))
             {
                 ReportAdd(context, subpatterns.Last());
             }
@@ -268,15 +272,16 @@ private static void AnalyzeCollectionExpression(SyntaxNodeAnalysisContext contex
         if (style == TrailingCommaStyle.None)
             return;
 
-        var objectCreation = (CollectionExpressionSyntax)context.Node;
+        var collectionExpression = (CollectionExpressionSyntax)context.Node;
 
-        SeparatedSyntaxList<CollectionElementSyntax> elements = objectCreation.Elements;
+        SeparatedSyntaxList<CollectionElementSyntax> elements = collectionExpression.Elements;
 
         if (!elements.Any())
             return;
 
         int count = elements.Count;
         int separatorCount = elements.SeparatorCount;
+        TextSpan bracesSpan = TextSpan.FromBounds(collectionExpression.OpenBracketToken.SpanStart, collectionExpression.CloseBracketToken.Span.End);
 
         if (count == separatorCount)
         {
@@ -285,7 +290,7 @@ private static void AnalyzeCollectionExpression(SyntaxNodeAnalysisContext contex
                 ReportRemove(context, elements.GetSeparator(count - 1));
             }
             else if (style == TrailingCommaStyle.OmitWhenSingleLine
-                && elements.IsSingleLine(cancellationToken: context.CancellationToken))
+                && bracesSpan.IsSingleLine(collectionExpression.SyntaxTree, cancellationToken: context.CancellationToken))
             {
                 ReportRemove(context, elements.GetSeparator(count - 1));
             }
@@ -297,7 +302,7 @@ private static void AnalyzeCollectionExpression(SyntaxNodeAnalysisContext contex
                 ReportAdd(context, elements.Last());
             }
             else if (style == TrailingCommaStyle.OmitWhenSingleLine
-                && !elements.IsSingleLine(cancellationToken: context.CancellationToken))
+                && !bracesSpan.IsSingleLine(collectionExpression.SyntaxTree, cancellationToken: context.CancellationToken))
             {
                 ReportAdd(context, elements.Last());
             }
diff --git a/src/Tests/Analyzers.Tests/RCS1260AddOrRemoveTrailingCommaTests.cs b/src/Tests/Analyzers.Tests/RCS1260AddOrRemoveTrailingCommaTests.cs
@@ -108,6 +108,56 @@ void M()
 """, options: Options.AddConfigOption(ConfigOptionKeys.TrailingCommaStyle, ConfigOptionValues.TrailingCommaStyle_Include));
     }
 
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.AddOrRemoveTrailingComma)]
+    public async Task Test_ArrayInitializer_OmitWhenSingleLine()
+    {
+        await VerifyDiagnosticAndFixAsync("""
+class C
+{
+    void M()
+    {
+        var arr = new[]
+        {
+            ""[||]
+        };
+    }
+}
+""", """
+class C
+{
+    void M()
+    {
+        var arr = new[]
+        {
+            "",
+        };
+    }
+}
+""", options: Options.AddConfigOption(ConfigOptionKeys.TrailingCommaStyle, ConfigOptionValues.TrailingCommaStyle_OmitWhenSingleLine));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.AddOrRemoveTrailingComma)]
+    public async Task Test_ArrayInitializer_OmitWhenSingleLine2()
+    {
+        await VerifyDiagnosticAndFixAsync("""
+class C
+{
+    void M()
+    {
+        var arr = new[] { ""[|,|] };
+    }
+}
+""", """
+class C
+{
+    void M()
+    {
+        var arr = new[] { "" };
+    }
+}
+""", options: Options.AddConfigOption(ConfigOptionKeys.TrailingCommaStyle, ConfigOptionValues.TrailingCommaStyle_OmitWhenSingleLine));
+    }
+
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.AddOrRemoveTrailingComma)]
     public async Task Test_ArrayInitializer_Omit()
     {

Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,7 @@ private static void AnalyzeInitializerExpression(SyntaxNodeAnalysisContext conte`
`69`	`69`	`ReportRemove(context, expressions.GetSeparator(count - 1));`
`70`	`70`	`}`
`71`	`71`	`else if (style == TrailingCommaStyle.OmitWhenSingleLine`
`72`		`- && expressions.IsSingleLine(cancellationToken: context.CancellationToken))`
	`72`	`+ && initializer.IsSingleLine(cancellationToken: context.CancellationToken))`
`73`	`73`	`{`
`74`	`74`	`ReportRemove(context, expressions.GetSeparator(count - 1));`
`75`	`75`	`}`
`@@ -81,7 +81,7 @@ private static void AnalyzeInitializerExpression(SyntaxNodeAnalysisContext conte`
`81`	`81`	`ReportAdd(context, expressions.Last());`
`82`	`82`	`}`
`83`	`83`	`else if (style == TrailingCommaStyle.OmitWhenSingleLine`
`84`		`- && !expressions.IsSingleLine(cancellationToken: context.CancellationToken))`
	`84`	`+ && !initializer.IsSingleLine(cancellationToken: context.CancellationToken))`
`85`	`85`	`{`
`86`	`86`	`ReportAdd(context, expressions.Last());`
`87`	`87`	`}`
`@@ -104,6 +104,7 @@ private static void AnalyzeEnumDeclaration(SyntaxNodeAnalysisContext context)`
`104`	`104`
`105`	`105`	`int count = members.Count;`
`106`	`106`	`int separatorCount = members.SeparatorCount;`
	`107`	`+ TextSpan bracesSpan = TextSpan.FromBounds(enumDeclaration.OpenBraceToken.SpanStart, enumDeclaration.CloseBraceToken.Span.End);`
`107`	`108`
`108`	`109`	`if (count == separatorCount)`
`109`	`110`	`{`
`@@ -112,7 +113,7 @@ private static void AnalyzeEnumDeclaration(SyntaxNodeAnalysisContext context)`
`112`	`113`	`ReportRemove(context, members.GetSeparator(count - 1));`
`113`	`114`	`}`
`114`	`115`	`else if (style == TrailingCommaStyle.OmitWhenSingleLine`
`115`		`- && members.IsSingleLine(cancellationToken: context.CancellationToken))`
	`116`	`+ && bracesSpan.IsSingleLine(enumDeclaration.SyntaxTree, cancellationToken: context.CancellationToken))`
`116`	`117`	`{`
`117`	`118`	`ReportRemove(context, members.GetSeparator(count - 1));`
`118`	`119`	`}`
`@@ -124,7 +125,7 @@ private static void AnalyzeEnumDeclaration(SyntaxNodeAnalysisContext context)`
`124`	`125`	`ReportAdd(context, members.Last());`
`125`	`126`	`}`
`126`	`127`	`else if (style == TrailingCommaStyle.OmitWhenSingleLine`
`127`		`- && !members.IsSingleLine(cancellationToken: context.CancellationToken))`
	`128`	`+ && !bracesSpan.IsSingleLine(enumDeclaration.SyntaxTree, cancellationToken: context.CancellationToken))`
`128`	`129`	`{`
`129`	`130`	`ReportAdd(context, members.Last());`
`130`	`131`	`}`
`@@ -147,6 +148,7 @@ private static void AnalyzeAnonymousObjectCreationExpression(SyntaxNodeAnalysisC`
`147`	`148`
`148`	`149`	`int count = initializers.Count;`
`149`	`150`	`int separatorCount = initializers.SeparatorCount;`
	`151`	`+ TextSpan bracesSpan = TextSpan.FromBounds(objectCreation.OpenBraceToken.SpanStart, objectCreation.CloseBraceToken.Span.End);`
`150`	`152`
`151`	`153`	`if (count == separatorCount)`
`152`	`154`	`{`
`@@ -155,7 +157,7 @@ private static void AnalyzeAnonymousObjectCreationExpression(SyntaxNodeAnalysisC`
`155`	`157`	`ReportRemove(context, initializers.GetSeparator(count - 1));`
`156`	`158`	`}`
`157`	`159`	`else if (style == TrailingCommaStyle.OmitWhenSingleLine`
`158`		`- && initializers.IsSingleLine(cancellationToken: context.CancellationToken))`
	`160`	`+ && bracesSpan.IsSingleLine(objectCreation.SyntaxTree, cancellationToken: context.CancellationToken))`
`159`	`161`	`{`
`160`	`162`	`ReportRemove(context, initializers.GetSeparator(count - 1));`
`161`	`163`	`}`
`@@ -167,7 +169,7 @@ private static void AnalyzeAnonymousObjectCreationExpression(SyntaxNodeAnalysisC`
`167`	`169`	`ReportAdd(context, initializers.Last());`
`168`	`170`	`}`
`169`	`171`	`else if (style == TrailingCommaStyle.OmitWhenSingleLine`
`170`		`- && !initializers.IsSingleLine(cancellationToken: context.CancellationToken))`
	`172`	`+ && !bracesSpan.IsSingleLine(objectCreation.SyntaxTree, cancellationToken: context.CancellationToken))`
`171`	`173`	`{`
`172`	`174`	`ReportAdd(context, initializers.Last());`
`173`	`175`	`}`
`@@ -181,15 +183,16 @@ private static void AnalyzeSwitchExpression(SyntaxNodeAnalysisContext context)`
`181`	`183`	`if (style == TrailingCommaStyle.None)`
`182`	`184`	`return;`
`183`	`185`
`184`		`- var objectCreation = (SwitchExpressionSyntax)context.Node;`
	`186`	`+ var switchExpression = (SwitchExpressionSyntax)context.Node;`
`185`	`187`
`186`		`- SeparatedSyntaxList<SwitchExpressionArmSyntax> arms = objectCreation.Arms;`
	`188`	`+ SeparatedSyntaxList<SwitchExpressionArmSyntax> arms = switchExpression.Arms;`
`187`	`189`
`188`	`190`	`if (!arms.Any())`
`189`	`191`	`return;`
`190`	`192`
`191`	`193`	`int count = arms.Count;`
`192`	`194`	`int separatorCount = arms.SeparatorCount;`
	`195`	`+ TextSpan bracesSpan = TextSpan.FromBounds(switchExpression.OpenBraceToken.SpanStart, switchExpression.CloseBraceToken.Span.End);`
`193`	`196`
`194`	`197`	`if (count == separatorCount)`
`195`	`198`	`{`
`@@ -198,7 +201,7 @@ private static void AnalyzeSwitchExpression(SyntaxNodeAnalysisContext context)`
`198`	`201`	`ReportRemove(context, arms.GetSeparator(count - 1));`
`199`	`202`	`}`
`200`	`203`	`else if (style == TrailingCommaStyle.OmitWhenSingleLine`
`201`		`- && arms.IsSingleLine(cancellationToken: context.CancellationToken))`
	`204`	`+ && bracesSpan.IsSingleLine(switchExpression.SyntaxTree, cancellationToken: context.CancellationToken))`
`202`	`205`	`{`
`203`	`206`	`ReportRemove(context, arms.GetSeparator(count - 1));`
`204`	`207`	`}`
`@@ -210,7 +213,7 @@ private static void AnalyzeSwitchExpression(SyntaxNodeAnalysisContext context)`
`210`	`213`	`ReportAdd(context, arms.Last());`
`211`	`214`	`}`
`212`	`215`	`else if (style == TrailingCommaStyle.OmitWhenSingleLine`
`213`		`- && !arms.IsSingleLine(cancellationToken: context.CancellationToken))`
	`216`	`+ && !bracesSpan.IsSingleLine(switchExpression.SyntaxTree, cancellationToken: context.CancellationToken))`
`214`	`217`	`{`
`215`	`218`	`ReportAdd(context, arms.Last());`
`216`	`219`	`}`
`@@ -224,15 +227,16 @@ private static void AnalyzePropertyPatternClause(SyntaxNodeAnalysisContext conte`
`224`	`227`	`if (style == TrailingCommaStyle.None)`
`225`	`228`	`return;`
`226`	`229`
`227`		`- var objectCreation = (PropertyPatternClauseSyntax)context.Node;`
	`230`	`+ var patternClause = (PropertyPatternClauseSyntax)context.Node;`
`228`	`231`
`229`		`- SeparatedSyntaxList<SubpatternSyntax> subpatterns = objectCreation.Subpatterns;`
	`232`	`+ SeparatedSyntaxList<SubpatternSyntax> subpatterns = patternClause.Subpatterns;`
`230`	`233`
`231`	`234`	`if (!subpatterns.Any())`
`232`	`235`	`return;`
`233`	`236`
`234`	`237`	`int count = subpatterns.Count;`
`235`	`238`	`int separatorCount = subpatterns.SeparatorCount;`
	`239`	`+ TextSpan bracesSpan = TextSpan.FromBounds(patternClause.OpenBraceToken.SpanStart, patternClause.CloseBraceToken.Span.End);`
`236`	`240`
`237`	`241`	`if (count == separatorCount)`
`238`	`242`	`{`
`@@ -241,7 +245,7 @@ private static void AnalyzePropertyPatternClause(SyntaxNodeAnalysisContext conte`
`241`	`245`	`ReportRemove(context, subpatterns.GetSeparator(count - 1));`
`242`	`246`	`}`
`243`	`247`	`else if (style == TrailingCommaStyle.OmitWhenSingleLine`
`244`		`- && subpatterns.IsSingleLine(cancellationToken: context.CancellationToken))`
	`248`	`+ && bracesSpan.IsSingleLine(patternClause.SyntaxTree, cancellationToken: context.CancellationToken))`
`245`	`249`	`{`
`246`	`250`	`ReportRemove(context, subpatterns.GetSeparator(count - 1));`
`247`	`251`	`}`
`@@ -253,7 +257,7 @@ private static void AnalyzePropertyPatternClause(SyntaxNodeAnalysisContext conte`
`253`	`257`	`ReportAdd(context, subpatterns.Last());`
`254`	`258`	`}`
`255`	`259`	`else if (style == TrailingCommaStyle.OmitWhenSingleLine`
`256`		`- && !subpatterns.IsSingleLine(cancellationToken: context.CancellationToken))`
	`260`	`+ && !bracesSpan.IsSingleLine(patternClause.SyntaxTree, cancellationToken: context.CancellationToken))`
`257`	`261`	`{`
`258`	`262`	`ReportAdd(context, subpatterns.Last());`
`259`	`263`	`}`
`@@ -268,15 +272,16 @@ private static void AnalyzeCollectionExpression(SyntaxNodeAnalysisContext contex`
`268`	`272`	`if (style == TrailingCommaStyle.None)`
`269`	`273`	`return;`
`270`	`274`
`271`		`- var objectCreation = (CollectionExpressionSyntax)context.Node;`
	`275`	`+ var collectionExpression = (CollectionExpressionSyntax)context.Node;`
`272`	`276`
`273`		`- SeparatedSyntaxList<CollectionElementSyntax> elements = objectCreation.Elements;`
	`277`	`+ SeparatedSyntaxList<CollectionElementSyntax> elements = collectionExpression.Elements;`
`274`	`278`
`275`	`279`	`if (!elements.Any())`
`276`	`280`	`return;`
`277`	`281`
`278`	`282`	`int count = elements.Count;`
`279`	`283`	`int separatorCount = elements.SeparatorCount;`
	`284`	`+ TextSpan bracesSpan = TextSpan.FromBounds(collectionExpression.OpenBracketToken.SpanStart, collectionExpression.CloseBracketToken.Span.End);`
`280`	`285`
`281`	`286`	`if (count == separatorCount)`
`282`	`287`	`{`
`@@ -285,7 +290,7 @@ private static void AnalyzeCollectionExpression(SyntaxNodeAnalysisContext contex`
`285`	`290`	`ReportRemove(context, elements.GetSeparator(count - 1));`
`286`	`291`	`}`
`287`	`292`	`else if (style == TrailingCommaStyle.OmitWhenSingleLine`
`288`		`- && elements.IsSingleLine(cancellationToken: context.CancellationToken))`
	`293`	`+ && bracesSpan.IsSingleLine(collectionExpression.SyntaxTree, cancellationToken: context.CancellationToken))`
`289`	`294`	`{`
`290`	`295`	`ReportRemove(context, elements.GetSeparator(count - 1));`
`291`	`296`	`}`
`@@ -297,7 +302,7 @@ private static void AnalyzeCollectionExpression(SyntaxNodeAnalysisContext contex`
`297`	`302`	`ReportAdd(context, elements.Last());`
`298`	`303`	`}`
`299`	`304`	`else if (style == TrailingCommaStyle.OmitWhenSingleLine`
`300`		`- && !elements.IsSingleLine(cancellationToken: context.CancellationToken))`
	`305`	`+ && !bracesSpan.IsSingleLine(collectionExpression.SyntaxTree, cancellationToken: context.CancellationToken))`
`301`	`306`	`{`
`302`	`307`	`ReportAdd(context, elements.Last());`
`303`	`308`	`}`