Fix #4364: Try SAM type when no candidates found

Author: Medowhill

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -816,6 +816,8 @@ class Definitions {
   def SetterMetaAnnot(implicit ctx: Context): ClassSymbol = SetterMetaAnnotType.symbol.asClass
   lazy val ShowAsInfixAnotType: TypeRef = ctx.requiredClassRef("scala.annotation.showAsInfix")
   def ShowAsInfixAnnot(implicit ctx: Context): ClassSymbol = ShowAsInfixAnotType.symbol.asClass
+  lazy val FunctionalInterfaceAnnotType = ctx.requiredClassRef("java.lang.FunctionalInterface")
+  def FunctionalInterfaceAnnot(implicit ctx: Context) = FunctionalInterfaceAnnotType.symbol.asClass
 
   // convenient one-parameter method types
   def methOfAny(tp: Type): MethodType = MethodType(List(AnyType), tp)

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

@@ -1517,7 +1517,17 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
         narrowByTypes(alts, args, resultType)
 
       case pt =>
-        alts filter (normalizedCompatible(_, pt))
+        val noSam = alts filter (normalizedCompatible(_, pt))
+        if (noSam.isEmpty) {
+          pt match {
+            case SAMType(mtp) =>
+              val sam = narrowByTypes(alts, mtp.paramInfos, mtp.resultType)
+              if (sam.nonEmpty && !pt.classSymbol.hasAnnotation(defn.FunctionalInterfaceAnnot))
+                ctx.warning(ex"$pt does not have the @FunctionalInterface annotation.", ctx.tree.pos)
+              sam
+            case _ => noSam
+          }
+        } else noSam
     }
     val found = narrowMostSpecific(candidates)
     if (found.length <= 1) found

tests/neg/i2033.scala

@@ -3,7 +3,7 @@ import collection._
 object Test {
   def check(obj: AnyRef): Unit = {
     val bos = new ByteArrayOutputStream()
-    val out = new ObjectOutputStream(println) // error
+    val out = new ObjectOutputStream(println)
     val arr = bos toByteArray ()
     val in = (())
     val deser = ()

tests/run/i4364a.scala

@@ -0,0 +1,13 @@
+object Test {
+  var flag = false
+
+  def f(): Unit = assert(false)
+  def f(x: Int): Unit = assert(false)
+  def f(x: String): Unit = flag = true
+
+  def foo(c: java.util.function.Consumer[String]) = c.accept("")
+
+  def main(args: Array[String]) = {
+    foo(f)
+  }
+}

tests/run/i4364b.scala

@@ -0,0 +1,23 @@
+object Test {
+  var flag = false
+
+  def f(x: Int): Unit = assert(false)
+  def f(x: String): Unit = assert(false)
+  def f: java.io.OutputStream = new java.io.OutputStream {
+    def write(x: Int) = ()
+  }
+
+  def g(x: Int): Unit = flag = true
+  def g(x: String): Unit = assert(false)
+
+  def main(args: Array[String]) = {
+    val oosF = new java.io.ObjectOutputStream(f)
+    oosF.write(0)
+    oosF.close()
+
+    val oosG = new java.io.ObjectOutputStream(g) // need warning
+    oosG.write(0)
+    oosG.close()
+    assert(flag)
+  }
+}