Adjust parameter order of static accessor method in Delambdafy

Under `-Ydelambdafy:method`, a public, static accessor method is
created to expose the private method containing the body of the
lambda.

Currently this accessor method has its parameters in the same order
structure as those of the lambda body method.

What is this order? There are three categories of parameters:

  1. lambda parameters
  2. captured parameters (added by lambdalift)
  3. self parameters (added to lambda bodies that end up in trait
     impl classes by mixin, and added unconditionally to the static
     accessor method.)

These are currently emitted in order #3, #1, #2.

Here are examples of the current behaviour:

BEFORE (trait):

```
% cat sandbox/test.scala
trait Test {
  def member: A
  def foo {
    val local = new B
    (arg: C) => "" + arg + member + local
  }
}

% qscalac -Ydelambdafy:method sandbox/test.scala && echo ':javap -private Test$class' | qscala

scala> :javap -private Test$class
Compiled from "test.scala"
public abstract class Test$class {
  public static void foo(Test);
  private static final java.lang.String $anonfun$1(Test, C, B);
  public static void $init$(Test);
  public static final java.lang.String accessor$1(Test, C, B);
}
```

BEFORE (class):

```
% cat sandbox/test.scala
abstract class Test {
  def member: A
  def foo {
    val local = new B
    (arg: C) => "" + arg + member + local
  }
}
% qscalac -Ydelambdafy:method sandbox/test.scala && echo ':javap -private Test' | qscala

scala> :javap -private Test
Compiled from "test.scala"
public abstract class Test {
  public abstract A member();
  public void foo();
  private final java.lang.String $anonfun$1(C, B);
  public Test();
  public static final java.lang.String accessor$1(Test, C, B);
}
```

Contrasting the class case with Java:

```
% cat sandbox/Test.java
public abstract class Test {
  public static class A {};
  public static class B {};
  public static class C {};
  public static interface I {
    public abstract Object c(C arg);
  }
  public abstract A member();
  public void test() {
    B local = new B();
    I i1 = (C arg) -> "" + member() + local;
  }
}

% javac -d . sandbox/Test.java && javap -private Test
Compiled from "Test.java"
public abstract class Test {
  public Test();
  public abstract Test$A member();
  public void test();
  private java.lang.Object lambda$test$0(Test$B, Test$C);
}
```

We can see that in Java 8 lambda parameters come first. If we
want to use Java's LambdaMetafactory to spin up our anoymous FunctionN
subclasses on the fly, a signature must change.

I can see three options for change:

  1. Adjust `Mixin` to always append the `$this` parameter, rather
     than prepending it.
  2. More conservatively, do this just for lambda bodies
  3. Adjust the parameters of the accessor method only. The body
     of this method can permute params before calling the lambda
     body method.

This commit implements option #3. This is the lowest risk / impact
to pave the way for experimentation with indy lambdas. But it isn't
ideal as a long term solution, as indy lambdas actually don't need
the accessor method at all, private methods can be used directly
by LambdaMetaFactory, saving a little indirection.

Option #1 might be worth a shot on the 2.12.x branch. Option #2 might
even be feasible on 2.11.x.

I've included a test that shows this in all in action. However, that
is currently disabled, as we don't have a partest category for tests
that require Java 8.

Author: retronym

src/compiler/scala/tools/nsc/transform/Delambdafy.scala

@@ -140,7 +140,20 @@ abstract class Delambdafy extends Transform with TypingTransformers with ast.Tre
         if (!thisProxy.exists) {
           target setFlag STATIC
         }
-        val params = ((optionSymbol(thisProxy) map {proxy:Symbol => ValDef(proxy)}) ++ (target.paramss.flatten map ValDef.apply)).toList
+        val targetParams = target.paramss.flatten map (param => ValDef(param))
+        val arity = fun.vparams.length
+        val numParamsBeforeMixin = enteringMixin(target.info.params.length)
+        val numParams = target.info.params.length
+        val numCapturedParams = numParamsBeforeMixin - arity
+        val hasSelfParam = {
+          val numSelfParams = numParams - arity - numCapturedParams
+          assert((0 to 1) contains numSelfParams, target.info)
+          numSelfParams > 0
+        }
+        val (selfParam, nonSelfParams) = targetParams.splitAt(if (hasSelfParam) 1 else 0)
+        val (lambdaParams, captureParams) = nonSelfParams.splitAt(arity)
+        val thisProxyParam: Option[ValDef] = optionSymbol(thisProxy) map {proxy:Symbol => ValDef(proxy)}
+        val params = thisProxyParam.toList ++ selfParam ++ captureParams ++ lambdaParams
 
         val methSym = oldClass.newMethod(unit.freshTermName(nme.accessor.toString() + "$"), target.pos, FINAL | BRIDGE | SYNTHETIC | PROTECTED | STATIC)
 
