Consume Roslyn with ref fields support

eng/Versions.props

@@ -49,7 +49,7 @@
     <!--
       TODO: Remove pinned version once arcade supplies a compiler that enables the repo to compile.
     -->
-    <MicrosoftNetCompilersToolsetVersion>4.4.0-1.22315.13</MicrosoftNetCompilersToolsetVersion>
+    <MicrosoftNetCompilersToolsetVersion>4.4.0-1.22328.22</MicrosoftNetCompilersToolsetVersion>
     <!-- SDK dependencies -->
     <MicrosoftDotNetCompatibilityVersion>2.0.0-preview.4.22252.4</MicrosoftDotNetCompatibilityVersion>
     <!-- Arcade dependencies -->

src/coreclr/System.Private.CoreLib/src/System/TypedReference.CoreCLR.cs

@@ -12,7 +12,7 @@ namespace System
     [System.Runtime.Versioning.NonVersionable] // This only applies to field layout
     public ref partial struct TypedReference
     {
-        private readonly ByReference<byte> _value;
+        private readonly ref byte _value;
         private readonly IntPtr _type;
 
         public static unsafe object? ToObject(TypedReference value)
@@ -38,11 +38,11 @@ public ref partial struct TypedReference
 
             if (pMethodTable->IsValueType)
             {
-                result = RuntimeHelpers.Box(pMethodTable, ref value._value.Value);
+                result = RuntimeHelpers.Box(pMethodTable, ref value._value);
             }
             else
             {
-                result = Unsafe.As<byte, object>(ref value._value.Value);
+                result = Unsafe.As<byte, object>(ref value._value);
             }
 
             return result;

src/coreclr/inc/dacvars.h

@@ -163,7 +163,6 @@ DEFINE_DACVAR(UNKNOWN_POINTER_TYPE, dac__g_pStringClass, ::g_pStringClass)
 DEFINE_DACVAR(UNKNOWN_POINTER_TYPE, dac__g_pArrayClass, ::g_pArrayClass)
 DEFINE_DACVAR(UNKNOWN_POINTER_TYPE, dac__g_pSZArrayHelperClass, ::g_pSZArrayHelperClass)
 DEFINE_DACVAR(UNKNOWN_POINTER_TYPE, dac__g_pNullableClass, ::g_pNullableClass)
-DEFINE_DACVAR(UNKNOWN_POINTER_TYPE, dac__g_pByReferenceClass, ::g_pByReferenceClass)
 DEFINE_DACVAR(UNKNOWN_POINTER_TYPE, dac__g_pExceptionClass, ::g_pExceptionClass)
 DEFINE_DACVAR(UNKNOWN_POINTER_TYPE, dac__g_pThreadAbortExceptionClass, ::g_pThreadAbortExceptionClass)
 DEFINE_DACVAR(UNKNOWN_POINTER_TYPE, dac__g_pOutOfMemoryExceptionClass, ::g_pOutOfMemoryExceptionClass)

src/coreclr/jit/importer.cpp

@@ -3791,8 +3791,6 @@ GenTree* Compiler::impIntrinsic(GenTree*                newobjThis,
             break;
 
         case NI_Internal_Runtime_MethodTable_Of:
-        case NI_System_ByReference_ctor:
-        case NI_System_ByReference_get_Value:
         case NI_System_Activator_AllocatorOf:
         case NI_System_Activator_DefaultConstructorOf:
         case NI_System_EETypePtr_EETypePtrOf:
@@ -3899,35 +3897,6 @@ GenTree* Compiler::impIntrinsic(GenTree*                newobjThis,
                 break;
             }
 
-            // Implement ByReference Ctor.  This wraps the assignment of the ref into a byref-like field
-            // in a value type.  The canonical example of this is Span<T>. In effect this is just a
-            // substitution.  The parameter byref will be assigned into the newly allocated object.
-            case NI_System_ByReference_ctor:
-            {
-                // Remove call to constructor and directly assign the byref passed
-                // to the call to the first slot of the ByReference struct.
-                GenTree*             op1               = impPopStack().val;
-                GenTree*             thisptr           = newobjThis;
-                CORINFO_FIELD_HANDLE fldHnd            = info.compCompHnd->getFieldInClass(clsHnd, 0);
-                GenTree*             field             = gtNewFieldRef(TYP_BYREF, fldHnd, thisptr, 0);
-                GenTree*             assign            = gtNewAssignNode(field, op1);
-                GenTree*             byReferenceStruct = gtCloneExpr(thisptr->gtGetOp1());
-                assert(byReferenceStruct != nullptr);
-                impPushOnStack(byReferenceStruct, typeInfo(TI_STRUCT, clsHnd));
-                retNode = assign;
-                break;
-            }
-
-            // Implement ptr value getter for ByReference struct.
-            case NI_System_ByReference_get_Value:
-            {
-                GenTree*             op1    = impPopStack().val;
-                CORINFO_FIELD_HANDLE fldHnd = info.compCompHnd->getFieldInClass(clsHnd, 0);
-                GenTree*             field  = gtNewFieldRef(TYP_BYREF, fldHnd, op1, 0);
-                retNode                     = field;
-                break;
-            }
-
             case NI_System_Runtime_CompilerServices_RuntimeHelpers_CreateSpan:
             {
                 retNode = impCreateSpanIntrinsic(sig);
@@ -5549,17 +5518,6 @@ NamedIntrinsic Compiler::lookupNamedIntrinsic(CORINFO_METHOD_HANDLE method)
                 result = NI_System_Activator_DefaultConstructorOf;
             }
         }
-        else if (strcmp(className, "ByReference`1") == 0)
-        {
-            if (strcmp(methodName, ".ctor") == 0)
-            {
-                result = NI_System_ByReference_ctor;
-            }
-            else if (strcmp(methodName, "get_Value") == 0)
-            {
-                result = NI_System_ByReference_get_Value;
-            }
-        }
         else if (strcmp(className, "Math") == 0 || strcmp(className, "MathF") == 0)
         {
             if (strcmp(methodName, "Abs") == 0)

src/coreclr/jit/namedintrinsiclist.h

@@ -76,8 +76,6 @@ enum NamedIntrinsic : unsigned short
     NI_Array_Get,
     NI_Array_Set,
 
-    NI_System_ByReference_ctor,
-    NI_System_ByReference_get_Value,
     NI_System_Activator_AllocatorOf,
     NI_System_Activator_DefaultConstructorOf,
     NI_System_EETypePtr_EETypePtrOf,

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

@@ -16,12 +16,12 @@ namespace System
     public ref struct TypedReference
     {
         // Do not change the ordering of these fields. The JIT has a dependency on this layout.
-        private readonly ByReference<byte> _value;
+        private readonly ref byte _value;
         private readonly RuntimeTypeHandle _typeHandle;
 
         private TypedReference(object target, int offset, RuntimeTypeHandle typeHandle)
         {
-            _value = new ByReference<byte>(ref Unsafe.Add<byte>(ref target.GetRawData(), offset));
+            _value = ref Unsafe.Add<byte>(ref target.GetRawData(), offset);
             _typeHandle = typeHandle;
         }
 
@@ -81,7 +81,7 @@ internal ref byte Value
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             get
             {
-                return ref _value.Value;
+                return ref _value;
             }
         }
     }

src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs

@@ -2298,11 +2298,6 @@ private int GatherClassGCLayout(TypeDesc type, byte* gcPtrs)
         {
             int result = 0;
 
-            if (type.IsByReferenceOfT)
-            {
-                return MarkGcField(gcPtrs, CorInfoGCType.TYPE_GC_BYREF);
-            }
-
             foreach (var field in type.GetFields())
             {
                 if (field.IsStatic)
@@ -2920,15 +2915,6 @@ private CorInfoType getFieldType(CORINFO_FIELD_STRUCT_* field, CORINFO_CLASS_STR
                 type = asCorInfoType(fieldType);
             }
 
-            Debug.Assert(!fieldDesc.OwningType.IsByReferenceOfT ||
-                fieldDesc.OwningType.GetKnownField("_value").FieldType.Category == TypeFlags.IntPtr);
-            if (type == CorInfoType.CORINFO_TYPE_NATIVEINT && fieldDesc.OwningType.IsByReferenceOfT)
-            {
-                Debug.Assert(structType == null || *structType == null);
-                Debug.Assert(fieldDesc.Offset.AsInt == 0);
-                type = CorInfoType.CORINFO_TYPE_BYREF;
-            }
-
             return type;
         }
 

src/coreclr/tools/Common/JitInterface/SystemVStructClassificator.cs

@@ -295,21 +295,7 @@ private static bool ClassifyEightBytes(TypeDesc typeDesc,
                     return false;
                 }
 
-                SystemVClassificationType fieldClassificationType;
-                if (typeDesc.IsByReferenceOfT)
-                {
-                    // ByReference<T> is a special type whose single IntPtr field holds a by-ref potentially interior pointer to GC
-                    // memory, so classify its field as such
-                    Debug.Assert(numIntroducedFields == 1);
-                    Debug.Assert(field.FieldType.IsWellKnownType(WellKnownType.IntPtr));
-
-                    fieldClassificationType = SystemVClassificationTypeIntegerByRef;
-                }
-                else
-                {
-                    fieldClassificationType = TypeDef2SystemVClassification(field.FieldType);
-                }
-
+                SystemVClassificationType fieldClassificationType = TypeDef2SystemVClassification(field.FieldType);
                 if (fieldClassificationType == SystemVClassificationTypeStruct)
                 {
                     bool inEmbeddedStructPrev = helper.InEmbeddedStruct;

src/coreclr/tools/Common/TypeSystem/Common/ExplicitLayoutValidator.cs

@@ -157,7 +157,7 @@ private void MarkByRefAndORefLocations(MetadataType type, List<FieldLayoutInterv
                     {
                         SetFieldLayout(refMap, offset, _pointerSize, FieldLayoutTag.ORef);
                     }
-                    else if (field.FieldType.IsByRef || field.FieldType.IsByReferenceOfT)
+                    else if (field.FieldType.IsByRef)
                     {
                         SetFieldLayout(refMap, offset, _pointerSize, FieldLayoutTag.ByRef);
                     }

src/coreclr/tools/Common/TypeSystem/Common/MetadataTypeSystemContext.cs

@@ -43,7 +43,6 @@ public abstract partial class MetadataTypeSystemContext : TypeSystemContext
             "Exception",
 
             "TypedReference",
-            "ByReference`1",
         };
 
         public static IEnumerable<string> WellKnownTypeNames => s_wellKnownTypeNames;
@@ -71,7 +70,7 @@ public virtual void SetSystemModule(ModuleDesc systemModule)
             // Initialize all well known types - it will save us from checking the name for each loaded type
             for (int typeIndex = 0; typeIndex < _wellKnownTypes.Length; typeIndex++)
             {
-                // Require System.Object to be present as a minimal sanity check. 
+                // Require System.Object to be present as a minimal sanity check.
                 // The set of required well-known types is not strictly defined since different .NET profiles implement different subsets.
                 MetadataType type = systemModule.GetType("System", s_wellKnownTypeNames[typeIndex], throwIfNotFound: typeIndex == (int)WellKnownType.Object);
                 if (type != null)
@@ -88,7 +87,7 @@ public override DefType GetWellKnownType(WellKnownType wellKnownType, bool throw
 
             int typeIndex = (int)wellKnownType - 1;
             DefType type = _wellKnownTypes[typeIndex];
-            if (type == null && throwIfNotFound) 
+            if (type == null && throwIfNotFound)
                 ThrowHelper.ThrowTypeLoadException("System", s_wellKnownTypeNames[typeIndex], SystemModule);
 
             return type;

src/coreclr/tools/Common/TypeSystem/Common/TypeDesc.cs

@@ -117,7 +117,6 @@ internal void SetWellKnownType(WellKnownType wellKnownType)
                 case WellKnownType.RuntimeMethodHandle:
                 case WellKnownType.RuntimeFieldHandle:
                 case WellKnownType.TypedReference:
-                case WellKnownType.ByReferenceOfT:
                     flags = TypeFlags.ValueType;
                     break;
 
@@ -298,18 +297,6 @@ public bool IsNullable
             }
         }
 
-        /// <summary>
-        /// Gets a value indicating whether this is a generic definition, or
-        /// an instance of System.ByReference`1.
-        /// </summary>
-        public bool IsByReferenceOfT
-        {
-            get
-            {
-                return this.GetTypeDefinition().IsWellKnownType(WellKnownType.ByReferenceOfT);
-            }
-        }
-
         /// <summary>
         /// Gets a value indicating whether this is an array type (<see cref="ArrayType"/>).
         /// Note this will return true for both multidimensional array types and vector types.

src/coreclr/tools/Common/TypeSystem/Common/WellKnownType.cs

@@ -46,6 +46,5 @@ public enum WellKnownType
         Exception,
 
         TypedReference,
-        ByReferenceOfT,
     }
 }

src/coreclr/tools/Common/TypeSystem/Interop/IL/MarshalHelpers.cs

@@ -411,7 +411,6 @@ internal static MarshallerKind GetMarshallerKind(
                 bool isBlittable = MarshalUtils.IsBlittableType(type);
 
                 // Blittable generics are allowed to be marshalled with the following exceptions:
-                // * ByReference<T>: This represents an interior pointer and is not actually blittable
                 // * Nullable<T>: We don't want to be locked into the default behavior as we may want special handling later
                 // * Vector64<T>: Represents the __m64 ABI primitive which requires currently unimplemented handling
                 // * Vector128<T>: Represents the __m128 ABI primitive which requires currently unimplemented handling
@@ -420,7 +419,6 @@ internal static MarshallerKind GetMarshallerKind(
                 // We can't block these types for field scenarios for back-compat reasons.
 
                 if (type.HasInstantiation && !isField && (!isBlittable
-                    || InteropTypes.IsSystemByReference(context, type)
                     || InteropTypes.IsSystemSpan(context, type)
                     || InteropTypes.IsSystemReadOnlySpan(context, type)
                     || InteropTypes.IsSystemNullable(context, type)

src/coreclr/tools/Common/TypeSystem/Interop/InteropTypes.cs

@@ -117,11 +117,6 @@ public static bool IsSystemArgIterator(TypeSystemContext context, TypeDesc type)
             return IsCoreNamedType(context, type, "System", "ArgIterator");
         }
 
-        public static bool IsSystemByReference(TypeSystemContext context, TypeDesc type)
-        {
-            return IsCoreNamedType(context, type, "System", "ByReference`1");
-        }
-
         public static bool IsSystemSpan(TypeSystemContext context, TypeDesc type)
         {
             return IsCoreNamedType(context, type, "System", "Span`1");

src/coreclr/tools/aot/ILCompiler.Compiler/IL/ILImporter.Scanner.cs

@@ -372,11 +372,6 @@ private void ImportCall(ILOpcode opcode, int token)
                     return;
                 }
 
-                if (method.OwningType.IsByReferenceOfT && (method.IsConstructor || method.Name == "get_Value"))
-                {
-                    return;
-                }
-
                 if (IsEETypePtrOf(method))
                 {
                     if (runtimeDeterminedMethod.IsRuntimeDeterminedExactMethod)

src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/GCRefMapBuilder.cs

@@ -7,15 +7,15 @@
 
 using Internal.TypeSystem;
 
-// The GCRef map is used to encode GC type of arguments for callsites. Logically, it is sequence <pos, token> where pos is 
+// The GCRef map is used to encode GC type of arguments for callsites. Logically, it is sequence <pos, token> where pos is
 // position of the reference in the stack frame and token is type of GC reference (one of GCREFMAP_XXX values).
 //
-// - The encoding always starts at the byte boundary. The high order bit of each byte is used to signal end of the encoding 
+// - The encoding always starts at the byte boundary. The high order bit of each byte is used to signal end of the encoding
 // stream. The last byte has the high order bit zero. It means that there are 7 useful bits in each byte.
 // - "pos" is always encoded as delta from previous pos.
-// - The basic encoding unit is two bits. Values 0, 1 and 2 are the common constructs (skip single slot, GC reference, interior 
-// pointer). Value 3 means that extended encoding follows. 
-// - The extended information is integer encoded in one or more four bit blocks. The high order bit of the four bit block is 
+// - The basic encoding unit is two bits. Values 0, 1 and 2 are the common constructs (skip single slot, GC reference, interior
+// pointer). Value 3 means that extended encoding follows.
+// - The extended information is integer encoded in one or more four bit blocks. The high order bit of the four bit block is
 // used to signal the end.
 // - For x86, the encoding starts by size of the callee poped stack. The size is encoded using the same mechanism as above (two bit
 // basic encoding, with extended encoding for large values).
@@ -35,7 +35,7 @@ public class GCRefMapBuilder
         private int _pendingByte;
 
         /// <summary>
-        /// Number of bits in pending byte. Note that the trailing zero bits are not written out, 
+        /// Number of bits in pending byte. Note that the trailing zero bits are not written out,
         /// so this can be more than 7.
         /// </summary>
         private int _bits;
@@ -293,7 +293,7 @@ private void GcScanValueType(TypeDesc type, ArgDestination argDest, int delta, C
 
         private void FindByRefPointerOffsetsInByRefLikeObject(TypeDesc type, ArgDestination argDest, int delta, CORCOMPILE_GCREFMAP_TOKENS[] frame)
         {
-            if (type.IsByReferenceOfT || type.IsByRef)
+            if (type.IsByRef)
             {
                 argDest.GcMark(frame, delta, interior: true);
                 return;

src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunMetadataFieldLayoutAlgorithm.cs

@@ -253,7 +253,7 @@ private void GetElementTypeInfoGeneric(
                     size = fieldType.GetElementSize().AsInt;
                     alignment = size;
                 }
-                else if (fieldType.IsByRef || fieldType.IsByRefLike || fieldType.IsByReferenceOfT)
+                else if (fieldType.IsByRef || fieldType.IsByRefLike)
                 {
                     ThrowHelper.ThrowTypeLoadException(ExceptionStringID.ClassLoadGeneral, fieldDesc.OwningType);
                 }

src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/CoreTestAssembly/InstanceFieldLayout.cs

@@ -296,7 +296,7 @@ namespace IsByRefLike
 {
     public ref struct ByRefLikeStruct
     {
-        ByReference<object> ByRef;
+        ref object ByRef;
     }
 
     public struct NotByRefLike

src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/CoreTestAssembly/Platform.cs

@@ -48,7 +48,7 @@ public struct Double { }
     public abstract class ValueType { }
     public abstract class Enum : ValueType { }
     public struct Nullable<T> where T : struct { }
-    
+
     public sealed class String { }
     public abstract class Array : System.Collections.IList { }
     public abstract class Delegate { }
@@ -68,11 +68,9 @@ public class Exception { }
 
     public ref struct TypedReference
     {
-        private readonly ByReference<byte> _value;
+        private readonly ref byte _value;
         private readonly RuntimeTypeHandle _typeHandle;
     }
-
-    public ref struct ByReference<T> { }
 }
 
 namespace System.Collections

src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/ILTestAssembly/InstanceFieldLayout.il

@@ -4,18 +4,18 @@
 .class public sequential ansi sealed beforefieldinit IsByRefLike.InvalidStruct
        extends [CoreTestAssembly]System.ValueType
 {
-  .field private valuetype [CoreTestAssembly]System.ByReference`1<object> ByRef
+  .field private object& ByRef
 }
 
 .class public auto ansi beforefieldinit IsByRefLike.InvalidClass1
        extends [CoreTestAssembly]System.Object
 {
-  .field private valuetype [CoreTestAssembly]System.ByReference`1<object> ByRef
+  .field private object& ByRef
 }
 
 .class public auto ansi beforefieldinit IsByRefLike.InvalidClass2
        extends [CoreTestAssembly]System.Object
 {
-  .custom instance void [CoreTestAssembly]System.Runtime.CompilerServices.IsByRefLikeAttribute::.ctor() = ( 01 00 00 00 ) 
-  .field private valuetype [CoreTestAssembly]System.ByReference`1<object> ByRef
+  .custom instance void [CoreTestAssembly]System.Runtime.CompilerServices.IsByRefLikeAttribute::.ctor() = ( 01 00 00 00 )
+  .field private object& ByRef
 }