Why is this method invocation ambiguous?

Question

Why does the first call to Foo below compile but the second one results in an ambiguous invocation compiler error?

(using c# 7.2)

    private static void AmbiguousAsyncOverload() {
      Foo(() => Bar());  // This is OK
      //Foo(Bar);        // Error, ambiguous overload
    }

    private static void Foo(Func<int> func) {
      func();
    }

    private static void Foo(Func<string> func) {
      func();
    }

    private static int Bar() {
      return 4;
    }

If I remove the first (Func<int>) implementation of Foo, and hence the possibility of ambiguity, then the compiler (correctly) reports that Bar doesn't have the correct signature to be passed into Foo, which implies it has enough information to resolve the ambiguity.

I would understand if the compiler didn't look at return values during overload resolution and therefore both calls failed, but my question is why does one call compile ok while the other doesn't.

Answer 1

This was an issue for all versions of C# up until it was fixed in v7.3. Return types were not taken into account during overload resolution. From the release notes (or the language proposal) for C# 7.3:

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.