Construct ClassBTypes from parsed classfiles

This infrastructure is required for the inliner: when inlining code
from a classfile, the corresponding ClassBType is needed for various
things (eg access checks, InnerClass attribute).

The test creates two ClassBTypes for the same class: once using the
(unpickled) Symbol, once using the parsed ASM ClassNode, and verifies
that the two are the same.

There's a cleanup to the InnerClass attribute:

    object T { class Member; def foo = { class Local } }
    class T

For Java compatibility the InnerClass entry for Member says the class
is nested in T (not in the module class T$). We now make sure to add
that entry only to T, not to T$ (unless Member is actually referenced
in the classfile T$, in that case it will be added, as required).

2 files changed, 96 insertions, 1 deletions

diff --git a/test/junit/scala/tools/nsc/backend/jvm/BTypesTest.scala b/test/junit/scala/tools/nsc/backend/jvm/BTypesTest.scala
index 221aad6536..2347e8288e 100644
--- a/test/junit/scala/tools/nsc/backend/jvm/BTypesTest.scala
+++ b/test/junit/scala/tools/nsc/backend/jvm/BTypesTest.scala
@@ -19,7 +19,7 @@ class BTypesTest {
 
   val btypes = new BTypesFromSymbols[g.type](g)
   import btypes._
-  duringBackend(btypes.intializeCoreBTypes())
+  duringBackend(btypes.initializeCoreBTypes())
 
   def classBTypeFromSymbol(sym: Symbol) = duringBackend(btypes.classBTypeFromSymbol(sym))
 
diff --git a/test/junit/scala/tools/nsc/backend/jvm/opt/BTypesFromClassfileTest.scala b/test/junit/scala/tools/nsc/backend/jvm/opt/BTypesFromClassfileTest.scala
new file mode 100644
index 0000000000..2975bd060d
--- /dev/null
+++ b/test/junit/scala/tools/nsc/backend/jvm/opt/BTypesFromClassfileTest.scala
@@ -0,0 +1,95 @@
+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 scala.tools.nsc.backend.jvm.BTypes.InternalName
+import scala.tools.testing.AssertUtil._
+
+import CodeGenTools._
+import scala.tools.partest.ASMConverters
+import ASMConverters._
+
+import scala.collection.convert.decorateAsScala._
+
+@RunWith(classOf[JUnit4])
+class BTypesFromClassfileTest {
+  val compiler = newCompiler(extraArgs = "-Ybackend:GenBCode")
+
+  import compiler._
+  import definitions._
+  import genBCode.bTypes
+  import bTypes._
+
+  def duringBackend[T](f: => T) = compiler.exitingDelambdafy(f)
+
+  val run = new compiler.Run() // initializes some of the compiler
+  duringBackend(bTypes.initializeCoreBTypes())
+
+  def clearCache() = bTypes.classBTypeFromInternalName.clear()
+
+  def sameBType(fromSym: ClassBType, fromClassfile: ClassBType, checked: Set[InternalName] = Set.empty): Set[InternalName] = {
+    if (checked(fromSym.internalName)) checked
+    else {
+      assert(fromSym == fromClassfile, s"$fromSym != $fromClassfile")
+      sameInfo(fromSym.info, fromClassfile.info, checked + fromSym.internalName)
+    }
+  }
+
+  def sameBTypes(fromSyms: Iterable[ClassBType], fromClassfiles: Iterable[ClassBType], checked: Set[InternalName]): Set[InternalName] = {
+    assert(fromSyms.size == fromClassfiles.size, s"\n$fromSyms\n$fromClassfiles")
+    (fromSyms, fromClassfiles).zipped.foldLeft(checked) {
+      case (chk, (fromSym, fromClassfile)) => sameBType(fromSym, fromClassfile, chk)
+    }
+  }
+
+  def sameInfo(fromSym: ClassInfo, fromClassfile: ClassInfo, checked: Set[InternalName]): Set[InternalName] = {
+    assert({
+      // Nested class symbols can undergo makeNotPrivate (ExplicitOuter). But this is only applied
+      // for symbols of class symbols that are being compiled, not those read from a pickle.
+      // So a class may be public in bytecode, but the symbol still says private.
+      if (fromSym.nestedInfo.isEmpty) fromSym.flags == fromClassfile.flags
+      else (fromSym.flags | ACC_PRIVATE | ACC_PUBLIC) == (fromClassfile.flags | ACC_PRIVATE | ACC_PUBLIC)
+    }, s"class flags differ\n$fromSym\n$fromClassfile")
+
+    val chk1 = sameBTypes(fromSym.superClass, fromClassfile.superClass, checked)
+
+    val chk2 = sameBTypes(fromSym.interfaces, fromClassfile.interfaces, chk1)
+
+    // The fromSym info has only member classes, no local or anonymous. The symbol is read from the
+    // Scala pickle data and only member classes are created / entered.
+    //  (This is different for symbols that are being compiled, there flatten will enter all local
+    //   and anonymous classes as members of the outer class. But not for unpickled symbols).
+    // The fromClassfile info has all nested classes, including anonymous and local. So we filter
+    // them out: member classes are identified by having the `outerName` defined.
+    val memberClassesFromClassfile = fromClassfile.nestedClasses.filter(_.info.nestedInfo.get.outerName.isDefined)
+    // Sorting is required: the backend sorts all InnerClass entries by internalName before writing
+    // them to the classfile (to make it deterministic: the entries are collected in a Set during
+    // code generation).
+    val chk3 = sameBTypes(fromSym.nestedClasses.sortBy(_.internalName), memberClassesFromClassfile.sortBy(_.internalName), chk2)
+    sameBTypes(fromSym.nestedInfo.map(_.enclosingClass), fromClassfile.nestedInfo.map(_.enclosingClass), chk3)
+  }
+
+  def check(classSym: Symbol): Unit = duringBackend {
+    clearCache()
+    val fromSymbol = classBTypeFromSymbol(classSym)
+    clearCache()
+    val fromClassfile = bTypes.classBTypeFromParsedClassfile(fromSymbol.internalName)
+    sameBType(fromSymbol, fromClassfile)
+  }
+
+  @Test
+  def compareClassBTypes(): Unit = {
+    // Note that not only these classes are tested, but also all their parents and all nested
+    // classes in their InnerClass attributes.
+    check(ObjectClass)
+    check(JavaNumberClass)
+    check(ConsClass)
+    check(ListModule.moduleClass)
+  }
+}