perf: optimise SyntaxNodeComparer (#1730)

It appears that `SyntaxNodeComparer` is run after a file is formated,
optimisation here may be impactful

- Prevent null `Func<T, T, Result>` allocations (still seeing some in
the profiler, no idea how to sotp this)
- Prevent boxing of `SyntaxTokenList`, `SyntaxNodeOrTokenList`
- Use `OrderBy.ToArray` instead of `OrderBy.ToList`
- Create `AllSeparatorsButLast` to prevent boxing
`SeparatedSyntaxList<SyntaxNode>` and `IEnumerable` creation

I have some other idea, but I'm focusing on the unhappy path right now.

### Benchmark (comparing `complexCode`)
#### Before
| Method | Mean | Error | StdDev | Gen0 | Gen1 | Gen2 | Allocated |
|---------------------------
|---------:|--------:|--------:|----------:|----------:|----------:|----------:|
| Default_SyntaxNodeComparer | 229.1 ms | 4.55 ms | 7.60 ms | 5000.0000
| 3000.0000 | 1000.0000 | 40.53 MB |


#### After


| Method | Mean | Error | StdDev | Gen0 | Gen1 | Allocated |
|---------------------------
|---------:|--------:|--------:|----------:|----------:|----------:|
| Default_SyntaxNodeComparer | 187.4 ms | 3.51 ms | 7.64 ms | 3000.0000
| 1000.0000 | 31.39 MB |

Co-authored-by: Bela VanderVoort <[email protected]>

Author: TimothyMakkison

Src/CSharpier.Core/CSharp/SyntaxNodeComparer.cs

@@ -50,6 +50,7 @@ CancellationToken cancellationToken
             cSharpParseOptions,
             cancellationToken: cancellationToken
         );
+        this.CompareFunc = Compare;
     }
 
     public string CompareSource()
@@ -148,14 +149,16 @@ SyntaxNode formattedStart
         return Equal;
     }
 
+#pragma warning disable CA1822
     private CompareResult CompareLists<T>(
-        IReadOnlyList<T> originalList,
-        IReadOnlyList<T> formattedList,
-        Func<T, T, CompareResult> comparer,
-        Func<T, TextSpan> getSpan,
+        T originalList,
+        T formattedList,
+        Func<SyntaxToken, SyntaxToken, CompareResult> comparer,
+        Func<SyntaxToken, TextSpan> getSpan,
         TextSpan originalParentSpan,
         TextSpan newParentSpan
     )
+        where T : IReadOnlyList<SyntaxToken>
     {
         for (var x = 0; x < originalList.Count || x < formattedList.Count; x++)
         {
@@ -169,25 +172,71 @@ TextSpan newParentSpan
                 return NotEqual(getSpan(originalList[x]), newParentSpan);
             }
 
-            if (
-                originalList[x] is SyntaxNode originalNode
-                && formattedList[x] is SyntaxNode formattedNode
-            )
+            var result = comparer(originalList[x], formattedList[x]);
+            if (result.IsInvalid)
+            {
+                return result;
+            }
+        }
+
+        return Equal;
+    }
+#pragma warning restore CA1822
+
+    private CompareResult CompareLists<T>(
+        T originalList,
+        T formattedList,
+        Func<SyntaxNode, SyntaxNode, CompareResult> comparer,
+        Func<SyntaxNode, TextSpan> getSpan,
+        TextSpan originalParentSpan,
+        TextSpan newParentSpan
+    )
+        where T : IReadOnlyList<SyntaxNode>
+    {
+        for (var x = 0; x < originalList.Count || x < formattedList.Count; x++)
+        {
+            if (x == originalList.Count)
+            {
+                return NotEqual(originalParentSpan, getSpan(formattedList[x]));
+            }
+
+            if (x == formattedList.Count)
             {
-                this.originalStack.Push((originalNode, originalNode.Parent));
-                this.formattedStack.Push((formattedNode, formattedNode.Parent));
+                return NotEqual(getSpan(originalList[x]), newParentSpan);
             }
-            else
+
+            var originalNode = originalList[x];
+            var formattedNode = formattedList[x];
+            this.originalStack.Push((originalNode, originalNode.Parent));
+            this.formattedStack.Push((formattedNode, formattedNode.Parent));
+        }
+
+        return Equal;
+    }
+
+    private static SyntaxToken[] AllSeparatorsButLast(in SeparatedSyntaxList<SyntaxNode> list)
+    {
+        if (list.Count <= 1)
+        {
+            return [];
+        }
+
+        var tokens = new SyntaxToken[list.Count - 1];
+        var tokenIndex = 0;
+
+        foreach (var element in list.GetWithSeparators())
+        {
+            if (element.IsToken)
             {
-                var result = comparer(originalList[x], formattedList[x]);
-                if (result.IsInvalid)
+                tokens[tokenIndex++] = element.AsToken();
+                if (tokenIndex == tokens.Length)
                 {
-                    return result;
+                    break;
                 }
             }
         }
 
-        return Equal;
+        return tokens;
     }
 
     private static CompareResult NotEqual(SyntaxNode? originalNode, SyntaxNode? formattedNode)
