ChildSyntaxList.ItemInternal optimization (#11926)

This is a port of dotnet/roslyn#73650 to Razor

The general idea behind this PR is that calls to getting items in a
syntax list are typically done sequentially, and thus walking the full
children of a node is often not necessary.

See the Roslyn PR for detailed performance analysis that was done upon
the roslyn investigation.

In the roslyn speedometer test profile that I'm looking at, 0.8% of CPU
is spent in ChildSyntaxList.ItemInternal (1.8 seconds of CPU), so this
optimization is worth bringing over from Roslyn.


![image](https://github.com/user-attachments/assets/3dd1069a-b093-412e-9b73-7133d8c2a5ee)

Author: ToddGrun

src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/ChildSyntaxList.Enumerator.cs

@@ -16,12 +16,14 @@ public struct Enumerator
         private SyntaxNode _node;
         private int _count;
         private int _childIndex;
+        private SlotData _slotData;
 
         internal Enumerator(SyntaxNode node, int count)
         {
             _node = node;
             _count = count;
             _childIndex = -1;
+            _slotData = new SlotData(node);
         }
 
         // PERF: Initialize an Enumerator directly from a SyntaxNode without going
@@ -31,6 +33,7 @@ internal void InitializeFrom(SyntaxNode node)
             _node = node;
             _count = CountNodes(node.Green);
             _childIndex = -1;
+            _slotData = new SlotData(node);
         }
 
         /// <summary>
@@ -58,8 +61,8 @@ public bool MoveNext()
         /// <returns>
         ///  The element in the <see cref="ChildSyntaxList" /> at the current position of the enumerator.
         /// </returns>
-        public readonly SyntaxNodeOrToken Current
-            => ItemInternal(_node, _childIndex);
+        public SyntaxNodeOrToken Current
+            => ItemInternal(_node, _childIndex, ref _slotData);
 
         /// <summary>
         ///  Sets the enumerator to its initial position, which is before the first element in the collection.
@@ -77,15 +80,15 @@ internal bool TryMoveNextAndGetCurrent(out SyntaxNodeOrToken current)
                 return false;
             }
 
-            current = ItemInternal(_node, _childIndex);
+            current = ItemInternal(_node, _childIndex, ref _slotData);
             return true;
         }
 
         internal SyntaxNode? TryMoveNextAndGetCurrentAsNode()
         {
             while (MoveNext())
             {
-                var nodeValue = ItemInternalAsNode(_node, _childIndex);
+                var nodeValue = ItemInternalAsNode(_node, _childIndex, ref _slotData);
                 if (nodeValue != null)
                 {
                     return nodeValue;

src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/ChildSyntaxList.cs

@@ -75,17 +75,60 @@ private static int Occupancy(GreenNode green)
         return green.IsList ? green.SlotCount : 1;
     }
 
+    internal readonly struct SlotData
+    {
+        /// <summary>
+        /// The green node slot index at which to start the search
+        /// </summary>
+        public readonly int SlotIndex;
+
+        /// <summary>
+        /// Indicates the total number of occupants in preceding slots
+        /// </summary>
+        public readonly int PrecedingOccupantSlotCount;
+
+        /// <summary>
+        /// Indicates the node start position plus any prior slot full widths
+        /// </summary>
+        public readonly int PositionAtSlotIndex;
+
+        public SlotData(SyntaxNode node)
+            : this(slotIndex: 0, precedingOccupantSlotCount: 0, node.Position)
+        {
+        }
+
+        public SlotData(int slotIndex, int precedingOccupantSlotCount, int positionAtSlotIndex)
+        {
+            SlotIndex = slotIndex;
+            PrecedingOccupantSlotCount = precedingOccupantSlotCount;
+            PositionAtSlotIndex = positionAtSlotIndex;
+        }
+    }
+
+    internal static SyntaxNodeOrToken ItemInternal(SyntaxNode node, int index)
+    {
+        var slotData = new SlotData(node);
+
+        return ItemInternal(node, index, ref slotData);
+    }
+
     /// <summary>
     /// An internal indexer that does not verify index.
     /// Used when caller has already ensured that index is within bounds.
     /// </summary>
-    internal static SyntaxNodeOrToken ItemInternal(SyntaxNode node, int index)
+    internal static SyntaxNodeOrToken ItemInternal(SyntaxNode node, int index, ref SlotData slotData)
     {
         GreenNode greenChild;
         var green = node.Green;
-        var idx = index;
-        var slotIndex = 0;
-        var position = node.Position;
+
+        // slotData may contain information that allows us to start the loop below using data
+        // calculated during a previous call. As index represents the offset into all children of
+        // node, idx represents the offset requested relative to the given slot index.
+        var idx = index - slotData.PrecedingOccupantSlotCount;
+        var slotIndex = slotData.SlotIndex;
+        var position = slotData.PositionAtSlotIndex;
+
+        Debug.Assert(idx >= 0);
 
         // find a slot that contains the node or its parent list (if node is in a list)
         // we will be skipping whole slots here so we will not loop for long
@@ -112,6 +155,12 @@ internal static SyntaxNodeOrToken ItemInternal(SyntaxNode node, int index)
             slotIndex++;
         }
 
+        if (slotIndex != slotData.SlotIndex)
+        {
+            // (index - idx) represents the number of occupants prior to this new slotIndex
+            slotData = new SlotData(slotIndex, index - idx, position);
+        }
+
         // get node that represents this slot
         var red = node.GetNodeSlot(slotIndex);
         if (!greenChild.IsList)
@@ -132,6 +181,7 @@ internal static SyntaxNodeOrToken ItemInternal(SyntaxNode node, int index)
                 // this is our node
                 return redChild;
             }
+
             // must be a separator
             // update greenChild and position and let it be handled as a token
             greenChild = greenChild.GetSlot(idx);
@@ -237,12 +287,15 @@ internal static SyntaxNodeOrToken ChildThatContainsPosition(SyntaxNode node, int
     /// An internal indexer that does not verify index.
     /// Used when caller has already ensured that index is within bounds.
     /// </summary>
-    internal static SyntaxNode? ItemInternalAsNode(SyntaxNode node, int index)
+    internal static SyntaxNode? ItemInternalAsNode(SyntaxNode node, int index, ref SlotData slotData)
     {
         GreenNode greenChild;
         var green = node.Green;
-        var idx = index;
-        var slotIndex = 0;
+        var idx = index - slotData.PrecedingOccupantSlotCount;
+        var slotIndex = slotData.SlotIndex;
+        var position = slotData.PositionAtSlotIndex;
+
+        Debug.Assert(idx >= 0);
 
         // find a slot that contains the node or its parent list (if node is in a list)
         // we will be skipping whole slots here so we will not loop for long
@@ -262,11 +315,18 @@ internal static SyntaxNodeOrToken ChildThatContainsPosition(SyntaxNode node, int
                 }
 
                 idx -= currentOccupancy;
+                position += greenChild.Width;
             }
 
             slotIndex++;
         }
 
+        if (slotIndex != slotData.SlotIndex)
+        {
+            // (index - idx) represents the number of occupants prior to this new slotIndex
+            slotData = new SlotData(slotIndex, index - idx, position);
+        }
+
         // get node that represents this slot
         var red = node.GetNodeSlot(slotIndex);
         if (greenChild.IsList && red != null)