Detach the constant pool from the full byte array of the class

This is in preparation for using lazy types for Java method
types. Those lazy types need to capture the constant pool,
so we don't want to retain the entire classfile contents.

Author: retronym

src/compiler/scala/tools/nsc/symtab/classfile/AbstractFileReader.scala

@@ -11,6 +11,7 @@ package classfile
 import java.lang.Float.intBitsToFloat
 import java.lang.Double.longBitsToDouble
 
+import scala.reflect.io.NoAbstractFile
 import scala.tools.nsc.io.AbstractFile
 
 /**
@@ -19,11 +20,13 @@ import scala.tools.nsc.io.AbstractFile
  * @author Philippe Altherr
  * @version 1.0, 23/03/2004
  */
-class AbstractFileReader(val file: AbstractFile) {
-
-  /** the buffer containing the file
-   */
-  val buf: Array[Byte] = file.toByteArray
+class AbstractFileReader(val buf: Array[Byte], val file: AbstractFile) {
+  def this(file: AbstractFile) {
+    this(file.toByteArray, file)
+  }
+  def this(buf: Array[Byte]) {
+    this(buf, NoAbstractFile)
+  }
 
   /** the current input pointer
    */

src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala

@@ -16,7 +16,7 @@ import scala.collection.mutable.{ArrayBuffer, ListBuffer}
 import scala.annotation.switch
 import scala.reflect.internal.JavaAccFlags
 import scala.reflect.internal.pickling.{ByteCodecs, PickleBuffer}
-import scala.reflect.io.NoAbstractFile
+import scala.reflect.io.{NoAbstractFile, VirtualFile}
 import scala.reflect.internal.util.Collections._
 import scala.tools.nsc.util.ClassPath
 import scala.tools.nsc.io.AbstractFile
@@ -171,6 +171,8 @@ abstract class ClassfileParser {
     protected val values       = new Array[AnyRef](len)
     protected val internalized = new Array[NameOrString](len)
 
+    private val initBp = in.bp
+
     { var i = 1
       while (i < starts.length) {
         starts(i) = in.bp
@@ -187,6 +189,7 @@ abstract class ClassfileParser {
         }
       }
     }
+    private val in1: AbstractFileReader = new AbstractFileReader(java.util.Arrays.copyOfRange(in.buf, initBp, in.bp))
 
     def recordAtIndex[T <: AnyRef](value: T, idx: Int): T = {
       values(idx) = value
@@ -195,12 +198,12 @@ abstract class ClassfileParser {
 
     def firstExpecting(index: Int, expected: Int): Int = {
       val start = starts(index)
-      val first = in.buf(start).toInt
+      val first = in1.buf(start - initBp).toInt
       if (first == expected) start + 1
       else this errorBadTag start
     }
 
-    class NameOrString(val value: String) {
+    class NameOrString(val value: String) { // TODO encode this as Name | String
       private var _name: Name = null
       def name: Name = {
         if (_name eq null) _name = TermName(value)
@@ -214,8 +217,8 @@ abstract class ClassfileParser {
         case name: NameOrString => name
         case _          =>
           val start = firstExpecting(index, CONSTANT_UTF8)
-          val len   = in.getChar(start).toInt
-          recordAtIndex(new NameOrString(fromMUTF8(in.buf, start, len + 2)), index)
+          val len   = in1.getChar(start - initBp).toInt
+          recordAtIndex(new NameOrString(fromMUTF8(in1.buf, start - initBp, len + 2)), index)
       }
     )
 
@@ -251,7 +254,7 @@ abstract class ClassfileParser {
      */
     def getClassName(index: Int): NameOrString = {
       val start = firstExpecting(index, CONSTANT_CLASS)
-      getExternalName((in getChar start).toInt)
+      getExternalName((in1.getChar(start - initBp)).toInt)
     }
 
     /** Return a name and a type at the given index. If the type is a method
@@ -266,10 +269,10 @@ abstract class ClassfileParser {
         case p: ((Name @unchecked, Type @unchecked)) => p
         case _                                       =>
           val start = firstExpecting(index, CONSTANT_NAMEANDTYPE)
-          val name = getName(in.getChar(start).toInt)
+          val name = getName(in1.getChar(start - initBp).toInt)
           // create a dummy symbol for method types
           val dummy = ownerTpe.typeSymbol.newMethod(name.name.toTermName, ownerTpe.typeSymbol.pos)
-          val tpe   = getType(dummy, in.getChar(start + 2).toInt)
+          val tpe   = getType(dummy, in1.getChar(start + 2 - initBp).toInt)
           // fix the return type, which is blindly set to the class currently parsed
           val restpe = tpe match {
             case MethodType(formals, _) if name == nme.CONSTRUCTOR => MethodType(formals, ownerTpe)
@@ -303,12 +306,12 @@ abstract class ClassfileParser {
 
     private def createConstant(index: Int): Constant = {
       val start = starts(index)
-      Constant((in.buf(start).toInt: @switch) match {
-        case CONSTANT_STRING  => getName(in.getChar(start + 1).toInt).value
-        case CONSTANT_INTEGER => in.getInt(start + 1)
-        case CONSTANT_FLOAT   => in.getFloat(start + 1)
-        case CONSTANT_LONG    => in.getLong(start + 1)
-        case CONSTANT_DOUBLE  => in.getDouble(start + 1)
+      Constant((in1.buf(start - initBp).toInt: @switch) match {
+        case CONSTANT_STRING  => getName(in1.getChar(start + 1 - initBp).toInt).value
+        case CONSTANT_INTEGER => in1.getInt(start + 1 - initBp)
+        case CONSTANT_FLOAT   => in1.getFloat(start + 1 - initBp)
+        case CONSTANT_LONG    => in1.getLong(start + 1 - initBp)
+        case CONSTANT_DOUBLE  => in1.getDouble(start + 1 - initBp)
         case CONSTANT_CLASS   => getClassOrArrayType(index).typeSymbol.tpe_* // !!! Is this necessary or desirable?
         case _                => errorBadTag(start)
       })