Refine condition when to generate a partial function

A partial function should be generated if

 - the argument is a Match
 - at least one formal is a partial function.

Author: odersky

compiler/src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -273,19 +273,24 @@ trait UntypedTreeInfo extends TreeInfo[Untyped] { self: Trees.Instance[Untyped]
     case _ => false
   }
 
-  def isFunctionWithUnknownParamType(tree: Tree): Boolean = tree match {
+  def functionWithUnknownParamType(tree: Tree): Option[Tree] = tree match {
     case Function(args, _) =>
-      args.exists {
+      if (args.exists {
         case ValDef(_, tpt, _) => tpt.isEmpty
         case _ => false
-      }
+      }) Some(tree)
+      else None
     case Match(EmptyTree, _) =>
-      true
+      Some(tree)
     case Block(Nil, expr) =>
-      isFunctionWithUnknownParamType(expr)
-    case _ => false
+      functionWithUnknownParamType(expr)
+    case _ =>
+      None
   }
 
+  def isFunctionWithUnknownParamType(tree: Tree): Boolean =
+    functionWithUnknownParamType(tree).isDefined
+
   /** Is `tree` an implicit function or closure, possibly nested in a block? */
   def isImplicitClosure(tree: Tree)(implicit ctx: Context): Boolean = unsplice(tree) match {
     case Function((param: untpd.ValDef) :: _, _) => param.mods.is(Implicit)

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

@@ -1402,7 +1402,8 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
           case ValDef(_, tpt, _) => tpt.isEmpty
           case _ => false
         }
-        if (untpd.isFunctionWithUnknownParamType(arg)) {
+        val fn = untpd.functionWithUnknownParamType(arg)
+        if (fn.isDefined) {
           def isUniform[T](xs: List[T])(p: (T, T) => Boolean) = xs.forall(p(_, xs.head))
           val formalsForArg: List[Type] = altFormals.map(_.head)
           def argTypesOfFormal(formal: Type): List[Type] =
@@ -1422,7 +1423,9 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
               // type of the i'th parameter of the closure.
               if (isUniform(ps)(ctx.typeComparer.isSameTypeWhenFrozen(_, _))) ps.head
               else WildcardType)
-            def isPartial = formalsForArg.forall(_.isRef(defn.PartialFunctionClass))
+            def isPartial = // we should generate a partial function for the arg
+              fn.get.isInstanceOf[untpd.Match] &&
+              formalsForArg.exists(_.isRef(defn.PartialFunctionClass))
             val commonFormal =
               if (isPartial) defn.PartialFunctionOf(commonParamTypes.head, newTypeVar(TypeBounds.empty))
               else defn.FunctionOf(commonParamTypes, WildcardType)