perf: replace ManualSkipAny with Span extensions

Author: TimothyMakkison

Src/CSharpier.Core/CSharp/SyntaxPrinter/SyntaxNodePrinters/InvocationExpression.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics.CodeAnalysis;
 using CSharpier.Core.DocTypes;
+using CSharpier.Core.Utilities;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -65,9 +66,10 @@ public static Doc PrintMemberChain(ExpressionSyntax node, PrintingContext contex
             (
                 groups.Length <= cutoff
                 && (
-                    groups.ManualSkipAny(
-                        shouldMergeFirstTwoGroups ? 1 : 0,
-                        o =>
+                    groups
+                        .AsSpan()
+                        .Skip(shouldMergeFirstTwoGroups ? 1 : 0)
+                        .Any(o =>
                             o.Last().Node
                                 is not (
                                     InvocationExpressionSyntax
@@ -77,7 +79,7 @@ or PostfixUnaryExpressionSyntax
                                         Operand: InvocationExpressionSyntax
                                     }
                                 )
-                    )
+                        )
                     // if the last group contains just a !, make sure it doesn't end up on a new line
                     || (
                         groups[^1].Length == 1 && groups[^1][0].Node is PostfixUnaryExpressionSyntax
@@ -112,19 +114,10 @@ is LiteralExpressionSyntax
             return Doc.Group(oneLine);
         }
 
-        var expanded = Doc.Concat(
-            Doc.Concat(groups[0].Select(o => o.Doc).ToArray()),
-            shouldMergeFirstTwoGroups
-                ? Doc.IndentIf(
-                    groups.Length > 2 && groups[1].Last().Doc is not Group { Contents: IndentDoc },
-                    Doc.Concat(groups[1].Select(o => o.Doc).ToArray())
-                )
-                : Doc.Null,
-            PrintIndentedGroup(groups.AsSpan()[(shouldMergeFirstTwoGroups ? 2 : 1)..])
-        );
-
+        var expanded = IntoExpanded(groups, shouldMergeFirstTwoGroups);
+        
         return
-            oneLine.ManualSkipAny(1, DocUtilities.ContainsBreak)
+            oneLine.AsSpan().Skip(1).Any(DocUtilities.ContainsBreak)
             || groups[0]
                 .Any(o =>
                     o.Node
@@ -140,11 +133,50 @@ is ParenthesizedExpressionSyntax
                 parent is ExpressionStatementSyntax expressionStatementSyntax
                 && expressionStatementSyntax.SemicolonToken.LeadingTrivia.Any(o => o.IsComment())
             )
-            || groups.Count == 1
+            || groups.Length == 1
             ? expanded
             : Doc.ConditionalGroup(Doc.Concat(oneLine), expanded);
     }
 
+    private static Doc IntoExpanded(
+        ValueListBuilder<PrintedNode[]> groups,
+        bool shouldMergeFirstTwoGroups
+    )
+    {
+        var docs = new ValueListBuilder<Doc>([null, null, null, null, null, null, null, null]);
+
+        foreach (var item in groups[0])
+        {
+            docs.Append(item.Doc);
+        }
+
+        if (shouldMergeFirstTwoGroups)
+        {
+            if (groups.Length > 2 && groups[1].Last().Doc is not Group { Contents: IndentDoc })
+            {
+                docs.Append(Doc.Indent(Doc.Concat(groups[1].Select(o => o.Doc).ToArray())));
+            }
+            else
+            {
+                foreach (var item in groups[1])
+                {
+                    docs.Append(item.Doc);
+                }
+            }
+        }
+
+        var indented = PrintIndentedGroup(groups.AsSpan()[(shouldMergeFirstTwoGroups ? 2 : 1)..]);
+
+        if (indented != Doc.Null)
+        {
+            docs.Append(indented);
+        }
+
+        var returnDoc = Doc.Concat(ref docs);
+        docs.Dispose();
+        return returnDoc;
+    }
+
     private static void FlattenAndPrintNodes(
         ExpressionSyntax expression,
         ref ValueListBuilder<PrintedNode> printedNodes,
@@ -469,7 +501,7 @@ is SimpleLambdaExpressionSyntax
                     or ArgumentSyntax
                     or BinaryExpressionSyntax
                     or ExpressionStatementSyntax
-            || groups[1].Skip(1).First().Node
+            || groups[1][1].Node
                 is InvocationExpressionSyntax
                     or ElementAccessExpressionSyntax
                     or PostfixUnaryExpressionSyntax

Src/CSharpier.Core/Utilities/ListExtensions.cs

@@ -30,45 +30,22 @@ public static void AddIfNotNull(this List<Doc> value, Doc doc)
         }
     }
 
-    public static bool ManualSkipAny<T>(
-        ref this ValueListBuilder<T> collection,
-        int count,
-        Func<T, bool> predicate
-    )
+    public static bool Any<T>(this ReadOnlySpan<T> span, Func<T, bool> predicate)
     {
-        if (predicate == null || count < 0)
-            throw new ArgumentException("Invalid arguments");
-
-        int skipped = 0;
-        foreach (var item in collection.AsSpan())
+        foreach (var item in span)
         {
-            if (skipped++ < count)
-                continue; // Skip the first 'count' items
-
             if (predicate(item))
-                return true; // If any item satisfies the predicate, return true
+                return true;
         }
 
-        return false; // No match found after skipping 'count' items
+        return false;
     }
 
-    public static bool ManualSkipAny<T>(this T[] collection, int count, Func<T, bool> predicate)
-    {
-        if (collection == null || predicate == null || count < 0)
-            throw new ArgumentException("Invalid arguments");
-
-        int skipped = 0;
-        foreach (var item in collection)
-        {
-            if (skipped++ < count)
-                continue; // Skip the first 'count' items
-
-            if (predicate(item))
-                return true; // If any item satisfies the predicate, return true
-        }
+    public static ReadOnlySpan<T> Skip<T>(this ReadOnlySpan<T> span, int count) =>
+        count > span.Length ? [] : span[count..];
 
-        return false; // No match found after skipping 'count' items
-    }
+    public static ReadOnlySpan<T> Skip<T>(this Span<T> span, int count) =>
+        count > span.Length ? [] : span[count..];
 
     // Overload for Any to prevent unnecessary allocations of EnumeratorImpl
     public static bool Any(this in SyntaxTriviaList triviaList, Func<SyntaxTrivia, bool> predicate)