@@ -155,9 +168,13 @@ abstract class Delambdafy extends Transform with TypingTransformers with ast.Tre
         oldClass.info.decls enter methSym
 
         val body = localTyper.typed {
-          val newTarget = Select(if (thisProxy.exists) gen.mkAttributedRef(paramSyms(0)) else gen.mkAttributedThis(oldClass), target)
-          val newParams = paramSyms drop (if (thisProxy.exists) 1 else 0) map Ident
-          Apply(newTarget, newParams)
+          val qual = thisProxyParam match {
+            case Some(t) => gen.mkAttributedRef(t.symbol)
+            case _       => gen.mkAttributedThis(oldClass)
+          }
+          val newTarget = Select(qual, target)
+          val args = (selfParam ++ lambdaParams ++ captureParams).map(t => Ident(t.symbol))
+          Apply(newTarget, args)
         } setPos fun.pos
         val methDef = DefDef(methSym, List(params), body)
 
@@ -186,7 +203,9 @@ abstract class Delambdafy extends Transform with TypingTransformers with ast.Tre
 
         newClass.info.decls enter methSym
 
-        val Apply(_, oldParams) = fun.body
+        val (selfParam, nonSelfParams) = fun.body.asInstanceOf[Apply].args.splitAt(if (accessor.symbol.owner.isTrait) 1 else 0)
+        val (lambdaParams, capturedParams) = nonSelfParams.splitAt(fun.vparams.length)
+        val oldParams = selfParam ++ capturedParams ++ lambdaParams
 
         val body = localTyper typed Apply(Select(gen.mkAttributedThis(oldClass), accessor.symbol), (optionSymbol(thisProxy) map {tp => Select(gen.mkAttributedThis(newClass), tp)}).toList ++ oldParams)
         body.substituteSymbols(fun.vparams map (_.symbol), params map (_.symbol))

test/pending/run/delambdafy-lambdametafactory.scala

@@ -0,0 +1,50 @@
+//
+// Tests that the static accessor method for lambda bodies
+// (generated under -Ydelambdafy:method) are compatible with
+// Java 8's LambdaMetafactory.
+//
+import java.lang.invoke._
+
+class C {
+  def test1: Unit = {
+    (x: String) => x.reverse
+  }
+  def test2: Unit = {
+    val capture1 = "capture1"
+    (x: String) => capture1 + " " + x.reverse
+  }
+  def test3: Unit = {
+    (x: String) => C.this + " " + x.reverse
+  }
+}
+trait T {
+  def test4: Unit = {
+    (x: String) => x.reverse
+  }
+}
+
+// A functional interface. Function1 contains abstract methods that are filled in by mixin 
+trait Function1ish[A, B] {
+  def apply(a: A): B
+}
+
+object Test {
+  def lambdaFactory[A, B](hostClass: Class[_], instantiatedParam: Class[A], instantiatedRet: Class[B], accessorName: String,
+                          capturedParams: Array[(Class[_], AnyRef)] = Array()) = {
+    val caller = MethodHandles.lookup
+    val methodType = MethodType.methodType(classOf[AnyRef], Array[Class[_]](classOf[AnyRef]))
+    val instantiatedMethodType = MethodType.methodType(instantiatedRet, Array[Class[_]](instantiatedParam))
+    val (capturedParamTypes, captured) = capturedParams.unzip
+    val targetMethodType = MethodType.methodType(instantiatedRet, capturedParamTypes :+ instantiatedParam)
+    val invokedType = MethodType.methodType(classOf[Function1ish[_, _]], capturedParamTypes)
+    val target = caller.findStatic(hostClass, accessorName, targetMethodType)
+    val site = LambdaMetafactory.metafactory(caller, "apply", invokedType, methodType, target, instantiatedMethodType)
+    site.getTarget.invokeWithArguments(captured: _*).asInstanceOf[Function1ish[A, B]]
+  }
+  def main(args: Array[String]) {
+    println(lambdaFactory(classOf[C], classOf[String], classOf[String], "accessor$1").apply("abc"))
+    println(lambdaFactory(classOf[C], classOf[String], classOf[String], "accessor$2", Array(classOf[String] -> "capture1")).apply("abc"))
+    println(lambdaFactory(classOf[C], classOf[String], classOf[String], "accessor$3", Array(classOf[C] -> new C)).apply("abc"))
+    println(lambdaFactory(Class.forName("T$class"), classOf[String], classOf[String], "accessor$4", Array(classOf[T] -> new T{})).apply("abc"))
+  }
+}