Fix more issues related to generic method/type validations and reference, add more test and other implementations

Author: buyaa-n

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

@@ -75,15 +75,15 @@ public override Type[] GetGenericParameterConstraints() =>
         public override string Name => _name;
         public override Module Module => _type.Module;
         public override Assembly Assembly => _type.Assembly;
-        public override string? FullName => _name;
+        public override string? FullName => null;
         public override string? Namespace => null;
         public override string? AssemblyQualifiedName => null;
         public override Type UnderlyingSystemType => this;
         public override bool IsGenericTypeDefinition => false;
         public override bool IsGenericType => false;
         public override bool IsGenericParameter => true;
         public override bool IsConstructedGenericType => false;
-        public override bool ContainsGenericParameters => _type.ContainsGenericParameters;
+        public override bool ContainsGenericParameters => false;
         public override MethodBase? DeclaringMethod => _type.DeclaringMethod;
         public override Type? BaseType => _parent;
         public override RuntimeTypeHandle TypeHandle => throw new NotSupportedException();

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

@@ -519,14 +519,22 @@ private MethodSpecificationHandle AddMethodSpecification(EntityHandle methodHand
                 method: methodHandle,
                 instantiation: _metadataBuilder.GetOrAddBlob(MetadataSignatureHelper.GetMethodSpecificationSignature(genericArgs, this)));
 
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2055:RequiresDynamicCode", Justification = "Test")]
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL3050:RequiresUnreferencedCode", Justification = "Test")]
         private EntityHandle GetMemberReferenceHandle(MemberInfo memberInfo)
         {
             if (!_memberReferences.TryGetValue(memberInfo, out var memberHandle))
             {
                 switch (memberInfo)
                 {
                     case FieldInfo field:
-                        memberHandle = AddMemberReference(field.Name, GetTypeHandle(memberInfo.DeclaringType!),
+                        Type declaringType = field.DeclaringType!;
+                        if (field.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));
                         break;
                     case ConstructorInfo ctor:
@@ -791,7 +799,7 @@ internal EntityHandle GetMemberHandle(MemberInfo member)
                 return ctor._methodBuilder._handle;
             }
 
-            if (member is FieldBuilderImpl fb && Equals(fb.Module))
+            if (member is FieldBuilderImpl fb && Equals(fb.Module) && !fb.DeclaringType!.IsGenericTypeDefinition)
             {
                 return fb._handle;
             }
@@ -857,7 +865,21 @@ private EntityHandle GetHandleForMember(MemberInfo member)
         }
 
         private static bool IsConstructedFromNotBakedTypeBuilder(Type type) => type.IsConstructedGenericType &&
-            type.GetGenericTypeDefinition() is TypeBuilderImpl tb && tb._handle == default;
+            (type.GetGenericTypeDefinition() is TypeBuilderImpl tb && tb._handle == default) ||
+             ContainsNotBakedTypeBuilder(type.GetGenericArguments());
+
+        private static bool ContainsNotBakedTypeBuilder(Type[] genericArguments)
+        {
+            foreach (Type type in genericArguments)
+            {
+                if (type is TypeBuilderImpl tb && tb._handle == default)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
 
         public override int GetMethodMetadataToken(ConstructorInfo constructor) => GetTokenForHandle(GetConstructorHandle(constructor));
 
@@ -880,6 +902,11 @@ internal EntityHandle GetMethodHandle(MethodInfo method)
                 return mb._handle;
             }
 
+            if (IsConstructedMethodFromNotBakedMethodBuilder(method))
+            {
+                return default;
+            }
+
             return GetHandleForMember(method);
         }
 

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

@@ -30,7 +30,12 @@ public ParameterBuilderImpl(MethodBuilderImpl methodBuilder, int sequence, Param
 
         public override int Position => _position;
 
-        public override void SetConstant(object? defaultValue) => _defaultValue = defaultValue;
+        public override void SetConstant(object? defaultValue)
+        {
+            FieldBuilderImpl.ValidateDefaultValueType(defaultValue, _methodBuilder.ParameterTypes![_position - 1]);
+            _defaultValue = defaultValue;
+            _attributes |= ParameterAttributes.HasDefault;
+        }
 
         protected override void SetCustomAttributeCore(ConstructorInfo con, ReadOnlySpan<byte> binaryAttribute)
         {

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

@@ -191,14 +191,20 @@ private void ValidateAllAbstractMethodsAreImplemented()
         }
 
         [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2065:DynamicallyAccessedMembers", Justification = "Methods are loaded from this TypeBuilder. The interface methods should be available at this point")]
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2075:DynamicallyAccessedMembers", Justification =
+            "Somehow #pragma warning disable IL2075 doesn't suppress anymore, related to https://github.com/dotnet/runtime/issues/96646")]
         [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2085:DynamicallyAccessedMembers", Justification = "Methods are loaded from this TypeBuilder")]
         private void CheckInterfaces(Type[] _interfaces)
         {
             foreach (Type interfaceType in _interfaces)
             {
-#pragma warning disable IL2075 // Analyzer produces a different warning code than illink. The IL2065 suppression takes care of illink: https://github.com/dotnet/runtime/issues/96646
-                MethodInfo[] interfaceMethods = interfaceType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static);
-#pragma warning restore IL2075
+                Type ifaceType = interfaceType;
+                if (interfaceType.IsConstructedGenericType &&
+                    IsConstructedFromTypeBuilder(interfaceType.GetGenericTypeDefinition(), interfaceType.GetGenericArguments()))
+                {
+                    ifaceType = interfaceType.GetGenericTypeDefinition();
+                }
+                MethodInfo[] interfaceMethods = ifaceType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static);
                 for (int i = 0; i < interfaceMethods.Length; i++)
                 {
                     MethodInfo interfaceMethod = interfaceMethods[i];
@@ -207,7 +213,9 @@ private void CheckInterfaces(Type[] _interfaces)
                         continue;
                     }
 
-                    MethodInfo? implementedMethod = GetMethodImpl(interfaceMethod.Name, GetBindingFlags(interfaceMethod), null, interfaceMethod.CallingConvention, GetParameterTypes(interfaceMethod.GetParameters()), null);
+                    Type[] parameterTypes = interfaceMethod.ContainsGenericParameters ?
+                        GetParameterTypesMatchGeneric(interfaceMethod.GetParameters(), interfaceType.GetGenericArguments()) : GetParameterTypes(interfaceMethod.GetParameters());
+                    MethodInfo? implementedMethod = GetMethodImpl(interfaceMethod.Name, GetBindingFlags(interfaceMethod), null, interfaceMethod.CallingConvention, parameterTypes, null);
 
                     if ((implementedMethod == null || implementedMethod.IsAbstract) && !FoundInInterfaceMapping(interfaceMethod))
                     {
@@ -216,12 +224,28 @@ private void CheckInterfaces(Type[] _interfaces)
                 }
 
                 // Check parent interfaces too
-#pragma warning disable IL2075 // Analyzer produces a different warning code than illink. The IL2065 suppression takes care of illink: https://github.com/dotnet/runtime/issues/96646
-                CheckInterfaces(interfaceType.GetInterfaces());
-#pragma warning restore IL2075
+                CheckInterfaces(ifaceType.GetInterfaces());
             }
         }
 
