Fix SA1107 implicit reliance on default line endings

sharwell · sharwell · commit c71c1293ca06 · 2025-12-08T20:59:47.000-06:00
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/ReadabilityRules/SA1107CodeFixProvider.cs b/StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/ReadabilityRules/SA1107CodeFixProvider.cs
@@ -5,15 +5,17 @@
 
 namespace StyleCop.Analyzers.ReadabilityRules
 {
+    using System.Collections.Generic;
     using System.Collections.Immutable;
     using System.Composition;
     using System.Diagnostics;
+    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 StyleCop.Analyzers.Helpers;
 
     /// <summary>
     /// Implements a code fix for <see cref="SA1107CodeMustNotContainMultipleStatementsOnOneLine"/>.
@@ -51,22 +53,40 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
                     context.RegisterCodeFix(
                         CodeAction.Create(
                             ReadabilityResources.SA1107CodeFix,
-                            cancellationToken => GetTransformedDocumentAsync(context.Document, root, node),
+                            cancellationToken => GetTransformedDocumentAsync(context.Document, root, node, cancellationToken),
                             nameof(SA1107CodeFixProvider)),
                         diagnostic);
                 }
             }
         }
 
-        private static Task<Document> GetTransformedDocumentAsync(Document document, SyntaxNode root, SyntaxNode node)
+        private static async Task<Document> GetTransformedDocumentAsync(Document document, SyntaxNode root, SyntaxNode node, CancellationToken cancellationToken)
         {
             SyntaxNode newSyntaxRoot = root;
             Debug.Assert(!node.HasLeadingTrivia, "The trivia should be trailing trivia of the previous node");
 
-            SyntaxNode newNode = node.WithLeadingTrivia(SyntaxFactory.ElasticCarriageReturnLineFeed);
-            newSyntaxRoot = newSyntaxRoot.ReplaceNode(node, newNode);
+            var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
+            var options = document.Project.Solution.Workspace.Options;
+            var firstToken = node.GetFirstToken();
+            var endOfLine = FormattingHelper.GetEndOfLineForCodeFix(firstToken, text, options);
+            var settings = SettingsHelper.GetStyleCopSettingsInCodeFix(document.Project.AnalyzerOptions, root.SyntaxTree, cancellationToken);
 
-            return Task.FromResult(document.WithSyntaxRoot(newSyntaxRoot));
+            var firstTokenOnLine = IndentationHelper.GetFirstTokenOnTextLine(firstToken);
+            var previousToken = firstToken.GetPreviousToken(includeZeroWidth: true);
+            var replacementPreviousToken = previousToken.WithTrailingTrivia(previousToken.TrailingTrivia.WithoutTrailingWhitespace().Add(endOfLine));
+            var indentSteps = IndentationHelper.GetIndentationSteps(settings.Indentation, firstTokenOnLine);
+            var indentTrivia = IndentationHelper.GenerateWhitespaceTrivia(settings.Indentation, indentSteps);
+
+            var replacementTokens = new Dictionary<SyntaxToken, SyntaxToken>()
+            {
+                [previousToken] = replacementPreviousToken,
+                [firstToken] = firstToken.WithLeadingTrivia(indentTrivia),
+            };
+
+            var newRoot = root.ReplaceTokens(
+                new[] { previousToken, firstToken },
+                (originalToken, rewrittenToken) => replacementTokens[originalToken]);
+            return document.WithSyntaxRoot(newRoot);
         }
     }
 }
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/ReadabilityRules/SA1107FixAllProvider.cs b/StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/ReadabilityRules/SA1107FixAllProvider.cs
@@ -5,12 +5,11 @@
 
 namespace StyleCop.Analyzers.ReadabilityRules
 {
+    using System.Collections.Generic;
     using System.Collections.Immutable;
     using System.Threading.Tasks;
     using Microsoft.CodeAnalysis;
     using Microsoft.CodeAnalysis.CodeFixes;
-    using Microsoft.CodeAnalysis.CSharp;
-    using Microsoft.CodeAnalysis.Editing;
     using StyleCop.Analyzers.Helpers;
 
     internal class SA1107FixAllProvider : DocumentBasedFixAllProvider
@@ -24,9 +23,10 @@ protected override async Task<SyntaxNode> FixAllInDocumentAsync(FixAllContext fi
                 return null;
             }
 
-            DocumentEditor editor = await DocumentEditor.CreateAsync(document, fixAllContext.CancellationToken).ConfigureAwait(false);
-
-            SyntaxNode root = editor.GetChangedRoot();
+            var root = await document.GetSyntaxRootAsync(fixAllContext.CancellationToken).ConfigureAwait(false);
+            var text = await document.GetTextAsync(fixAllContext.CancellationToken).ConfigureAwait(false);
+            var options = document.Project.Solution.Workspace.Options;
+            var settings = SettingsHelper.GetStyleCopSettingsInCodeFix(document.Project.AnalyzerOptions, root.SyntaxTree, fixAllContext.CancellationToken);
 
             ImmutableList<SyntaxNode> nodesToChange = ImmutableList.Create<SyntaxNode>();
 
@@ -37,17 +37,29 @@ protected override async Task<SyntaxNode> FixAllInDocumentAsync(FixAllContext fi
                 var syntaxNode = root.FindNode(location.SourceSpan);
                 if (syntaxNode != null)
                 {
-                    editor.TrackNode(syntaxNode);
                     nodesToChange = nodesToChange.Add(syntaxNode);
                 }
             }
 
+            var replacementTokens = new Dictionary<SyntaxToken, SyntaxToken>();
             foreach (var node in nodesToChange)
             {
-                editor.ReplaceNode(node, node.WithLeadingTrivia(SyntaxFactory.ElasticCarriageReturnLineFeed));
+                var firstToken = node.GetFirstToken();
+                var endOfLine = FormattingHelper.GetEndOfLineForCodeFix(firstToken, text, options);
+
+                var firstTokenOnLine = IndentationHelper.GetFirstTokenOnTextLine(firstToken);
+                var previousToken = firstToken.GetPreviousToken(includeZeroWidth: true);
+                var replacementPreviousToken = previousToken.WithTrailingTrivia(previousToken.TrailingTrivia.WithoutTrailingWhitespace().Add(endOfLine));
+                var indentSteps = IndentationHelper.GetIndentationSteps(settings.Indentation, firstTokenOnLine);
+                var indentTrivia = IndentationHelper.GenerateWhitespaceTrivia(settings.Indentation, indentSteps);
+
+                replacementTokens.Add(previousToken, replacementPreviousToken);
+                replacementTokens.Add(firstToken, firstToken.WithLeadingTrivia(indentTrivia));
             }
 
-            return editor.GetChangedRoot();
+            return root.ReplaceTokens(
+                replacementTokens.Keys,
+                (originalToken, rewrittenToken) => replacementTokens[originalToken]);
         }
     }
 }
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test/ReadabilityRules/SA1107UnitTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test/ReadabilityRules/SA1107UnitTests.cs
@@ -49,7 +49,7 @@ public static void Foo(string a, string b)
         }
 
         [Theory]
