The type parameter name of unbound generic type has not consistent naming conventions

[hiihellox10]

Background

We use this library to generate APIs for our project mdoc. Recently we encountered an issue that's typeof operator with unbound generic type.

We need to identify whether a TypeReference is an unbound generic type. Currently, we use TypeReference.GenericParameters.Name to determine whether it is an unbound generic type if it is an unbound generic type that the parameter name will be named ![n], but sometimes some unbound generic type does not follow the naming conventions that the parameter name will be named the type parameter name of the generic type(e.g., TKey, TValue).

It looks like is an issue, I wrote an example code to reproduce the issue.

Do you have other solutions to help us identify an unbound generic type?

Example Code

using Mono.Cecil;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;

namespace UnboundGenericType
{
    class Program
    {
        static void Main(string[] args)
        {
            var test = new TestTypeParameterName();
            test.TestAttribute();
        }
    }

    public class TestTypeParameterName
    {
        public void TestAttribute()
        {
            var dictionaryParameters = GetGenericTypeArguments("UnboundGenericTypeWithDictionary");
            foreach (var item in dictionaryParameters)
            {
                // The type parameter name of Dictionary is: !0, !1.
                // Those parameter name looks like is a correct name of unbound generic type.
                var parameterName = item.Name;
            }

            var mockDictionaryParameters = GetGenericTypeArguments("UnboundGenericTypeWithMockDictionary");
            foreach (var item in mockDictionaryParameters)
            {
                // The type parameter name of MockDictionary is: TKey, TValue.
                // Those parameter name looks like is a TypeReference of MockDictionary<Tkey, TValue> not is a TypeReference of MockDictionary<,>.
                // Why the parameter name of the two types unbound generic type does not have consistent naming conventions.
                var parameterName = item.Name;
            }
        }

        private ICollection<GenericParameter> GetGenericTypeArguments(string method)
        {
            var methodDefinition = GetMethod(method);
            var customAttribute = methodDefinition.CustomAttributes.FirstOrDefault();
            var attributeArguments = customAttribute.ConstructorArguments.FirstOrDefault();
            var genericParameter = (TypeReference)attributeArguments.Value;

            return genericParameter.GenericParameters;
        }

        private MethodDefinition GetMethod(string methodName)
        {
            var type = typeof(UnboundGenericType);
            var typeDefinition = GetTypeDefinition(type);

            return typeDefinition.Methods.FirstOrDefault(i => i.Name == methodName);
        }

        private TypeDefinition GetTypeDefinition(Type type)
        {
            ReaderParameters readerParameters = new ReaderParameters()
            {
                AssemblyResolver = new DefaultAssemblyResolver()
            };

            var filePath = type.Module.FullyQualifiedName;
            var assemblyFullpath = Path.Combine(Path.GetDirectoryName(typeof(object).Module.Assembly.Location), filePath);
            var assemblyModule = ModuleDefinition.ReadModule(assemblyFullpath, readerParameters);

            return assemblyModule.GetTypes().SingleOrDefault(i => i.FullName == type.FullName);
        }
    }

    public class UnboundGenericType
    {
        [TypeOf(typeof(Dictionary<,>))]
        public void UnboundGenericTypeWithDictionary()
        {
        }

        [TypeOf(typeof(MockDictionary<,>))]
        public void UnboundGenericTypeWithMockDictionary()
        {
        }
    }

    public class MockDictionary<Tkey, TValue>
    {
    }

    public class TypeOfAttribute : Attribute
    {
        private Type _type;

        public TypeOfAttribute(Type type)
        {
            _type = type;
        }
    }
}

[jbevain]

Hi,

The difference you're seeing between the Dictionary<> and your MockDictionary<> is that Dictionary<> is defined in another module (and thus is represented as a TypeReference), while MockDictionary<> is defined in the current module (and thus is represented as a TypeDefinition.

In the metadata, the name of the generic parameters are not referenced between modules, only their position.

So if you want to be consistent, you need to resolve the TypeReference into a TypeDefinition from its module to look at its generic parameters to get the original generic parameter name.