Untuple using def not val.

As retronym noted on #897, `val` forces to early.

src/dotty/tools/dotc/ast/Desugar.scala

@@ -591,18 +591,19 @@ object desugar {
   /** Map n-ary function `(p1, ..., pn) => body` where n != 1 to unary function as follows:
    *
    *    x$1 => {
-   *      val p1 = x$1._1
+   *      def p1 = x$1._1
    *      ...
-   *      val pn = x$1._n
+   *      def pn = x$1._n
    *      body
    *    }
    */
-  def makeUnaryCaseLambda(params: List[ValDef], body: Tree)(implicit ctx: Context): Tree = {
+  def makeTupledFunction(params: List[ValDef], body: Tree)(implicit ctx: Context): Tree = {
     val param = makeSyntheticParameter()
     def selector(n: Int) = Select(refOfDef(param), nme.selectorName(n))
     val vdefs =
       params.zipWithIndex.map{
-        case(param, idx) => cpy.ValDef(param)(rhs = selector(idx))
+        case (param, idx) =>
+          DefDef(param.name, Nil, Nil, TypeTree(), selector(idx)).withPos(param.pos)
       }
     Function(param :: Nil, Block(vdefs, body))
   }

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

@@ -624,7 +624,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
 
       val desugared =
         if (protoFormals.length == 1 && params.length != 1 && ptIsCorrectProduct(protoFormals.head)) {
-          desugar.makeUnaryCaseLambda(params, fnBody)
+          desugar.makeTupledFunction(params, fnBody)
         }
         else {
           val inferredParams: List[untpd.ValDef] =

tests/run/function-arity.scala

@@ -0,0 +1,8 @@
+object Test {
+  class T[A] { def foo(f: (=> A) => Int) = f(???) }
+
+  def main(args: Array[String]): Unit = {
+    new T[(Int, Int)].foo((ii) => 0)
+    new T[(Int, Int)].foo((x, y) => 0) // check that this does not run into ???
+  }
+}