Overload resolution for method groups and Action/Func<Task> overloads

[lt-gerjan]

Version Used:
Latest

Steps to Reproduce:

    void LocalFunction(Action action) // this doesn't work
    {
        var capture = "Captured";
        void closure()
        {
            var local = capture;
            
            action();
        }
        
        Task.Run(closure); // error CS0121: The call is ambiguous between the following methods or properties: 'Task.Run(Action)' and 'Task.Run(Func<Task>)'
    }
    
    void ActionDelegate(Action action) // this works
    {
        var capture = "Captured";
        Action closure = () =>
        {
            var local = capture;
            
            action();
        };
        
        Task.Run(closure);
    } 

See:
https://sharplab.io/#v2:CYLg1APgAgDABFAjAbgLAChYMQVjZgZgQCY4BhODAbwwEgM5GEAWOAGQHsBjAQwBsoOAC4BLDgDsAFElI8uoiQEoGTGuiYa4ANx4AnOLwAOQgK66ApnAC8cAERkexs+eC38mplFZc+HAM7OksrqHnBqoZo6+r68fNYGjqYW7hFMKqlwcgpSiikeAL7pmkUaAPSlUABsAHQASiZSPv7OuXDlcA1cHAC23ebiQnBCABYifkWFIYxFXtjEACLmfOYA5jxC5tKIsvJi4sEa4aFRCU4W8faJzq55mjIGvgHnNkHWAHwlqp8eJzH88UYkuZbhFvposnsgiCmPlodMpncavVGo8Wrd8pQERh8kA

Expected Behavior:
I would expect that the two examples are identical and both should compile

Actual Behavior:
error CS0121: The call is ambiguous between the following methods or properties: 'Task.Run(Action)' and 'Task.Run(Func<Task>)'

What I am not getting is that the compiler says that is has to choose between Task.Run(Action) and Task.Run(Func<Task>) but my closure clearly has the same signature as an Action right? (no param, no return)

Edit: the fun thing is that Visual Studio (analyzer + fix) hints for using a local function, which results in a compiler error @kuhlenh

[CyrusNajmabadi]

tagging @agocke . IT does seem weird to have ambiguity, given that one of the overloads expect Func<Task>, and i don't see how void closure() would ever be considered for that...

[lt-gerjan]

@CyrusNajmabadi Yes, Im not getting the ambiguity part of the error message

[agocke]

Doesn't look like this has anything to do with local functions:

using System.Threading.Tasks;
public class C 
{
    public void M() 
    {
        Task.Run(M2);
    }
    
    void M2()
    {

    }
}

Output: error CS0121: The call is ambiguous between the following methods or properties: 'Task.Run(Action)' and 'Task.Run(Func<Task>)'

Plain old overload resolution.

[agocke]

cc @gafter

[lt-gerjan]

@agocke Thanks, so is this considered as a bug or more a (known) design issue? (in the overload resolution space)

[agocke]

This appears to be a bug, since I don't think there's a conversion from void M() to Func<Task> but maybe I'm missing something in the spec. @gafter, what do you think?

[alrz]

Doesn't repro on master. worth to add a test maybe

[agocke]

It looks like this was part of the "bestest betterness" feature implemented for C# 7.3 (which is why it does not repro in master).

See https://github.com/dotnet/csharplang/blob/master/proposals/csharp-7.3/improved-overload-candidates.md for the specification, specifically number (3), which addresses this scenario.