Mono.Cecil.TypeResolver.Resolve C# (CSharp) Method

        public TypeReference Resolve(TypeReference typeReference, bool includeTypeDefinitions)
        {
            if (IsDummy ())
                return typeReference;

            if (_typeDefinitionContext != null && _typeDefinitionContext.GenericArguments.Contains (typeReference))
                return typeReference;
            if (_methodDefinitionContext != null && _methodDefinitionContext.GenericArguments.Contains (typeReference))
                return typeReference;

            var genericParameter = typeReference as GenericParameter;
            if (genericParameter != null) {
                if (_typeDefinitionContext != null && _typeDefinitionContext.GenericArguments.Contains (genericParameter))
                    return genericParameter;
                if (_methodDefinitionContext != null && _methodDefinitionContext.GenericArguments.Contains (genericParameter))
                    return genericParameter;
                return ResolveGenericParameter (genericParameter);
            }

            var arrayType = typeReference as ArrayType;
            if (arrayType != null)
                return new ArrayType (Resolve (arrayType.ElementType), arrayType.Rank);

            var pointerType = typeReference as PointerType;
            if (pointerType != null)
                return new PointerType (Resolve (pointerType.ElementType));

            var byReferenceType = typeReference as ByReferenceType;
            if (byReferenceType != null)
                return new ByReferenceType (Resolve (byReferenceType.ElementType));

            var pinnedType = typeReference as PinnedType;
            if (pinnedType != null)
                return new PinnedType (Resolve (pinnedType.ElementType));

            var genericInstanceType = typeReference as GenericInstanceType;
            if (genericInstanceType != null) {
                var newGenericInstanceType = new GenericInstanceType (genericInstanceType.ElementType);
                foreach (var genericArgument in genericInstanceType.GenericArguments)
                    newGenericInstanceType.GenericArguments.Add (Resolve (genericArgument));
                return newGenericInstanceType;
            }

            var requiredModType = typeReference as RequiredModifierType;
            if (requiredModType != null)
                return Resolve (requiredModType.ElementType, includeTypeDefinitions);

            if (includeTypeDefinitions) {
                var typeDefinition = typeReference as TypeDefinition;
                if (typeDefinition != null && typeDefinition.HasGenericParameters) {
                    var newGenericInstanceType = new GenericInstanceType (typeDefinition);
                    foreach (var gp in typeDefinition.GenericParameters)
                        newGenericInstanceType.GenericArguments.Add (Resolve (gp));
                    return newGenericInstanceType;
                }
            }

            if (typeReference is TypeSpecification)
                throw new NotSupportedException (string.Format ("The type {0} cannot be resolved correctly.", typeReference.FullName));

            return typeReference;
        }