@@ -210,6 +259,8 @@ private static CompareResult NotEqual(TextSpan? originalSpan, TextSpan? formatte
         };
     }
 
+    private Func<SyntaxToken, SyntaxToken, CompareResult> CompareFunc { get; }
+
     private CompareResult Compare(SyntaxToken originalToken, SyntaxToken formattedToken)
     {
         return this.Compare(originalToken, formattedToken, null, null);

Src/CSharpier.Generators/SyntaxNodeComparerGenerator.cs

@@ -137,7 +137,7 @@ private static void GenerateMethod(StringBuilder sourceBuilder, INamedTypeSymbol
             $$"""
                   private CompareResult Compare{{type.Name}}({{type.Name}} originalNode, {{type.Name}} formattedNode)
                   {
-                      CompareResult result;
+                       CompareResult result;
             """
         );
 
@@ -228,10 +228,13 @@ private static void GenerateMethod(StringBuilder sourceBuilder, INamedTypeSymbol
                 }
                 else
                 {
-                    var compare = propertyType.Name == nameof(SyntaxTokenList) ? "Compare" : "null";
+                    var compare =
+                        propertyType.Name == nameof(SyntaxTokenList)
+                            ? "CompareFunc"
+                            : "static (_, _) => default";
                     if (propertyName == "Modifiers")
                     {
-                        propertyName += ".OrderBy(o => o.Text).ToList()";
+                        propertyName += ".OrderBy(o => o.Text).ToArray()";
                     }
 
                     sourceBuilder.AppendLine(
@@ -249,13 +252,13 @@ private static void GenerateMethod(StringBuilder sourceBuilder, INamedTypeSymbol
             )
             {
                 sourceBuilder.AppendLine(
-                    $"            result = this.CompareLists(originalNode.{propertyName}, formattedNode.{propertyName}, null, o => o.Span, originalNode.Span, formattedNode.Span);"
+                    $"            result = this.CompareLists(originalNode.{propertyName}, formattedNode.{propertyName}, static (_, _) => default, o => o.Span, originalNode.Span, formattedNode.Span);"
                 );
                 sourceBuilder.AppendLine("            if (result.IsInvalid) return result;");
 
                 // Omit the last separator when comparing the original node with the formatted node, as it legitimately may be added or removed
                 sourceBuilder.AppendLine(
-                    $"            result = this.CompareLists(originalNode.{propertyName}.GetSeparators().Take(originalNode.{propertyName}.Count() - 1).ToList(), formattedNode.{propertyName}.GetSeparators().Take(formattedNode.{propertyName}.Count() - 1).ToList(), Compare, o => o.Span, originalNode.Span, formattedNode.Span);"
+                    $"            result = this.CompareLists(AllSeparatorsButLast(originalNode.{propertyName}), AllSeparatorsButLast(formattedNode.{propertyName}), CompareFunc, o => o.Span, originalNode.Span, formattedNode.Span);"
                 );
                 sourceBuilder.AppendLine("            if (result.IsInvalid) return result;");
             }