Add PooledArrayBuilder<T>.Sort(...) methods

@ToddGrun pointed out that we could add some basic `Sort(...)` methods to `PooledArrayBuilder<T>` that call into the underlying `ImmutableArray<T>.Builder`'s `Sort(...)` methods. We can use this to avoid realizing an `ImmutableArray<T>` in some cases. However, these methods don't go the extra step of trying to sort inline elements directly. Instead, they always move the inline elements to a builder.

Author: DustinCampbell

src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Extensions/FunctionsDirectivePass.cs

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Collections.Generic;
 using Microsoft.AspNetCore.Razor.Language.Components;
 using Microsoft.AspNetCore.Razor.Language.Intermediate;
 using Microsoft.AspNetCore.Razor.PooledObjects;
@@ -9,6 +10,8 @@ namespace Microsoft.AspNetCore.Razor.Language.Extensions;
 
 public sealed class FunctionsDirectivePass : IntermediateNodePassBase, IRazorDirectiveClassifierPass
 {
+    private static readonly Comparer<int?> s_nullableIntComparer = Comparer<int?>.Default;
+
     protected override void ExecuteCore(RazorCodeDocument codeDocument, DocumentIntermediateNode documentNode)
     {
         var @class = documentNode.FindPrimaryClass();
@@ -27,19 +30,22 @@ protected override void ExecuteCore(RazorCodeDocument codeDocument, DocumentInte
         }
 
         // Now we have all the directive nodes, we want to add them to the end of the class node in document order.
-        var orderedDirectives = directiveNodes.ToImmutableOrderedByAndClear(n => n.Node.Source?.AbsoluteIndex);
+        // So, we sort them by their absolute index.
+        directiveNodes.Sort(CompareAbsoluteIndices);
 
-        foreach (var directiveReference in orderedDirectives)
+        foreach (var directiveReference in directiveNodes)
         {
             var node = directiveReference.Node;
-            for (var i = 0; i < node.Children.Count; i++)
-            {
-                @class.Children.Add(node.Children[i]);
-            }
+            @class.Children.AddRange(node.Children);
 
             // We don't want to keep the original directive node around anymore.
             // Otherwise this can cause unintended side effects in the subsequent passes.
             directiveReference.Remove();
         }
+
+        static int CompareAbsoluteIndices(IntermediateNodeReference n1, IntermediateNodeReference n2)
+        {
+            return s_nullableIntComparer.Compare(n1.Node.Source?.AbsoluteIndex, n2.Node.Source?.AbsoluteIndex);
+        }
     }
 }

src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/PooledObjects/PooledArrayBuilder`1.cs

@@ -91,6 +91,20 @@ public void Dispose()
         }
     }
 
+    /// <summary>
+    ///  Retrieves the inner <see cref="_builder"/>, moving any inline elements to it if necessary.
+    /// </summary>
+    private ImmutableArray<T>.Builder GetBuilder()
+    {
+        if (!TryGetBuilder(out var builder))
+        {
+            MoveInlineItemsToBuilder();
+            builder = _builder;
+        }
+
+        return builder;
+    }
+
     /// <summary>
     ///  Retrieves the inner <see cref="_builder"/>.
     /// </summary>
@@ -1611,6 +1625,33 @@ private void ShiftInlineItemsByOffset(int index, int offset)
         }
     }
 
+    /// <summary>
+    ///  Sorts the contents of this builder.
+    /// </summary>
+    public void Sort()
+    {
+        var builder = GetBuilder();
+        builder.Sort();
+    }
+
+    /// <summary>
+    ///  Sorts the contents of this builder using the provided <see cref="IComparer{T}"/>.
+    /// </summary>
+    public void Sort(IComparer<T> comparer)
+    {
+        var builder = GetBuilder();
+        builder.Sort(comparer);
+    }
+
+    /// <summary>
+    ///  Sorts the contents of this builder using the provided <see cref="Comparison{T}"/>.
+    /// </summary>
+    public void Sort(Comparison<T> comparison)
+    {
+        var builder = GetBuilder();
+        builder.Sort(comparison);
+    }
+
     public readonly ImmutableArray<T> ToImmutableOrdered()
     {
         var result = ToImmutable();