-        [InlineData("\n", Skip = "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3656")]
+        [InlineData("\n")]
         [InlineData("\r\n")]
         public async Task TestWrongCodeAsync(string lineEnding)
         {
@@ -88,19 +88,18 @@ public static void Foo(string a, string b)
     {
         int i = 5;
         int j = 6, k = 3;
-        if (true)
+        if(true)
         {
             i++;
         }
         else
         {
             j++;
         }
-
         Foo(""a"", ""b"");
 
         Func<int, int, int> g = (c, d) => { c++;
-            return c + d; };
+        return c + d; };
     }
 }
 ".ReplaceLineEndings(lineEnding);
@@ -157,17 +156,20 @@ static void Main(string[] args)
         }[|;|]
     }
 }
+";
+            string fixedCode = @"
+class Program
+{
+    static void Main(string[] args)
+    {
+        {
+        }
+        ;
+    }
+}
 ";
 
-            await new CSharpTest
-            {
-                TestCode = testCode,
-                FixedCode = testCode,
-
-                // A code fix is offered even though no changes are applied by it
-                NumberOfIncrementalIterations = 1,
-                NumberOfFixAllIterations = 1,
-            }.RunAsync(CancellationToken.None).ConfigureAwait(false);
+            await VerifyCSharpFixAsync(testCode, DiagnosticResult.EmptyDiagnosticResults, fixedCode, CancellationToken.None).ConfigureAwait(false);
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -5,12 +5,11 @@`
`5`	`5`
`6`	`6`	`namespace StyleCop.Analyzers.ReadabilityRules`
`7`	`7`	`{`
	`8`	`+ using System.Collections.Generic;`
`8`	`9`	`using System.Collections.Immutable;`
`9`	`10`	`using System.Threading.Tasks;`
`10`	`11`	`using Microsoft.CodeAnalysis;`
`11`	`12`	`using Microsoft.CodeAnalysis.CodeFixes;`
`12`		`- using Microsoft.CodeAnalysis.CSharp;`
`13`		`- using Microsoft.CodeAnalysis.Editing;`
`14`	`13`	`using StyleCop.Analyzers.Helpers;`
`15`	`14`
`16`	`15`	`internal class SA1107FixAllProvider : DocumentBasedFixAllProvider`
`@@ -24,9 +23,10 @@ protected override async Task<SyntaxNode> FixAllInDocumentAsync(FixAllContext fi`
`24`	`23`	`return null;`
`25`	`24`	`}`
`26`	`25`
`27`		`- DocumentEditor editor = await DocumentEditor.CreateAsync(document, fixAllContext.CancellationToken).ConfigureAwait(false);`
`28`		`-`
`29`		`- SyntaxNode root = editor.GetChangedRoot();`
	`26`	`+ var root = await document.GetSyntaxRootAsync(fixAllContext.CancellationToken).ConfigureAwait(false);`
	`27`	`+ var text = await document.GetTextAsync(fixAllContext.CancellationToken).ConfigureAwait(false);`
	`28`	`+ var options = document.Project.Solution.Workspace.Options;`
	`29`	`+ var settings = SettingsHelper.GetStyleCopSettingsInCodeFix(document.Project.AnalyzerOptions, root.SyntaxTree, fixAllContext.CancellationToken);`
`30`	`30`
`31`	`31`	`ImmutableList<SyntaxNode> nodesToChange = ImmutableList.Create<SyntaxNode>();`
`32`	`32`
`@@ -37,17 +37,29 @@ protected override async Task<SyntaxNode> FixAllInDocumentAsync(FixAllContext fi`
`37`	`37`	`var syntaxNode = root.FindNode(location.SourceSpan);`
`38`	`38`	`if (syntaxNode != null)`
`39`	`39`	`{`
`40`		`- editor.TrackNode(syntaxNode);`
`41`	`40`	`nodesToChange = nodesToChange.Add(syntaxNode);`
`42`	`41`	`}`
`43`	`42`	`}`
`44`	`43`
	`44`	`+ var replacementTokens = new Dictionary<SyntaxToken, SyntaxToken>();`
`45`	`45`	`foreach (var node in nodesToChange)`
`46`	`46`	`{`
`47`		`- editor.ReplaceNode(node, node.WithLeadingTrivia(SyntaxFactory.ElasticCarriageReturnLineFeed));`
	`47`	`+ var firstToken = node.GetFirstToken();`
	`48`	`+ var endOfLine = FormattingHelper.GetEndOfLineForCodeFix(firstToken, text, options);`
	`49`	`+`
	`50`	`+ var firstTokenOnLine = IndentationHelper.GetFirstTokenOnTextLine(firstToken);`
	`51`	`+ var previousToken = firstToken.GetPreviousToken(includeZeroWidth: true);`
	`52`	`+ var replacementPreviousToken = previousToken.WithTrailingTrivia(previousToken.TrailingTrivia.WithoutTrailingWhitespace().Add(endOfLine));`
	`53`	`+ var indentSteps = IndentationHelper.GetIndentationSteps(settings.Indentation, firstTokenOnLine);`
	`54`	`+ var indentTrivia = IndentationHelper.GenerateWhitespaceTrivia(settings.Indentation, indentSteps);`
	`55`	`+`
	`56`	`+ replacementTokens.Add(previousToken, replacementPreviousToken);`
	`57`	`+ replacementTokens.Add(firstToken, firstToken.WithLeadingTrivia(indentTrivia));`
`48`	`58`	`}`
`49`	`59`
`50`		`- return editor.GetChangedRoot();`
	`60`	`+ return root.ReplaceTokens(`
	`61`	`+ replacementTokens.Keys,`
	`62`	`+ (originalToken, rewrittenToken) => replacementTokens[originalToken]);`
`51`	`63`	`}`
`52`	`64`	`}`
`53`	`65`	`}`
Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,7 @@ public static void Foo(string a, string b)`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`[Theory]`
`52`		`- [InlineData("\n", Skip = "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3656")]`
	`52`	`+ [InlineData("\n")]`
