ReadOperand throws exception when reading type reference to an open generic

[llebron]

This example throws an exception reliably.

        class TestGeneric<T> { }

        class OpenGenericRef
        {
            public void Foo()
            {
                System.Type type = typeof(TestGeneric<>);
            }
        }

        class ReflectionRunner
        {
            public static void RunReflection()
            {
                MethodInfo methodInfo = typeof(OpenGenericRef).GetMethod("Foo");
                try
                {
                    List<Instruction> instructions = MethodBodyReader.GetInstructions(methodInfo);
                }
                catch (Exception e)
                {
                    string exceptionMessage = e.Message;
                    string exceptionStackTrace = e.StackTrace;
                }
            }
        }

Exception message:
VAR 0 (T) cannot be expanded in this context with 0 instantiations

Exception stack trace:

"  at (wrapper managed-to-native) System.Reflection.RuntimeModule.ResolveMemberToken(intptr,int,intptr[],intptr[],System.Reflection.ResolveTokenError&)  
at System.Reflection.RuntimeModule.ResolveMember (System.Reflection.Module module, System.IntPtr monoModule, System.Int32 metadataToken, System.Type[] genericTypeArguments, System.Type[] genericMethodArguments) [0x0000f] in <dcf6bec1c5764d29a37432d4b047f650>:0 \n  
at System.Reflection.RuntimeModule.ResolveMember (System.Int32 metadataToken, System.Type[] genericTypeArguments, System.Type[] genericMethodArguments) [0x00000] in <dcf6bec1c5764d29a37432d4b047f650>:0 \n  at
Mono.Reflection.MethodBodyReader.ReadOperand (Mono.Reflection.Instruction instruction) [0x00216] in Mono.Reflection/MethodBodyReader.cs:194 \n  at Mono.Reflection.MethodBodyReader.ReadInstructions (System.Int32 metadataToken) [0x00021]

I have traced it to this line, in MethodBodyReader, as the instruction's operand type is InlineTok:

				case OperandType.InlineTok:
				case OperandType.InlineType:
				case OperandType.InlineMethod:
				case OperandType.InlineField:
					instruction.Operand = module.ResolveMember(il.ReadInt32(), type_arguments, method_arguments);
					break;

[llebron]

Not sure if anyone is monitoring this repository, but I have added this workaround, which suffices for my purposes:

void ReadOperand(Instruction instruction)
		{
			switch (instruction.OpCode.OperandType)
			{
				case OperandType.InlineNone:
					break;
				case OperandType.InlineSwitch:
					int length = il.ReadInt32();
					int base_offset = il.position + (4 * length);
					int[] branches = new int[length];
					for (int i = 0; i < length; i++)
						branches[i] = il.ReadInt32() + base_offset;

					instruction.Operand = branches;
					break;
				case OperandType.ShortInlineBrTarget:
					instruction.Operand = (((sbyte)il.ReadByte()) + il.position);
					break;
				case OperandType.InlineBrTarget:
					instruction.Operand = il.ReadInt32() + il.position;
					break;
				case OperandType.ShortInlineI:
					if (instruction.OpCode == OpCodes.Ldc_I4_S)
						instruction.Operand = (sbyte)il.ReadByte();
					else
						instruction.Operand = il.ReadByte();
					break;
				case OperandType.InlineI:
					instruction.Operand = il.ReadInt32();
					break;
				case OperandType.ShortInlineR:
					instruction.Operand = il.ReadSingle();
					break;
				case OperandType.InlineR:
					instruction.Operand = il.ReadDouble();
					break;
				case OperandType.InlineI8:
					instruction.Operand = il.ReadInt64();
					break;
				case OperandType.InlineSig:
					instruction.Operand = module.ResolveSignature(il.ReadInt32());
					break;
				case OperandType.InlineString:
					instruction.Operand = module.ResolveString(il.ReadInt32());
					break;
				case OperandType.InlineType:
				case OperandType.InlineMethod:
				case OperandType.InlineField:
					instruction.Operand = module.ResolveMember(il.ReadInt32(), type_arguments, method_arguments);
					break;

				// *** Begin alteration of library code ***
				// This library will throw a BadImageFormatException if 
				// module.ResolveMember is called with an unbound generic type
				// with type_arguments and method_arguments provided
				// So, we added this logic to handle that case explicitly, by only providing the token
				// itself for such cases
				case OperandType.InlineTok:
					int token = il.ReadInt32();

					// First, just try to resolve without providing any args, since
					// this may be an unbound generic type
					MemberInfo memberInfo = module.ResolveMember(token);

					// If the MethodInfo is an unbound generic type,
					// just store the resolved version with no type args
					if (memberInfo is Type type && type.ContainsGenericParameters)
					{
						instruction.Operand = memberInfo;
					}
					// Otherwise, fully resolve the member with type and method args provided
					else
					{
						instruction.Operand = module.ResolveMember(token, type_arguments, method_arguments);
					}
					break;
				// *** End alteration of library code ***

				case OperandType.ShortInlineVar:
					instruction.Operand = GetVariable(instruction, il.ReadByte());
					break;
				case OperandType.InlineVar:
					instruction.Operand = GetVariable(instruction, il.ReadInt16());
					break;
				default:
					throw new NotSupportedException();
			}
		}