Merge pull request #4076 from sharwell/line-endings

Fix line ending handling

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/DocumentationRules/FileHeaderCodeFixProvider.cs

@@ -18,7 +18,7 @@ namespace StyleCop.Analyzers.DocumentationRules
     using Microsoft.CodeAnalysis.CodeActions;
     using Microsoft.CodeAnalysis.CodeFixes;
     using Microsoft.CodeAnalysis.CSharp;
-    using Microsoft.CodeAnalysis.Formatting;
+    using Microsoft.CodeAnalysis.Text;
     using StyleCop.Analyzers.Helpers;
     using StyleCop.Analyzers.Helpers.ObjectPools;
     using StyleCop.Analyzers.Settings.ObjectModel;
@@ -79,13 +79,14 @@ private static async Task<Document> GetTransformedDocumentAsync(Document documen
         private static async Task<SyntaxNode> GetTransformedSyntaxRootAsync(Document document, CancellationToken cancellationToken)
         {
             var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+            var sourceText = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
             var settings = document.Project.AnalyzerOptions.GetStyleCopSettingsInCodeFix(root.SyntaxTree, cancellationToken);
 
             var fileHeader = FileHeaderHelpers.ParseFileHeader(root);
             SyntaxNode newSyntaxRoot;
             if (fileHeader.IsMissing)
             {
-                newSyntaxRoot = AddHeader(document, root, GetFileName(document), settings);
+                newSyntaxRoot = AddHeader(document, sourceText, root, GetFileName(document), settings);
             }
             else
             {
@@ -98,18 +99,18 @@ private static async Task<SyntaxNode> GetTransformedSyntaxRootAsync(Document doc
                 var xmlFileHeader = FileHeaderHelpers.ParseXmlFileHeader(root);
                 if (isMultiLineComment && !xmlFileHeader.IsMalformed)
                 {
-                    newSyntaxRoot = ReplaceWellFormedMultiLineCommentHeader(document, root, settings, commentIndex, xmlFileHeader);
+                    newSyntaxRoot = ReplaceWellFormedMultiLineCommentHeader(document, sourceText, root, settings, commentIndex, xmlFileHeader);
                 }
                 else
                 {
-                    newSyntaxRoot = ReplaceHeader(document, root, settings, xmlFileHeader.IsMalformed);
+                    newSyntaxRoot = ReplaceHeader(document, sourceText, root, settings, xmlFileHeader.IsMalformed);
                 }
             }
 
             return newSyntaxRoot;
         }
 
-        private static SyntaxNode ReplaceWellFormedMultiLineCommentHeader(Document document, SyntaxNode root, StyleCopSettings settings, int commentIndex, XmlFileHeader header)
+        private static SyntaxNode ReplaceWellFormedMultiLineCommentHeader(Document document, SourceText sourceText, SyntaxNode root, StyleCopSettings settings, int commentIndex, XmlFileHeader header)
         {
             SyntaxTriviaList trivia = root.GetLeadingTrivia();
             var commentTrivia = trivia[commentIndex];
@@ -135,7 +136,10 @@ private static SyntaxNode ReplaceWellFormedMultiLineCommentHeader(Document docum
             string interlinePadding = " *";
 
             int minExpectedLength = (commentIndentation + interlinePadding).Length;
-            string newLineText = document.Project.Solution.Workspace.Options.GetOption(FormattingOptions.NewLine, LanguageNames.CSharp);
+            var options = document.Project.Solution.Workspace.Options;
+            var firstToken = root.GetFirstToken(includeZeroWidth: true);
+            SyntaxTrivia newLineTrivia = FormattingHelper.GetEndOfLineForCodeFix(firstToken, sourceText, options);
+            string newLineText = newLineTrivia.ToFullString();
 
             // Examine second line to see if we should have stars or not if it's blank
             // set the interline padding to be blank also.
@@ -213,7 +217,7 @@ private static SyntaxNode ReplaceWellFormedMultiLineCommentHeader(Document docum
             return root.WithLeadingTrivia(trivia.Replace(commentTrivia, newTrivia));
         }
 
-        private static SyntaxNode ReplaceHeader(Document document, SyntaxNode root, StyleCopSettings settings, bool isMalformedHeader)
+        private static SyntaxNode ReplaceHeader(Document document, SourceText sourceText, SyntaxNode root, StyleCopSettings settings, bool isMalformedHeader)
         {
             // If the header is well formed Xml then we parse out the copyright otherwise
             // Skip single line comments, whitespace, and end of line trivia until a blank line is encountered.
@@ -312,8 +316,10 @@ private static SyntaxNode ReplaceHeader(Document document, SyntaxNode root, Styl
                 trivia = trivia.RemoveAt(removalList[i]);
             }
 
-            string newLineText = document.Project.Solution.Workspace.Options.GetOption(FormattingOptions.NewLine, LanguageNames.CSharp);
-            var newLineTrivia = SyntaxFactory.EndOfLine(newLineText);
+            var options = document.Project.Solution.Workspace.Options;
+            var firstToken = root.GetFirstToken(includeZeroWidth: true);
+            SyntaxTrivia newLineTrivia = FormattingHelper.GetEndOfLineForCodeFix(firstToken, sourceText, options);
+            string newLineText = newLineTrivia.ToFullString();
 
             var newHeaderTrivia = CreateNewHeader(leadingSpaces + "//", GetFileName(document), settings, newLineText);
             if (!isMalformedHeader && copyrightTriviaIndex.HasValue)
@@ -356,10 +362,12 @@ private static bool FirstLineIsComment(SyntaxTriviaList trivia)
             return false;
         }
 
-        private static SyntaxNode AddHeader(Document document, SyntaxNode root, string name, StyleCopSettings settings)
+        private static SyntaxNode AddHeader(Document document, SourceText sourceText, SyntaxNode root, string name, StyleCopSettings settings)
         {
-            string newLineText = document.Project.Solution.Workspace.Options.GetOption(FormattingOptions.NewLine, LanguageNames.CSharp);
-            var newLineTrivia = SyntaxFactory.EndOfLine(newLineText);
+            var options = document.Project.Solution.Workspace.Options;
+            var firstToken = root.GetFirstToken(includeZeroWidth: true);
+            SyntaxTrivia newLineTrivia = FormattingHelper.GetEndOfLineForCodeFix(firstToken, sourceText, options);
+            string newLineText = newLineTrivia.ToFullString();
             var newTrivia = CreateNewHeader("//", name, settings, newLineText).Add(newLineTrivia).Add(newLineTrivia);
 
             // Skip blank lines already at the beginning of the document, since we add our own

StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/Helpers/FormattingHelper.cs

@@ -6,14 +6,87 @@
 namespace StyleCop.Analyzers.Helpers
 {
     using System.Linq;
+    using System.Threading;
+    using System.Threading.Tasks;
     using Microsoft.CodeAnalysis;
     using Microsoft.CodeAnalysis.CodeActions;
     using Microsoft.CodeAnalysis.CSharp;
     using Microsoft.CodeAnalysis.CSharp.Syntax;
     using Microsoft.CodeAnalysis.Formatting;
+    using Microsoft.CodeAnalysis.Options;
+    using Microsoft.CodeAnalysis.Text;
 
     internal static class FormattingHelper
     {
+        /// <summary>
+        /// Retrieves the appropriate end-of-line trivia for use in code fixes at the specified token location.
+        /// </summary>
+        /// <remarks><para>This method attempts to preserve the existing line ending style near the specified
+        /// token. If no suitable end-of-line trivia is found, a default carriage return and line feed (CRLF) is
+        /// returned.</para></remarks>
+        /// <param name="token">The syntax token for which to determine the end-of-line trivia.</param>
+        /// <param name="options">The options to use for formatting. This value is only used if the document does not already contain line endings.</param>
+        /// <param name="cancellationToken">A cancellation token that can be used to cancel the asynchronous operation.</param>
+        /// <returns>A <see cref="SyntaxTrivia"/> representing the end-of-line trivia suitable for code fixes at the given token
+        /// position.</returns>
+        public static async Task<SyntaxTrivia> GetEndOfLineForCodeFixAsync(SyntaxToken token, OptionSet options, CancellationToken cancellationToken)
+        {
+            if (TryGetPrecedingEndOfLineTrivia(token, out var precedingEndOfLine))
+            {
+                return precedingEndOfLine;
+            }
+
+            var text = await token.SyntaxTree.GetTextAsync(cancellationToken).ConfigureAwait(false);
+            return GetEndOfLineForCodeFix(token, text, options);
+        }
+
+        /// <summary>
+        /// Retrieves the appropriate end-of-line trivia for use in code fixes, based on the position of the specified
+        /// syntax token and the provided source text.
+        /// </summary>
+        /// <remarks><para>This method examines the token's position and surrounding lines to select the most
+        /// contextually appropriate end-of-line trivia, ensuring consistency with the existing file
+        /// formatting.</para></remarks>
+        /// <param name="token">The syntax token for which to determine the end-of-line trivia.</param>
+        /// <param name="text">The source text containing the token. Used to identify line boundaries and end-of-line characters.</param>
+        /// <param name="options">The options to use for formatting. This value is only used if the document does not already contain line endings.</param>
+        /// <returns>A <see cref="SyntaxTrivia"/> representing the end-of-line trivia suitable for code fixes. If no specific
+        /// trivia is found, returns a default carriage return and line feed trivia.</returns>
+        public static SyntaxTrivia GetEndOfLineForCodeFix(SyntaxToken token, SourceText text, OptionSet options)
+        {
+            if (TryGetPrecedingEndOfLineTrivia(token, out var precedingEndOfLine))
+            {
+                return precedingEndOfLine;
+            }
+
+            var lineNumber = token.GetLine();
+            if (lineNumber >= 0 && lineNumber < text.Lines.Count && GetEndOfLineTriviaForLine(text.Lines[lineNumber]) is { } followingTrivia)
+            {
+                return followingTrivia;
+            }
+
+            if (lineNumber > 0 && GetEndOfLineTriviaForLine(text.Lines[lineNumber - 1]) is { } precedingTrivia)
+            {
+                return precedingTrivia;
+            }
+
+            return SyntaxFactory.SyntaxTrivia(SyntaxKind.EndOfLineTrivia, options.GetOption(FormattingOptions.NewLine, LanguageNames.CSharp));
+
+            static SyntaxTrivia? GetEndOfLineTriviaForLine(TextLine textLine)
+            {
+                return (textLine.EndIncludingLineBreak - textLine.End) switch
+                {
+                    2 => SyntaxFactory.CarriageReturnLineFeed,
+                    1 => textLine.Text[textLine.End] switch
+                    {
+                        '\n' => SyntaxFactory.LineFeed,
+                        char c => SyntaxFactory.EndOfLine(c.ToString()),
+                    },
+                    _ => null,
+                };
+            }
+        }
+
         public static SyntaxTrivia GetNewLineTrivia(Document document)
         {
             return SyntaxFactory.SyntaxTrivia(SyntaxKind.EndOfLineTrivia, document.Project.Solution.Workspace.Options.GetOption(FormattingOptions.NewLine, LanguageNames.CSharp));
@@ -152,5 +225,39 @@ private static SyntaxTrivia WithoutFormattingImpl(SyntaxTrivia trivia)
         {
             return trivia.WithoutAnnotations(Formatter.Annotation, SyntaxAnnotation.ElasticAnnotation);
         }
+
+        /// <summary>
+        /// Returns the closest end of line trivia preceding the <paramref name="token"/>.
+        /// This currently only looks immediately before the specified token.
+        /// </summary>
+        /// <param name="token">The token to process.</param>
+        /// <param name="trivia">When this method returns, contains the closest preceding end of line trivia, if found; otherwise, the default value.</param>
+        /// <returns><see langword="true"/> if an end of line trivia was found; otherwise, <see langword="false"/>.</returns>
+        private static bool TryGetPrecedingEndOfLineTrivia(this SyntaxToken token, out SyntaxTrivia trivia)
+        {
+            var leadingTrivia = token.LeadingTrivia;
+            for (var i = leadingTrivia.Count - 1; i >= 0; i--)
+            {
+                if (leadingTrivia[i].IsKind(SyntaxKind.EndOfLineTrivia))
+                {
+                    trivia = leadingTrivia[i];
+                    return true;
+                }
+            }
+
+            var prevToken = token.GetPreviousToken();
+            var prevTrailingTrivia = prevToken.TrailingTrivia;
+            for (var i = prevTrailingTrivia.Count - 1; i >= 0; i--)
+            {
+                if (prevTrailingTrivia[i].IsKind(SyntaxKind.EndOfLineTrivia))
+                {
+                    trivia = prevTrailingTrivia[i];
+                    return true;
+                }
+            }
+
+            trivia = default;
+            return false;
+        }
     }
 }

StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/LayoutRules/SA1501CodeFixProvider.cs

@@ -133,7 +133,7 @@ private static int DetermineIndentationLevel(IndentationSettings indentationSett
             }
             else
             {
-                parentIndentationLevel = IndentationHelper.GetIndentationSteps(indentationSettings, GetFirstOnLineParent(parent));
+                parentIndentationLevel = IndentationHelper.GetIndentationSteps(indentationSettings, parent.GetFirstOnLineAncestorOrSelf());
             }
 
             return parentIndentationLevel;
@@ -275,18 +275,6 @@ private static SyntaxNode GetStatementParent(SyntaxNode node)
             return statementSyntax;
         }
 
-        private static SyntaxNode GetFirstOnLineParent(SyntaxNode parent)
-        {
-            // if the parent is not the first on a line, find the parent that is.
-            // This mainly happens for 'else if' statements.
-            while (!parent.GetFirstToken().IsFirstInLine())
-            {
-                parent = parent.Parent;
-            }
-
-            return parent;
-        }
-
         private class FixAll : DocumentBasedFixAllProvider
         {
             public static FixAllProvider Instance { get; } =

StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/LayoutRules/SA1513CodeFixProvider.cs

@@ -61,11 +61,13 @@ private static async Task<Document> GetTransformedDocumentAsync(Document documen
         private static async Task<SyntaxNode> GetTransformedDocumentAsync(Document document, ImmutableArray<Diagnostic> diagnostics, CancellationToken cancellationToken)
         {
             var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+            var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
+            var options = document.Project.Solution.Workspace.Options;
             return root.ReplaceTokens(
                 diagnostics.Select(diagnostic => root.FindToken(diagnostic.Location.SourceSpan.End)),
                 (originalToken, rewrittenToken) =>
                 {
-                    var endOfLineTrivia = rewrittenToken.GetPrecedingEndOfLineTrivia();
+                    var endOfLineTrivia = FormattingHelper.GetEndOfLineForCodeFix(rewrittenToken, text, options);
                     var newTrivia = rewrittenToken.LeadingTrivia.Insert(0, endOfLineTrivia);
                     return rewrittenToken.WithLeadingTrivia(newTrivia);
                 });

StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/NamingRules/RenameToUpperCaseCodeFixProvider.cs

@@ -76,7 +76,7 @@ Task<Document> RenameNamespace(CancellationToken cancellationToken)
                     {
                         IdentifierNameSyntax identifierSyntax = (IdentifierNameSyntax)token.Parent;
 
-                        var newIdentifierSyntax = identifierSyntax.WithIdentifier(SyntaxFactory.Identifier(newName));
+                        var newIdentifierSyntax = identifierSyntax.WithIdentifier(SyntaxFactory.Identifier(newName)).WithTriviaFrom(identifierSyntax);
 
                         var newRoot = root.ReplaceNode(identifierSyntax, newIdentifierSyntax);
                         return Task.FromResult(context.Document.WithSyntaxRoot(newRoot));

StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/OrderingRules/SA1212SA1213CodeFixProvider.cs

@@ -53,6 +53,8 @@ public override Task RegisterCodeFixesAsync(CodeFixContext context)
         private static async Task<Document> GetTransformedDocumentAsync(Document document, Diagnostic diagnostic, CancellationToken cancellationToken)
         {
             var syntaxRoot = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+            var sourceText = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
+            var options = document.Project.Solution.Workspace.Options;
 
             var accessorToken = syntaxRoot.FindToken(diagnostic.Location.SourceSpan.Start);
             var accessorList = (AccessorListSyntax)accessorToken.Parent.Parent;
@@ -67,8 +69,9 @@ private static async Task<Document> GetTransformedDocumentAsync(Document documen
 
             if (HasLeadingBlankLines(secondAccessor))
             {
+                var endOfLine = FormattingHelper.GetEndOfLineForCodeFix(firstAccesor.Keyword, sourceText, options);
                 trackedFirstAccessor = syntaxRoot.GetCurrentNode(firstAccesor);
-                var newFirstAccessor = trackedFirstAccessor.WithLeadingTrivia(new[] { SyntaxFactory.CarriageReturnLineFeed }.Concat(firstAccesor.GetFirstToken().WithoutLeadingBlankLines().LeadingTrivia));
+                var newFirstAccessor = trackedFirstAccessor.WithLeadingTrivia(new[] { endOfLine }.Concat(firstAccesor.GetFirstToken().WithoutLeadingBlankLines().LeadingTrivia));
                 syntaxRoot = syntaxRoot.ReplaceNode(trackedFirstAccessor, newFirstAccessor);
             }