Ensure Array.Resize creates an array of the same type as the incoming array

Author: xtqqczze

src/libraries/System.Private.CoreLib/src/System/Array.cs

@@ -54,17 +54,33 @@ public static void Resize<T>([NotNull] ref T[]? array, int newSize)
 
             if (larray.Length != newSize)
             {
-                // Due to array variance, it's possible that the incoming array is
-                // actually of type U[], where U:T; or that an int[] <-> uint[] or
-                // similar cast has occurred. In any case, since it's always legal
-                // to reinterpret U as T in this scenario (but not necessarily the
-                // other way around), we can use SpanHelpers.Memmove here.
+                T[] newArray;
+
+                if (larray.GetType() == typeof(T[]))
+                {
+                    // We know the type of the array to be exactly T[].
+
+                    newArray = new T[newSize];
+                }
+                else
+                {
+                    // The array is actually a U[] where U:T. We'll make sure to create
+                    // an array of the exact same backing type. The cast to T[] will
+                    // never fail.
+
+                    newArray = Unsafe.As<T[]>(Array.CreateInstanceFromArrayType(larray.GetType(), newSize));
+                }
+
+                // In either case, the newly-allocated array is the exact same type as the
+                // original incoming array. It's safe for us to Buffer.Memmove the contents
+                // from the source array to the destination array, otherwise the contents
+                // wouldn't have been valid for the source array in the first place.
 
-                T[] newArray = new T[newSize];
                 Buffer.Memmove(
                     ref MemoryMarshal.GetArrayDataReference(newArray),
                     ref MemoryMarshal.GetArrayDataReference(larray),
                     (uint)Math.Min(newSize, larray.Length));
+
                 array = newArray;
             }
 

src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.cs

@@ -29,7 +29,7 @@ public static T[] GetSubArray<T>(T[] array, Range range)
 
             T[] dest;
 
-            if (typeof(T[]) == array.GetType())
+            if (array.GetType() == typeof(T[]))
             {
                 // We know the type of the array to be exactly T[].
 
@@ -50,7 +50,7 @@ public static T[] GetSubArray<T>(T[] array, Range range)
             }
 
             // In either case, the newly-allocated array is the exact same type as the
-            // original incoming array. It's safe for us to SpanHelpers.Memmove the contents
+            // original incoming array. It's safe for us to Buffer.Memmove the contents
             // from the source array to the destination array, otherwise the contents
             // wouldn't have been valid for the source array in the first place.