Revert ArrayBuilder changes, it cannot be changed

Author: Henr1k80

src/libraries/Common/src/System/Collections/Generic/ArrayBuilder.cs

@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Diagnostics;
-using System.Runtime.CompilerServices;
 
 namespace System.Collections.Generic
 {
@@ -12,9 +11,7 @@ namespace System.Collections.Generic
     /// <typeparam name="T">The element type.</typeparam>
     internal struct ArrayBuilder<T>
     {
-        private InlineArray16<T> _stackAllocatedBuffer = default;
-        private const int StackAllocatedCapacity = 16;
-        private const int DefaultHeapCapacity = 4;
+        private const int DefaultCapacity = 4;
 
         private T[]? _array; // Starts out null, initialized on first Add.
         private int _count; // Number of items into _array we're using.
@@ -26,17 +23,20 @@ internal struct ArrayBuilder<T>
         public ArrayBuilder(int capacity) : this()
         {
             Debug.Assert(capacity >= 0);
-            if (capacity > StackAllocatedCapacity)
+            if (capacity > 0)
             {
-                _array = new T[capacity - StackAllocatedCapacity];
+                _array = new T[capacity];
             }
         }
 
         /// <summary>
         /// Gets the number of items this instance can store without re-allocating,
         /// or 0 if the backing array is <c>null</c>.
         /// </summary>
-        public int Capacity => _array?.Length + StackAllocatedCapacity ?? StackAllocatedCapacity;
+        public int Capacity => _array?.Length ?? 0;
+
+        /// <summary>Gets the current underlying array.</summary>
+        public T[]? Buffer => _array;
 
         /// <summary>
         /// Gets the number of items in the array currently in use.
@@ -52,7 +52,7 @@ public T this[int index]
             get
             {
                 Debug.Assert(index >= 0 && index < _count);
-                return index < StackAllocatedCapacity ? _stackAllocatedBuffer[index] : _array![index - StackAllocatedCapacity];
+                return _array![index];
             }
         }
 
@@ -76,7 +76,7 @@ public void Add(T item)
         public T First()
         {
             Debug.Assert(_count > 0);
-            return _stackAllocatedBuffer[0];
+            return _array![0];
         }
 
         /// <summary>
@@ -85,7 +85,7 @@ public T First()
         public T Last()
         {
             Debug.Assert(_count > 0);
-            return _count <= StackAllocatedCapacity ? _stackAllocatedBuffer[_count - 1] : _array![_count - StackAllocatedCapacity - 1];
+            return _array![_count - 1];
         }
 
         /// <summary>
@@ -101,19 +101,17 @@ public T[] ToArray()
                 return Array.Empty<T>();
             }
 
-            T[] result = new T[_count];
-            int index = 0;
-            foreach (T stackAllocatedValue in _stackAllocatedBuffer)
+            Debug.Assert(_array != null); // Nonzero _count should imply this
+
+            T[] result = _array;
+            if (_count < result.Length)
             {
-                result[index++] = stackAllocatedValue;
-                if (index >= _count)
-                {
-                    return result;
-                }
+                // Avoid a bit of overhead (method call, some branches, extra codegen)
+                // which would be incurred by using Array.Resize
+                result = new T[_count];
+                Array.Copy(_array, result, _count);
             }
 
-            _array.AsSpan(0, _count - StackAllocatedCapacity).CopyTo(result.AsSpan(start: StackAllocatedCapacity));
-
 #if DEBUG
             // Try to prevent callers from using the ArrayBuilder after ToArray, if _count != 0.
             _count = -1;
@@ -134,42 +132,25 @@ public T[] ToArray()
         public void UncheckedAdd(T item)
         {
             Debug.Assert(_count < Capacity);
-            if (_count < StackAllocatedCapacity)
-            {
-                _stackAllocatedBuffer[_count++] = item;
-            }
-            else
-            {
-                _array![_count++ - StackAllocatedCapacity] = item;
-            }
+
+            _array![_count++] = item;
         }
 
         private void EnsureCapacity(int minimum)
         {
             Debug.Assert(minimum > Capacity);
 
-            if (minimum < StackAllocatedCapacity)
-            {
-                return;
-            }
-
-            if (_array == null)
-            {
-                // Initial capacity has not been set correctly, we will use the default size
-                _array = new T[DefaultHeapCapacity];
-                return;
-            }
-
-            int nextHeapCapacity = 2 * _array.Length;
+            int capacity = Capacity;
+            int nextCapacity = capacity == 0 ? DefaultCapacity : 2 * capacity;
 
-            if ((uint)nextHeapCapacity > (uint)Array.MaxLength)
+            if ((uint)nextCapacity > (uint)Array.MaxLength)
             {
-                nextHeapCapacity = Math.Max(_array.Length + 1, Array.MaxLength);
+                nextCapacity = Math.Max(capacity + 1, Array.MaxLength);
             }
 
-            nextHeapCapacity = Math.Max(nextHeapCapacity, minimum);
+            nextCapacity = Math.Max(nextCapacity, minimum);
 
-            T[] next = new T[nextHeapCapacity];
+            T[] next = new T[nextCapacity];
             if (_count > 0)
             {
                 Array.Copy(_array!, next, _count);