Add runtime support for ref fields

src/coreclr/utilcode/util.cpp

@@ -1805,9 +1805,7 @@ HRESULT validateOneArg(
                 // Validate the referenced type.
                 if(FAILED(hr = validateOneArg(tk, pSig, pulNSentinels, pImport, FALSE))) IfFailGo(hr);
                 break;
-            case ELEMENT_TYPE_BYREF:  //fallthru
-                if(TypeFromToken(tk)==mdtFieldDef) IfFailGo(VLDTR_E_SIG_BYREFINFIELD);
-                FALLTHROUGH;
+            case ELEMENT_TYPE_BYREF:
             case ELEMENT_TYPE_PINNED:
             case ELEMENT_TYPE_SZARRAY:
                 // Validate the referenced type.

src/coreclr/vm/field.cpp

@@ -61,6 +61,8 @@ VOID FieldDesc::Init(mdFieldDef mb, CorElementType FieldType, DWORD dwMemberAttr
         FieldType == ELEMENT_TYPE_R8 ||
         FieldType == ELEMENT_TYPE_CLASS ||
         FieldType == ELEMENT_TYPE_VALUETYPE ||
+        FieldType == ELEMENT_TYPE_BYREF ||
+        FieldType == ELEMENT_TYPE_TYPEDBYREF ||
         FieldType == ELEMENT_TYPE_PTR ||
         FieldType == ELEMENT_TYPE_FNPTR
         );
@@ -70,7 +72,8 @@ VOID FieldDesc::Init(mdFieldDef mb, CorElementType FieldType, DWORD dwMemberAttr
     m_requiresFullMbValue = 0;
     SetMemberDef(mb);
 
-    m_type = FieldType;
+    // A TypedByRef should be treated like a regular value type.
+    m_type = FieldType != ELEMENT_TYPE_TYPEDBYREF ? FieldType : ELEMENT_TYPE_VALUETYPE;
     m_prot = fdFieldAccessMask & dwMemberAttrs;
     m_isStatic = fIsStatic != 0;
     m_isRVA = fIsRVA != 0;
@@ -81,7 +84,7 @@ VOID FieldDesc::Init(mdFieldDef mb, CorElementType FieldType, DWORD dwMemberAttr
 #endif
 
     _ASSERTE(GetMemberDef() == mb);                 // no truncation
-    _ASSERTE(GetFieldType() == FieldType);
+    _ASSERTE(GetFieldType() == FieldType || (FieldType == ELEMENT_TYPE_TYPEDBYREF && m_type == ELEMENT_TYPE_VALUETYPE));
     _ASSERTE(GetFieldProtection() == (fdFieldAccessMask & dwMemberAttrs));
     _ASSERTE((BOOL) IsStatic() == (fIsStatic != 0));
 }
@@ -152,6 +155,7 @@ TypeHandle FieldDesc::LookupFieldTypeHandle(ClassLoadLevel level, BOOL dropGener
     _ASSERTE(type == ELEMENT_TYPE_CLASS ||
              type == ELEMENT_TYPE_VALUETYPE ||
              type == ELEMENT_TYPE_STRING ||
+             type == ELEMENT_TYPE_TYPEDBYREF ||
              type == ELEMENT_TYPE_SZARRAY ||
              type == ELEMENT_TYPE_VAR
              );

src/coreclr/vm/jitinterface.cpp

@@ -9002,9 +9002,6 @@ CorInfoType CEEInfo::getFieldTypeInternal (CORINFO_FIELD_HANDLE fieldHnd,
     FieldDesc* field = (FieldDesc*) fieldHnd;
     CorElementType type   = field->GetFieldType();
 
-    // <REVISIT_TODO>TODO should not burn the time to do this for anything but Value Classes</REVISIT_TODO>
-    _ASSERTE(type != ELEMENT_TYPE_BYREF);
-
     if (type == ELEMENT_TYPE_I)
     {
         PTR_MethodTable enclosingMethodTable = field->GetApproxEnclosingMethodTable();

src/coreclr/vm/methodtablebuilder.cpp

@@ -3935,6 +3935,27 @@ VOID    MethodTableBuilder::InitializeFieldDescs(FieldDesc *pFieldDescList,
                 break;
             }
 
+        case ELEMENT_TYPE_BYREF:
+            {
+                dwLog2FieldSize = LOG2_PTRSIZE;
+                if (fIsStatic)
+                {
+                    // Byref-like types cannot be used for static fields
+                    BuildMethodTableThrowException(IDS_CLASSLOAD_BYREFLIKE_STATICFIELD);
+                }
+                if (!bmtFP->fIsByRefLikeType)
+                {
+                    // Non-byref-like types cannot contain byref-like instance fields
+                    BuildMethodTableThrowException(IDS_CLASSLOAD_BYREFLIKE_INSTANCEFIELD);
+                }
+                break;
+            }
+
+        case ELEMENT_TYPE_TYPEDBYREF:
+            {
+                goto IS_VALUETYPE;
+            }
+
         // Class type variable (method type variables aren't allowed in fields)
         // These only occur in open types used for verification/reflection.
         case ELEMENT_TYPE_VAR:
@@ -4042,7 +4063,10 @@ VOID    MethodTableBuilder::InitializeFieldDescs(FieldDesc *pFieldDescList,
                         pByValueClass = (MethodTable *)-1;
                     }
                 } // If 'this' is a value class
-
+            }
+            // TypedReference shares the rest of the code here
+IS_VALUETYPE:
+            {
                 // It's not self-referential so try to load it
                 if (pByValueClass == NULL)
                 {

src/libraries/System.Reflection.Emit/tests/ModuleBuilder/ModuleBuilderDefineEnum.cs

@@ -160,11 +160,11 @@ public void DefineEnum_VoidUnderlyingType_ThrowsArgumentException()
         }
 
         [Fact]
-        public void DefineEnum_ByRefUnderlyingType_ThrowsCOMExceptionOnCreation()
+        public void DefineEnum_ByRefUnderlyingType_ThrowsTypeLoadExceptionOnCreation()
         {
             ModuleBuilder module = Helpers.DynamicModule();
             EnumBuilder enumBuilder = module.DefineEnum("Name", TypeAttributes.Public, typeof(int).MakeByRefType());
-            Assert.Throws<COMException>(() => enumBuilder.CreateTypeInfo());
+            Assert.Throws<TypeLoadException>(() => enumBuilder.CreateTypeInfo());
         }
 
         [Theory]

src/libraries/System.Reflection.Emit/tests/TypeBuilder/TypeBuilderDefineField.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Collections.Generic;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using Xunit;
 
@@ -112,15 +113,6 @@ public void DefineField_VoidFieldType_ThrowsArgumentException()
             AssertExtensions.Throws<ArgumentException>(null, () => type.DefineField("Name", typeof(void), FieldAttributes.Public));
         }
 
-        [Fact]
-        public void DefineField_ByRefFieldType_ThrowsCOMExceptionOnCreation()
-        {
-            TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
-            type.DefineField("Name", typeof(int).MakeByRefType(), FieldAttributes.Public);
-
-            Assert.Throws<COMException>(() => type.CreateTypeInfo());
-        }
-
         [Theory]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/2389", TestRuntimes.Mono)]
         [InlineData((FieldAttributes)(-1), (FieldAttributes)(-38145))]
@@ -152,6 +144,40 @@ public void DefineField_DynamicFieldTypeNotCreated_ThrowsTypeLoadException()
             Assert.Equal(createdFieldType, field.FieldType);
         }
 
+        [Fact]
+        public void DefineByRefField_Class_ThrowsTypeLoadExceptionOnCreation()
+        {
+            TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
+            type.DefineField("Name", typeof(int).MakeByRefType(), FieldAttributes.Public);
+
+            Assert.Throws<TypeLoadException>(() => type.CreateTypeInfo());
+        }
+
+        [Fact]
+        public void DefineByRefField_ValueType_NonByRefLike_ThrowsTypeLoadExceptionOnCreation()
+        {
+            TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public, baseType: typeof(ValueType));
+            type.DefineField("Name", typeof(int).MakeByRefType(), FieldAttributes.Public);
+
+            Assert.Throws<TypeLoadException>(() => type.CreateTypeInfo());
+        }
+
+        [Fact]
+        public void DefineByRefField_ValueType_ByRefLike()
+        {
+            TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public, baseType: typeof(ValueType));
+            type.DefineField("Name", typeof(int).MakeByRefType(), FieldAttributes.Public);
+
+            // Define type to be ByRefLike
+            CustomAttributeBuilder ca = new(typeof(IsByRefLikeAttribute).GetConstructors()[0], new object[] { });
+            type.SetCustomAttribute(ca);
+
+            Type createdType = type.CreateTypeInfo().AsType();
+            FieldInfo[] fields = createdType.GetFields();
+            Assert.Equal(1, fields.Length);
+            Assert.True(fields[0].FieldType.IsByRef);
+        }
+
         [Fact]
         public void GetField_TypeNotCreated_ThrowsNotSupportedException()
         {

src/libraries/System.Reflection.Emit/tests/Utilities.cs

@@ -54,9 +54,16 @@ public static ModuleBuilder DynamicModule(string assemblyName = "TestAssembly",
             return DynamicAssembly(assemblyName).DefineDynamicModule(moduleName);
         }
 
-        public static TypeBuilder DynamicType(TypeAttributes attributes, string assemblyName = "TestAssembly", string moduleName = "TestModule", string typeName = "TestType")
+        public static TypeBuilder DynamicType(TypeAttributes attributes, string assemblyName = "TestAssembly", string moduleName = "TestModule", string typeName = "TestType", Type? baseType = null)
         {
-            return DynamicModule(assemblyName, moduleName).DefineType(typeName, attributes);
+            if (baseType is null)
+            {
+                return DynamicModule(assemblyName, moduleName).DefineType(typeName, attributes);
+            }
+            else
+            {
+                return DynamicModule(assemblyName, moduleName).DefineType(typeName, attributes, baseType);
+            }
         }
 
         public static EnumBuilder DynamicEnum(TypeAttributes visibility, Type underlyingType, string enumName = "TestEnum", string assemblyName = "TestAssembly", string moduleName = "TestModule")

src/mono/System.Private.CoreLib/src/System/Reflection/Emit/TypeBuilder.Mono.cs

@@ -884,7 +884,7 @@ private bool has_ctor_method()
                     if (fb == null)
                         continue;
                     if (fb.FieldType.IsByRef)
-                        throw new COMException();
+                        throw new TypeLoadException();
                 }
             }
 

