private void MakeMethodParameters(MethodBase method, Cci.IMethodReference methodRef, out Type[] methodGenericParameters, out ParameterInfo[] parameters, out ParameterInfo returnParameter)
{
Type declaringType = method.DeclaringType;
if (methodRef.IsGeneric && methodRef.AsGenericMethodInstanceReference == null)
{
// generic definition
methodGenericParameters = MakeGenericParameters((MethodInfo)method, methodRef);
}
else
{
methodGenericParameters = Type.EmptyTypes;
}
Type[] typeGenericParameters;
if (declaringType.IsGenericTypeDefinition)
{
typeGenericParameters = declaringType.GetGenericArguments();
}
else
{
typeGenericParameters = Type.EmptyTypes;
}
GenericContext genericContext = methodGenericParameters.Length > 0 || typeGenericParameters.Length > 0 ?
new GenericContext(typeGenericParameters, methodGenericParameters) : default(GenericContext);
parameters = new ParameterInfo[methodRef.ParameterCount];
int i = 0;
foreach (var parameter in methodRef.GetParameters(_context))
{
parameters[i] = MakeParameterInfo(method, i + 1, parameter.GetType(_context), genericContext, parameter.CustomModifiers, parameter.IsByReference);
i++;
}
returnParameter = MakeParameterInfo(method, 0, methodRef.GetType(_context), genericContext, methodRef.ReturnValueCustomModifiers, methodRef.ReturnValueIsByRef);
}
private MethodBase ResolveOverload(MemberInfo[] members, Cci.IMethodReference methodRef)
{
IEnumerable<Cci.IParameterTypeInformation> paramRefs = methodRef.GetParameters(_context);
Type[] reusableResolvedParameters = null;
Type[] typeGenericParameters = members[0].DeclaringType.GetGenericArguments();
MethodBase candidate = null;
foreach (MethodBase method in members)
{
Debug.Assert(!method.IsGenericMethod || method.IsGenericMethodDefinition);
if (methodRef.AcceptsExtraArguments && method.CallingConvention != CallingConventions.VarArgs)
{
continue;
}
if (methodRef.IsGeneric != method.IsGenericMethodDefinition)
{
continue;
}
Type[] methodGenericParameters = (methodRef.IsGeneric) ? method.GetGenericArguments() : Type.EmptyTypes;
if (methodGenericParameters.Length != methodRef.GenericParameterCount)
{
continue;
}
GenericContext genericContext = new GenericContext(typeGenericParameters, methodGenericParameters);
Type[] resolvedParameters = reusableResolvedParameters ??
ResolveMethodParameters(methodRef, paramRefs, genericContext);
if (ParametersMatch(resolvedParameters, method.GetParameters()) && ReturnTypeMatches(methodRef, method, genericContext))
{
Debug.Assert(candidate == null);
candidate = method;
#if !DEBUG
break;
#endif
}
// We can reuse resolved parameters if the method isn't generic.
// If it is its signature might contain references to its generic parameters which are different for each overload.
if (reusableResolvedParameters == null && !methodRef.IsGeneric)
{
reusableResolvedParameters = resolvedParameters;
}
}
Debug.Assert(candidate != null);
return candidate;
}
private void GetParameterTypes(Cci.ISignature signature, out Type[] types, out Type[][] reqMods, out Type[][] optMods)
{
// name, default value, marshalling and custom attributes are handled later in DefineParameter
types = new Type[signature.ParameterCount];
reqMods = optMods = null;
int i = 0;
foreach (var parameter in signature.GetParameters(_context))
{
Type type = ResolveParameterType(parameter);
// TODO (tomat, Dev12): this doesn't handle types constructed from modified types, we need Ref.Emit support for that:
ModifiedType modifiedType = type as ModifiedType;
if (modifiedType != null)
{
type = modifiedType.UnmodifiedType;
if (modifiedType.RequiredModifiers != null)
{
if (reqMods == null)
{
reqMods = new Type[types.Length][];
}
reqMods[i] = modifiedType.RequiredModifiers;
}
if (modifiedType.OptionalModifiers != null)
{
if (optMods == null)
{
optMods = new Type[types.Length][];
}
optMods[i] = modifiedType.OptionalModifiers;
}
}
types[i++] = type;
}
}