Inline final methods defined in traits

In order to inline a final trait method, callsites of such methods are
first re-written from interface calls to static calls of the trait's
implementation class. Then inlining proceeds as ususal.

One problem that came up during development was that mixin methods are
added to class symbols only for classes being compiled, but not for
others. In order to inline a mixin method, we need the InlineInfo,
which so far was built using the class (and method) symbols. So we had
a problem with separate compilation.

Looking up the symbol from a given classfile name was already known to
be brittle (it's also one of the weak points of the current inliner),
so we changed the strategy. Now the InlineInfo for every class is
encoded in a new classfile attribute.

This classfile attribute is relatively small, because all strings it
references (class internal names, method names, method descriptors)
would exist anyway in the constant pool, so it just adds a few
references.

When building the InlineInfo for a class symbol, we only look at the
symbol properties for symbols being compiled in the current run. For
unpickled symbols, we build the InlineInfo by reading the classfile
attribute.

This change also adds delambdafy:method classes to currentRun.symSource.
Otherwise, currentRun.compiles(lambdaClass) is false.

1 files changed, 55 insertions, 9 deletions

diff --git a/test/junit/scala/tools/nsc/backend/jvm/CodeGenTools.scala b/test/junit/scala/tools/nsc/backend/jvm/CodeGenTools.scala
index e94f33db3d..c64f6e7f10 100644
--- a/test/junit/scala/tools/nsc/backend/jvm/CodeGenTools.scala
+++ b/test/junit/scala/tools/nsc/backend/jvm/CodeGenTools.scala
@@ -14,6 +14,7 @@ import scala.tools.nsc.settings.{MutableSettings, ScalaSettings}
 import scala.tools.nsc.{Settings, Global}
 import scala.tools.partest.ASMConverters
 import scala.collection.JavaConverters._
+import scala.tools.testing.TempDir
 
 object CodeGenTools {
   import ASMConverters._
@@ -42,20 +43,27 @@ object CodeGenTools {
   }
 
   def newCompiler(defaultArgs: String = "-usejavacp", extraArgs: String = ""): Global = {
+    val compiler = newCompilerWithoutVirtualOutdir(defaultArgs, extraArgs)
+    resetOutput(compiler)
+    compiler
+  }
+  
+  def newCompilerWithoutVirtualOutdir(defaultArgs: String = "-usejavacp", extraArgs: String = ""): Global = {
     val settings = new Settings()
     val args = (CommandLineParser tokenize defaultArgs) ++ (CommandLineParser tokenize extraArgs)
     settings.processArguments(args, processAll = true)
-    val compiler = new Global(settings)
-    resetOutput(compiler)
-    compiler
+    new Global(settings)
   }
 
-  def compile(compiler: Global)(code: String): List[(String, Array[Byte])] = {
+  def newRun(compiler: Global): compiler.Run = {
     compiler.reporter.reset()
     resetOutput(compiler)
-    val run = new compiler.Run()
-    run.compileSources(List(new BatchSourceFile("unitTestSource.scala", code)))
-    val outDir = compiler.settings.outputDirs.getSingleOutput.get
+    new compiler.Run()
+  }
+
+  def makeSourceFile(code: String, filename: String): BatchSourceFile = new BatchSourceFile(filename, code)
+
+  def getGeneratedClassfiles(outDir: AbstractFile): List[(String, Array[Byte])] = {
     def files(dir: AbstractFile): List[(String, Array[Byte])] = {
       val res = ListBuffer.empty[(String, Array[Byte])]
       for (f <- dir.iterator) {
@@ -67,8 +75,46 @@ object CodeGenTools {
     files(outDir)
   }
 
-  def compileClasses(compiler: Global)(code: String): List[ClassNode] = {
-    compile(compiler)(code).map(p => AsmUtils.readClass(p._2)).sortBy(_.name)
+  def compile(compiler: Global)(scalaCode: String, javaCode: List[(String, String)] = Nil): List[(String, Array[Byte])] = {
+    val run = newRun(compiler)
+    run.compileSources(makeSourceFile(scalaCode, "unitTestSource.scala") :: javaCode.map(p => makeSourceFile(p._1, p._2)))
+    getGeneratedClassfiles(compiler.settings.outputDirs.getSingleOutput.get)
+  }
+
+  /**
+   * Compile multiple Scala files separately into a single output directory.
+   *
+   * Note that a new compiler instance is created for compiling each file because symbols survive
+   * across runs. This makes separate compilation slower.
+   *
+   * The output directory is a physical directory, I have not figured out if / how it's possible to
+   * add a VirtualDirectory to the classpath of a compiler.
+   */
+  def compileSeparately(codes: List[String], extraArgs: String = ""): List[(String, Array[Byte])] = {
+    val outDir = AbstractFile.getDirectory(TempDir.createTempDir())
+    val outDirPath = outDir.canonicalPath
+    val argsWithOutDir = extraArgs + s" -d $outDirPath -cp $outDirPath"
+
+    for (code <- codes) {
+      val compiler = newCompilerWithoutVirtualOutdir(extraArgs = argsWithOutDir)
+      new compiler.Run().compileSources(List(makeSourceFile(code, "unitTestSource.scala")))
+    }
+
+    val classfiles = getGeneratedClassfiles(outDir)
+    outDir.delete()
+    classfiles
+  }
+
+  def compileClassesSeparately(codes: List[String], extraArgs: String = "") = {
+    readAsmClasses(compileSeparately(codes, extraArgs))
+  }
+
+  def readAsmClasses(classfiles: List[(String, Array[Byte])]) = {
+    classfiles.map(p => AsmUtils.readClass(p._2)).sortBy(_.name)
+  }
+
+  def compileClasses(compiler: Global)(code: String, javaCode: List[(String, String)] = Nil): List[ClassNode] = {
+    readAsmClasses(compile(compiler)(code, javaCode))
   }
 
   def compileMethods(compiler: Global)(code: String): List[MethodNode] = {