src/tests/Loader/classloader/RefFields/InvalidCSharp.il

@@ -0,0 +1,92 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+.assembly extern System.Runtime { .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A ) }
+
+.assembly InvalidCSharp { }
+
+.class public auto ansi sealed beforefieldinit InvalidCSharp.InvalidStructWithRefField
+    extends [System.Runtime]System.ValueType
+{
+    // Type requires IsByRefLikeAttribute to be valid.
+    .field public string& invalid
+}
+
+// This is invalid metadata and is unable to be loaded.
+// -  [field sig] (0x80131815 (VER_E_FIELD_SIG))
+//
+// .class public auto ansi sealed beforefieldinit InvalidCSharp.InvalidStructWithStaticRefField
+//     extends [System.Runtime]System.ValueType
+// {
+//     .custom instance void [System.Runtime]System.Runtime.CompilerServices.IsByRefLikeAttribute::.ctor() = (
+//         01 00 00 00
+//     )
+//     .field public static string& invalid
+// }
+
+.class public auto ansi sealed beforefieldinit InvalidCSharp.WithRefField
+    extends [System.Runtime]System.ValueType
+{
+    .custom instance void [System.Runtime]System.Runtime.CompilerServices.IsByRefLikeAttribute::.ctor() = (
+        01 00 00 00
+    )
+    .field public string& Str
+
+    .method public hidebysig specialname rtspecialname
+        instance void .ctor (
+            string&
+        ) cil managed
+    {
+        ldarg.0
+        ldarg.1
+        stfld string& InvalidCSharp.WithRefField::Str
+        ret
+    }
+
+    .method public hidebysig
+        instance bool ConfirmFieldInstance (
+            string
+        ) cil managed
+    {
+        ldarg.0
+        ldfld string& InvalidCSharp.WithRefField::Str
+        ldind.ref
+        ldarg.1
+        ceq
+        ret
+    }
+}
+
+.class public auto ansi sealed beforefieldinit InvalidCSharp.WithRefStructField
+    extends [System.Runtime]System.ValueType
+{
+    .custom instance void [System.Runtime]System.Runtime.CompilerServices.IsByRefLikeAttribute::.ctor() = (
+        01 00 00 00
+    )
+    .field public valuetype InvalidCSharp.WithRefField& Field
+
+    .method public hidebysig specialname rtspecialname
+        instance void .ctor (
+            valuetype InvalidCSharp.WithRefField&
+        ) cil managed
+    {
+        ldarg.0
+        ldarg.1
+        stfld valuetype InvalidCSharp.WithRefField& InvalidCSharp.WithRefStructField::Field
+        ret
+    }
+
+    .method public hidebysig
+        instance bool ConfirmFieldInstance (
+            valuetype InvalidCSharp.WithRefField&
+        ) cil managed
+    {
+        ldarg.0
+        ldfld valuetype InvalidCSharp.WithRefField& InvalidCSharp.WithRefStructField::Field
+        ldind.ref
+        ldarg.1
+        ldind.ref
+        ceq
+        ret
+    }
+}

