Enable generic attributes

src/mscorlib/src/System/Reflection/CustomAttribute.cs

@@ -1557,7 +1557,7 @@ private unsafe static object[] GetCustomAttributes(
                 // Create custom attribute object
                 if (ctorHasParameters)
                 {
-                    attribute = CreateCaObject(decoratedModule, ctor, ref blobStart, blobEnd, out cNamedArgs);
+                    attribute = CreateCaObject(decoratedModule, attributeType, ctor, ref blobStart, blobEnd, out cNamedArgs);
                 }
                 else
                 {
@@ -1717,7 +1717,7 @@ private unsafe static bool FilterCustomAttributeRecord(
             if (ctorHasParameters)
             {
                 // Resolve method ctor token found in decorated decoratedModule scope
-                ctor = ModuleHandle.ResolveMethodHandleInternal(decoratedModule.GetNativeHandle(), caRecord.tkCtor);
+                ctor = decoratedModule.ResolveMethod(caRecord.tkCtor, attributeType.GenericTypeArguments, null).MethodHandle.GetMethodInfo();
             }
             else
             {
@@ -1848,13 +1848,13 @@ private static void ParseAttributeUsageAttribute(
         }
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        private static unsafe extern Object _CreateCaObject(RuntimeModule pModule, IRuntimeMethodInfo pCtor, byte** ppBlob, byte* pEndBlob, int* pcNamedArgs);
-        private static unsafe Object CreateCaObject(RuntimeModule module, IRuntimeMethodInfo ctor, ref IntPtr blob, IntPtr blobEnd, out int namedArgs)
+        private static unsafe extern Object _CreateCaObject(RuntimeModule pModule, RuntimeType type, IRuntimeMethodInfo pCtor, byte** ppBlob, byte* pEndBlob, int* pcNamedArgs);
+        private static unsafe Object CreateCaObject(RuntimeModule module, RuntimeType type, IRuntimeMethodInfo ctor, ref IntPtr blob, IntPtr blobEnd, out int namedArgs)
         {
             byte* pBlob = (byte*)blob;
             byte* pBlobEnd = (byte*)blobEnd;
             int cNamedArgs;
-            object ca = _CreateCaObject(module, ctor, &pBlob, pBlobEnd, &cNamedArgs);
+            object ca = _CreateCaObject(module, type, ctor, &pBlob, pBlobEnd, &cNamedArgs);
             blob = (IntPtr)pBlob;
             namedArgs = cNamedArgs;
             return ca;

src/vm/callhelpers.h

@@ -131,6 +131,21 @@ class MethodDescCallSite
         m_argIt.ForceSigWalk();
     }
 
+    void DefaultInit(TypeHandle th)
+    {
+        CONTRACTL
+        {
+            MODE_ANY;
+        GC_TRIGGERS;
+        THROWS;
+        }
+        CONTRACTL_END;
+
+        m_pCallTarget = m_pMD->GetCallTarget(NULL, th);
+
+        m_argIt.ForceSigWalk();
+}
+
 #ifdef FEATURE_INTERPRETER
 public:
     void CallTargetWorker(const ARG_SLOT *pArguments, ARG_SLOT *pReturnValue, int cbReturnValue, bool transitionToPreemptive = false);
@@ -234,6 +249,25 @@ class MethodDescCallSite
         DefaultInit(porProtectedThis);
     }
 
+    MethodDescCallSite(MethodDesc* pMD, TypeHandle th) :
+        m_pMD(pMD),
+        m_methodSig(pMD, th),
+        m_argIt(&m_methodSig)
+    {
+        CONTRACTL
+        {
+            THROWS;
+            GC_TRIGGERS;
+            MODE_COOPERATIVE;
+        }
+        CONTRACTL_END;
+
+        // We don't have a "this" pointer - ensure that we have activated the containing module
+        m_pMD->EnsureActive();
+
+        DefaultInit(th);
+    }
+
     //
     // Only use this constructor if you're certain you know where
     // you're going and it cannot be affected by generics/virtual

src/vm/customattribute.cpp

@@ -670,7 +670,7 @@ FCIMPL2(Object*, RuntimeTypeHandle::CreateCaInstance, ReflectClassBaseObject* pC
     CONTRACTL {
         FCALL_CHECK;
         PRECONDITION(CheckPointer(pCaTypeUNSAFE));
-        PRECONDITION(!pCaTypeUNSAFE->GetType().IsGenericVariable()); 
+        PRECONDITION(!pCaTypeUNSAFE->GetType().IsGenericVariable());
         PRECONDITION(pCaTypeUNSAFE->GetType().IsValueType() || CheckPointer(pCtorUNSAFE));
     }
     CONTRACTL_END;
@@ -694,10 +694,6 @@ FCIMPL2(Object*, RuntimeTypeHandle::CreateCaInstance, ReflectClassBaseObject* pC
         PRECONDITION(
             (!pCtor && gc.refCaType->GetType().IsValueType() && !gc.refCaType->GetType().GetMethodTable()->HasDefaultConstructor()) || 
             (pCtor == gc.refCaType->GetType().GetMethodTable()->GetDefaultConstructor()));
-
-        // If we relax this, we need to insure custom attributes construct properly for Nullable<T>
-        if (gc.refCaType->GetType().HasInstantiation())
-            COMPlusThrow(kNotSupportedException, W("Argument_GenericsInvalid"));
 
         gc.o = pCaMT->Allocate();
 
@@ -731,16 +727,20 @@ FCIMPL2(Object*, RuntimeTypeHandle::CreateCaInstance, ReflectClassBaseObject* pC
 }
 FCIMPLEND
 
-FCIMPL5(LPVOID, COMCustomAttribute::CreateCaObject, ReflectModuleBaseObject* pAttributedModuleUNSAFE, ReflectMethodObject *pMethodUNSAFE, BYTE** ppBlob, BYTE* pEndBlob, INT32* pcNamedArgs)
+FCIMPL6(LPVOID, COMCustomAttribute::CreateCaObject, ReflectModuleBaseObject* pAttributedModuleUNSAFE, ReflectClassBaseObject* pCaTypeUNSAFE, ReflectMethodObject *pMethodUNSAFE, BYTE** ppBlob, BYTE* pEndBlob, INT32* pcNamedArgs)
 {
     FCALL_CONTRACT;
 
     struct
     {
+        REFLECTCLASSBASEREF refCaType;
         OBJECTREF ca;
         REFLECTMETHODREF refCtor;
         REFLECTMODULEBASEREF refAttributedModule;
     } gc;
+    gc.refCaType = (REFLECTCLASSBASEREF)ObjectToOBJECTREF(pCaTypeUNSAFE);
+    TypeHandle th = gc.refCaType->GetType();
+
     gc.ca = NULL;
     gc.refCtor = (REFLECTMETHODREF)ObjectToOBJECTREF(pMethodUNSAFE);
     gc.refAttributedModule = (REFLECTMODULEBASEREF)ObjectToOBJECTREF(pAttributedModuleUNSAFE);
@@ -749,10 +749,10 @@ FCIMPL5(LPVOID, COMCustomAttribute::CreateCaObject, ReflectModuleBaseObject* pAt
         FCThrowRes(kArgumentNullException, W("Arg_InvalidHandle"));
 
     MethodDesc* pCtorMD = gc.refCtor->GetMethod();
-
+    
     HELPER_METHOD_FRAME_BEGIN_RET_PROTECT(gc);
     {
-        MethodDescCallSite ctorCallSite(pCtorMD);
+        MethodDescCallSite ctorCallSite(pCtorMD, th);
         MetaSig* pSig = ctorCallSite.GetMetaSig();
         BYTE* pBlob = *ppBlob;
 
@@ -767,10 +767,6 @@ FCIMPL5(LPVOID, COMCustomAttribute::CreateCaObject, ReflectModuleBaseObject* pAt
         OBJECTREF *argToProtect = (OBJECTREF*)_alloca(cArgs * sizeof(OBJECTREF));
         memset((void*)argToProtect, 0, cArgs * sizeof(OBJECTREF));
 
-        // If we relax this, we need to insure custom attributes construct properly for Nullable<T>
-        if (pCtorMD->GetMethodTable()->HasInstantiation())
-            COMPlusThrow(kNotSupportedException, W("Argument_GenericsInvalid"));
-
         // load the this pointer
         argToProtect[0] = pCtorMD->GetMethodTable()->Allocate(); // this is the value to return after the ctor invocation
 

src/vm/customattribute.h

@@ -189,7 +189,7 @@ class COMCustomAttribute
 
     // custom attributes utility functions
     static FCDECL5(VOID, ParseAttributeUsageAttribute, PVOID pData, ULONG cData, ULONG* pTargets, CLR_BOOL* pInherited, CLR_BOOL* pAllowMultiple);
-    static FCDECL5(LPVOID, CreateCaObject, ReflectModuleBaseObject* pAttributedModuleUNSAFE, ReflectMethodObject *pMethodUNSAFE, BYTE** ppBlob, BYTE* pEndBlob, INT32* pcNamedArgs);
+    static FCDECL6(LPVOID, CreateCaObject, ReflectModuleBaseObject* pAttributedModuleUNSAFE, ReflectClassBaseObject* pCaTypeUNSAFE, ReflectMethodObject *pMethodUNSAFE, BYTE** ppBlob, BYTE* pEndBlob, INT32* pcNamedArgs);
     static FCDECL7(void, GetPropertyOrFieldData, ReflectModuleBaseObject *pModuleUNSAFE, BYTE** ppBlobStart, BYTE* pBlobEnd, STRINGREF* pName, CLR_BOOL* pbIsProperty, OBJECTREF* pType, OBJECTREF* value);
     static FCDECL4(VOID, GetSecurityAttributes, ReflectModuleBaseObject *pModuleUNSAFE, DWORD tkToken, CLR_BOOL fAssembly, PTRARRAYREF* ppArray);
 

tests/src/reflection/GenericAttribute/GenericAttributeMetadata.cs

@@ -0,0 +1,78 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+// 
+
+using System;
+using System.Reflection;
+using System.Collections;
+using System.Runtime.CompilerServices;
+
+[assembly: SingleAttribute<int>()]
+[assembly: SingleAttribute<bool>()]
+
+[assembly: MultiAttribute<int>()]
+[assembly: MultiAttribute<int>(1)]
+[assembly: MultiAttribute<int>(Value = 2)]
+[assembly: MultiAttribute<bool>()]
+[assembly: MultiAttribute<bool>(true)]
+
+[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Property, AllowMultiple = false)]
+public class SingleAttribute<T> : Attribute
+{
+
+}
+
+[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Property, AllowMultiple = true)]
+public class MultiAttribute<T> : Attribute
+{
+    public T Value { get; set; }
+
+    public MultiAttribute()
+    {
+    }
+
+    public MultiAttribute(T value)
+    {
+        Value = value;
+    }
+}
+
+public enum MyEnum
+{
+    Ctor,
+    Property
+}
+
+[SingleAttribute<int>()]
+[SingleAttribute<bool>()]
+[MultiAttribute<int>()]
+[MultiAttribute<int>(1)]
+[MultiAttribute<int>(Value = 2)]
+[MultiAttribute<bool>()]
+[MultiAttribute<bool>(true)]
+[MultiAttribute<bool>(Value = true)]
+[MultiAttribute<bool?>()]
+[MultiAttribute<string>("Ctor")]
+[MultiAttribute<string>(Value = "Property")]
+[MultiAttribute<Type>(typeof(Class))]
+[MultiAttribute<Type>(Value = typeof(Class.Derive))]
+[MultiAttribute<MyEnum>(MyEnum.Ctor)]
+[MultiAttribute<MyEnum>(Value = MyEnum.Property)]
+public class Class
+{
+    public class Derive : Class
+    {
+
+    }
+
+    [SingleAttribute<int>()]
+    [SingleAttribute<bool>()]
+    [MultiAttribute<int>()]
+    [MultiAttribute<int>(1)]
+    [MultiAttribute<int>(Value = 2)]
+    [MultiAttribute<bool>()]
+    [MultiAttribute<bool>(true)]
+    public int Property { get; set; }
+}