Avoid forcing lambda parameter types in overloading resolution

When taking the `typedArgs` of a `FunProto` we now always avoid failing
on untyped parameters of lambdas. Instead we give the parameter a ? type
and continue.

This allows to use lambdas with untyped parameters in more situations
than before.

Author: odersky

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

@@ -832,7 +832,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
           case funRef: TermRef =>
             val app =
               if (proto.allArgTypesAreCurrent())
-                new ApplyToTyped(tree, fun1, funRef, proto.typedArgs, pt)
+                new ApplyToTyped(tree, fun1, funRef, proto.unforcedTypedArgs, pt)
               else
                 new ApplyToUntyped(tree, fun1, funRef, proto, pt)(argCtx(tree))
             convertNewGenericArray(app.result)
@@ -857,7 +857,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
           }
 
       fun1.tpe match {
-        case err: ErrorType => cpy.Apply(tree)(fun1, proto.typedArgs).withType(err)
+        case err: ErrorType => cpy.Apply(tree)(fun1, proto.unforcedTypedArgs).withType(err)
         case TryDynamicCallType => typedDynamicApply(tree, pt)
         case _ =>
           if (originalProto.isDropped) fun1
@@ -1604,7 +1604,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
           if (isDetermined(alts2)) alts2
           else {
             pretypeArgs(alts2, pt)
-            narrowByTrees(alts2, pt.typedArgs, resultType)
+            narrowByTrees(alts2, pt.unforcedTypedArgs, resultType)
           }
         }
 
@@ -1665,7 +1665,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
     else pt match {
       case pt @ FunProto(_, resType: FunProto) =>
         // try to narrow further with snd argument list
-        val advanced = advanceCandidates(pt.typedArgs.tpes)
+        val advanced = advanceCandidates(pt.unforcedTypedArgs.tpes)
         resolveOverloaded(advanced.map(_._1), resType, Nil) // resolve with candidates where first params are stripped
           .map(advanced.toMap) // map surviving result(s) back to original candidates
       case _ =>
@@ -1697,40 +1697,38 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
   private def pretypeArgs(alts: List[TermRef], pt: FunProto)(implicit ctx: Context): Unit = {
     def recur(altFormals: List[List[Type]], args: List[untpd.Tree]): Unit = args match {
       case arg :: args1 if !altFormals.exists(_.isEmpty) =>
-        def isUnknownParamType(t: untpd.Tree) = t match {
-          case ValDef(_, tpt, _) => tpt.isEmpty
-          case _ => false
-        }
-        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] =
-            formal match {
-              case defn.FunctionOf(args, result, isImplicit, isErased) => args
-              case defn.PartialFunctionOf(arg, result) => arg :: Nil
-              case _ => Nil
+        untpd.functionWithUnknownParamType(arg) match {
+          case Some(fn) =>
+            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] =
+              formal match {
+                case defn.FunctionOf(args, result, isImplicit, isErased) => args
+                case defn.PartialFunctionOf(arg, result) => arg :: Nil
+                case _ => Nil
+              }
+            val formalParamTypessForArg: List[List[Type]] =
+              formalsForArg.map(argTypesOfFormal)
+            if (formalParamTypessForArg.forall(_.nonEmpty) &&
+                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)(_ frozen_=:= _)) ps.head
+                else WildcardType)
+              def isPartial = // we should generate a partial function for the arg
+                fn.isInstanceOf[untpd.Match] &&
+                formalsForArg.exists(_.isRef(defn.PartialFunctionClass))
+              val commonFormal =
+                if (isPartial) defn.PartialFunctionOf(commonParamTypes.head, WildcardType)
+                else defn.FunctionOf(commonParamTypes, WildcardType)
+              overload.println(i"pretype arg $arg with expected type $commonFormal")
+              if (commonParamTypes.forall(isFullyDefined(_, ForceDegree.noBottom)))
+                pt.typedArg(arg, commonFormal)(ctx.addMode(Mode.ImplicitsEnabled))
             }
