Better Betterness is not that better

[marek-safar]

Consider following example

using System;

public class BrokenOverloadResolution
{
    static void Test (Action a)
    {
    }

    static void Test (Func<object> f)
    {
    }

    public void MethodGroupExactMatching ()
    {
        // This fails to compile with
        // 
        // error CS0121: The call is ambiguous between the following methods or properties: 'BrokenOverloadResolution.Test(Action)' and 'BrokenOverloadResolution.Test(Func<object>)'
        //
        Test (Listen);

        //
        // non-void version works
        //
        // Test2 (DontListen);
    }

    void Listen ()
    {
    }

    object DontListen ()
    {
        return null;
    }

    public static void Main ()
    {
    }
}

Compilation produces after #6560 fix error message CS0121: The call is ambiguous between the following methods or properties: 'BrokenOverloadResolution.Test(Action)' and 'BrokenOverloadResolution.Test(Func<object>)' but there is no ambiguity.

Removing "ambiguous" candidate static void Test (Action a) leads to real compilation error which says error CS0407: 'void BrokenOverloadResolution.Listen()' has the wrong return type which makes sense as void is not convertible to object but that means there is no real ambiguity.

Reading #7934 does not mentioned anything special about method group conversions with return type void.

[Joe4evr]

Isn't this what #250 (bestest betterness) is supposed to fix?

[markhurd]

Just noting the equivalent VB.NET code has worked since at least VS2013.

[jaredpar]

Chatted with @gafter and this is indeed an example of the bestest betterness discussion. In particular point 3:

• For a method group conversion, candidate methods whose return type doesn't match up with the delegate's return type are removed from the set.

Going to let the language design issue track this for now. It's on our candidate list for an upcoming version

dotnet/csharplang#98

[Clancey]

Additionally, it has issues with Linq.

var files = new string[0];
var maxDate = files.Max(System.IO.File.GetCreationTime);

Error CS0121: The call is ambiguous between the following methods or properties: 'Enumerable.Max(IEnumerable, Func<TSource, int>)' and 'Enumerable.Max(IEnumerable, Func<TSource, int?>)'

However slightly changing the code works:

files.Max(x=> System.IO.File.GetCreationTime(x));

[gafter]

@jaredpar Actually, now that I think about it further it might not be the same. This is a lambda conversion, not a method group conversion. I'll note to look at that too when we look at bestest betterness.

[jaredpar]

@gafter the most recent comment is a lambda conversion. The original question is about method group conversions.