private static bool MatchParameters(GenericContext <ParameterDefinition> baseParameterType, GenericContext <ParameterDefinition> parameterType)
{
var baseParam = baseParameterType.ResolveWithContext(baseParameterType.Item.ParameterType);
var param = parameterType.ResolveWithContext(parameterType.Item.ParameterType);
return(IsSameType(baseParam, param));
}
static bool MatchParameters(GenericContext <ParameterDefinition> baseParameterType, GenericContext <ParameterDefinition> parameterType)
{
if (baseParameterType.Item.IsIn != parameterType.Item.IsIn ||
baseParameterType.Item.IsOut != parameterType.Item.IsOut)
{
return(false);
}
var baseParam = baseParameterType.ResolveWithContext(baseParameterType.Item.ParameterType);
var param = parameterType.ResolveWithContext(parameterType.Item.ParameterType);
return(IsSameType(baseParam, param));
}
private static bool MatchMethod(GenericContext <MethodDefinition> candidate, GenericContext <MethodDefinition> method)
{
var mCandidate = candidate.Item;
var mMethod = method.Item;
if (mCandidate.Name != mMethod.Name)
{
return(false);
}
if (mCandidate.HasOverrides)
{
return(false);
}
if (!IsSameType(candidate.ResolveWithContext(mCandidate.ReturnType), method.ResolveWithContext(mMethod.ReturnType)))
{
return(false);
}
if (mCandidate.HasGenericParameters || mMethod.HasGenericParameters)
{
if (!mCandidate.HasGenericParameters || !mMethod.HasGenericParameters || mCandidate.GenericParameters.Count != mMethod.GenericParameters.Count)
{
return(false);
}
}
if (mCandidate.HasParameters || mMethod.HasParameters)
{
if (!mCandidate.HasParameters || !mMethod.HasParameters || mCandidate.Parameters.Count != mMethod.Parameters.Count)
{
return(false);
}
for (int index = 0; index < mCandidate.Parameters.Count; index++)
{
if (!MatchParameters(candidate.ApplyTo(mCandidate.Parameters[index]), method.ApplyTo(mMethod.Parameters[index])))
{
return(false);
}
}
}
return(true);
}
private static bool MatchEvent(GenericContext <EventDefinition> candidate, GenericContext <EventDefinition> ev)
{
var mCandidate = candidate.Item;
var mEvent = ev.Item;
if (mCandidate.Name != mEvent.Name)
{
return(false);
}
if ((mCandidate.AddMethod ?? mCandidate.RemoveMethod).HasOverrides)
{
return(false);
}
if (!IsSameType(candidate.ResolveWithContext(mCandidate.EventType), ev.ResolveWithContext(mEvent.EventType)))
{
return(false);
}
return(true);
}
private static bool MatchProperty(GenericContext <PropertyDefinition> candidate, GenericContext <PropertyDefinition> property)
{
var mCandidate = candidate.Item;
var mProperty = property.Item;
if (mCandidate.Name != mProperty.Name)
{
return(false);
}
if ((mCandidate.GetMethod ?? mCandidate.SetMethod).HasOverrides)
{
return(false);
}
if (!IsSameType(candidate.ResolveWithContext(mCandidate.PropertyType), property.ResolveWithContext(mProperty.PropertyType)))
{
return(false);
}
if (mCandidate.HasParameters || mProperty.HasParameters)
{
if (!mCandidate.HasParameters || !mProperty.HasParameters || mCandidate.Parameters.Count != mProperty.Parameters.Count)
{
return(false);
}
for (int index = 0; index < mCandidate.Parameters.Count; index++)
{
if (!MatchParameters(candidate.ApplyTo(mCandidate.Parameters[index]), property.ApplyTo(mProperty.Parameters[index])))
{
return(false);
}
}
}
return(true);
}
private static IEnumerable <GenericContext <TypeDefinition> > BaseTypes(GenericContext <TypeDefinition> type)
{
while (type.Item.BaseType != null)
{
var baseType = type.Item.BaseType;
var genericBaseType = baseType as GenericInstanceType;
if (genericBaseType != null)
{
type = new GenericContext <TypeDefinition>(genericBaseType.ResolveOrThrow(),
genericBaseType.GenericArguments.Select(t => type.ResolveWithContext(t)));
}
else
{
type = new GenericContext <TypeDefinition>(baseType.ResolveOrThrow());
}
yield return(type);
}
}
static IEnumerable <GenericContext <TypeDefinition> > BaseTypes(GenericContext <TypeDefinition> type)
{
while (type.Item.BaseType != null)
{
var baseType = type.Item.BaseType;
var genericBaseType = baseType as GenericInstanceType;
if (genericBaseType != null)
{
#pragma warning disable 618
type = new GenericContext <TypeDefinition>(genericBaseType.ResolveOrThrow(),
#pragma warning restore 618
genericBaseType.GenericArguments.Select(t => type.ResolveWithContext(t)));
}
else
#pragma warning disable 618
{
type = new GenericContext <TypeDefinition>(baseType.ResolveOrThrow());
}
#pragma warning restore 618
yield return(type);
}
}