-          val formalParamTypessForArg: List[List[Type]] =
-            formalsForArg.map(argTypesOfFormal)
-          if (formalParamTypessForArg.forall(_.nonEmpty) &&
-              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)(_ frozen_=:= _)) ps.head
-              else WildcardType)
-            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, WildcardType)
-              else defn.FunctionOf(commonParamTypes, WildcardType)
-            overload.println(i"pretype arg $arg with expected type $commonFormal")
-            pt.typedArg(arg, commonFormal)(ctx.addMode(Mode.ImplicitsEnabled))
-          }
+          case None =>
         }
         recur(altFormals.map(_.tail), args1)
       case _ =>

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

@@ -288,21 +288,28 @@ object ProtoTypes {
     private def cacheTypedArg(arg: untpd.Tree, typerFn: untpd.Tree => Tree, force: Boolean)(implicit ctx: Context): Tree = {
       var targ = state.typedArg(arg)
       if (targ == null) {
-        if (!force && untpd.functionWithUnknownParamType(arg).isDefined)
-          // If force = false, assume ? rather than reporting an error.
-          // That way we don't cause a "missing parameter" error in `typerFn(arg)`
-          targ = arg.withType(WildcardType)
-        else {
-          targ = typerFn(arg)
-          if (!ctx.reporter.hasUnreportedErrors) {
-            // FIXME: This can swallow warnings by updating the typerstate from a nested
-            // context that gets discarded later. But we do have to update the
-            // typerstate if there are no errors. If we also omitted the next two lines
-            // when warning were emitted, `pos/t1756.scala` would fail when run with -feature.
-            // It would produce an orphan type parameter for CI when pickling.
-            state.typedArg = state.typedArg.updated(arg, targ)
-            state.evalState = state.evalState.updated(arg, (ctx.typerState, ctx.typerState.constraint))
-          }
+        untpd.functionWithUnknownParamType(arg) match {
+          case Some(untpd.Function(args, _)) if !force =>
+            // If force = false, assume what we know about the parameter types rather than reporting an error.
+            // That way we don't cause a "missing parameter" error in `typerFn(arg)`
+            val paramTypes = args map {
+              case ValDef(_, tpt, _) if !tpt.isEmpty => typer.typedType(tpt).typeOpt
+              case _ => WildcardType
+            }
+            targ = arg.withType(defn.FunctionOf(paramTypes, WildcardType))
+          case Some(_) if !force =>
+            targ = arg.withType(WildcardType)
+          case _ =>
+            targ = typerFn(arg)
+            if (!ctx.reporter.hasUnreportedErrors) {
+              // FIXME: This can swallow warnings by updating the typerstate from a nested
+              // context that gets discarded later. But we do have to update the
+              // typerstate if there are no errors. If we also omitted the next two lines
+              // when warning were emitted, `pos/t1756.scala` would fail when run with -feature.
+              // It would produce an orphan type parameter for CI when pickling.
+              state.typedArg = state.typedArg.updated(arg, targ)
+              state.evalState = state.evalState.updated(arg, (ctx.typerState, ctx.typerState.constraint))
+            }
         }
       }
       targ
@@ -314,7 +321,7 @@ object ProtoTypes {
      *                  with unknown parameter types - this will then cause a
      *                  "missing parameter type" error
      */
-    private def typedArgs(force: Boolean): List[Tree] =
+    protected[this] def typedArgs(force: Boolean): List[Tree] =
       if (state.typedArgs.size == args.length) state.typedArgs
       else {
         val args1 = args.mapconserve(cacheTypedArg(_, typer.typed(_), force))
@@ -376,7 +383,7 @@ object ProtoTypes {
       derivedFunProto(args, tm(resultType), typer)
 
     def fold[T](x: T, ta: TypeAccumulator[T])(implicit ctx: Context): T =
-      ta(ta.foldOver(x, typedArgs.tpes), resultType)
+      ta(ta.foldOver(x, unforcedTypedArgs.tpes), resultType)
 
     override def deepenProto(implicit ctx: Context): FunProto = derivedFunProto(args, resultType.deepenProto, typer)
 
@@ -390,7 +397,7 @@ object ProtoTypes {
    *  [](args): resultType, where args are known to be typed
    */
   class FunProtoTyped(args: List[tpd.Tree], resultType: Type)(typer: Typer, isContextual: Boolean)(implicit ctx: Context) extends FunProto(args, resultType)(typer, isContextual)(ctx) {
-    override def typedArgs: List[tpd.Tree] = args
+    override def typedArgs(force: Boolean): List[tpd.Tree] = args
     override def withContext(ctx: Context): FunProtoTyped = this
   }
 

tests/neg/i1640.scala

@@ -1,4 +1,4 @@
 object Test extends App {
   List(1, 2, 3) map (_ match { case x => x + 1 })
-  List((1, 2)) x (_ match { case (x, z) => x + z }) // error // error // error
+  List((1, 2)) x (_ match { case (x, z) => x + z }) // error
 }

tests/neg/overloaded.scala

@@ -3,11 +3,11 @@
 object Test {
   def mapX(f: Char => Char): String = ???
   def mapX[U](f: U => U): U = ???
-  mapX(x => x) // error: missing parameter type
+  mapX(x => x) //OK
 
   def foo(f: Char => Char): Unit = ???
   def foo(f: Int => Int): String = ???
-  foo(x => x) // error: missing parameter type
+  foo(x => x) // error: ambiguous
 
   def bar(f: (Char, Char) => Unit): Unit = ???
   def bar(f: Char => Unit) = ???

tests/neg/parser-stability-10.scala

@@ -9,6 +9,6 @@ def unapply(i1: Int)(i6: List[Int]): Int = {
 }  // error
 object i5 {
   import collection.mutable._
-  try { ??? mutable { case i1(i5, i3, i4) => i5 }}  // error // error
+  try { ??? mutable { case i1(i5, i3, i4) => i5 }}  // error
 }
 // error

tests/neg/t6455.scala

@@ -2,5 +2,5 @@ object O { def filter(p: Int => Boolean): O.type = this }
 
 class Test {
   // should not compile because we no longer rewrite withFilter => filter under -Xfuture
-  O.withFilter(f => true) // error // error
+  O.withFilter(f => true) // error
 }

tests/neg/t7239.scala

@@ -17,7 +17,7 @@ object Test {
                        (implicit F0: NoImplicit): HasWithFilter = ???
   }
 
-  BrokenMethod().withFilter(_ => true) // error // error
+  BrokenMethod().withFilter(_ => true) // error
   BrokenMethod().filter(_ => true)     // ok
 
   locally {
@@ -35,6 +35,6 @@ object Test {
     // `(B => Boolean)`. Only later during pickling does the
     // defensive check for erroneous types in the tree pick up
     // the problem.
-    BrokenMethod().withFilter(x => true) // error // error
+    BrokenMethod().withFilter(x => true) // error
   }
 }

tests/run/overloads.check

@@ -13,3 +13,5 @@ ok: Funcs.foo('a') = 2
 ok: Funcs.foo(97) = 3
 ok: M1.f(3) = 11
 ok: M2.f(3) = 22
+ok: M3.f("abc", _.length) = cba
+ok: M3.f(2, _ + 2) = 4

tests/run/overloads.scala

@@ -31,6 +31,11 @@ object M2 {
     def f[A](x: A) = 22;
 }
 
+object M3 {
+    def f(x: Int, f: Int => Int) = f(x)
+    def f(x: String, f: String => String) = f(x)
+}
+
 object overloads {
 
     def check(what: String, actual: Any, expected: Any): Unit = {
@@ -78,6 +83,10 @@ object overloads {
 //       val y = new scala.collection.mutable.Stack[Int];
 //      check("M1.f(" + y +")", M1.f(y), 12);
 //      check("M2.f(" + y +")", M2.f(y), 21);
+
+        check("M3.f(\"abc\", _.length)", M3.f("abc", _.reverse), "cba")
+        check("M3.f(2, _ + 2)", M3.f(2, _ + 2), 4)
+
     }
 
 }