private static Conversion ToConversion(OverloadResolutionResult <MethodSymbol> result, MethodGroup methodGroup, NamedTypeSymbol delegateType)
{
// 6.6 An implicit conversion (6.1) exists from a method group (7.1) to a compatible
// delegate type. Given a delegate type D and an expression E that is classified as
// a method group, an implicit conversion exists from E to D if E contains at least
// one method that is applicable in its normal form (7.5.3.1) to an argument list
// constructed by use of the parameter types and modifiers of D...
// SPEC VIOLATION: Unfortunately, we cannot exactly implement the specification for
// the scenario in which an extension method that extends a value type is converted
// to a delegate. The code we generate that captures a delegate to a static method
// that is "partially evaluated" with the bound-to-the-delegate first argument
// requires that the first argument be of reference type.
// SPEC VIOLATION: Similarly, we cannot capture a method of Nullable<T>, because
// boxing a Nullable<T> gives a T, not a boxed Nullable<T>. (We can capture methods
// of object on a nullable receiver, but not GetValueOrDefault.)
if (!result.Succeeded)
{
return(Conversion.NoConversion);
}
MethodSymbol method = result.BestResult.Member;
if (methodGroup.IsExtensionMethodGroup && !method.Parameters[0].Type.IsReferenceType)
{
return(Conversion.NoConversion);
}
//cannot capture stack-only types.
if (!method.IsStatic && methodGroup.Receiver?.Type?.IsRestrictedType() == true)
{
return(Conversion.NoConversion);
}
if (method.ContainingType.IsNullableType() && !method.IsOverride)
{
return(Conversion.NoConversion);
}
// NOTE: Section 6.6 will be slightly updated:
//
// - The candidate methods considered are only those methods that are applicable in their
// normal form (§7.5.3.1), and do not omit any optional parameters. Thus, candidate methods
// are ignored if they are applicable only in their expanded form, or if one or more of their
// optional parameters do not have a corresponding parameter in the targeted delegate type.
//
// Therefore, we shouldn't get here unless the parameter count matches.
// NOTE: Delegate type compatibility is important, but is not part of the existence check.
Debug.Assert(method.ParameterCount == delegateType.DelegateInvokeMethod.ParameterCount + (methodGroup.IsExtensionMethodGroup ? 1 : 0));
return(new Conversion(ConversionKind.MethodGroup, method, methodGroup.IsExtensionMethodGroup));
}
