public bool ReturnTypesMatch(IMethodDefinition implMethod, IMethodDefinition contractMethod)
{
ITypeReference implType = implMethod.GetReturnType();
ITypeReference contractType = contractMethod.GetReturnType();
if (implType == null || contractType == null)
{
return(true);
}
if (!_typeComparer.Equals(implType, contractType))
{
return(false);
}
return(true);
}
private bool ReturnTypesMatch(IDifferences differences, IMethodDefinition implMethod, IMethodDefinition contractMethod)
{
ITypeReference implReturnType = implMethod.GetReturnType();
ITypeReference contractReturnType = contractMethod.GetReturnType();
if (implReturnType == null || contractReturnType == null)
return true;
if (!_typeComparer.Equals(implReturnType, contractReturnType))
{
differences.AddTypeMismatchDifference("DelegateReturnTypesMustMatch", implReturnType, contractReturnType,
"Return type on delegate '{0}' is '{1}' in the implementation but '{2}' in the contract.",
implMethod.ContainingType.FullName(), implReturnType.FullName(), contractReturnType.FullName());
return false;
}
return true;
}
private bool ReturnTypesMatch(IDifferences differences, IMethodDefinition implMethod, IMethodDefinition contractMethod)
{
ITypeReference implReturnType = implMethod.GetReturnType();
ITypeReference contractReturnType = contractMethod.GetReturnType();
if (implReturnType == null || contractReturnType == null)
{
return(true);
}
if (!_typeComparer.Equals(implReturnType, contractReturnType))
{
differences.AddTypeMismatchDifference("DelegateReturnTypesMustMatch", implReturnType, contractReturnType,
$"Return type on delegate '{implMethod.ContainingType.FullName()}' is '{implReturnType.FullName()}' in the {Implementation} but '{contractReturnType.FullName()}' in the {Contract}.");
return(false);
}
return(true);
}
public override DifferenceType Diff(IDifferences differences, MemberMapping mapping)
{
ITypeDefinitionMember implMember = mapping[0];
ITypeDefinitionMember contractMember = mapping[1];
IMethodDefinition foundMethod;
if (!(implMember == null && contractMember != null))
{
return(DifferenceType.Unknown);
}
// Nested types are handled separately.
// @TODO: Events and Properties - should we consider these too (or rely on the fact that dropping one of these will also drop their accessors.)
if (!(contractMember is IMethodDefinition || contractMember is IFieldDefinition))
{
return(DifferenceType.Unknown);
}
string incompatibeDifferenceMessage = $"Member '{contractMember.FullName()}' does not exist in the {Implementation} but it does exist in the {Contract}.";
ITypeDefinition contractType = mapping.ContainingType[0];
if (contractType != null)
{
IMethodDefinition contractMethod = contractMember as IMethodDefinition;
if (contractMethod != null)
{
// If the contract is a Explicit Interface method, we don't need to check if the method is in implementation since that will be caught by different rule.
if (contractMethod.IsExplicitInterfaceMethod())
{
return(DifferenceType.Unknown);
}
// It is valid to promote a member from a base type up so check to see if it member exits on a base type.
var lookForMethodInBaseResult = FindMatchingBase(contractType, contractMethod, out foundMethod);
if (lookForMethodInBaseResult == FindMethodResult.Found)
{
return(DifferenceType.Unknown);
}
if (lookForMethodInBaseResult == FindMethodResult.ReturnTypeChanged)
{
incompatibeDifferenceMessage += $" There does exist a member with return type '{foundMethod.GetReturnType().FullName()}' instead of '{contractMethod.GetReturnType().FullName()}'";
}
}
}
differences.AddIncompatibleDifference(this, incompatibeDifferenceMessage);
return(DifferenceType.Added);
}
public bool ReturnTypesMatch(IMethodDefinition implMethod, IMethodDefinition contractMethod)
{
ITypeReference implType = implMethod.GetReturnType();
ITypeReference contractType = contractMethod.GetReturnType();
if (implType == null || contractType == null)
return true;
if (!_typeComparer.Equals(implType, contractType))
{
return false;
}
return true;
}
