Validation of method-based coercion expression is not correct

[BladeWise]

The check to ensure the method singature of a method-based UnaryExpression expression is probably not correct.

The current method is

procyon/Procyon.Expressions/src/main/java/com/strobel/expressions/Expression.java

Lines 3200 to 3230 in fec0d7a

	private static UnaryExpression getMethodBasedCoercionOperator(
	final ExpressionType unaryType,
	final Expression operand,
	final Type convertToType,
	final MethodInfo method) {
	assert method != null;
	validateOperator(method);
	final ParameterList parameters = method.getParameters();
	if (parameters.size() != 0) {
	throw Error.incorrectNumberOfMethodCallArguments(method);
	}
	final Type returnType = method.getReturnType();
	if (TypeUtils.areReferenceAssignable(convertToType, returnType)) {
	return new UnaryExpression(unaryType, operand, returnType, method);
	}
	// check for auto(un)boxing call
	if (TypeUtils.isAutoUnboxed(convertToType) && returnType.isPrimitive() &&
	TypeUtils.areEquivalent(returnType, TypeUtils.getUnderlyingPrimitive(convertToType))) {
	return new UnaryExpression(unaryType, operand, convertToType, method);
	}
	throw Error.methodBasedOperatorMustHaveValidReturnType(unaryType, method);
	}

which means that the coercion method must be:

• A valid operator (see below)
• Parameterless
• A method whose return type is allowed to be assigned to the expected coercion type

To be a valid operator, as per the following function

procyon/Procyon.Expressions/src/main/java/com/strobel/expressions/Expression.java

Lines 3145 to 3169 in fec0d7a

	private static void validateOperator(final MethodInfo method) {
	assert method != null;
	if (method.isStatic()) {
	throw Error.operatorMethodMustNotBeStatic(method);
	}
	final Type returnType = method.getReturnType();
	if (returnType == PrimitiveTypes.Void) {
	throw Error.operatorMethodMustNotReturnVoid(method);
	}
	final ParameterList parameters = method.getParameters();
	if (parameters.size() != 0) {
	throw Error.operatorMethodParametersMustMatchReturnValue(method);
	}
	final Type<?> returnClass = TypeUtils.getBoxedTypeOrSelf(returnType);
	if (!TypeUtils.areReferenceAssignable(method.getDeclaringType(), returnClass)) {
	throw Error.methodBasedOperatorMustHaveValidReturnType(method);
	}
	}

it must be:

• Non-Static
• Non-Void returning
• Parameterless
• Declared by a class compatible with its return type

Above criteria do not meet what I would expect from a coercion operator, because there is no way for a non-static parameterless method declared by the expected return type, to convert a value from another type (that cannot be supplied). Eventually, it should be provided by a type assignable from the operand type.

Looking at the 'default' coercion methods

procyon/Procyon.Reflection/src/main/java/com/strobel/util/TypeUtils.java

Lines 265 to 285 in fec0d7a

	public static MethodInfo getCoercionMethod(final Type<?> source, final Type<?> destination) {
	// NOTE: If destination type is an autoboxing type, we will need an implicit box later.
	final Type<?> unboxedDestinationType = isAutoUnboxed(destination)
	? getUnderlyingPrimitive(destination)
	: destination;
	if (destination == Types.String) {
	return Types.String.getMethod("valueOf", source);
	}
	/*
	if (!destination.isPrimitive()) {
	return null;
	}
	*/
	final MethodInfo method;
	if (destination == PrimitiveTypes.Integer) {
	method = source.getMethod("intValue", BindingFlags.PublicInstance);
	}

we can see that the actual criteria could be
either:

• Static
• Provided by a type assignable from the coercion type
• Accepting a parameter compatible with the provided operand type
• Returning a type compatible with the coercion method
  like String::valueOf
  or
• Non-Static
• Provided by a type assignable from the operand type
• Parameterless
• Returning a type compatible with the coercion method
  like Long.intValue().

At least, the default coercion methods seem to fall in the above categories (and to be honest, I would avoid the strict check over the declaring type: why a static method provided by another class to perform the conversion is not allowed?).

For reference the current .NET implementation requires the method to be:

• Static
• Accepting a single parameter assignable from the operand type
• Able to return a value assignable from the expected coercion type