Share some array code between CoreCLR and NativeAOT

src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs

@@ -415,15 +415,15 @@ internal static unsafe ushort GetElementSize(this Array array)
 
         // Returns pointer to the multi-dimensional array bounds.
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal static ref int GetMultiDimensionalArrayBounds(Array array)
+        internal static ref int GetMultiDimensionalArrayBounds(this Array array)
         {
             Debug.Assert(GetMultiDimensionalArrayRank(array) > 0);
             // See comment on RawArrayData for details
             return ref Unsafe.As<byte, int>(ref Unsafe.As<RawArrayData>(array).Data);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal static unsafe int GetMultiDimensionalArrayRank(Array array)
+        internal static unsafe int GetMultiDimensionalArrayRank(this Array array)
         {
             int rank = GetMethodTable(array)->MultiDimensionalArrayRank;
             GC.KeepAlive(array); // Keep MethodTable alive
@@ -822,6 +822,16 @@ internal unsafe struct MethodTable
 
         public bool HasDefaultConstructor => (Flags & (enum_flag_HasComponentSize | enum_flag_HasDefaultCtor)) == enum_flag_HasDefaultCtor;
 
+        public bool IsSzArray
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                Debug.Assert(IsArray);
+                return BaseSize == (uint)(3 * sizeof(IntPtr));
+            }
+        }
+
         public bool IsMultiDimensionalArray
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]

src/coreclr/nativeaot/Common/src/Internal/Runtime/MethodTable.cs

@@ -408,17 +408,31 @@ internal int ArrayRank
             {
                 Debug.Assert(this.IsArray);
 
-                int boundsSize = (int)this.ParameterizedTypeShape - SZARRAY_BASE_SIZE;
+                int boundsSize = (int)this.BaseSize - SZARRAY_BASE_SIZE;
                 if (boundsSize > 0)
                 {
                     // Multidim array case: Base size includes space for two Int32s
                     // (upper and lower bound) per each dimension of the array.
-                    return boundsSize / (2 * sizeof(int));
+                    return (int)((uint)boundsSize / (uint)(2 * sizeof(int)));
                 }
                 return 1;
             }
         }
 
+        // Returns rank of multi-dimensional array rank, 0 for sz arrays
+        internal int MultiDimensionalArrayRank
+        {
+            get
+            {
+                Debug.Assert(this.IsArray);
+
+                int boundsSize = (int)this.BaseSize - SZARRAY_BASE_SIZE;
+                // Multidim array case: Base size includes space for two Int32s
+                // (upper and lower bound) per each dimension of the array.
+                return (int)((uint)boundsSize / (uint)(2 * sizeof(int)));
+            }
+        }
+
         internal bool IsSzArray
         {
             get

src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/MethodTable.Runtime.cs

@@ -42,7 +42,7 @@ internal static class WellKnownEETypes
         // This is recognized by the fact that System.Object and interfaces are the only ones without a base type
         internal static unsafe bool IsSystemObject(MethodTable* pEEType)
         {
-            if (pEEType->IsArray)
+            if (!pEEType->IsCanonical)
                 return false;
             return (pEEType->NonArrayBaseType == null) && !pEEType->IsInterface;
         }

src/coreclr/nativeaot/System.Private.CoreLib/src/System/InvokeUtils.cs

@@ -144,13 +144,13 @@ private static Exception ConvertOrWidenPrimitivesEnumsAndPointersIfPossible(obje
                 }
 
                 dstObject = RuntimeImports.RhNewObject(dstEEType);
-                PrimitiveWiden(dstElementType, srcElementType, ref dstObject.GetRawData(), ref srcObject.GetRawData());
+                PrimitiveWiden(ref srcObject.GetRawData(), ref dstObject.GetRawData(), srcElementType, dstElementType);
             }
             return null;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)] // Two callers, one of them is potentially perf sensitive
-        internal static void PrimitiveWiden(EETypeElementType dstType, EETypeElementType srcType, ref byte dstValue, ref byte srcValue)
+        internal static void PrimitiveWiden(ref byte srcValue, ref byte dstValue, EETypeElementType srcType, EETypeElementType dstType)
         {
             // Caller must check that the conversion is valid and the source/destination types are different
             Debug.Assert(CanPrimitiveWiden(dstType, srcType) && dstType != srcType);