Support generic fields in PersistedAssemblyBuilder

src/libraries/System.Reflection.Emit/src/System/Reflection/Emit/ModuleBuilderImpl.cs

@@ -734,13 +734,15 @@ private EntityHandle GetMemberReferenceHandle(MemberInfo memberInfo)
                 {
                     case FieldInfo field:
                         Type declaringType = field.DeclaringType!;
-                        if (field.DeclaringType!.IsGenericTypeDefinition)
+                        if (declaringType.IsGenericTypeDefinition)
                         {
                             //The type of the field has to be fully instantiated type.
                             declaringType = declaringType.MakeGenericType(declaringType.GetGenericArguments());
                         }
+
                         memberHandle = AddMemberReference(field.Name, GetTypeHandle(declaringType),
-                            MetadataSignatureHelper.GetFieldSignature(field.FieldType, field.GetRequiredCustomModifiers(), field.GetOptionalCustomModifiers(), this));
+                            MetadataSignatureHelper.GetFieldSignature(GetFieldType(field), field.GetRequiredCustomModifiers(), field.GetOptionalCustomModifiers(), this));
+
                         break;
                     case ConstructorInfo ctor:
                         ctor = (ConstructorInfo)GetOriginalMemberIfConstructedType(ctor);
@@ -770,6 +772,26 @@ private EntityHandle GetMemberReferenceHandle(MemberInfo memberInfo)
             }
 
             return memberHandle;
+
+            // The field type has to be the original open generic field type, not the closed type.
+            [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2075:UnrecognizedReflectionPattern", Justification = "Internal reflection implementation")]
+            static Type GetFieldType(FieldInfo fieldInfo)
+            {
+                if (fieldInfo.DeclaringType!.IsGenericType)
+                {
+                    fieldInfo = fieldInfo.DeclaringType!.GetGenericTypeDefinition().GetField(fieldInfo.Name, GetBindingFlags(fieldInfo))!;
+                }
+
+                return fieldInfo.FieldType;
+
+                static BindingFlags GetBindingFlags(FieldInfo fieldInfo)
+                {
+                    BindingFlags flags = BindingFlags.Default;
+                    flags |= fieldInfo.IsPublic ? BindingFlags.Public : BindingFlags.NonPublic;
+                    flags |= fieldInfo.IsStatic ? BindingFlags.Static : BindingFlags.Instance;
+                    return flags;
+                }
+            }
         }
 
         private EntityHandle GetMethodReference(MethodInfo methodInfo, Type[] optionalParameterTypes)

src/libraries/System.Reflection.Emit/tests/PersistedAssemblyBuilder/AssemblySaveTypeBuilderTests.cs

@@ -5,6 +5,8 @@
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Linq;
+using System.Reflection.Metadata;
+using System.Reflection.PortableExecutable;
 using Xunit;
 
 namespace System.Reflection.Emit.Tests
@@ -124,11 +126,15 @@ public void CreateMembersThatUsesTypeLoadedFromCoreAssemblyTest()
             }
         }
 
-        private static TypeBuilder CreateAssemblyAndDefineType(out PersistedAssemblyBuilder assemblyBuilder)
+        private static ModuleBuilder CreateAssembly(out PersistedAssemblyBuilder assemblyBuilder)
         {
             assemblyBuilder = AssemblySaveTools.PopulateAssemblyBuilder(s_assemblyName);
-            return assemblyBuilder.DefineDynamicModule("MyModule")
-                .DefineType("TestInterface", TypeAttributes.Interface | TypeAttributes.Abstract);
+            return assemblyBuilder.DefineDynamicModule("MyModule");
+        }
+
+        private static TypeBuilder CreateAssemblyAndDefineType(out PersistedAssemblyBuilder assemblyBuilder)
+        {
+            return CreateAssembly(out assemblyBuilder).DefineType("TestInterface", TypeAttributes.Interface | TypeAttributes.Abstract);
         }
 
         [Fact]
@@ -205,6 +211,83 @@ public void SaveGenericTypeParametersForAType(string[] typeParamNames)
             }
         }
 
+        private class GenericClassWithGenericField<T>
+        {
+#pragma warning disable CS0649
+            public T F;
+#pragma warning restore CS0649
+        }
+
+        private class GenericClassWithNonGenericField<T>
+        {
+#pragma warning disable CS0649
+            public int F;
+#pragma warning restore CS0649
+        }
+
+        public static IEnumerable<object[]> GenericTypesWithField()
+        {
+            yield return new object[] { typeof(GenericClassWithGenericField<int>), true };
+            yield return new object[] { typeof(GenericClassWithNonGenericField<bool>), false };
+        }
+
+        [Theory]
+        [MemberData(nameof(GenericTypesWithField))]
+        public void SaveGenericField(Type declaringType, bool shouldFieldBeGeneric)
+        {
+            using (TempFile file = TempFile.Create())
+            {
+                ModuleBuilder mb = CreateAssembly(out PersistedAssemblyBuilder assemblyBuilder);
+                TypeBuilder tb = mb.DefineType("C", TypeAttributes.Class);
+                MethodBuilder method = tb.DefineMethod("TestMethod", MethodAttributes.Public, returnType: typeof(int), parameterTypes: null);
+                ILGenerator il = method.GetILGenerator();
+                il.Emit(OpCodes.Newobj, declaringType.GetConstructor([]));
+                il.Emit(OpCodes.Ldfld, declaringType.GetField("F"));
+                il.Emit(OpCodes.Ret);
+                Type createdType = tb.CreateType();
+                assemblyBuilder.Save(file.Path);
+
+                using (FileStream stream = File.OpenRead(file.Path))
+                {
+                    using (PEReader peReader = new PEReader(stream))
+                    {
+                        bool found = false;
+                        MetadataReader metadataReader = peReader.GetMetadataReader();
+                        foreach (MemberReferenceHandle memberRefHandle in metadataReader.MemberReferences)
+                        {
+                            MemberReference memberRef = metadataReader.GetMemberReference(memberRefHandle);
+                            if (memberRef.GetKind() == MemberReferenceKind.Field)
+                            {
+                                Assert.False(found);
+                                found = true;
+
+                                Assert.Equal("F", metadataReader.GetString(memberRef.Name));
+
+                                // A reference to a generic field should point to the open generic field, and not the resolved generic type.
+                                Assert.Equal(shouldFieldBeGeneric, IsGenericField(metadataReader.GetBlobReader(memberRef.Signature)));
+                            }
+                        }
+
+                        Assert.True(found);
+                    }
+                }
+            }
+
+            static bool IsGenericField(BlobReader signatureReader)
+            {
+                while (signatureReader.RemainingBytes > 0)
+                {
+                    SignatureTypeCode typeCode = signatureReader.ReadSignatureTypeCode();
+                    if (typeCode == SignatureTypeCode.GenericTypeParameter)
+                    {
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+        }
+
         private static void SetVariousGenericParameterValues(GenericTypeParameterBuilder[] typeParams)
         {
             typeParams[0].SetInterfaceConstraints([typeof(IAccess), typeof(INoMethod)]);