Implementation for UnsafeAccessorTypeAttribute

src/coreclr/System.Private.CoreLib/src/System/Reflection/TypeNameResolver.CoreCLR.cs

@@ -3,6 +3,7 @@
 
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
 using System.IO;
 using System.Reflection.Metadata;
 using System.Runtime.CompilerServices;
@@ -21,9 +22,12 @@ internal partial struct TypeNameResolver
         private bool _extensibleParser;
         private bool _requireAssemblyQualifiedName;
         private bool _suppressContextualReflectionContext;
+        private IntPtr _unsafeAccessorMethod;
         private Assembly? _requestingAssembly;
         private Assembly? _topLevelAssembly;
 
+        private bool SupportsUnboundGenerics { get => _unsafeAccessorMethod != IntPtr.Zero; }
+
         [RequiresUnreferencedCode("The type might be removed")]
         internal static Type? GetType(
             string typeName,
@@ -128,14 +132,14 @@ internal static RuntimeType GetTypeReferencedByCustomAttribute(string typeName,
 
         // Used by VM
         internal static unsafe RuntimeType? GetTypeHelper(char* pTypeName, RuntimeAssembly? requestingAssembly,
-            bool throwOnError, bool requireAssemblyQualifiedName)
+            bool throwOnError, bool requireAssemblyQualifiedName, IntPtr unsafeAccessorMethod)
         {
             ReadOnlySpan<char> typeName = MemoryMarshal.CreateReadOnlySpanFromNullTerminated(pTypeName);
-            return GetTypeHelper(typeName, requestingAssembly, throwOnError, requireAssemblyQualifiedName);
+            return GetTypeHelper(typeName, requestingAssembly, throwOnError, requireAssemblyQualifiedName, unsafeAccessorMethod);
         }
 
         internal static unsafe RuntimeType? GetTypeHelper(ReadOnlySpan<char> typeName, RuntimeAssembly? requestingAssembly,
-            bool throwOnError, bool requireAssemblyQualifiedName)
+            bool throwOnError, bool requireAssemblyQualifiedName, IntPtr unsafeAccessorMethod = 0)
         {
             // Compat: Empty name throws TypeLoadException instead of
             // the natural ArgumentException
@@ -158,6 +162,7 @@ internal static RuntimeType GetTypeReferencedByCustomAttribute(string typeName,
                 _throwOnError = throwOnError,
                 _suppressContextualReflectionContext = true,
                 _requireAssemblyQualifiedName = requireAssemblyQualifiedName,
+                _unsafeAccessorMethod = unsafeAccessorMethod,
             }.Resolve(parsed);
 
             if (type != null)
@@ -186,6 +191,9 @@ internal static RuntimeType GetTypeReferencedByCustomAttribute(string typeName,
             return assembly;
         }
 
+        [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "UnsafeAccessors_ResolveGenericParamToTypeHandle")]
+        private static partial IntPtr ResolveGenericParamToTypeHandle(IntPtr unsafeAccessorMethod, [MarshalAs(UnmanagedType.Bool)] bool isMethodParam, uint paramIndex);
+
         [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
             Justification = "TypeNameResolver.GetType is marked as RequiresUnreferencedCode.")]
         [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2075:UnrecognizedReflectionPattern",
@@ -228,6 +236,42 @@ internal static RuntimeType GetTypeReferencedByCustomAttribute(string typeName,
             {
                 if (assembly is null)
                 {
+                    if (SupportsUnboundGenerics
+                        && !string.IsNullOrEmpty(escapedTypeName)
+                        && escapedTypeName[0] == '!')
+                    {
+                        Debug.Assert(_throwOnError); // Unbound generic support currently always throws.
+
+                        // Parse the type as an unbound generic parameter. Following the common VAR/MVAR IL syntax:
+                        //  !<Number> - Represents a zero-based index into the type's generic parameters.
+                        //  !!<Number> - Represents a zero-based index into the method's generic parameters.
+
+                        // Confirm we have at least one more character
+                        if (escapedTypeName.Length == 1)
+                        {
+                            throw new TypeLoadException(SR.Format(SR.TypeLoad_ResolveType, escapedTypeName), typeName: escapedTypeName);
+                        }
+
+                        // At this point we expect either another '!' and then a number or a number.
+                        bool isMethodParam = escapedTypeName[1] == '!';
+                        ReadOnlySpan<char> toParse = isMethodParam
+                            ? escapedTypeName.AsSpan(2)  // Skip over "!!"
+                            : escapedTypeName.AsSpan(1); // Skip over "!"
+                        if (!uint.TryParse(toParse, NumberStyles.None, null, out uint paramIndex))
+                        {
+                            throw new TypeLoadException(SR.Format(SR.TypeLoad_ResolveType, escapedTypeName), typeName: escapedTypeName);
+                        }
+
+                        Debug.Assert(_unsafeAccessorMethod != IntPtr.Zero);
+                        IntPtr typeHandle = ResolveGenericParamToTypeHandle(_unsafeAccessorMethod, isMethodParam, paramIndex);
+                        if (typeHandle == IntPtr.Zero)
+                        {
+                            throw new TypeLoadException(SR.Format(SR.TypeLoad_ResolveType, escapedTypeName), typeName: escapedTypeName);
+                        }
+
+                        return RuntimeTypeHandle.GetRuntimeTypeFromHandle(typeHandle);
+                    }
+
                     if (_requireAssemblyQualifiedName)
                     {
                         if (_throwOnError)

src/coreclr/dlls/mscorrc/mscorrc.rc

@@ -596,6 +596,8 @@ BEGIN
         BFA_BAD_FIELD_TOKEN                     "Field token out of range."
         BFA_INVALID_FIELD_ACC_FLAGS             "Invalid Field Access Flags."
         BFA_INVALID_UNSAFEACCESSOR              "Invalid usage of UnsafeAccessorAttribute."
+        BFA_INVALID_UNSAFEACCESSORTYPE          "Invalid usage of UnsafeAccessorTypeAttribute."
+        BFA_INVALID_UNSAFEACCESSORTYPE_VALUETYPE "ValueTypes are not supported with UnsafeAccessorTypeAttribute."
         BFA_FIELD_LITERAL_AND_INIT              "Field is Literal and InitOnly."
         BFA_NONSTATIC_GLOBAL_FIELD              "Non-Static Global Field."
         BFA_INSTANCE_FIELD_IN_INT               "Instance Field in an Interface."

src/coreclr/dlls/mscorrc/resource.h

@@ -415,10 +415,11 @@
 #define BFA_BAD_TYPEREF_TOKEN                   0x2046
 #define BFA_BAD_CLASS_INT_CA_FORMAT             0x2048
 #define BFA_BAD_COMPLUS_SIG                     0x2049
-#define BFA_BAD_ELEM_IN_SIZEOF                  0x204b
-#define BFA_IJW_IN_COLLECTIBLE_ALC              0x204c
-#define BFA_INVALID_UNSAFEACCESSOR              0x204d
-
+#define BFA_BAD_ELEM_IN_SIZEOF                  0x204a
+#define BFA_IJW_IN_COLLECTIBLE_ALC              0x204b
+#define BFA_INVALID_UNSAFEACCESSOR              0x204c
+#define BFA_INVALID_UNSAFEACCESSORTYPE          0x204d
+#define BFA_INVALID_UNSAFEACCESSORTYPE_VALUETYPE 0x204e
 #define IDS_CLASSLOAD_INTERFACE_NO_ACCESS       0x204f
 
 #define BFA_BAD_CA_HEADER                       0x2050

src/coreclr/tools/Common/TypeSystem/Common/Utilities/CustomAttributeTypeNameParser.cs

@@ -21,7 +21,7 @@ public static class CustomAttributeTypeNameParser
         /// This is the inverse of what <see cref="CustomAttributeTypeNameFormatter"/> does.
         /// </summary>
         public static TypeDesc GetTypeByCustomAttributeTypeName(this ModuleDesc module, string name, bool throwIfNotFound = true,
-            Func<ModuleDesc, string, MetadataType> canonResolver = null)
+            Func<ModuleDesc, string, TypeDesc> canonGenericResolver = null)
         {
             if (!TypeName.TryParse(name.AsSpan(), out TypeName parsed, s_typeNameParseOptions))
                 ThrowHelper.ThrowTypeLoadException(name, module);
@@ -31,7 +31,7 @@ public static TypeDesc GetTypeByCustomAttributeTypeName(this ModuleDesc module,
                 _context = module.Context,
                 _module = module,
                 _throwIfNotFound = throwIfNotFound,
-                _canonResolver = canonResolver
+                _canonGenericResolver = canonGenericResolver
             }.Resolve(parsed);
         }
 
@@ -91,7 +91,7 @@ private struct TypeNameResolver
             internal TypeSystemContext _context;
             internal ModuleDesc _module;
             internal bool _throwIfNotFound;
-            internal Func<ModuleDesc, string, MetadataType> _canonResolver;
+            internal Func<ModuleDesc, string, TypeDesc> _canonGenericResolver;
 
             internal List<ModuleDesc> _referencedModules;
 
@@ -136,30 +136,30 @@ private TypeDesc GetSimpleType(TypeName typeName)
                 }
 
                 ModuleDesc module = _module;
-                if (topLevelTypeName.AssemblyName != null)
+                if (topLevelTypeName.AssemblyName is not null)
                 {
                     module = _context.ResolveAssembly(typeName.AssemblyName, throwIfNotFound: _throwIfNotFound);
                     if (module == null)
                         return null;
                 }
 
-                if (module != null)
+                if (module is not null)
                 {
                     TypeDesc type = GetSimpleTypeFromModule(typeName, module);
-                    if (type != null)
+                    if (type is not null)
                     {
                         _referencedModules?.Add(module);
                         return type;
                     }
                 }
 
-                // If it didn't resolve and wasn't assembly-qualified, we also try core library
                 if (topLevelTypeName.AssemblyName == null)
                 {
+                    // If it didn't resolve and wasn't assembly-qualified, we also try core library
                     if (module != _context.SystemModule)
                     {
                         TypeDesc type = GetSimpleTypeFromModule(typeName, _context.SystemModule);
-                        if (type != null)
+                        if (type is not null)
                         {
                             _referencedModules?.Add(_context.SystemModule);
                             return type;
@@ -184,9 +184,9 @@ private TypeDesc GetSimpleTypeFromModule(TypeName typeName, ModuleDesc module)
 
                 string fullName = TypeNameHelpers.Unescape(typeName.FullName);
 
-                if (_canonResolver != null)
+                if (_canonGenericResolver != null)
                 {
-                    MetadataType canonType = _canonResolver(module, fullName);
+                    TypeDesc canonType = _canonGenericResolver(module, fullName);
                     if (canonType != null)
                         return canonType;
                 }