Fix typing of PartialFunction argument to overloaded method

Applications#preTypeArgs can type arguments with an expected type like
`PartialFunction[Int, WildcardType]`, before this commit this was
rejected by `typedClosure` because it requires the expected type to be
fully-defined. Fixed by replacing the underdefined expected type by a
new one where the argument types come from the closure method type.

This is useful in particular to type `Map#collect` in 2.13 which is
overloaded.

Author: smarter

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

@@ -991,13 +991,22 @@ class Typer extends Namer
             pt match {
               case SAMType(sam)
               if !defn.isFunctionType(pt) && mt <:< sam =>
-                if (!isFullyDefined(pt, ForceDegree.all))
-                  ctx.error(ex"result type of lambda is an underspecified SAM type $pt", tree.sourcePos)
-                else if (pt.classSymbol.isOneOf(FinalOrSealed)) {
+                val targetTpe =
+                  if (!isFullyDefined(pt, ForceDegree.all)) {
+                    if (pt.isRef(defn.PartialFunctionClass))
+                      // Replace the underspecified expected type by one based on the closure method type
+                      defn.PartialFunctionOf(mt.firstParamTypes.head, mt.resultType)
+                    else {
+                      ctx.error(ex"result type of lambda is an underspecified SAM type $pt", tree.sourcePos)
+                      pt
+                    }
+                  }
+                  else pt
+                if (pt.classSymbol.isOneOf(FinalOrSealed)) {
                   val offendingFlag = pt.classSymbol.flags & FinalOrSealed
                   ctx.error(ex"lambda cannot implement $offendingFlag ${pt.classSymbol}", tree.sourcePos)
                 }
-                TypeTree(pt)
+                TypeTree(targetTpe)
               case _ =>
                 if (mt.isParamDependent) {
                   throw new java.lang.Error(

compiler/test/dotty/tools/repl/ReplCompilerTests.scala

@@ -115,10 +115,9 @@ class ReplCompilerTests extends ReplTest {
   }
 
   @Test def i4051 = fromInitialState { implicit state =>
-    // FIXME: shouldn't have to pass a type parameter to collect.
     val source =
       """val x: PartialFunction[Int, Int] = { case x => x }
-        |val y = Map(("A", 1), ("B", 2), ("X", 3)).collect[Int] { case (k, v) => v }.toList""".stripMargin
+        |val y = Map(("A", 1), ("B", 2), ("X", 3)).collect { case (k, v) => v }.toList""".stripMargin
 
     val expected = List(
       "val x: PartialFunction[Int, Int] = <function1>",