Better formatting of multiline comments when indentation is changing

.gitignore

@@ -52,3 +52,5 @@ publish
 /.husky/pre-commit
 
 debug.txt
+
+Src/CSharpier.VSCode/.idea/prettier.xml

Scripts/CreateTestingPR.ps1

@@ -1,6 +1,6 @@
 param (
     [string]$pathToTestingRepo,
-    [switch] $fast = $false
+    [switch]$fast = $false
 )
 
 if (!$pathToTestingRepo) {

Src/CSharpier.Tests/FormattingTests/TestFiles/Comments_EdgeCase.cst

@@ -0,0 +1,18 @@
+public class ClassName
+{
+  /// multiline
+  /// second line
+  private string field;
+
+  public void Method()
+  {
+    /* multiline
+     *  multiline
+     */
+    var variable = true;
+  }
+    /// <summary> no tabs here
+	/// Tabs here
+	/// </summary>
+    public class ClassName { }
+}

Src/CSharpier.Tests/FormattingTests/TestFiles/Comments_EdgeCase.expected.cst

@@ -0,0 +1,19 @@
+public class ClassName
+{
+    /// multiline
+    /// second line
+    private string field;
+
+    public void Method()
+    {
+        /* multiline
+         *  multiline
+         */
+        var variable = true;
+    }
+
+    /// <summary> no tabs here
+    /// Tabs here
+    /// </summary>
+    public class ClassName { }
+}

Src/CSharpier.Tests/SyntaxNodeComparerTests.cs

@@ -311,6 +311,38 @@ public void Mismatched_Disabled_Text_Should_Not_Print_Error()
 #endif
 }
 ";
+        var result = AreEqual(left, right);
+        result.Should().BeEmpty();
+    }
+
+    [Test]
+    public void Comments_Should_Ignore_Indent_Width()
+    {
+        var left =
+            @"class ClassName
+{
+    /// multiline
+    /// multiline
+    private string field;
+
+    /* multiline
+     * multiline
+     */
+    private string field;
+}";
+
+        var right =
+            @"class ClassName
+{
+  /// multiline
+  /// multiline
+  private string field;
+
+  /* multiline
+   * multiline
+   */
+  private string field;
+}";
 
         var result = AreEqual(left, right);
         result.Should().BeEmpty();

Src/CSharpier/DocPrinter/DocPrinter.cs

@@ -131,7 +131,8 @@ private void ProcessNextCommand()
                     this.Output.Append(this.EndOfLine);
                 }
 
-                this.Output.Append(indent.Value).Append(leadingComment.Comment);
+                this.AppendComment(leadingComment, indent);
+
                 this.CurrentWidth = indent.Length;
                 this.NewLineNextStringValue = false;
                 this.SkipNextNewLine = false;
@@ -155,6 +156,47 @@ private void ProcessNextCommand()
         }
     }
 
+    private void AppendComment(LeadingComment leadingComment, Indent indent)
+    {
+        var stringReader = new StringReader(leadingComment.Comment);
+        var line = stringReader.ReadLine();
+        var firstLine = line;
+        string? extraIndent = null;
+        while (line != null)
+        {
+            this.Output.Append(indent.Value);
+            if (extraIndent?.Length > 0)
+            {
+                this.Output.Append(extraIndent);
+            }
+            this.Output.Append(line.Trim());
+            line = stringReader.ReadLine();
+            if (line == null)
+            {
+                return;
+            }
+
+            this.Output.Append(this.EndOfLine);
+            if (extraIndent != null)
+            {
+                continue;
+            }
+
+            // comparing the amount of whitespace ensures formatting like this is possible
+            // /*
+            //  *  keeps the * in line
+            //  */
+            var firstLineIndentLength =
+                firstLine!.Replace("\t", "    ").Length - firstLine.TrimStart().Length;
+            var secondLineIndentLength =
+                line.Replace("\t", "    ").Length - line.TrimStart().Length;
+            extraIndent = new string(
+                ' ',
+                Math.Max(secondLineIndentLength - firstLineIndentLength, 0)
+            );
+        }
+    }
+
     private void ProcessString(StringDoc stringDoc, Indent indent)
     {
         if (string.IsNullOrEmpty(stringDoc.Value))

Src/CSharpier/DocTypes/LeadingComment.cs

@@ -2,6 +2,6 @@ namespace CSharpier.DocTypes;
 
 internal class LeadingComment : Doc
 {
-    public CommentType Type { get; set; }
-    public string Comment { get; set; } = string.Empty;
+    public CommentType Type { get; init; }
+    public string Comment { get; init; } = string.Empty;
 }

Src/CSharpier/SyntaxNodeComparer.cs

@@ -230,6 +230,26 @@ private CompareResult Compare(SyntaxTrivia originalTrivia, SyntaxTrivia formatte
               : NotEqual(originalTrivia.Span, formattedTrivia.Span);
         }
 
+        if (originalTrivia.IsComment())
+        {
+            var originalStringReader = new StringReader(originalTrivia.ToString());
+            var formattedStringReader = new StringReader(formattedTrivia.ToString());
+            var originalLine = originalStringReader.ReadLine();
+            var formattedLine = formattedStringReader.ReadLine();
+            while (originalLine != null)
+            {
+                if (formattedLine == null || originalLine.Trim() != formattedLine.Trim())
+                {
+                    return NotEqual(originalTrivia.Span, formattedTrivia.Span);
+                }
+
+                originalLine = originalStringReader.ReadLine();
+                formattedLine = formattedStringReader.ReadLine();
+            }
+
+            return Equal;
+        }
+
         return originalTrivia.ToString().TrimEnd() == formattedTrivia.ToString().TrimEnd()
           ? Equal
           : NotEqual(originalTrivia.Span, formattedTrivia.Span);

Src/CSharpier/SyntaxPrinter/Token.cs

@@ -135,26 +135,38 @@ private static Doc PrivatePrintLeadingTrivia(
             {
                 printNewLines = true;
             }
-            if (IsSingleLineComment(kind))
+
+            void AddLeadingComment(CommentType commentType)
             {
+                // when printing comments, we need leading whitespace to ensure something like the following formats correctly
+                // /*
+                //  * keep the * in line
+                //  */
+                var previousTrivia = x > 0 ? leadingTrivia[x - 1] : (SyntaxTrivia?)null;
                 docs.Add(
                     Doc.LeadingComment(
-                        trivia.ToFullString().TrimEnd('\n', '\r'),
-                        CommentType.SingleLine
-                    ),
+                        (
+                            previousTrivia?.Kind() is SyntaxKind.WhitespaceTrivia
+                                ? previousTrivia
+                                : null
+                        ) + trivia.ToFullString().TrimEnd('\n', '\r'),
+                        commentType
+                    )
+                );
+            }
+
+            if (IsSingleLineComment(kind))
+            {
+                AddLeadingComment(CommentType.SingleLine);
+                docs.Add(
                     kind == SyntaxKind.SingleLineDocumentationCommentTrivia
                       ? Doc.HardLineSkipBreakIfFirstInGroup
                       : Doc.Null
                 );
             }
             else if (IsMultiLineComment(kind))
             {
-                docs.Add(
-                    Doc.LeadingComment(
-                        trivia.ToFullString().TrimEnd('\n', '\r'),
-                        CommentType.MultiLine
-                    )
-                );
+                AddLeadingComment(CommentType.MultiLine);
             }
             else if (kind == SyntaxKind.DisabledTextTrivia)
             {