src/tests/Loader/classloader/RefFields/InvalidCSharp.ilproj

@@ -0,0 +1,8 @@
+<Project Sdk="Microsoft.NET.Sdk.IL">
+  <PropertyGroup>
+    <OutputType>Library</OutputType>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="InvalidCSharp.il" />
+  </ItemGroup>
+</Project>

src/tests/Loader/classloader/RefFields/Validate.cs

@@ -0,0 +1,50 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.IO;
+using InvalidCSharp;
+
+using Xunit;
+
+class Validate
+{
+    [Fact]
+    [SkipOnMono("Mono doesn't validate ref field state during type load")]
+    public static void Validate_Invalid_RefField_Fails()
+    {
+        Console.WriteLine($"{nameof(Validate_Invalid_RefField_Fails)}...");
+        Assert.Throws<TypeLoadException>(() => { var t = typeof(InvalidStructWithRefField); });
+    }
+
+    [Fact]
+    public static void Validate_RefStructWithRefField_Load()
+    {
+        Console.WriteLine($"{nameof(Validate_RefStructWithRefField_Load)}...");
+        var t = typeof(WithRefField);
+    }
+
+    [Fact]
+    public static void Validate_Create_RefField()
+    {
+        var str = nameof(Validate_Create_RefField);
+        Console.WriteLine($"{str}...");
+
+        WithRefField s = new(ref str);
+        Assert.True(s.ConfirmFieldInstance(str));
+
+        string newStr = new(str);
+        Assert.False(s.ConfirmFieldInstance(newStr));
+    }
+
+    [Fact]
+    public static void Validate_Create_RefStructField()
+    {
+        var str = nameof(Validate_Create_RefStructField);
+        Console.WriteLine($"{str}...");
+
+        WithRefField s = new(ref str);
+        WithRefStructField t = new(ref s);
+        Assert.True(t.ConfirmFieldInstance(ref s));
+    }
+}

src/tests/Loader/classloader/RefFields/Validate.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <OutputType>Exe</OutputType>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="Validate.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="InvalidCSharp.ilproj" />
+  </ItemGroup>
+</Project>