private static void EvaluateCondition(MemberMetaInfo targetMember, Location attributeLocation, ConditionExpression conditions, IDiagnosticReporter reporter)
{
switch (conditions.Condition)
{
// Since all objects contain Equals(object), this is the least we call back into
// TODO : Note we might still want to warn user about that a returning type doesn't contain a correct signature
// For example : If we try to evaluate the member equals to true,
// even if the member returns a type that is obvious that wouldn't evaluate with true, then it would still evaluate, but just to false
case Condition.Equal:
case Condition.NotEqual:
break;
// In these cases we need to check if either the return type implements IComparable or IComparable<T>
// We might also want to warn about boxing issue if the given compared type is a valuetype and returning type only has IComparable though
case Condition.GreaterThan:
case Condition.GreaterThanOrEqual:
case Condition.LessThan:
case Condition.LessThanOrEqual: {
// Valid compare types
// Value Types : bool, char, byte, sbyte, ushort, short, int, uint, ulong, long, float, double
// Ref Types : Types (but why), string (but why)
// We currently consider 'null' to be not comparable, so there's this
if (conditions.ComparedValue is null)
{
reporter.ReportDiagnostic(DiagnosticHelper.CompareValueInvalid(conditions, attributeLocation));
break;
}
// Valid implicit conversion for IComparable is matched with C# specification :
// https://docs.microsoft.com/dotnet/csharp/language-reference/builtin-types/numeric-conversions
//
// [Possible Improvement]
// TODO : We also don't support even if IComparation<T>'s T is implicit convertible from the compared type
// We only support when it's primitive is implicitly convertible (supported by C# specification) to another primitive type
// So types that only return IComparable<long> would work well with int numbers
//
// This can be done using a compilation extensions provided out of the box:
// https://docs.microsoft.com/dotnet/api/microsoft.codeanalysis.csharp.csharpextensions.classifyconversion
var returnType = targetMember.ReturnType !;
var comparedType = conditions.ComparedValue.GetType();
if (!returnType.Implements(typeof(IComparable)) || !returnType.Implements(typeof(IComparable <>)))
{
reporter.ReportDiagnostic(DiagnosticHelper.ReturnTypeNotComparable(targetMember, conditions.Condition, attributeLocation));
break;
}
if (!returnType.Implements(typeof(IComparable <>).MakeGenericType(comparedType)) ||
!returnType.GetInterfaces(typeof(IComparable <>)).Any(x => x.IsImplicitConvertibleFrom(comparedType)))
{
reporter.ReportDiagnostic(DiagnosticHelper.ReturnTypeInvalidComparable(targetMember, comparedType, attributeLocation));
break;
}
break;
}
// Since all objects can be evaluated with is operator
case Condition.IsTypeOf:
case Condition.IsNotTypeOf: {
if (!(conditions.ComparedValue is null) && conditions.ComparedValue.GetType() != typeof(Type))
{
reporter.ReportDiagnostic(DiagnosticHelper.CompareValueInvalid(conditions, attributeLocation, ", it should be only a kind of Type and none other"));
}
break;
}
default:
reporter.ReportDiagnostic(DiagnosticHelper.InvalidCondition(conditions.Condition, attributeLocation));
break;
}
}
