Avoid overloading error involving SAM conversions

After the previous commit (and also in Scala 2), the following code
doesn't compile:

  def foo[V](v: V): Int = 1
  def foo[U](fn: java.util.function.Function[Int, U]): Int = 2
  val f: Int => Int = x => x
  foo(f) // error: ambiguous overload

The problem is that we assume that the overload taking a `Function` is
applicable, even though it cannot be used since `f` is not a lambda
expression. We can fix this by inspecting the shape of the argument and
disallowing SAM conversion if the argument is known to be a non-lambda
tree.

Author: smarter

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

@@ -316,7 +316,7 @@ trait Applications extends Compatibility {
   abstract class Application[Arg](methRef: TermRef, funType: Type, args: List[Arg], resultType: Type)(using Context) {
 
     /** The type of typed arguments: either tpd.Tree or Type */
-    type TypedArg
+    type TypedArg <: Tree | Type
 
     /** The kind of application that gets typed */
     def applyKind: ApplyKind
@@ -621,7 +621,7 @@ trait Applications extends Compatibility {
    *  in a "can/cannot apply" answer, without needing to construct trees or
    *  issue error messages.
    */
-  abstract class TestApplication[Arg](methRef: TermRef, funType: Type, args: List[Arg], resultType: Type, argMatch: ArgMatch)(using Context)
+  abstract class TestApplication[Arg <: Tree | Type](methRef: TermRef, funType: Type, args: List[Arg], resultType: Type, argMatch: ArgMatch)(using Context)
   extends Application[Arg](methRef, funType, args, resultType) {
     type TypedArg = Arg
     type Result = Unit
@@ -637,7 +637,15 @@ trait Applications extends Compatibility {
         val argtpe1 = argtpe.widen
 
         def SAMargOK =
-          defn.isFunctionType(argtpe1) && formal.match
+          val isLambda = defn.isFunctionType(argtpe1) && arg.match
+            case closure(_) =>
+              true
+            case arg: Tree =>
+              // `arg` might be an untyped function due to how `FunProto#cacheTypedArg` works.
+              untpd.isFunction(arg)
+            case _: Type =>
+              true
+          isLambda && defn.isFunctionType(argtpe1) && formal.match
             case SAMType(sam) => argtpe <:< sam.toFunctionType(isJava = formal.classSymbol.is(JavaDefined))
             case _ => false
 

tests/neg/i11938.scala

@@ -9,11 +9,12 @@ object Test {
 
   def main(args: Array[String]): Unit = {
     assert(foo((x: Int) => x) == 2)
+    val f: Int => Int = x => x
+    assert(foo(f) == 1)
     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 }