better warning, fix tests, & add comments

Author: Medowhill

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

@@ -1364,7 +1364,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
    *  Two trials: First, without implicits or SAM conversions enabled. Then,
    *  if the fist finds no eligible candidates, with implicits and SAM conversions enabled.
    */
-  def resolveOverloaded(alts: List[TermRef], pt: Type)(implicit ctx: Context): List[TermRef] = track("resolveOverloaded") {
+  def resolveOverloaded(alts: List[TermRef], pt: Type, pos: Position = NoPosition)(implicit ctx: Context): List[TermRef] = track("resolveOverloaded") {
 
     /** Is `alt` a method or polytype whose result type after the first value parameter
      *  section conforms to the expected type `resultType`? If `resultType`
@@ -1409,9 +1409,9 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
       case _ => chosen
     }
 
-    var found = resolveOverloaded(alts, pt, Nil)(ctx.retractMode(Mode.ImplicitsEnabled))
+    var found = resolveOverloaded(alts, pt, Nil, pos)(ctx.retractMode(Mode.ImplicitsEnabled))
     if (found.isEmpty && ctx.mode.is(Mode.ImplicitsEnabled))
-      found = resolveOverloaded(alts, pt, Nil)
+      found = resolveOverloaded(alts, pt, Nil, pos)
     found match {
       case alt :: Nil => adaptByResult(alt) :: Nil
       case _ => found
@@ -1423,7 +1423,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
    *  called twice from the public `resolveOverloaded` method, once with
    *  implicits and SAM conversions enabled, and once without.
    */
-  private def resolveOverloaded(alts: List[TermRef], pt: Type, targs: List[Type])(implicit ctx: Context): List[TermRef] = track("resolveOverloaded") {
+  private def resolveOverloaded(alts: List[TermRef], pt: Type, targs: List[Type], pos: Position)(implicit ctx: Context): List[TermRef] = track("resolveOverloaded") {
 
     def isDetermined(alts: List[TermRef]) = alts.isEmpty || alts.tail.isEmpty
 
@@ -1511,19 +1511,27 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
 
       case pt @ PolyProto(targs1, pt1) if targs.isEmpty =>
         val alts1 = alts filter pt.isMatchedBy
-        resolveOverloaded(alts1, pt1, targs1.tpes)
+        resolveOverloaded(alts1, pt1, targs1.tpes, pos)
 
       case defn.FunctionOf(args, resultType, _, _) =>
         narrowByTypes(alts, args, resultType)
 
       case pt =>
         val noSam = alts filter (normalizedCompatible(_, pt))
         if (noSam.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) =>
               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)
+                ctx.warning(ex"${sam.head.designator} is eta-expanded even though $pt does not have the @FunctionalInterface annotation.", pos)
               sam
             case _ => noSam
           }
@@ -1536,7 +1544,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
       if (noDefaults.length == 1) noDefaults // return unique alternative without default parameters if it exists
       else {
         val deepPt = pt.deepenProto
-        if (deepPt ne pt) resolveOverloaded(alts, deepPt, targs)
+        if (deepPt ne pt) resolveOverloaded(alts, deepPt, targs, pos)
         else alts
       }
     }

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

@@ -2268,7 +2268,7 @@ class Typer extends Namer
         val altDenots = ref.denot.alternatives
         typr.println(i"adapt overloaded $ref with alternatives ${altDenots map (_.info)}%, %")
         val alts = altDenots.map(TermRef(ref.prefix, ref.name, _))
-        resolveOverloaded(alts, pt) match {
+        resolveOverloaded(alts, pt, tree.pos) match {
           case alt :: Nil =>
             readaptSimplified(tree.withType(alt))
           case Nil =>

tests/neg-custom-args/fatal-warnings/i4364.scala

@@ -0,0 +1,14 @@
+object Test {
+  def foo(c: java.util.function.Consumer[String]) = c.accept("")
+
+  def f(x: String): Unit = ()
+  def f(x: Int): Unit = ()
+
+  def main(args: Array[String]) = {
+    foo(f) // Ok: Consumer is @FunctionalInterface
+
+    val oos = new java.io.ObjectOutputStream(f) // error: OutputStream is not @FunctionalInterface
+    oos.write(0)
+    oos.close()
+  }
+}

tests/run/i4364a.scala

@@ -1,9 +1,7 @@
 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 f(x: String): Unit = ()
 
   def foo(c: java.util.function.Consumer[String]) = c.accept("")
 

tests/run/i4364b.scala

@@ -1,23 +1,13 @@
 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)
+    val oos = new java.io.ObjectOutputStream(f)
+    oos.write(0)
+    oos.close()
   }
 }