fix scala#4419: liftFun should also update method parameter types

WIP - tests/pos/pickleinf.scala still fails

Author: liufengyun

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

@@ -193,6 +193,12 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
      */
     protected def liftFun(): Unit = ()
 
+    /** Whether `liftFun` is needed? It is the case if default arguments are used.
+     */
+    protected def needLiftFun: Boolean =
+      !isJavaAnnotConstr(methRef.symbol) &&
+      args.size < reqiredArgNum(funType)
+
     /** A flag signalling that the typechecking the application was so far successful */
     private[this] var _ok = true
 
@@ -205,12 +211,27 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
     /** The function's type after widening and instantiating polytypes
      *  with TypeParamRefs in constraint set
      */
-    val methType = funType.widen match {
+    lazy val methType: Type = constrainType(liftedFunType)
+
+    def constrainType(tp: Type) = tp.widen match {
       case funType: MethodType => funType
       case funType: PolyType => constrained(funType).resultType
       case tp => tp //was: funType
     }
 
+    def reqiredArgNum(tp: Type): Int = tp.widen match {
+      case funType: MethodType => funType.paramInfos.size
+      case funType: PolyType => reqiredArgNum(funType.resultType)
+      case tp => args.size
+    }
+
+    def liftedFunType =
+      if (needLiftFun) {
+        liftFun()
+        constrainType(normalizedFun.tpe)
+      }
+      else funType
+
     /** The arguments re-ordered so that each named argument matches the
      *  same-named formal parameter.
      */
@@ -220,7 +241,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
       else
         args
 
-    protected def init() = methType match {
+    protected def init() = methType.widen match {
       case methType: MethodType =>
         // apply the result type constraint, unless method type is dependent
         val resultApprox = resultTypeApprox(methType)
@@ -231,6 +252,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
             ()
           else
             fail(err.typeMismatchMsg(methType.resultType, resultType))
+
         // match all arguments with corresponding formal parameters
         matchArgs(orderedArgs, methType.paramInfos, 0)
       case _ =>
@@ -425,8 +447,8 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
           }
 
           def tryDefault(n: Int, args1: List[Arg]): Unit = {
-            if (!isJavaAnnotConstr(methRef.symbol))
-              liftFun()
+            // if (!isJavaAnnotConstr(methRef.symbol))
+            //   liftFun()
             val getter = findDefaultGetter(n + numArgs(normalizedFun))
             if (getter.isEmpty) missingArg(n)
             else {
@@ -543,7 +565,6 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
     private[this] var typedArgBuf = new mutable.ListBuffer[Tree]
     private[this] var liftedDefs: mutable.ListBuffer[Tree] = null
     private[this] var myNormalizedFun: Tree = fun
-    init()
 
     def addArg(arg: Tree, formal: Type): Unit =
       typedArgBuf += adapt(arg, formal.widenExpr)
@@ -598,6 +619,8 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
     private def sameSeq[T <: Trees.Tree[_]](xs: List[T], ys: List[T]): Boolean = firstDiff(xs, ys) < 0
 
     val result = {
+      init()
+
       var typedArgs = typedArgBuf.toList
       def app0 = cpy.Apply(app)(normalizedFun, typedArgs) // needs to be a `def` because typedArgs can change later
       val app1 =
@@ -606,7 +629,6 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
           if (!sameSeq(args, orderedArgs.dropWhile(_ eq EmptyTree)) && !isJavaAnnotConstr(methRef.symbol)) {
             // need to lift arguments to maintain evaluation order in the
             // presence of argument reorderings.
-
             liftFun()
 
             // lift arguments in the definition order

tests/pos/i4419.scala

@@ -0,0 +1,12 @@
+class Foo(config: String) {
+  case class Bar(val x: Int) {
+    def doThings: String = config //Do whatever here
+  }
+}
+
+
+object Test {
+  def test(foo: Foo)(bar: foo.Bar = foo.Bar(5)) = ???
+
+  test(new Foo("port"))()
+}