Drop special treatment of function types in overloading resolution

[Cherry-picked 0337efd]

Author: odersky

compiler/src/dotty/tools/dotc/typer/Applications.scala

@@ -2068,34 +2068,27 @@ trait Applications extends Compatibility {
           else resolveMapped(alts1, _.widen.appliedTo(targs1.tpes), pt1)
 
       case pt =>
-        val compat0 = pt.dealias match
-          case defn.FunctionNOf(args, resType, _) =>
-            narrowByTypes(alts, args, resType)
-          case _ =>
-            Nil
-        if (compat0.isEmpty) then
-          val compat = alts.filterConserve(normalizedCompatible(_, pt, keepConstraint = false))
-          if (compat.isEmpty)
-            /*
-            * the case should not be moved to the enclosing match
-            * since SAM type must be considered only if there are no candidates
-            * For example, the second f should be chosen for the following code:
-            *   def f(x: String): Unit = ???
-            *   def f: java.io.OutputStream = ???
-            *   new java.io.ObjectOutputStream(f)
-            */
-            pt match {
-              case SAMType(mtp, _) =>
-                narrowByTypes(alts, mtp.paramInfos, mtp.resultType)
-              case _ =>
-                // pick any alternatives that are not methods since these might be convertible
-                // to the expected type, or be used as extension method arguments.
-                val convertible = alts.filterNot(alt =>
-                    normalize(alt, IgnoredProto(pt)).widenSingleton.isInstanceOf[MethodType])
-                if convertible.length == 1 then convertible else compat
-            }
-          else compat
-        else compat0
+        val compat = alts.filterConserve(normalizedCompatible(_, pt, keepConstraint = false))
+        if compat.isEmpty then
+          pt match
+            case SAMType(mtp, _) =>
+              // If we have a SAM type as expected type, treat it as if the expression was eta-expanded
+              // Note 1: No need to do that for function types, the previous normalizedCompatible test already
+              // handles those.
+              // Note 2: This case should not be moved to the enclosing match
+              // since fSAM types must be considered only if there are no candidates.
+              // For example, the second f should be chosen for the following code:
+              //    def f(x: String): Unit = ???
+              //    def f: java.io.OutputStream = ???
+              //    new java.io.ObjectOutputStream(f)
+              narrowByTypes(alts, mtp.paramInfos, mtp.resultType)
+            case _ =>
+              // pick any alternatives that are not methods since these might be convertible
+              // to the expected type, or be used as extension method arguments.
+              val convertible = alts.filterNot(alt =>
+                  normalize(alt, IgnoredProto(pt)).widenSingleton.isInstanceOf[MethodType])
+              if convertible.length == 1 then convertible else compat
+        else compat
     }
 
     /** The type of alternative `alt` after instantiating its first parameter

tests/run/i19641.scala

@@ -0,0 +1,17 @@
+type DiagnosticConsturctor = (Int) => DiagnosticSet
+
+final class Diagnostic
+
+final class DiagnosticSet(elements: List[Diagnostic] = List())
+
+enum Result:
+  case Success extends Result
+  case Failure(diagnose: DiagnosticConsturctor) extends Result
+  def diagnose(n: Int): DiagnosticSet =
+    this match
+      case Success => DiagnosticSet()
+      case Failure(d) => d(n)
+
+@main def Test(): Unit =
+  val r : Result = Result.Failure((n) => DiagnosticSet(List(Diagnostic())))
+  r.diagnose(1)

tests/run/i4364a.scala

@@ -6,8 +6,10 @@ object Test {
   def f(x: String): Unit = ()
 
   def foo(c: Consumer[String]) = c.accept("")
+  def bar(c: String => Unit) = c("")
 
   def main(args: Array[String]) = {
     foo(f)
+    bar(f)
   }
 }