public override MethodBase?ResolveMethod(int metadataToken, Type[]?genericTypeArguments, Type[]?genericMethodArguments)
{
try
{
MetadataToken tk = new MetadataToken(metadataToken);
if (!tk.IsMethodDef && !tk.IsMethodSpec)
{
if (!tk.IsMemberRef)
{
throw new ArgumentException(SR.Format(SR.Argument_ResolveMethod, tk, this),
nameof(metadataToken));
}
unsafe
{
ConstArray sig = MetadataImport.GetMemberRefProps(tk);
if (*(MdSigCallingConvention *)sig.Signature == MdSigCallingConvention.Field)
{
throw new ArgumentException(SR.Format(SR.Argument_ResolveMethod, tk, this),
nameof(metadataToken));
}
}
}
RuntimeTypeHandle[]? typeArgs = null;
RuntimeTypeHandle[]? methodArgs = null;
if (genericTypeArguments?.Length > 0)
{
typeArgs = ConvertToTypeHandleArray(genericTypeArguments);
}
if (genericMethodArguments?.Length > 0)
{
methodArgs = ConvertToTypeHandleArray(genericMethodArguments);
}
ModuleHandle moduleHandle = new ModuleHandle(this);
IRuntimeMethodInfo methodHandle = moduleHandle.ResolveMethodHandle(tk, typeArgs, methodArgs).GetMethodInfo();
Type declaringType = RuntimeMethodHandle.GetDeclaringType(methodHandle);
if (declaringType.IsGenericType || declaringType.IsArray)
{
MetadataToken tkDeclaringType = new MetadataToken(MetadataImport.GetParentToken(tk));
if (tk.IsMethodSpec)
{
tkDeclaringType = new MetadataToken(MetadataImport.GetParentToken(tkDeclaringType));
}
declaringType = ResolveType(tkDeclaringType, genericTypeArguments, genericMethodArguments);
}
return(RuntimeType.GetMethodBase(declaringType as RuntimeType, methodHandle));
}
catch (BadImageFormatException e)
{
throw new ArgumentException(SR.Argument_BadImageFormatExceptionResolve, e);
}
}
// this method is a big perf hit, so don't call unnecessarily
internal static MethodInfo GetMethodInfo(RuntimeMethodHandle rmh)
{
if (rmh.IsNullHandle())
{
return(null);
}
#if _DEBUG
try
{
#endif
// Assert here because reflection will check grants and if we fail the check,
// there will be an infinite recursion that overflows the stack.
PermissionSet.s_fullTrust.Assert();
RuntimeTypeHandle rth = rmh.GetDeclaringType();
return(System.RuntimeType.GetMethodBase(rth, rmh) as MethodInfo);
#if _DEBUG
}
catch (Exception)
{
return(null);
}
#endif
}
internal static MethodInfo GetMethodInfo(RuntimeMethodHandleInternal rmh)
{
if (rmh.IsNullHandle())
{
return((MethodInfo)null);
}
PermissionSet.s_fullTrust.Assert();
return(RuntimeType.GetMethodBase(RuntimeMethodHandle.GetDeclaringType(rmh), rmh) as MethodInfo);
}
[System.Security.SecuritySafeCritical] // auto-generated
public override MethodBase ResolveMethod(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments)
{
MetadataToken tk = new MetadataToken(metadataToken);
if (!MetadataImport.IsValidToken(tk))
{
throw new ArgumentOutOfRangeException("metadataToken",
Environment.GetResourceString("Argument_InvalidToken", tk, this));
}
RuntimeTypeHandle[] typeArgs = ConvertToTypeHandleArray(genericTypeArguments);
RuntimeTypeHandle[] methodArgs = ConvertToTypeHandleArray(genericMethodArguments);
try
{
if (!tk.IsMethodDef && !tk.IsMethodSpec)
{
if (!tk.IsMemberRef)
{
throw new ArgumentException("metadataToken",
Environment.GetResourceString("Argument_ResolveMethod", tk, this));
}
unsafe
{
ConstArray sig = MetadataImport.GetMemberRefProps(tk);
if (*(MdSigCallingConvention *)sig.Signature.ToPointer() == MdSigCallingConvention.Field)
{
throw new ArgumentException("metadataToken",
Environment.GetResourceString("Argument_ResolveMethod", tk, this));
}
}
}
IRuntimeMethodInfo methodHandle = ModuleHandle.ResolveMethodHandleInternal(GetNativeHandle(), tk, typeArgs, methodArgs);
Type declaringType = RuntimeMethodHandle.GetDeclaringType(methodHandle);
if (declaringType.IsGenericType || declaringType.IsArray)
{
MetadataToken tkDeclaringType = new MetadataToken(MetadataImport.GetParentToken(tk));
if (tk.IsMethodSpec)
{
tkDeclaringType = new MetadataToken(MetadataImport.GetParentToken(tkDeclaringType));
}
declaringType = ResolveType(tkDeclaringType, genericTypeArguments, genericMethodArguments);
}
return(System.RuntimeType.GetMethodBase(declaringType as RuntimeType, methodHandle));
}
catch (BadImageFormatException e)
{
throw new ArgumentException(Environment.GetResourceString("Argument_BadImageFormatExceptionResolve"), e);
}
}
internal override int ParentToken(int token)
{
RuntimeType declaringType = null;
object obj2 = this.m_scope[token];
if (obj2 is RuntimeMethodHandle)
{
declaringType = RuntimeMethodHandle.GetDeclaringType(((RuntimeMethodHandle)obj2).GetMethodInfo());
}
else if (obj2 is RuntimeFieldHandle)
{
declaringType = RuntimeFieldHandle.GetApproxDeclaringType(((RuntimeFieldHandle)obj2).GetRuntimeFieldInfo());
}
else if (obj2 is DynamicMethod)
{
DynamicMethod method = (DynamicMethod)obj2;
declaringType = RuntimeMethodHandle.GetDeclaringType(method.m_methodHandle);
}
else if (obj2 is GenericMethodInfo)
{
GenericMethodInfo info = (GenericMethodInfo)obj2;
declaringType = info.m_context.GetRuntimeType();
}
else if (obj2 is GenericFieldInfo)
{
GenericFieldInfo info2 = (GenericFieldInfo)obj2;
declaringType = info2.m_context.GetRuntimeType();
}
else if (obj2 is VarArgMethod)
{
VarArgMethod method2 = (VarArgMethod)obj2;
DynamicMethod dynamicMethod = method2.m_dynamicMethod;
if (dynamicMethod != null)
{
dynamicMethod.GetMethodDescriptor();
declaringType = RuntimeMethodHandle.GetDeclaringType(dynamicMethod.m_methodHandle);
}
else
{
RuntimeMethodInfo info3 = method2.m_method;
if (info3.DeclaringType == null)
{
declaringType = RuntimeMethodHandle.GetDeclaringType(info3);
}
else
{
declaringType = info3.DeclaringType.TypeHandle.GetRuntimeType();
}
}
}
if (declaringType == null)
{
return(-1);
}
return(this.m_scope.GetTokenFor(declaringType.GetTypeHandleInternal()));
}
public unsafe override MethodBase ResolveMethod(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments)
{
MetadataToken metadataToken2 = new MetadataToken(metadataToken);
if (!this.MetadataImport.IsValidToken(metadataToken2))
{
throw new ArgumentOutOfRangeException("metadataToken", Environment.GetResourceString("Argument_InvalidToken", new object[]
{
metadataToken2,
this
}));
}
RuntimeTypeHandle[] typeInstantiationContext = RuntimeModule.ConvertToTypeHandleArray(genericTypeArguments);
RuntimeTypeHandle[] methodInstantiationContext = RuntimeModule.ConvertToTypeHandleArray(genericMethodArguments);
MethodBase methodBase;
try
{
if (!metadataToken2.IsMethodDef && !metadataToken2.IsMethodSpec)
{
if (!metadataToken2.IsMemberRef)
{
throw new ArgumentException("metadataToken", Environment.GetResourceString("Argument_ResolveMethod", new object[]
{
metadataToken2,
this
}));
}
if (*(byte *)this.MetadataImport.GetMemberRefProps(metadataToken2).Signature.ToPointer() == 6)
{
throw new ArgumentException("metadataToken", Environment.GetResourceString("Argument_ResolveMethod", new object[]
{
metadataToken2,
this
}));
}
}
IRuntimeMethodInfo runtimeMethodInfo = ModuleHandle.ResolveMethodHandleInternal(this.GetNativeHandle(), metadataToken2, typeInstantiationContext, methodInstantiationContext);
Type type = RuntimeMethodHandle.GetDeclaringType(runtimeMethodInfo);
if (type.IsGenericType || type.IsArray)
{
MetadataToken token = new MetadataToken(this.MetadataImport.GetParentToken(metadataToken2));
if (metadataToken2.IsMethodSpec)
{
token = new MetadataToken(this.MetadataImport.GetParentToken(token));
}
type = this.ResolveType(token, genericTypeArguments, genericMethodArguments);
}
methodBase = RuntimeType.GetMethodBase(type as RuntimeType, runtimeMethodInfo);
}
catch (BadImageFormatException innerException)
{
throw new ArgumentException(Environment.GetResourceString("Argument_BadImageFormatExceptionResolve"), innerException);
}
return(methodBase);
}
internal static unsafe ParameterInfo[] GetParameters(MethodBase method, MemberInfo member, Signature sig, out ParameterInfo returnParameter, bool fetchReturnParameter)
{
RuntimeMethodHandle methodHandle = method.GetMethodHandle();
returnParameter = null;
int length = sig.Arguments.Length;
ParameterInfo[] infoArray = fetchReturnParameter ? null : new ParameterInfo[length];
int methodDef = methodHandle.GetMethodDef();
int count = 0;
if (!System.Reflection.MetadataToken.IsNullToken(methodDef))
{
MetadataImport metadataImport = methodHandle.GetDeclaringType().GetModuleHandle().GetMetadataImport();
count = metadataImport.EnumParamsCount(methodDef);
int *result = stackalloc int[count];
metadataImport.EnumParams(methodDef, result, count);
for (uint i = 0; i < count; i++)
{
ParameterAttributes attributes;
int num5;
int parameterToken = result[(int)((int *)i)];
metadataImport.GetParamDefProps(parameterToken, out num5, out attributes);
num5--;
if (fetchReturnParameter && (num5 == -1))
{
returnParameter = new ParameterInfo(sig, metadataImport, parameterToken, num5, attributes, member);
}
else if (!fetchReturnParameter && (num5 >= 0))
{
infoArray[num5] = new ParameterInfo(sig, metadataImport, parameterToken, num5, attributes, member);
}
}
}
if (fetchReturnParameter)
{
if (returnParameter == null)
{
returnParameter = new ParameterInfo(sig, MetadataImport.EmptyImport, 0, -1, ParameterAttributes.None, member);
}
return(infoArray);
}
if (count < (infoArray.Length + 1))
{
for (int j = 0; j < infoArray.Length; j++)
{
if (infoArray[j] == null)
{
infoArray[j] = new ParameterInfo(sig, MetadataImport.EmptyImport, 0, j, ParameterAttributes.None, member);
}
}
}
return(infoArray);
}
internal override unsafe int ParentToken(int token)
{
RuntimeTypeHandle owner = RuntimeTypeHandle.EmptyHandle;
Object handle = m_scope[token];
if (handle is RuntimeMethodHandle)
{
RuntimeMethodHandle method = (RuntimeMethodHandle)handle;
owner = method.GetDeclaringType();
}
else if (handle is RuntimeFieldHandle)
{
RuntimeFieldHandle field = (RuntimeFieldHandle)handle;
owner = field.GetApproxDeclaringType();
}
else if (handle is DynamicMethod)
{
DynamicMethod dynMeth = (DynamicMethod)handle;
owner = dynMeth.m_method.GetDeclaringType();
}
else if (handle is GenericMethodInfo)
{
GenericMethodInfo gmi = (GenericMethodInfo)handle;
owner = gmi.m_context;
}
else if (handle is VarArgMethod)
{
VarArgMethod varargMeth = (VarArgMethod)handle;
if (varargMeth.m_method is DynamicMethod)
{
owner = ((DynamicMethod)varargMeth.m_method).m_method.GetDeclaringType();
}
else if (varargMeth.m_method is DynamicMethod.RTDynamicMethod)
{
owner = ((DynamicMethod.RTDynamicMethod)varargMeth.m_method).m_owner.m_method.GetDeclaringType();
}
else
{
owner = varargMeth.m_method.MethodHandle.GetDeclaringType();
}
}
if (owner.IsNullHandle())
{
return(-1);
}
return(m_scope.GetTokenFor(owner));
}
public int GetTokenFor(RuntimeMethodHandle method)
{
IRuntimeMethodInfo methodInfo = method.GetMethodInfo();
RuntimeMethodHandleInternal internal2 = methodInfo.Value;
if ((methodInfo != null) && !RuntimeMethodHandle.IsDynamicMethod(internal2))
{
RuntimeType declaringType = RuntimeMethodHandle.GetDeclaringType(internal2);
if ((declaringType != null) && RuntimeTypeHandle.IsGenericType(declaringType))
{
MethodBase methodBase = RuntimeType.GetMethodBase(methodInfo);
Type genericTypeDefinition = methodBase.DeclaringType.GetGenericTypeDefinition();
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_MethodDeclaringTypeGenericLcg"), new object[] { methodBase, genericTypeDefinition }));
}
}
this.m_tokens.Add(method);
return((this.m_tokens.Count - 1) | 0x6000000);
}
public int GetTokenFor(RuntimeMethodHandle method)
{
IRuntimeMethodInfo methodInfo = method.GetMethodInfo();
RuntimeMethodHandleInternal value = methodInfo.Value;
if (methodInfo != null && !RuntimeMethodHandle.IsDynamicMethod(value))
{
RuntimeType declaringType = RuntimeMethodHandle.GetDeclaringType(value);
if (declaringType != null && RuntimeTypeHandle.HasInstantiation(declaringType))
{
MethodBase methodBase = RuntimeType.GetMethodBase(methodInfo);
Type genericTypeDefinition = methodBase.DeclaringType.GetGenericTypeDefinition();
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_MethodDeclaringTypeGenericLcg"), methodBase, genericTypeDefinition));
}
}
this.m_tokens.Add(method);
return(this.m_tokens.Count - 1 | 100663296);
}
public unsafe MethodBase ResolveMethod(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments)
{
MethodBase methodBase;
System.Reflection.MetadataToken token = new System.Reflection.MetadataToken(metadataToken);
if (!this.MetadataImport.IsValidToken((int)token))
{
throw new ArgumentOutOfRangeException("metadataToken", string.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_InvalidToken", new object[] { token, this }), new object[0]));
}
RuntimeTypeHandle[] typeInstantiationContext = ConvertToTypeHandleArray(genericTypeArguments);
RuntimeTypeHandle[] methodInstantiationContext = ConvertToTypeHandleArray(genericMethodArguments);
try
{
if (!token.IsMethodDef && !token.IsMethodSpec)
{
if (!token.IsMemberRef)
{
throw new ArgumentException("metadataToken", string.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_ResolveMethod", new object[] { token, this }), new object[0]));
}
if (*(((byte *)this.MetadataImport.GetMemberRefProps((int)token).Signature.ToPointer())) == 6)
{
throw new ArgumentException("metadataToken", string.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_ResolveMethod"), new object[] { token, this }));
}
}
RuntimeMethodHandle methodHandle = this.GetModuleHandle().ResolveMethodHandle((int)token, typeInstantiationContext, methodInstantiationContext);
Type runtimeType = methodHandle.GetDeclaringType().GetRuntimeType();
if (runtimeType.IsGenericType || runtimeType.IsArray)
{
System.Reflection.MetadataToken token2 = new System.Reflection.MetadataToken(this.MetadataImport.GetParentToken((int)token));
if (token.IsMethodSpec)
{
token2 = new System.Reflection.MetadataToken(this.MetadataImport.GetParentToken((int)token2));
}
runtimeType = this.ResolveType((int)token2, genericTypeArguments, genericMethodArguments);
}
methodBase = System.RuntimeType.GetMethodBase(runtimeType.GetTypeHandleInternal(), methodHandle);
}
catch (BadImageFormatException exception)
{
throw new ArgumentException(Environment.GetResourceString("Argument_BadImageFormatExceptionResolve"), exception);
}
return(methodBase);
}
public int GetTokenFor(RuntimeMethodHandle method)
{
IRuntimeMethodInfo methodReal = method.GetMethodInfo();
RuntimeMethodHandleInternal rmhi = methodReal.Value;
if (methodReal != null && !RuntimeMethodHandle.IsDynamicMethod(rmhi))
{
RuntimeType type = RuntimeMethodHandle.GetDeclaringType(rmhi);
if ((type != null) && RuntimeTypeHandle.HasInstantiation(type))
{
// Do we really need to retrieve this much info just to throw an exception?
MethodBase m = RuntimeType.GetMethodBase(methodReal);
Type t = m.DeclaringType.GetGenericTypeDefinition();
throw new ArgumentException(SR.Format(SR.Argument_MethodDeclaringTypeGenericLcg, m, t));
}
}
m_tokens.Add(method);
return(m_tokens.Count - 1 | (int)MetadataTokenType.MethodDef);
}
public override unsafe MethodBase ResolveMethod(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments)
{
System.Reflection.MetadataToken metadataToken1 = new System.Reflection.MetadataToken(metadataToken);
if (!this.MetadataImport.IsValidToken((int)metadataToken1))
{
throw new ArgumentOutOfRangeException("metadataToken", Environment.GetResourceString("Argument_InvalidToken", (object)metadataToken1, (object)this));
}
RuntimeTypeHandle[] typeHandleArray1 = RuntimeModule.ConvertToTypeHandleArray(genericTypeArguments);
RuntimeTypeHandle[] typeHandleArray2 = RuntimeModule.ConvertToTypeHandleArray(genericMethodArguments);
try
{
if (!metadataToken1.IsMethodDef && !metadataToken1.IsMethodSpec)
{
if (!metadataToken1.IsMemberRef)
{
throw new ArgumentException("metadataToken", Environment.GetResourceString("Argument_ResolveMethod", (object)metadataToken1, (object)this));
}
if ((int)*(byte *)this.MetadataImport.GetMemberRefProps((int)metadataToken1).Signature.ToPointer() == 6)
{
throw new ArgumentException("metadataToken", Environment.GetResourceString("Argument_ResolveMethod", (object)metadataToken1, (object)this));
}
}
IRuntimeMethodInfo runtimeMethodInfo = ModuleHandle.ResolveMethodHandleInternal(this.GetNativeHandle(), (int)metadataToken1, typeHandleArray1, typeHandleArray2);
Type type = (Type)RuntimeMethodHandle.GetDeclaringType(runtimeMethodInfo);
if (type.IsGenericType || type.IsArray)
{
System.Reflection.MetadataToken metadataToken2 = new System.Reflection.MetadataToken(this.MetadataImport.GetParentToken((int)metadataToken1));
if (metadataToken1.IsMethodSpec)
{
metadataToken2 = new System.Reflection.MetadataToken(this.MetadataImport.GetParentToken((int)metadataToken2));
}
type = this.ResolveType((int)metadataToken2, genericTypeArguments, genericMethodArguments);
}
return(RuntimeType.GetMethodBase(type as RuntimeType, runtimeMethodInfo));
}
catch (BadImageFormatException ex)
{
throw new ArgumentException(Environment.GetResourceString("Argument_BadImageFormatExceptionResolve"), (Exception)ex);
}
}
internal static ParameterInfo[] GetParameters(IRuntimeMethodInfo methodHandle, MemberInfo member, Signature sig, out ParameterInfo returnParameter, bool fetchReturnParameter)
{
returnParameter = (ParameterInfo)null;
int length = sig.Arguments.Length;
ParameterInfo[] parameterInfoArray = fetchReturnParameter ? (ParameterInfo[])null : new ParameterInfo[length];
int methodDef = RuntimeMethodHandle.GetMethodDef(methodHandle);
int num1 = 0;
if (!System.Reflection.MetadataToken.IsNullToken(methodDef))
{
MetadataImport metadataImport = RuntimeTypeHandle.GetMetadataImport(RuntimeMethodHandle.GetDeclaringType(methodHandle));
MetadataEnumResult result;
metadataImport.EnumParams(methodDef, out result);
num1 = result.Length;
if (num1 > length + 1)
{
throw new BadImageFormatException(Environment.GetResourceString("BadImageFormat_ParameterSignatureMismatch"));
}
for (int index = 0; index < num1; ++index)
{
int num2 = result[index];
int sequence;
ParameterAttributes attributes;
metadataImport.GetParamDefProps(num2, out sequence, out attributes);
--sequence;
if (fetchReturnParameter && sequence == -1)
{
if (returnParameter != null)
{
throw new BadImageFormatException(Environment.GetResourceString("BadImageFormat_ParameterSignatureMismatch"));
}
returnParameter = (ParameterInfo) new RuntimeParameterInfo(sig, metadataImport, num2, sequence, attributes, member);
}
else if (!fetchReturnParameter && sequence >= 0)
{
if (sequence >= length)
{
throw new BadImageFormatException(Environment.GetResourceString("BadImageFormat_ParameterSignatureMismatch"));
}
parameterInfoArray[sequence] = (ParameterInfo) new RuntimeParameterInfo(sig, metadataImport, num2, sequence, attributes, member);
}
}
}
if (fetchReturnParameter)
{
if (returnParameter == null)
{
returnParameter = (ParameterInfo) new RuntimeParameterInfo(sig, MetadataImport.EmptyImport, 0, -1, ParameterAttributes.None, member);
}
}
else if (num1 < parameterInfoArray.Length + 1)
{
for (int position = 0; position < parameterInfoArray.Length; ++position)
{
if (parameterInfoArray[position] == null)
{
parameterInfoArray[position] = (ParameterInfo) new RuntimeParameterInfo(sig, MetadataImport.EmptyImport, 0, position, ParameterAttributes.None, member);
}
}
}
return(parameterInfoArray);
}
[System.Security.SecurityCritical] // auto-generated
internal unsafe static ParameterInfo[] GetParameters(
IRuntimeMethodInfo methodHandle, MemberInfo member, Signature sig, out ParameterInfo returnParameter, bool fetchReturnParameter)
{
returnParameter = null;
int sigArgCount = sig.Arguments.Length;
ParameterInfo[] args = fetchReturnParameter ? null : new ParameterInfo[sigArgCount];
int tkMethodDef = RuntimeMethodHandle.GetMethodDef(methodHandle);
int cParamDefs = 0;
// Not all methods have tokens. Arrays, pointers and byRef types do not have tokens as they
// are generated on the fly by the runtime.
if (!MdToken.IsNullToken(tkMethodDef))
{
MetadataImport scope = RuntimeTypeHandle.GetMetadataImport(RuntimeMethodHandle.GetDeclaringType(methodHandle));
MetadataEnumResult tkParamDefs;
scope.EnumParams(tkMethodDef, out tkParamDefs);
cParamDefs = tkParamDefs.Length;
// Not all parameters have tokens. Parameters may have no token
// if they have no name and no attributes.
if (cParamDefs > sigArgCount + 1 /* return type */)
{
throw new BadImageFormatException(Environment.GetResourceString("BadImageFormat_ParameterSignatureMismatch"));
}
for (int i = 0; i < cParamDefs; i++)
{
#region Populate ParameterInfos
ParameterAttributes attr;
int position, tkParamDef = tkParamDefs[i];
scope.GetParamDefProps(tkParamDef, out position, out attr);
position--;
if (fetchReturnParameter == true && position == -1)
{
// more than one return parameter?
if (returnParameter != null)
{
throw new BadImageFormatException(Environment.GetResourceString("BadImageFormat_ParameterSignatureMismatch"));
}
returnParameter = new RuntimeParameterInfo(sig, scope, tkParamDef, position, attr, member);
}
else if (fetchReturnParameter == false && position >= 0)
{
// position beyong sigArgCount?
if (position >= sigArgCount)
{
throw new BadImageFormatException(Environment.GetResourceString("BadImageFormat_ParameterSignatureMismatch"));
}
args[position] = new RuntimeParameterInfo(sig, scope, tkParamDef, position, attr, member);
}
#endregion
}
}
// Fill in empty ParameterInfos for those without tokens
if (fetchReturnParameter)
{
if (returnParameter == null)
{
returnParameter = new RuntimeParameterInfo(sig, MetadataImport.EmptyImport, 0, -1, (ParameterAttributes)0, member);
}
}
else
{
if (cParamDefs < args.Length + 1)
{
for (int i = 0; i < args.Length; i++)
{
if (args[i] != null)
{
continue;
}
args[i] = new RuntimeParameterInfo(sig, MetadataImport.EmptyImport, 0, i, (ParameterAttributes)0, member);
}
}
}
return(args);
}
internal static unsafe ParameterInfo[] GetParameters(IRuntimeMethodInfo methodHandle, MemberInfo member, Signature sig, out ParameterInfo returnParameter, bool fetchReturnParameter)
{
returnParameter = null;
int length = sig.Arguments.Length;
ParameterInfo[] infoArray = fetchReturnParameter ? null : new ParameterInfo[length];
int methodDef = RuntimeMethodHandle.GetMethodDef(methodHandle);
int count = 0;
if (!System.Reflection.MetadataToken.IsNullToken(methodDef))
{
MetadataImport metadataImport = RuntimeTypeHandle.GetMetadataImport(RuntimeMethodHandle.GetDeclaringType(methodHandle));
count = metadataImport.EnumParamsCount(methodDef);
int *result = (int *)stackalloc byte[(((IntPtr)count) * 4)];
metadataImport.EnumParams(methodDef, result, count);
if (count > (length + 1))
{
throw new BadImageFormatException(Environment.GetResourceString("BadImageFormat_ParameterSignatureMismatch"));
}
for (uint i = 0; i < count; i++)
{
ParameterAttributes attributes;
int num5;
int parameterToken = result[(int)((int *)i)];
metadataImport.GetParamDefProps(parameterToken, out num5, out attributes);
num5--;
if (fetchReturnParameter && (num5 == -1))
{
if (returnParameter != null)
{
throw new BadImageFormatException(Environment.GetResourceString("BadImageFormat_ParameterSignatureMismatch"));
}
returnParameter = new RuntimeParameterInfo(sig, metadataImport, parameterToken, num5, attributes, member);
}
else if (!fetchReturnParameter && (num5 >= 0))
{
if (num5 >= length)
{
throw new BadImageFormatException(Environment.GetResourceString("BadImageFormat_ParameterSignatureMismatch"));
}
infoArray[num5] = new RuntimeParameterInfo(sig, metadataImport, parameterToken, num5, attributes, member);
}
}
}
if (fetchReturnParameter)
{
if (returnParameter == null)
{
returnParameter = new RuntimeParameterInfo(sig, MetadataImport.EmptyImport, 0, -1, ParameterAttributes.None, member);
}
return(infoArray);
}
if (count < (infoArray.Length + 1))
{
for (int j = 0; j < infoArray.Length; j++)
{
if (infoArray[j] == null)
{
infoArray[j] = new RuntimeParameterInfo(sig, MetadataImport.EmptyImport, 0, j, ParameterAttributes.None, member);
}
}
}
return(infoArray);
}
internal static ParameterInfo[] GetParameters(IRuntimeMethodInfo methodHandle, MemberInfo member, Signature sig, out ParameterInfo returnParameter, bool fetchReturnParameter)
{
returnParameter = null;
int num = sig.Arguments.Length;
ParameterInfo[] array = fetchReturnParameter ? null : new ParameterInfo[num];
int methodDef = RuntimeMethodHandle.GetMethodDef(methodHandle);
int num2 = 0;
if (!System.Reflection.MetadataToken.IsNullToken(methodDef))
{
MetadataImport metadataImport = RuntimeTypeHandle.GetMetadataImport(RuntimeMethodHandle.GetDeclaringType(methodHandle));
MetadataEnumResult metadataEnumResult;
metadataImport.EnumParams(methodDef, out metadataEnumResult);
num2 = metadataEnumResult.Length;
if (num2 > num + 1)
{
throw new BadImageFormatException(Environment.GetResourceString("BadImageFormat_ParameterSignatureMismatch"));
}
for (int i = 0; i < num2; i++)
{
int num3 = metadataEnumResult[i];
int num4;
ParameterAttributes attributes;
metadataImport.GetParamDefProps(num3, out num4, out attributes);
num4--;
if (fetchReturnParameter && num4 == -1)
{
if (returnParameter != null)
{
throw new BadImageFormatException(Environment.GetResourceString("BadImageFormat_ParameterSignatureMismatch"));
}
returnParameter = new RuntimeParameterInfo(sig, metadataImport, num3, num4, attributes, member);
}
else if (!fetchReturnParameter && num4 >= 0)
{
if (num4 >= num)
{
throw new BadImageFormatException(Environment.GetResourceString("BadImageFormat_ParameterSignatureMismatch"));
}
array[num4] = new RuntimeParameterInfo(sig, metadataImport, num3, num4, attributes, member);
}
}
}
if (fetchReturnParameter)
{
if (returnParameter == null)
{
returnParameter = new RuntimeParameterInfo(sig, MetadataImport.EmptyImport, 0, -1, ParameterAttributes.None, member);
}
}
else if (num2 < array.Length + 1)
{
for (int j = 0; j < array.Length; j++)
{
if (array[j] == null)
{
array[j] = new RuntimeParameterInfo(sig, MetadataImport.EmptyImport, 0, j, ParameterAttributes.None, member);
}
}
}
return(array);
}