`53`	`53`	`[InlineData("\r\n")]`
`54`	`54`	`public async Task TestWrongCodeAsync(string lineEnding)`
`55`	`55`	`{`
`@@ -88,19 +88,18 @@ public static void Foo(string a, string b)`
`88`	`88`	`{`
`89`	`89`	`int i = 5;`
`90`	`90`	`int j = 6, k = 3;`
`91`		`- if (true)`
	`91`	`+ if(true)`
`92`	`92`	`{`
`93`	`93`	`i++;`
`94`	`94`	`}`
`95`	`95`	`else`
`96`	`96`	`{`
`97`	`97`	`j++;`
`98`	`98`	`}`
`99`		`-`
`100`	`99`	`Foo(""a"", ""b"");`
`101`	`100`
`102`	`101`	`Func<int, int, int> g = (c, d) => { c++;`
`103`		`- return c + d; };`
	`102`	`+ return c + d; };`
`104`	`103`	`}`
`105`	`104`	`}`
`106`	`105`	`".ReplaceLineEndings(lineEnding);`
`@@ -157,17 +156,20 @@ static void Main(string[] args)`
`157`	`156`	`}[\|;\|]`
`158`	`157`	`}`
`159`	`158`	`}`
	`159`	`+";`
	`160`	`+ string fixedCode = @"`
	`161`	`+class Program`
	`162`	`+{`
	`163`	`+ static void Main(string[] args)`
	`164`	`+ {`
	`165`	`+ {`
	`166`	`+ }`
	`167`	`+ ;`
	`168`	`+ }`
	`169`	`+}`
`160`	`170`	`";`
`161`	`171`
`162`		`- await new CSharpTest`
`163`		`- {`
`164`		`- TestCode = testCode,`
`165`		`- FixedCode = testCode,`
`166`		`-`
`167`		`- // A code fix is offered even though no changes are applied by it`
`168`		`- NumberOfIncrementalIterations = 1,`
`169`		`- NumberOfFixAllIterations = 1,`
`170`		`- }.RunAsync(CancellationToken.None).ConfigureAwait(false);`
	`172`	`+ await VerifyCSharpFixAsync(testCode, DiagnosticResult.EmptyDiagnosticResults, fixedCode, CancellationToken.None).ConfigureAwait(false);`
`171`	`173`	`}`
`172`	`174`	`}`
`173`	`175`	`}`