+        private static bool IsConstructedFromTypeBuilder(Type constructedType, Type[] genericArgs)
+        {
+            if (constructedType is TypeBuilderImpl)
+            {
+                return true;
+            }
+
+            foreach (Type arg in genericArgs)
+            {
+                if (arg is TypeBuilderImpl or GenericTypeParameterBuilderImpl)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
         private bool FoundInInterfaceMapping(MethodInfo abstractMethod)
         {
             if (_methodOverrides == null)
@@ -836,8 +860,6 @@ internal static BindingFlags GetBindingFlags(MethodInfo method)
 
         private static bool MatchesTheFilter(MethodBuilderImpl method, BindingFlags methodFlags, BindingFlags bindingFlags, CallingConventions callConv, Type[]? argumentTypes)
         {
-            bindingFlags ^= BindingFlags.DeclaredOnly;
-
             if ((bindingFlags & methodFlags) != methodFlags)
             {
                 return false;
@@ -977,19 +999,17 @@ public override MethodInfo[] GetMethods(BindingFlags bindingAttr)
         }
 
         [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields)]
-        public override FieldInfo? GetField(string name, BindingFlags bindingAttr)
+        public override FieldInfo? GetField(string name, BindingFlags bindingFlags)
         {
             ArgumentNullException.ThrowIfNull(name);
+            ThrowIfNotCreated();
 
             FieldInfo? match = null;
-
-            BindingFlags fieldFlags = bindingAttr ^ BindingFlags.DeclaredOnly;
-            fieldFlags ^= BindingFlags.IgnoreCase;
-            StringComparison compare = (bindingAttr & BindingFlags.IgnoreCase) != 0 ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;
+            StringComparison compare = (bindingFlags & BindingFlags.IgnoreCase) != 0 ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;
             foreach (FieldBuilderImpl fieldInfo in _fieldDefinitions)
             {
-                BindingFlags currentFieldFlags = GetBindingFlags(fieldInfo);
-                if (name.Equals(fieldInfo.Name, compare) && (fieldFlags & currentFieldFlags) == currentFieldFlags)
+                BindingFlags fieldFlags = GetBindingFlags(fieldInfo);
+                if (name.Equals(fieldInfo.Name, compare) && (bindingFlags & fieldFlags) == fieldFlags)
                 {
                     if (match != null)
                     {
@@ -1003,9 +1023,9 @@ public override MethodInfo[] GetMethods(BindingFlags bindingAttr)
                 }
             }
 
-            if (match == null && !bindingAttr.HasFlag(BindingFlags.DeclaredOnly) && _typeParent != null)
+            if (match == null && !bindingFlags.HasFlag(BindingFlags.DeclaredOnly) && _typeParent != null)
             {
-                match = _typeParent.GetField(name, bindingAttr);
+                match = _typeParent.GetField(name, bindingFlags);
             }
 
             return match;
@@ -1022,7 +1042,23 @@ private static BindingFlags GetBindingFlags(FieldBuilderImpl field)
         }
 
         [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields)]
-        public override FieldInfo[] GetFields(BindingFlags bindingAttr) => throw new NotSupportedException();
+        public override FieldInfo[] GetFields(BindingFlags bindingAttr)
+        {
+            ThrowIfNotCreated();
+
+            List<FieldBuilderImpl> candidates = new List<FieldBuilderImpl>(_fieldDefinitions.Count);
+            for (int i = 0; i < _fieldDefinitions.Count; i++)
+            {
+                FieldBuilderImpl fieldInfo = _fieldDefinitions[i];
+                BindingFlags fieldFlags = GetBindingFlags(fieldInfo);
+                if ((bindingAttr & fieldFlags) == fieldFlags)
+                {
+                    candidates.Add(fieldInfo);
+                }
+            }
+
+            return candidates.ToArray();
+        }
 
         [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)]
         [return: DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)]
@@ -1105,6 +1141,21 @@ private static Type[] GetParameterTypes(ParameterInfo[] parameterInfos)
             return parameterTypes;
         }
 
+        private static Type[] GetParameterTypesMatchGeneric(ParameterInfo[] parameters, Type[] genericArguments)
+        {
+            Type[] parameterTypes = new Type[parameters.Length];
+            for (int i = 0; i < parameters.Length; i++)
+            {
+                parameterTypes[i] = parameters[i].ParameterType;
+                if (parameterTypes[i].IsGenericParameter)
+                {
+                    parameterTypes[i] = genericArguments[parameterTypes[i].GenericParameterPosition];
+                }
+            }
+
+            return parameterTypes;
+        }
+
         private void ValidateInterfaceType(Type interfaceType)
         {
             if (!interfaceType.IsInterface)

src/libraries/System.Reflection.Emit/tests/PersistableAssemblyBuilder/AssemblySaveCustomAttributeTests.cs

@@ -171,10 +171,6 @@ private static void DefineMethodsAndSetAttributes(List<CustomAttributeBuilder> m
                 {
                     ParameterBuilder pb = meb.DefineParameter(param.Position + 1, param.Attributes, param.Name);
                     paramAttributes.ForEach(pb.SetCustomAttribute);
-                    if (param.ParameterType.Equals(typeof(string)))
-                    {
-                        pb.SetConstant("Hello");
-                    }
                 }
             }
         }