Merge pull request #4377 from lrytz/opt/scalaInlineInfo

Emit the ScalaInlineInfo attribute under GenASM

10 files changed, 396 insertions, 31 deletions

diff --git a/src/compiler/scala/tools/nsc/backend/jvm/AsmUtils.scala b/src/compiler/scala/tools/nsc/backend/jvm/AsmUtils.scala
index 75aa0fc984..d3f09217cd 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/AsmUtils.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/AsmUtils.scala
@@ -8,8 +8,9 @@ package scala.tools.nsc.backend.jvm
 import scala.tools.asm.tree.{InsnList, AbstractInsnNode, ClassNode, MethodNode}
 import java.io.{StringWriter, PrintWriter}
 import scala.tools.asm.util.{TraceClassVisitor, TraceMethodVisitor, Textifier}
-import scala.tools.asm.ClassReader
+import scala.tools.asm.{Attribute, ClassReader}
 import scala.collection.convert.decorateAsScala._
+import scala.tools.nsc.backend.jvm.opt.InlineInfoAttributePrototype
 
 object AsmUtils {
 
@@ -49,7 +50,7 @@ object AsmUtils {
 
   def readClass(bytes: Array[Byte]): ClassNode = {
     val node = new ClassNode()
-    new ClassReader(bytes).accept(node, 0)
+    new ClassReader(bytes).accept(node, Array[Attribute](InlineInfoAttributePrototype), 0)
     node
   }
 
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala
index 27827015c3..2ebf338f5e 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala
@@ -3,9 +3,11 @@
  * @author  Martin Odersky
  */
 
-package scala.tools.nsc.backend.jvm
+package scala.tools.nsc
+package backend.jvm
 
 import scala.tools.nsc.Global
+import scala.tools.nsc.backend.jvm.BTypes.{MethodInlineInfo, InlineInfo, InternalName}
 
 /**
  * This trait contains code shared between GenBCode and GenASM that depends on types defined in
@@ -300,4 +302,97 @@ final class BCodeAsmCommon[G <: Global](val global: G) {
     }
     interfaces.map(_.typeSymbol)
   }
+
+  /**
+   * This is a hack to work around SI-9111. The completer of `methodSym` may report type errors. We
+   * cannot change the typer context of the completer at this point and make it silent: the context
+   * captured when creating the completer in the namer. However, we can temporarily replace
+   * global.reporter (it's a var) to store errors.
+   */
+  def completeSilentlyAndCheckErroneous(sym: Symbol): Boolean = {
+    if (sym.hasCompleteInfo) false
+    else {
+      val originalReporter = global.reporter
+      val storeReporter = new reporters.StoreReporter()
+      global.reporter = storeReporter
+      try {
+        sym.info
+      } finally {
+        global.reporter = originalReporter
+      }
+      sym.isErroneous
+    }
+  }
+
+  /**
+   * Build the [[InlineInfo]] for a class symbol.
+   */
+  def buildInlineInfoFromClassSymbol(classSym: Symbol, classSymToInternalName: Symbol => InternalName, methodSymToDescriptor: Symbol => String): InlineInfo = {
+    val selfType = {
+      // The mixin phase uses typeOfThis for the self parameter in implementation class methods.
+      val selfSym = classSym.typeOfThis.typeSymbol
+      if (selfSym != classSym) Some(classSymToInternalName(selfSym)) else None
+    }
+
+    val isEffectivelyFinal = classSym.isEffectivelyFinal
+
+    var warning = Option.empty[String]
+
+    // Primitive methods cannot be inlined, so there's no point in building a MethodInlineInfo. Also, some
+    // primitive methods (e.g., `isInstanceOf`) have non-erased types, which confuses [[typeToBType]].
+    val methodInlineInfos = classSym.info.decls.iterator.filter(m => m.isMethod && !scalaPrimitives.isPrimitive(m)).flatMap({
+      case methodSym =>
+        if (completeSilentlyAndCheckErroneous(methodSym)) {
+          // Happens due to SI-9111. Just don't provide any MethodInlineInfo for that method, we don't need fail the compiler.
+          if (!classSym.isJavaDefined) devWarning("SI-9111 should only be possible for Java classes")
+          warning = Some(s"Failed to get the type of a method of class symbol ${classSym.fullName} due to SI-9111")
+          None
+        } else {
+          val name      = methodSym.javaSimpleName.toString // same as in genDefDef
+          val signature = name + methodSymToDescriptor(methodSym)
+
+          // Some detours are required here because of changing flags (lateDEFERRED, lateMODULE):
+          // 1. Why the phase travel? Concrete trait methods obtain the lateDEFERRED flag in Mixin.
+          //    This makes isEffectivelyFinalOrNotOverridden false, which would prevent non-final
+          //    but non-overridden methods of sealed traits from being inlined.
+          // 2. Why the special case for `classSym.isImplClass`? Impl class symbols obtain the
+          //    lateMODULE flag during Mixin. During the phase travel to exitingPickler, the late
+          //    flag is ignored. The members are therefore not isEffectivelyFinal (their owner
+          //    is not a module). Since we know that all impl class members are static, we can
+          //    just take the shortcut.
+          val effectivelyFinal = classSym.isImplClass || exitingPickler(methodSym.isEffectivelyFinalOrNotOverridden)
+
+          // Identify trait interface methods that have a static implementation in the implementation
+          // class. Invocations of these methods can be re-wrired directly to the static implementation
+          // if they are final or the receiver is known.
+          //
+          // Using `erasure.needsImplMethod` is not enough: it keeps field accessors, module getters
+          // and super accessors. When AddInterfaces creates the impl class, these methods are
+          // initially added to it.
+          //
+          // The mixin phase later on filters out most of these members from the impl class (see
+          // Mixin.isImplementedStatically). However, accessors for concrete lazy vals remain in the
+          // impl class after mixin. So the filter in mixin is not exactly what we need here (we
+          // want to identify concrete trait methods, not any accessors). So we check some symbol
+          // properties manually.
+          val traitMethodWithStaticImplementation = {
+            import symtab.Flags._
+            classSym.isTrait && !classSym.isImplClass &&
+              erasure.needsImplMethod(methodSym) &&
+              !methodSym.isModule &&
+              !(methodSym hasFlag (ACCESSOR | SUPERACCESSOR))
+          }
+
+          val info = MethodInlineInfo(
+            effectivelyFinal                    = effectivelyFinal,
+            traitMethodWithStaticImplementation = traitMethodWithStaticImplementation,
+            annotatedInline                     = methodSym.hasAnnotation(ScalaInlineClass),
+            annotatedNoInline                   = methodSym.hasAnnotation(ScalaNoInlineClass)
+          )
+          Some((signature, info))
+        }
+    }).toMap
+
+    InlineInfo(selfType, isEffectivelyFinal, methodInlineInfos, warning)
+  }
 }
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala
index a194fe8fe4..ec26ef9b48 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala
@@ -936,4 +936,52 @@ object BTypes {
    * But that would create overhead in a Collection[InternalName].
    */
   type InternalName = String
+
+  /**
+   * Metadata about a ClassBType, used by the inliner.
+   *
+   * More information may be added in the future to enable more elaborate inlinine heuristics.
+   *
+   * @param traitImplClassSelfType `Some(tp)` if this InlineInfo describes a trait, and the `self`
+   *                               parameter type of the methods in the implementation class is not
+   *                               the trait itself. Example:
+   *                                 trait T { self: U => def f = 1 }
+   *                               Generates something like:
+   *                                 class T$class { static def f(self: U) = 1 }
+   *
+   *                               In order to inline a trat method call, the INVOKEINTERFACE is
+   *                               rewritten to an INVOKESTATIC of the impl class, so we need the
+   *                               self type (U) to get the right signature.
+   *
+   *                               `None` if the self type is the interface type, or if this
+   *                               InlineInfo does not describe a trait.
+   *
+   * @param isEffectivelyFinal     True if the class cannot have subclasses: final classes, module
+   *                               classes, trait impl classes.
+   *
+   * @param methodInfos            The [[MethodInlineInfo]]s for the methods declared in this class.
+   *                               The map is indexed by the string s"$name$descriptor" (to
+   *                               disambiguate overloads).
+   */
+  final case class InlineInfo(traitImplClassSelfType: Option[InternalName],
+                              isEffectivelyFinal: Boolean,
+                              methodInfos: Map[String, MethodInlineInfo],
+                              warning: Option[String])
+
+  val EmptyInlineInfo = InlineInfo(None, false, Map.empty, None)
+
+  /**
+   * Metadata about a method, used by the inliner.
+   *
+   * @param effectivelyFinal                    True if the method cannot be overridden (in Scala)
+   * @param traitMethodWithStaticImplementation True if the method is an interface method method of
+   *                                            a trait method and has a static counterpart in the
+   *                                            implementation class.
+   * @param annotatedInline                     True if the method is annotated `@inline`
+   * @param annotatedNoInline                   True if the method is annotated `@noinline`
+   */
+  final case class MethodInlineInfo(effectivelyFinal: Boolean,
+                                    traitMethodWithStaticImplementation: Boolean,
+                                    annotatedInline: Boolean,
+                                    annotatedNoInline: Boolean)
 }
\ No newline at end of file
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala
index 707336e5de..62268e1907 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala
@@ -9,6 +9,7 @@ package backend.jvm
 
 import scala.collection.{ mutable, immutable }
 import scala.reflect.internal.pickling.{ PickleFormat, PickleBuffer }
+import scala.tools.nsc.backend.jvm.opt.InlineInfoAttribute
 import scala.tools.nsc.symtab._
 import scala.tools.asm
 import asm.Label
@@ -1292,6 +1293,9 @@ abstract class GenASM extends SubComponent with BytecodeWriters { self =>
       jclass.visitAttribute(if(ssa.isDefined) pickleMarkerLocal else pickleMarkerForeign)
       emitAnnotations(jclass, c.symbol.annotations ++ ssa)
 
+      if (!settings.YskipInlineInfoAttribute.value)
+        jclass.visitAttribute(InlineInfoAttribute(buildInlineInfoFromClassSymbol(c.symbol, javaName, javaType(_).getDescriptor)))
+
       // typestate: entering mode with valid call sequences:
       //   ( visitInnerClass | visitField | visitMethod )* visitEnd
 
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/InlineInfoAttribute.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/InlineInfoAttribute.scala
new file mode 100644
index 0000000000..4812f2290f
--- /dev/null
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/InlineInfoAttribute.scala
@@ -0,0 +1,147 @@
+/* NSC -- new Scala compiler
+ * Copyright 2005-2014 LAMP/EPFL
+ * @author  Martin Odersky
+ */
+
+package scala.tools.nsc
+package backend.jvm
+package opt
+
+import scala.tools.asm._
+import scala.tools.nsc.backend.jvm.BTypes.{InlineInfo, MethodInlineInfo}
+
+/**
+ * This attribute stores the InlineInfo for a ClassBType as an independent classfile attribute.
+ * The compiler does so for every class being compiled.
+ *
+ * The reason is that a precise InlineInfo can only be obtained if the symbol for a class is available.
+ * For example, we need to know if a method is final in Scala's terms, or if it has the @inline annotation.
+ * Looking up a class symbol for a given class filename is brittle (name-mangling).
+ *
+ * The attribute is also helpful for inlining mixin methods. The mixin phase only adds mixin method
+ * symbols to classes that are being compiled. For all other class symbols, there are no mixin members.
+ * However, the inliner requires an InlineInfo for inlining mixin members. That problem is solved by
+ * reading the InlineInfo from this attribute.
+ *
+ * In principle we could encode the InlineInfo into a Java annotation (instead of a classfile attribute).
+ * However, an attribute allows us to save many bits. In particular, note that the strings in an
+ * InlineInfo are serialized as references to constants in the constant pool, and those strings
+ * (traitImplClassSelfType, method names, method signatures) would exist in there anyway. So the
+ * ScalaInlineAttribute remains relatively compact.
+ */
+case class InlineInfoAttribute(inlineInfo: InlineInfo) extends Attribute(InlineInfoAttribute.attributeName) {
+  /**
+   * Not sure what this method is good for, it is not invoked anywhere in the ASM framework. However,
+   * the example in the ASM manual also overrides it to `false` for custom attributes, so it might be
+   * a good idea.
+   */
+  override def isUnknown: Boolean = false
+
+  /**
+   * Serialize the `inlineInfo` into a byte array. Strings are added to the constant pool and serialized
+   * as references.
+   */
+  override def write(cw: ClassWriter, code: Array[Byte], len: Int, maxStack: Int, maxLocals: Int): ByteVector = {
+    val result = new ByteVector()
+
+    result.putByte(InlineInfoAttribute.VERSION)
+
+    var hasSelfIsFinal = 0
+    if (inlineInfo.isEffectivelyFinal)               hasSelfIsFinal |= 1
+    if (inlineInfo.traitImplClassSelfType.isDefined) hasSelfIsFinal |= 2
+    result.putByte(hasSelfIsFinal)
+
+    for (selfInternalName <- inlineInfo.traitImplClassSelfType) {
+      result.putShort(cw.newUTF8(selfInternalName))
+    }
+
+    // The method count fits in a short (the methods_count in a classfile is also a short)
+    result.putShort(inlineInfo.methodInfos.size)
+
+    // Sort the methodInfos for stability of classfiles
+    for ((nameAndType, info) <- inlineInfo.methodInfos.toList.sortBy(_._1)) {
+      val (name, desc) = nameAndType.span(_ != '(')
+      // Name and desc are added separately because a NameAndType entry also stores them separately.
+      // This makes sure that we use the existing constant pool entries for the method.
+      result.putShort(cw.newUTF8(name))
+      result.putShort(cw.newUTF8(desc))
+
+      var inlineInfo = 0
+      if (info.effectivelyFinal)                    inlineInfo |= 1
+      if (info.traitMethodWithStaticImplementation) inlineInfo |= 2
+      if (info.annotatedInline)                     inlineInfo |= 4
+      if (info.annotatedNoInline)                   inlineInfo |= 8
+      result.putByte(inlineInfo)
+    }
+
+    result
+  }
+
+  /**
+   * De-serialize the attribute into an InlineInfo. The attribute starts at cr.b(off), but we don't
+   * need to access that array directly, we can use the `read` methods provided by the ClassReader.
+   *
+   * `buf` is a pre-allocated character array that is guaranteed to be long enough to hold any
+   * string of the constant pool. So we can use it to invoke `cr.readUTF8`.
+   */
+  override def read(cr: ClassReader, off: Int, len: Int, buf: Array[Char], codeOff: Int, labels: Array[Label]): InlineInfoAttribute = {
+    var next = off
+
+    def nextByte()  = { val r = cr.readByte(next)     ; next += 1; r }
+    def nextUTF8()  = { val r = cr.readUTF8(next, buf); next += 2; r }
+    def nextShort() = { val r = cr.readShort(next)    ; next += 2; r }
+
+    val version = nextByte()
+    if (version == 1) {
+      val hasSelfIsFinal = nextByte()
+      val isFinal = (hasSelfIsFinal & 1) != 0
+      val hasSelf = (hasSelfIsFinal & 2) != 0
+
+      val self = if (hasSelf) {
+        val selfName = nextUTF8()
+        Some(selfName)
+      } else {
+        None
+      }
+
+      val numEntries = nextShort()
+      val infos = (0 until numEntries).map(_ => {
+        val name = nextUTF8()
+        val desc = nextUTF8()
+
+        val inlineInfo = nextByte()
+        val isFinal                             = (inlineInfo & 1) != 0
+        val traitMethodWithStaticImplementation = (inlineInfo & 2) != 0
+        val isInline                            = (inlineInfo & 4) != 0
+        val isNoInline                          = (inlineInfo & 8) != 0
+        (name + desc, MethodInlineInfo(isFinal, traitMethodWithStaticImplementation, isInline, isNoInline))
+      }).toMap
+
+      InlineInfoAttribute(InlineInfo(self, isFinal, infos, None))
+    } else {
+      val msg = s"Cannot read ScalaInlineInfo version $version in classfile ${cr.getClassName}. Use a more recent compiler."
+      InlineInfoAttribute(BTypes.EmptyInlineInfo.copy(warning = Some(msg)))
+    }
+  }
+}
+
+object InlineInfoAttribute {
+  /**
+   * [u1]    version
+   * [u1]    isEffectivelyFinal (<< 0), hasTraitImplClassSelfType (<< 1)
+   * [u2]?   traitImplClassSelfType (reference)
+   * [u2]    numMethodEntries
+   *   [u2]  name (reference)
+   *   [u2]  descriptor (reference)
+   *   [u1]  isFinal (<< 0), traitMethodWithStaticImplementation (<< 1), hasInlineAnnotation (<< 2), hasNoInlineAnnotation (<< 3)
+   */
+  final val VERSION: Byte = 1
+
+  final val attributeName = "ScalaInlineInfo"
+}
+
+/**
+ * In order to instruct the ASM framework to de-serialize the ScalaInlineInfo attribute, we need
+ * to pass a prototype instance when running the class reader.
+ */
+object InlineInfoAttributePrototype extends InlineInfoAttribute(InlineInfo(null, false, null, null))
diff --git a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
index a5b722612d..d7f4cca615 100644
--- a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
+++ b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
@@ -213,6 +213,8 @@ trait ScalaSettings extends AbsScalaSettings
   // the current standard is "inline" but we are moving towards "method"
   val Ydelambdafy        = ChoiceSetting     ("-Ydelambdafy", "strategy", "Strategy used for translating lambdas into JVM code.", List("inline", "method"), "inline")
 
+  val YskipInlineInfoAttribute = BooleanSetting("-Yskip-inline-info-attribute", "Do not add the ScalaInlineInfo attribute to classfiles generated by -Ybackend:GenASM")
+
   object YoptChoices extends MultiChoiceEnumeration {
     val unreachableCode         = Choice("unreachable-code",          "Eliminate unreachable code, exception handlers protecting no instructions, debug information of eliminated variables.")
     val simplifyJumps           = Choice("simplify-jumps",            "Simplify branching instructions, eliminate unnecessary ones.")
diff --git a/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala b/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala
index f786ffb8f3..3591372bbe 100644
--- a/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala
+++ b/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala
@@ -55,7 +55,7 @@ abstract class AddInterfaces extends InfoTransform { self: Erasure =>
   )
 
   /** Does symbol need an implementation method? */
-  private def needsImplMethod(sym: Symbol) = (
+  def needsImplMethod(sym: Symbol) = (
        sym.isMethod
     && isInterfaceMember(sym)
     && (!sym.hasFlag(DEFERRED | SUPERACCESSOR) || (sym hasFlag lateDEFERRED))
diff --git a/test/files/run/t7974.check b/test/files/run/t7974.check
index d8152d3286..4eae5eb152 100644
--- a/test/files/run/t7974.check
+++ b/test/files/run/t7974.check
@@ -1,19 +1,3 @@
-public class Symbols {
-
-
-
-
-  // access flags 0x12
-  private final Lscala/Symbol; someSymbol3
-
-  // access flags 0xA
-  private static Lscala/Symbol; symbol$1
-
-  // access flags 0xA
-  private static Lscala/Symbol; symbol$2
-
-  // access flags 0xA
-  private static Lscala/Symbol; symbol$3
 
   // access flags 0x9
   public static <clinit>()V
@@ -33,6 +17,7 @@ public class Symbols {
     MAXSTACK = 2
     MAXLOCALS = 0
 
+
   // access flags 0x1
   public someSymbol1()Lscala/Symbol;
     GETSTATIC Symbols.symbol$1 : Lscala/Symbol;
@@ -40,6 +25,7 @@ public class Symbols {
     MAXSTACK = 1
     MAXLOCALS = 1
 
+
   // access flags 0x1
   public someSymbol2()Lscala/Symbol;
     GETSTATIC Symbols.symbol$2 : Lscala/Symbol;
@@ -47,6 +33,7 @@ public class Symbols {
     MAXSTACK = 1
     MAXLOCALS = 1
 
+
   // access flags 0x1
   public sameSymbol1()Lscala/Symbol;
     GETSTATIC Symbols.symbol$1 : Lscala/Symbol;
@@ -54,6 +41,7 @@ public class Symbols {
     MAXSTACK = 1
     MAXLOCALS = 1
 
+
   // access flags 0x1
   public someSymbol3()Lscala/Symbol;
     ALOAD 0
@@ -62,6 +50,7 @@ public class Symbols {
     MAXSTACK = 1
     MAXLOCALS = 1
 
+
   // access flags 0x1
   public <init>()V
     ALOAD 0
@@ -72,4 +61,4 @@ public class Symbols {
     RETURN
     MAXSTACK = 2
     MAXLOCALS = 1
-}
+
diff --git a/test/files/run/t7974/Test.scala b/test/files/run/t7974/Test.scala
index 29d2b9cb64..296ec32ee2 100644
--- a/test/files/run/t7974/Test.scala
+++ b/test/files/run/t7974/Test.scala
@@ -1,20 +1,14 @@
-import java.io.PrintWriter;
+import java.io.PrintWriter
 
 import scala.tools.partest.BytecodeTest
+import scala.tools.nsc.backend.jvm.AsmUtils
 import scala.tools.asm.util._
 import scala.tools.nsc.util.stringFromWriter
+import scala.collection.convert.decorateAsScala._
 
 object Test extends BytecodeTest {
   def show {
     val classNode = loadClassNode("Symbols", skipDebugInfo = true)
-    val textifier = new Textifier
-    classNode.accept(new TraceClassVisitor(null, textifier, null))
-
-    val classString = stringFromWriter(w => textifier.print(w))
-    val result =
-      classString.split('\n')
-        .dropWhile(elem => elem != "public class Symbols {")
-        .filterNot(elem => elem.startsWith("  @Lscala/reflect/ScalaSignature") || elem.startsWith("  ATTRIBUTE ScalaSig"))
-    result foreach println
+    classNode.methods.asScala.foreach(m => println(AsmUtils.textify(m)))
   }
 }
diff --git a/test/junit/scala/tools/nsc/backend/jvm/opt/ScalaInlineInfoTest.scala b/test/junit/scala/tools/nsc/backend/jvm/opt/ScalaInlineInfoTest.scala
new file mode 100644
index 0000000000..f8e887426b
--- /dev/null
+++ b/test/junit/scala/tools/nsc/backend/jvm/opt/ScalaInlineInfoTest.scala
@@ -0,0 +1,85 @@
+package scala.tools.nsc
+package backend.jvm
+package opt
+
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+import org.junit.Test
+import scala.tools.asm.Opcodes._
+import org.junit.Assert._
+
+import CodeGenTools._
+import scala.tools.nsc.backend.jvm.BTypes.{MethodInlineInfo, InlineInfo}
+import scala.tools.partest.ASMConverters
+import ASMConverters._
+import scala.collection.convert.decorateAsScala._
+
+object ScalaInlineInfoTest {
+  var compiler = newCompiler(extraArgs = "-Ybackend:GenBCode -Yopt:l:none")
+  def clear(): Unit = { compiler = null }
+}
+
+@RunWith(classOf[JUnit4])
+class ScalaInlineInfoTest {
+  val compiler = newCompiler()
+
+  @Test
+  def traitMembersInlineInfo(): Unit = {
+    val code =
+      """trait T {
+        |  def f1 = 1                   // concrete method
+        |  private def f2 = 1           // implOnly method (does not end up in the interface)
+        |  def f3 = {
+        |    def nest = 0               // nested method (does not end up in the interface)
+        |    nest
+        |  }
+        |
+        |  @inline
+        |  def f4 = super.toString      // super accessor
+        |
+        |  object O                     // module accessor (method is generated)
+        |  def f5 = {
+        |    object L { val x = 0 }     // nested module (just flattened out)
+        |    L.x
+        |  }
+        |
+        |  @noinline
+        |  def f6: Int                  // abstract method (not in impl class)
+        |
+        |  // fields
+        |
+        |  val x1 = 0
+        |  var y2 = 0
+        |  var x3: Int
+        |  lazy val x4 = 0
+        |
+        |  final val x5 = 0
+        |}
+      """.stripMargin
+
+    val cs @ List(t, tl, to, tCls) = compileClasses(compiler)(code)
+    val List(info) = t.attrs.asScala.collect({ case a: InlineInfoAttribute => a.inlineInfo }).toList
+    val expect = InlineInfo(
+      None,  // self type
+      false, // final class
+      Map(
+        ("O()LT$O$;",                            MethodInlineInfo(true, false,false,false)),
+        ("T$$super$toString()Ljava/lang/String;",MethodInlineInfo(false,false,false,false)),
+        ("T$_setter_$x1_$eq(I)V",                MethodInlineInfo(false,false,false,false)),
+        ("f1()I",                                MethodInlineInfo(false,true, false,false)),
+        ("f3()I",                                MethodInlineInfo(false,true, false,false)),
+        ("f4()Ljava/lang/String;",               MethodInlineInfo(false,true, true, false)),
+        ("f5()I",                                MethodInlineInfo(false,true, false,false)),
+        ("f6()I",                                MethodInlineInfo(false,false,false,true )),
+        ("x1()I",                                MethodInlineInfo(false,false,false,false)),
+        ("x3()I",                                MethodInlineInfo(false,false,false,false)),
+        ("x3_$eq(I)V",                           MethodInlineInfo(false,false,false,false)),
+        ("x4()I",                                MethodInlineInfo(false,false,false,false)),
+        ("x5()I",                                MethodInlineInfo(true, false,false,false)),
+        ("y2()I",                                MethodInlineInfo(false,false,false,false)),
+        ("y2_$eq(I)V",                           MethodInlineInfo(false,false,false,false))),
+      None // warning
+    )
+    assert(info == expect, info)
+  }
+}