Overloading resolution: Handle SAM types more like Java and Scala 2

`resolveOverloaded` is called twice, first with implicit conversions
off, then on. Before this commit, turning off implicit conversions also
turned off SAM conversions, this behavior does not match Java or Scala 2
which means we could end up picking a different overload than they
do (cf #11938).

This commit enables SAM conversions in the first pass, _except_ for
conversions to PartialFunction as that would break a lot of existing
code and wouldn't match how either Java or Scala 2 pick overloads.

This is an alternative to #11945 (which special-cased
SAM types with an explicit `@FunctionalInterfaces` annotation) and #11990
(which special-cased SAM types that subtype a scala Function type).
Special-casing PartialFunction instead seems more defensible since it's
already special-cased in Scala 2 and is not considered a SAM type by
Java.

Fixes #11938.

Author: smarter

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

@@ -634,12 +634,32 @@ trait Applications extends Compatibility {
         // matches expected type
         false
       case argtpe =>
-        def SAMargOK = formal match {
-          case SAMType(sam) => argtpe <:< sam.toFunctionType(isJava = formal.classSymbol.is(JavaDefined))
-          case _ => false
-        }
+        val argtpe1 = argtpe.widen
+
+        def SAMargOK =
+          defn.isFunctionType(argtpe1) && formal.match
+            case SAMType(sam) => argtpe <:< sam.toFunctionType(isJava = formal.classSymbol.is(JavaDefined))
+            case _ => false
+
         isCompatible(argtpe, formal)
-        || ctx.mode.is(Mode.ImplicitsEnabled) && SAMargOK
+        // Only allow SAM-conversion to PartialFunction if implicit conversions
+        // are enabled. This is necessary to avoid ambiguity between an overload
+        // taking a PartialFunction and one taking a Function1 because
+        // PartialFunction extends Function1 but Function1 is SAM-convertible to
+        // PartialFunction. Concretely, given:
+        //
+        //   def foo(a: Int => Int): Unit = println("1")
+        //   def foo(a: PartialFunction[Int, Int]): Unit = println("2")
+        //
+        // - `foo(x => x)` will print 1, because the PartialFunction overload
+        //   won't be seen as applicable in the first call to
+        //   `resolveOverloaded`, this behavior happens to match what Java does
+        //   since PartialFunction is not a SAM type according to Java
+        //   (`isDefined` is abstract).
+        // - `foo { case x if x % 2 == 0 => x }` will print 2, because both
+        //    overloads are applicable, but PartialFunction is a subtype of
+        //    Function1 so it's more specific.
+        || (!formal.isRef(defn.PartialFunctionClass) || ctx.mode.is(Mode.ImplicitsEnabled)) && SAMargOK
         || argMatch == ArgMatch.CompatibleCAP
             && {
               val argtpe1 = argtpe.widen

tests/neg/i11938.scala

@@ -0,0 +1,16 @@
+import java.util.function.Function
+
+object Test {
+  def foo[V](v: V): Int = 1
+  def foo[U](fn: Function[Int, U]): Int = 2
+
+  def main(args: Array[String]): Unit = {
+    val f: Int => Int = x => x
+    foo(f) // error
+      // Like Scala 2, we emit an error here because the Function1 argument was
+      // deemed SAM-convertible to Function, even though it's not a lambda
+      // expression and therefore not convertible. If we wanted to support this,
+      // we would have to tweak TestApplication#argOK to look at the shape of
+      // `arg` and turn off SAM conversions when it's a non-closure tree.
+  }
+}

tests/run/i11938.scala

@@ -0,0 +1,22 @@
+import java.util.function.Function
+
+object Test {
+  def foo[V](v: V): Int = 1
+  def foo[U](fn: Function[Int, U]): Int = 2
+
+  def foo2(a: Int => Int): Int = 1
+  def foo2(a: PartialFunction[Int, Int]): Int = 2
+
+  def main(args: Array[String]): Unit = {
+    assert(foo((x: Int) => x) == 2)
+    val jf: Function[Int, Int] = x => x
+    assert(foo(jf) == 2)
+
+    assert(foo2(x => x) == 1)
+    val f: Int => Int = x => x
+    assert(foo2(f) == 1)
+    assert(foo2({ case x if x % 2 == 0 => x }) == 2)
+    val pf: PartialFunction[Int, Int] = { case x if x % 2 == 0 => x }
+    assert(foo2(pf) == 2)
+  }
+}