Refine pretypeArgs

It worked more or less by accident before. Now it's more complicated,
but we also have tests.

Author: odersky

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

@@ -1151,17 +1151,38 @@ trait Applications extends Compatibility { self: Typer =>
         }
         arg match {
           case arg: untpd.Function if arg.args.exists(isUnknownParamType) =>
-            val commonFormal = altFormals.map(_.head).reduceLeft(_ | _)
-            overload.println(i"pretype arg $arg with expected type $commonFormal")
-            pt.typedArg(arg, commonFormal)
+            def isUniform[T](xs: List[T])(p: (T, T) => Boolean) = xs.forall(p(_, xs.head))
+            val formalsForArg: List[Type] = altFormals.map(_.head)
+            // For alternatives alt_1, ..., alt_n, test whether formal types for current argument are of the form
+            //   (p_1_1, ..., p_m_1) => r_1
+            //   ...
+            //   (p_1_n, ..., p_m_n) => r_n
+            val decomposedFormalsForArg: List[Option[(List[Type], Type)]] =
+              formalsForArg.map(defn.FunctionOf.unapply)
+            if (decomposedFormalsForArg.forall(_.isDefined)) {
+              val formalParamTypessForArg: List[List[Type]] =
+                decomposedFormalsForArg.map(_.get._1)
+              if (isUniform(formalParamTypessForArg)((x, y) => x.length == y.length)) {
+                val commonParamTypes = formalParamTypessForArg.transpose.map(ps =>
+                  // Given definitions above, for i = 1,...,m,
+                  //   ps(i) = List(p_i_1, ..., p_i_n)  -- i.e. a column
+                  // If all p_i_k's are the same, assume the type as formal parameter
+                  // type of the i'th parameter of the closure.
+                  if (isUniform(ps)(ctx.typeComparer.isSameTypeWhenFrozen(_, _))) ps.head
+                  else WildcardType)
+                val commonFormal = defn.FunctionOf(commonParamTypes, WildcardType)
+                overload.println(i"pretype arg $arg with expected type $commonFormal")
+                pt.typedArg(arg, commonFormal)
+              }
+            }
           case _ =>
         }
         recur(altFormals.map(_.tail), args1)
       case _ =>
     }
     def paramTypes(alt: Type): List[Type] = alt match {
       case mt: MethodType => mt.paramTypes
-      case mt: PolyType => paramTypes(mt.resultType).map(wildApprox(_))
+      case mt: PolyType => paramTypes(mt.resultType)
       case _ => Nil
     }
     recur(alts.map(alt => paramTypes(alt.widen)), pt.args)

tests/neg/overloaded.scala

@@ -0,0 +1,17 @@
+// testing the limits of parameter type inference
+
+object Test {
+  def mapX(f: Char => Char): String = ???
+  def mapX[U](f: U => U): U = ???
+  mapX(x => x) // error: missing parameter type
+
+  def foo(f: Char => Char): Unit = ???
+  def foo(f: Int => Int): String = ???
+  foo(x => x) // error: missing parameter type
+
+  def bar(f: (Char, Char) => Unit): Unit = ???
+  def bar(f: Char => Unit) = ???
+  bar((x, y) => ())
+  bar (x => ())
+
+}

tests/pos/overloaded.scala

@@ -24,5 +24,27 @@ object overloaded {
 
   def map(f: Char => Char): String = ???
   def map[U](f: Char => U): Seq[U] = ???
-  map(x => x.toUpper)
+  val r1 = map(x => x.toUpper)
+  val t1: String = r1
+  val r2 = map(x => x.toInt)
+  val t2: Seq[Int] = r2
+
+  def flatMap(f: Char => String): String = ???
+  def flatMap[U](f: Char => Seq[U]): Seq[U] = ???
+  val r3 = flatMap(x => x.toString)
+  val t3: String = r3
+  val r4 = flatMap(x => List(x))
+  val t4: Seq[Char] = r4
+
+  def bar(f: (Char, Char) => Unit): Unit = ???
+  def bar(f: Char => Unit) = ???
+  bar((x, y) => ())
+  bar (x => ())
+
+  def combine(f: (Char, Int) => Int): Int = ???
+  def combine(f: (String, Int) => String): String = ???
+  val r5 = combine((x: Char, y) => x + y)
+  val t5: Int = r5
+  val r6 = combine((x: String, y) => x ++ y.toString)
+  val t6: String = r6
 }