Alternative fix for RuntimeHelpers.GetSubArray AOT compatibility warning (#95296)

* Revert "Simplify RuntimeHelpers.GetSubArray (#66011)"

This reverts commit ca3c95b.

* Alternative fix for the AOT compatibility warning

* Add test

Author: jkotas

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

@@ -27,18 +27,32 @@ public static T[] GetSubArray<T>(T[] array, Range range)
 
             (int offset, int length) = range.GetOffsetAndLength(array.Length);
 
-            if (length == 0)
+            T[] dest;
+
+            if (typeof(T[]) == array.GetType())
             {
-                return Array.Empty<T>();
+                // We know the type of the array to be exactly T[].
+
+                if (length == 0)
+                {
+                    return Array.Empty<T>();
+                }
+
+                dest = new T[length];
             }
+            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.
 
-            T[] dest = new T[length];
+                dest = Unsafe.As<T[]>(Array.CreateInstanceFromArrayType(array.GetType(), length));
+            }
 
-            // 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 Buffer.Memmove here.
+            // 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.
 
             Buffer.Memmove(
                 ref MemoryMarshal.GetArrayDataReference(dest),

src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Runtime/CompilerServices/RuntimeHelpersTests.cs

@@ -348,7 +348,7 @@ public static void IsReferenceOrContainsReferences()
         }
 
         [Fact]
-        public static void ArrayRangeHelperTest()
+        public static void ArrayGetSubArrayTest()
         {
             int[] a = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
             Range range = Range.All;
@@ -361,6 +361,18 @@ public static void ArrayRangeHelperTest()
             Assert.Throws<ArgumentOutOfRangeException>(() => { int [] array = RuntimeHelpers.GetSubArray(a, range); });
         }
 
+        [Fact]
+        public static void ArrayGetSubArrayCoVarianceTest()
+        {
+            object[] arr = new string[10];
+            object[] slice = RuntimeHelpers.GetSubArray<object>(arr, new Range(Index.FromStart(1), Index.FromEnd(2)));
+            Assert.IsType<string[]>(slice);
+
+            uint[] arr2 = (uint[])(object)new int[10];
+            uint[] slice2 = RuntimeHelpers.GetSubArray<uint>(arr2, new Range(Index.FromStart(1), Index.FromEnd(2)));
+            Assert.IsType<int[]>(slice2);
+        }
+
         [Fact]
         [SkipOnMono("Not presently implemented on Mono")]
         public static void AllocateTypeAssociatedMemoryInvalidArguments()