Rewrite closure invocations to the lambda body method

When an indylambda closure is allocated and invoked within the same
method, rewrite the invocation to the implementation method.

This works for any indylambda / SAM type, not only Scala functions.
However, the Scala compiler (under -Xexperimental) currently desugars
function literals for non-FunctionN types to an anonymous class during
typer.

No testing yet, waiting for FunctionN to become SAMs first.

The feature requires scala-java8-compat to be on the classpath and a
number of compiler flags:
-Ydelambdafy:method -Ybackend:GenBCode -Yopt:closure-elimination -target:jvm-1.8

➜  scala git:(opt/closureInlining) ant -Dscala-java8-compat.package=1 -Dlocker.skip=1
➜  scala git:(opt/closureInlining) cd sandbox

➜  sandbox git:(opt/closureInlining) cat Fun.java
public interface Fun<T> {
  T apply(T x);
}
➜  sandbox git:(opt/closureInlining) javac Fun.java

➜  sandbox git:(opt/closureInlining) cat Test.scala
class C {
  val z = "too"
  def f = {
    val kap = "me! me!"
    val f: Tuple2[String, String] => String = (o => z + kap + o.toString)
    f(("a", "b"))
  }

  def g = {
    val f: Int => String = x => x.toString
    f(10)
  }

  def h = {
    val f: Fun[Int] = x => x + 100 // Java SAM, requires -Xexperimental, will create an anonymous class in typer
    f(10)
  }

  def i = {
    val l = 10l
    val f: (Long, String) => String = (x, s) => s + l + z + x
    f(20l, "n")
  }

  def j = {
    val f: Int => Int = x => x + 101 // specialized
    f(33)
  }
}
➜  sandbox git:(opt/closureInlining) ../build/quick/bin/scalac -target:jvm-1.8 -Yopt:closure-elimination -Ydelambdafy:method -Ybackend:GenBCode -Xexperimental -cp ../build/quick/scala-java8-compat:. Test.scala

➜  sandbox git:(opt/closureInlining) asm -a C.class
➜  sandbox git:(opt/closureInlining) cat C.asm

[...]

  public g()Ljava/lang/String;
   L0
    INVOKEDYNAMIC apply()Lscala/compat/java8/JFunction1; [
      // handle kind 0x6 : INVOKESTATIC
      java/lang/invoke/LambdaMetafactory.altMetafactory(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;[Ljava/lang/Object;)Ljava/lang/invoke/CallSite;
      // arguments:
      (Ljava/lang/Object;)Ljava/lang/Object;,
      // handle kind 0x6 : INVOKESTATIC
      C.C$$$anonfun$2$adapted(Ljava/lang/Object;)Ljava/lang/String;,
      (Ljava/lang/Object;)Ljava/lang/String;,
      3,
      1,
      Lscala/Serializable;.class,
      0
    ]
    CHECKCAST scala/Function1
   L1
    ASTORE 1
   L2
    ALOAD 1
    BIPUSH 10
    INVOKESTATIC scala/runtime/BoxesRunTime.boxToInteger (I)Ljava/lang/Integer;
    ASTORE 2
    POP
    ALOAD 2
    INVOKESTATIC C.C$$$anonfun$2$adapted (Ljava/lang/Object;)Ljava/lang/String;
    CHECKCAST java/lang/String
   L3
    ARETURN

[...]

1 files changed, 22 insertions, 0 deletions

diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BackendReporting.scala b/src/compiler/scala/tools/nsc/backend/jvm/BackendReporting.scala
index d641f708d2..4fc05cafdc 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BackendReporting.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BackendReporting.scala
@@ -247,6 +247,28 @@ object BackendReporting {
                                      callsiteClass: InternalName, callsiteName: String, callsiteDesc: String) extends CannotInlineWarning
 
   /**
+   * Used in `rewriteClosureApplyInvocations` when a closure apply callsite cannot be rewritten
+   * to the closure body method.
+   */
+  trait RewriteClosureApplyToClosureBodyFailed extends OptimizerWarning {
+    def pos: Position
+
+    override def emitWarning(settings: ScalaSettings): Boolean = this match {
+      case RewriteClosureAccessCheckFailed(_, cause) => cause.emitWarning(settings)
+      case RewriteClosureIllegalAccess(_, _)         => settings.YoptWarningEmitAtInlineFailed
+    }
+
+    override def toString: String = this match {
+      case RewriteClosureAccessCheckFailed(_, cause) =>
+        s"Failed to rewrite the closure invocation to its implementation method:\n" + cause
+      case RewriteClosureIllegalAccess(_, callsiteClass) =>
+        s"The closure body invocation cannot be rewritten because the target method is not accessible in class $callsiteClass."
+    }
+  }
+  case class RewriteClosureAccessCheckFailed(pos: Position, cause: OptimizerWarning) extends RewriteClosureApplyToClosureBodyFailed
+  case class RewriteClosureIllegalAccess(pos: Position, callsiteClass: InternalName) extends RewriteClosureApplyToClosureBodyFailed
+
+  /**
    * Used in the InlineInfo of a ClassBType, when some issue occurred obtaining the inline information.
    */
   sealed trait ClassInlineInfoWarning extends OptimizerWarning {