Merge pull request scala#4210 from lrytz/opt/classBTypeFromClassfile

Construct ClassBTypes from parsed classfiles

Author: gkossakowski

src/compiler/scala/tools/nsc/backend/jvm/AsmUtils.scala

@@ -5,10 +5,11 @@
 
 package scala.tools.nsc.backend.jvm
 
-import scala.tools.asm.tree.{AbstractInsnNode, ClassNode, MethodNode}
-import java.io.PrintWriter
+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.collection.convert.decorateAsScala._
 
 object AsmUtils {
 
@@ -36,19 +37,12 @@ object AsmUtils {
 
   def traceMethod(mnode: MethodNode): Unit = {
     println(s"Bytecode for method ${mnode.name}")
-    val p = new Textifier
-    val tracer = new TraceMethodVisitor(p)
-    mnode.accept(tracer)
-    val w = new PrintWriter(System.out)
-    p.print(w)
-    w.flush()
+    println(textify(mnode))
   }
 
   def traceClass(cnode: ClassNode): Unit = {
     println(s"Bytecode for class ${cnode.name}")
-    val w = new PrintWriter(System.out)
-    cnode.accept(new TraceClassVisitor(w))
-    w.flush()
+    println(textify(cnode))
   }
 
   def traceClass(bytes: Array[Byte]): Unit = traceClass(readClass(bytes))
@@ -59,8 +53,56 @@ object AsmUtils {
     node
   }
 
-  def instructionString(instruction: AbstractInsnNode): String = instruction.getOpcode match {
-    case -1 => instruction.toString
-    case op => scala.tools.asm.util.Printer.OPCODES(op)
+  /**
+   * Returns a human-readable representation of the cnode ClassNode.
+   */
+  def textify(cnode: ClassNode): String = {
+    val trace = new TraceClassVisitor(new PrintWriter(new StringWriter))
+    cnode.accept(trace)
+    val sw = new StringWriter
+    val pw = new PrintWriter(sw)
+    trace.p.print(pw)
+    sw.toString
   }
+
+  /**
+   * Returns a human-readable representation of the code in the mnode MethodNode.
+   */
+  def textify(mnode: MethodNode): String = {
+    val trace = new TraceClassVisitor(new PrintWriter(new StringWriter))
+    mnode.accept(trace)
+    val sw = new StringWriter
+    val pw = new PrintWriter(sw)
+    trace.p.print(pw)
+    sw.toString
+  }
+
+  /**
+   * Returns a human-readable representation of the given instruction.
+   */
+  def textify(insn: AbstractInsnNode): String = {
+    val trace = new TraceMethodVisitor(new Textifier)
+    insn.accept(trace)
+    val sw = new StringWriter
+    val pw = new PrintWriter(sw)
+    trace.p.print(pw)
+    sw.toString.trim
+  }
+
+  /**
+   * Returns a human-readable representation of the given instruction sequence.
+   */
+  def textify(insns: Iterator[AbstractInsnNode]): String = {
+    val trace = new TraceMethodVisitor(new Textifier)
+    insns.foreach(_.accept(trace))
+    val sw: StringWriter = new StringWriter
+    val pw: PrintWriter = new PrintWriter(sw)
+    trace.p.print(pw)
+    sw.toString.trim
+  }
+
+  /**
+   * Returns a human-readable representation of the given instruction sequence.
+   */
+  def textify(insns: InsnList): String = textify(insns.iterator().asScala)
 }

src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala

@@ -791,32 +791,28 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
       assert(moduleClass.companionClass == NoSymbol, moduleClass)
       innerClassBufferASM.clear()
       this.cunit = cunit
-      val moduleName = internalName(moduleClass) // + "$"
-      val mirrorName = moduleName.substring(0, moduleName.length() - 1)
 
-      val flags = (asm.Opcodes.ACC_SUPER | asm.Opcodes.ACC_PUBLIC | asm.Opcodes.ACC_FINAL)
+      val bType = mirrorClassClassBType(moduleClass)
       val mirrorClass = new asm.tree.ClassNode
       mirrorClass.visit(
         classfileVersion,
-        flags,
-        mirrorName,
+        bType.info.flags,
+        bType.internalName,
         null /* no java-generic-signature */,
         ObjectReference.internalName,
         EMPTY_STRING_ARRAY
       )
 
-      if (emitSource) {
-        mirrorClass.visitSource("" + cunit.source,
-                                null /* SourceDebugExtension */)
-      }
+      if (emitSource)
+        mirrorClass.visitSource("" + cunit.source, null /* SourceDebugExtension */)
 
-      val ssa = getAnnotPickle(mirrorName, moduleClass.companionSymbol)
+      val ssa = getAnnotPickle(bType.internalName, moduleClass.companionSymbol)
       mirrorClass.visitAttribute(if (ssa.isDefined) pickleMarkerLocal else pickleMarkerForeign)
       emitAnnotations(mirrorClass, moduleClass.annotations ++ ssa)
 
-      addForwarders(isRemote(moduleClass), mirrorClass, mirrorName, moduleClass)
+      addForwarders(isRemote(moduleClass), mirrorClass, bType.internalName, moduleClass)
 
-      innerClassBufferASM ++= classBTypeFromSymbol(moduleClass).info.memberClasses
+      innerClassBufferASM ++= bType.info.nestedClasses
       addInnerClassesASM(mirrorClass, innerClassBufferASM.toList)
 
       mirrorClass.visitEnd()
@@ -932,7 +928,7 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
       constructor.visitMaxs(0, 0) // just to follow protocol, dummy arguments
       constructor.visitEnd()
 
-      innerClassBufferASM ++= classBTypeFromSymbol(cls).info.memberClasses
+      innerClassBufferASM ++= classBTypeFromSymbol(cls).info.nestedClasses
       addInnerClassesASM(beanInfoClass, innerClassBufferASM.toList)
 
       beanInfoClass.visitEnd()

src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala

@@ -271,7 +271,7 @@ abstract class BCodeIdiomatic extends SubComponent {
       assert(from != BOOL && to != BOOL, s"inconvertible types : $from -> $to")
 
       // We're done with BOOL already
-      from match {
+      (from: @unchecked) match {
 
         // using `asm.Type.SHORT` instead of `BType.SHORT` because otherwise "warning: could not emit switch for @switch annotated match"
 
@@ -361,7 +361,7 @@ abstract class BCodeIdiomatic extends SubComponent {
           assert(elem.isNonVoidPrimitiveType)
           val rand = {
             // using `asm.Type.SHORT` instead of `BType.SHORT` because otherwise "warning: could not emit switch for @switch annotated match"
-            elem match {
+            (elem: @unchecked) match {
               case BOOL   => Opcodes.T_BOOLEAN
               case BYTE   => Opcodes.T_BYTE
               case SHORT  => Opcodes.T_SHORT

src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala

@@ -118,7 +118,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers {
 
       addClassFields()
 
-      innerClassBufferASM ++= classBTypeFromSymbol(claszSymbol).info.memberClasses
+      innerClassBufferASM ++= classBTypeFromSymbol(claszSymbol).info.nestedClasses
       gen(cd.impl)
       addInnerClassesASM(cnode, innerClassBufferASM.toList)