Fix #2367: Allow SAM conversion for overloaded functions

If just one of a number of alternatives is a SAM, allow a lambda argument,
just like we do for non-overloaded methods with SAM type parameters.

Author: odersky

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

@@ -474,21 +474,24 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
     type TypedArg = Arg
     type Result = Unit
 
+    protected def argOK(arg: TypedArg, formal: Type) = argType(arg, formal) match {
+      case ref: TermRef if ref.denot.isOverloaded =>
+        // in this case we could not resolve overloading because no alternative
+        // matches expected type
+        false
+      case argtpe =>
+        def SAMargOK = formal match {
+          case SAMType(meth) =>argtpe <:< meth.info.toFunctionType()
+          case _ => false
+        }
+        isCompatible(argtpe, formal) || SAMargOK
+    }
+
     /** The type of the given argument */
     protected def argType(arg: Arg, formal: Type): Type
 
     def typedArg(arg: Arg, formal: Type): Arg = arg
-    def addArg(arg: TypedArg, formal: Type) =
-      ok = ok & {
-        argType(arg, formal) match {
-          case ref: TermRef if ref.denot.isOverloaded =>
-            // in this case we could not resolve overloading because no alternative
-            // matches expected type
-            false
-          case argtpe =>
-            isCompatible(argtpe, formal)
-        }
-      }
+    final def addArg(arg: TypedArg, formal: Type) = ok = ok & argOK(arg, formal)
     def makeVarArg(n: Int, elemFormal: Type) = {}
     def fail(msg: => Message, arg: Arg) =
       ok = false
@@ -512,11 +515,10 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
   }
 
   /** Subclass of Application for applicability tests with type arguments and value
-    *  argument trees.
-    */
+   * argument trees.
+   */
   class ApplicableToTreesDirectly(methRef: TermRef, targs: List[Type], args: List[Tree], resultType: Type)(implicit ctx: Context) extends ApplicableToTrees(methRef, targs, args, resultType)(ctx) {
-    override def addArg(arg: TypedArg, formal: Type) =
-      ok = ok & (argType(arg, formal) <:< formal)
+    override def argOK(arg: TypedArg, formal: Type) = argType(arg, formal) <:< formal
   }
 
   /** Subclass of Application for applicability tests with value argument types. */

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

@@ -2161,6 +2161,11 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       }
     }
 
+    def toSAM(tree: Tree): Tree = tree match {
+      case tree: Block => tpd.cpy.Block(tree)(tree.stats, toSAM(tree.expr))
+      case tree: Closure => tpd.cpy.Closure(tree)(tpt = TypeTree(pt)).withType(pt)
+    }
+
     def adaptToSubType(wtp: Type): Tree = {
       // try converting a constant to the target type
       val folded = ConstFold(tree, pt)
@@ -2172,7 +2177,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
         return tpd.Block(adapt(tree, WildcardType) :: Nil, Literal(Constant(())))
       // convert function literal to SAM closure
       tree match {
-        case Closure(Nil, id @ Ident(nme.ANON_FUN), _)
+        case closure(Nil, id @ Ident(nme.ANON_FUN), _)
         if defn.isFunctionType(wtp) && !defn.isFunctionType(pt) =>
           pt match {
             case SAMType(meth)
@@ -2181,7 +2186,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
               // but this prevents case blocks from implementing polymorphic partial functions,
               // since we do not know the result parameter a priori. Have to wait until the
               // body is typechecked.
-              return cpy.Closure(tree)(Nil, id, TypeTree(pt)).withType(pt)
+              return toSAM(tree)
             case _ =>
           }
         case _ =>

tests/pos/i2367.scala

@@ -0,0 +1,8 @@
+object Test {
+  new Thread(() => println("hi"))
+
+  def foo(x: Int => Int, y: Int): Int = 1
+  def foo(x: Int, y: Int): Int = 2
+  foo(1, 2)
+  foo(x => x, 2)
+}