Apply suggestions from code review

Co-authored-by: Jan Kotas <[email protected]>
dotnet · jkotas · Jun 27, 2024 · May 27, 2024 · May 27, 2024 · May 27, 2024
commit d9205c6ffae6c66c9f3987d7cc2f9058abbbc901
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Array.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Array.CoreCLR.cs
@@ -437,33 +437,24 @@ private unsafe void InternalSetValue(object? value, nint flattenedIndex)
                 if (pElementMethodTable->IsValueType)
                 {
                     ref byte offsetDataRef = ref Unsafe.Add(ref arrayDataRef, flattenedIndex * pMethodTable->ComponentSize);
+                    nuint elementSize = pElementMethodTable->GetNumInstanceFieldBytes();
                     if (pElementMethodTable->ContainsGCPointers)
-                        SpanHelpers.ClearWithReferences(ref Unsafe.As<byte, nint>(ref offsetDataRef), pElementMethodTable->GetNumInstanceFieldBytes() / (nuint)sizeof(IntPtr));
+                        SpanHelpers.ClearWithReferences(ref Unsafe.As<byte, nint>(ref offsetDataRef), elementSize / (nuint)sizeof(IntPtr));
                     else
-                        SpanHelpers.ClearWithoutReferences(ref offsetDataRef, pElementMethodTable->GetNumInstanceFieldBytes());
+                        SpanHelpers.ClearWithoutReferences(ref offsetDataRef, elementSize);
                 }
                 else
                 {
-                    ref object? elementRef = ref Unsafe.As<byte, object?>(ref arrayDataRef);
-                    ref object? offsetElementRef = ref Unsafe.Add(ref elementRef, (nuint)flattenedIndex);
-                    offsetElementRef = null;
+                    Unsafe.Add(ref Unsafe.As<byte, object?>(ref arrayDataRef), (nuint)flattenedIndex) = null;
                 }
             }
-            else if (TypeHandle.AreSameType(arrayElementTypeHandle, TypeHandle.TypeHandleOf<object>()))
-            {
-                // Everything is compatible with Object
-                ref object? elementRef = ref Unsafe.As<byte, object?>(ref arrayDataRef);
-                ref object? offsetElementRef = ref Unsafe.Add(ref elementRef, (nuint)flattenedIndex);
-                offsetElementRef = value;
-            }
             else if (!pElementMethodTable->IsValueType)
             {
-                if (CastHelpers.IsInstanceOfAny(pElementMethodTable, value) == null)
+                if (pElementMethodTable != TypeHandle.TypeHandleOf<object>().AsMethodTable() //  Everything is compatible with Object
+                    && CastHelpers.IsInstanceOfAny(pElementMethodTable, value) == null)
                     throw new InvalidCastException(SR.InvalidCast_StoreArrayElement);
 
-                ref object? elementRef = ref Unsafe.As<byte, object?>(ref arrayDataRef);
-                ref object? offsetElementRef = ref Unsafe.Add(ref elementRef, (nuint)flattenedIndex);
-                offsetElementRef = value;
+                Unsafe.Add(ref Unsafe.As<byte, object?>(ref arrayDataRef), (nuint)flattenedIndex) = value;
             }
             else
             {
@@ -476,23 +467,28 @@ private unsafe void InternalSetValue(object? value, nint flattenedIndex)
                     {
                         RuntimeHelpers.Unbox_Nullable(ref offsetDataRef, pElementMethodTable, value);
                     }
-                    else if (pElementMethodTable->ContainsGCPointers)
-                    {
-                        Buffer.BulkMoveWithWriteBarrier(ref offsetDataRef, ref value.GetRawData(), pElementMethodTable->GetNumInstanceFieldBytes());
-                    }
                     else
                     {
-                        SpanHelpers.Memmove(ref offsetDataRef, ref value.GetRawData(), pElementMethodTable->GetNumInstanceFieldBytes());
+                        nuint elementSize = pElementMethodTable->GetNumInstanceFieldBytes();
+                        if (pElementMethodTable->ContainsGCPointers)
+                        {
+                            Buffer.BulkMoveWithWriteBarrier(ref offsetDataRef, ref value.GetRawData(), elementSize);
+                        }
+                        else
+                        {
+                            SpanHelpers.Memmove(ref offsetDataRef, ref value.GetRawData(), elementSize);
+                        }
                     }
                 }
                 else
                 {
                     // Allow enum -> primitive conversion, disallow primitive -> enum conversion
-                    MethodTable* thSrc = RuntimeHelpers.GetMethodTable(value);
-                    CorElementType srcType = thSrc->GetVerifierCorElementType();
+                    MethodTable* pValueMethodTable = RuntimeHelpers.GetMethodTable(value);
+                    CorElementType srcType = pValueMethodTable->GetVerifierCorElementType();
                     CorElementType targetType = pElementMethodTable->GetVerifierCorElementType();
 
-                    if (!srcType.IsPrimitiveType() || !targetType.IsPrimitiveType() || !pElementMethodTable->IsTruePrimitive)
+                    // Array.SetValue() does *not* permit conversion from a primitive to an Enum.  
+                    if (!pValueMethodTable->IsPrimitive || !pElementMethodTable->IsTruePrimitive)
                         throw new InvalidCastException(SR.InvalidCast_StoreArrayElement);
 
                     // Get a properly widened type

diff --git a/...eclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs b/...eclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs
@@ -25,7 +25,7 @@ public static unsafe void InitializeArray(Array array, RuntimeFieldHandle fldHan
                 throw new ArgumentException(SR.Argument_BadFieldForInitializeArray);
 
             // Note that we do not check that the field is actually in the PE file that is initializing
-            // the array. Basically the data being published is can be accessed by anyone with the proper
+            // the array. Basically, the data being published can be accessed by anyone with the proper
             // permissions (C# marks these as assembly visibility, and thus are protected from outside
             // snooping)