Reuse the buffer for classfile reading

Classfile parsing does re-enter when we're reading package objects
or classfiles for things like `scala/native.class`.

But for the most part the prior refactorings mean that we typically
only parse a single classfile at a time, and as such we can profit
from a one-element cache for the buffer to read this into.

Author: retronym

src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala

@@ -13,12 +13,12 @@
 package scala.tools.nsc
 package symtab
 
-import classfile.ClassfileParser
+import classfile.{ClassfileParser, ReusableDataReader}
 import java.io.IOException
 import scala.reflect.internal.MissingRequirementError
 import scala.reflect.io.{AbstractFile, NoAbstractFile}
 import scala.tools.nsc.util.{ClassPath, ClassRepresentation}
-import scala.reflect.internal.util.StatisticsStatics
+import scala.reflect.internal.util.{ReusableInstance, StatisticsStatics}
 
 /** This class ...
  *
@@ -294,11 +294,11 @@ abstract class SymbolLoaders {
       }
     }
   }
-
+  private val classFileDataReader: ReusableInstance[ReusableDataReader] = new ReusableInstance[ReusableDataReader](() => new ReusableDataReader())
   class ClassfileLoader(val classfile: AbstractFile, clazz: ClassSymbol, module: ModuleSymbol) extends SymbolLoader with FlagAssigningCompleter {
     private object classfileParser extends {
       val symbolTable: SymbolLoaders.this.symbolTable.type = SymbolLoaders.this.symbolTable
-    } with ClassfileParser {
+    } with ClassfileParser(classFileDataReader) {
       override protected def lookupMemberAtTyperPhaseIfPossible(sym: Symbol, name: Name): Symbol =
         SymbolLoaders.this.lookupMemberAtTyperPhaseIfPossible(sym, name)
       /*

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

@@ -24,6 +24,7 @@ import scala.collection.mutable.{ArrayBuffer, ListBuffer}
 import scala.annotation.switch
 import scala.reflect.internal.JavaAccFlags
 import scala.reflect.internal.pickling.ByteCodecs
+import scala.reflect.internal.util.ReusableInstance
 import scala.reflect.io.{NoAbstractFile, VirtualFile}
 import scala.tools.nsc.util.ClassPath
 import scala.tools.nsc.io.AbstractFile
@@ -34,7 +35,7 @@ import scala.util.control.NonFatal
  *  @author Martin Odersky
  *  @version 1.0
  */
-abstract class ClassfileParser {
+abstract class ClassfileParser(reader: ReusableInstance[ReusableDataReader]) {
   val symbolTable: SymbolTable {
     def settings: Settings
   }
@@ -143,14 +144,18 @@ abstract class ClassfileParser {
   def parse(file: AbstractFile, clazz: ClassSymbol, module: ModuleSymbol): Unit = {
     this.file = file
     pushBusy(clazz) {
-      this.in           = new ByteBufferDataReader(file.toByteBuffer)
-      this.clazz        = clazz
-      this.staticModule = module
-      this.isScala      = false
-
-      parseHeader()
-      this.pool = new ConstantPool
-      parseClass()
+      reader.using { reader =>
+        this.in           = reader.reset(file)
+        this.clazz        = clazz
+        this.staticModule = module
+        this.isScala      = false
+
+        parseHeader()
+        this.pool = new ConstantPool
+        parseClass()
+        pool = null
+        in = null
+      }
     }
   }
 
@@ -482,11 +487,6 @@ abstract class ClassfileParser {
       n == "scala.runtime.Nothing$" || n == "scala.runtime.Null$"
     }
 
-    def release(): Unit = {
-      pool = null
-      in = null
-    }
-
     if (isScala) {
       () // We're done
     } else if (isScalaRaw && !isNothingOrNull) {
@@ -547,7 +547,6 @@ abstract class ClassfileParser {
       // We would also need to make sure that clazzTParams is populated before member type completers called sig2type.
       clazz.initialize
     }
-    release()
   }
 
   /** Add type parameters of enclosing classes */

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

@@ -0,0 +1,149 @@
+/*
+ * Scala (https://www.scala-lang.org)
+ *
+ * Copyright EPFL and Lightbend, Inc.
+ *
+ * Licensed under Apache License 2.0
+ * (http://www.apache.org/licenses/LICENSE-2.0).
+ *
+ * See the NOTICE file distributed with this work for
+ * additional information regarding copyright ownership.
+ */
+
+package scala.tools.nsc.symtab.classfile
+
+import java.io.{ByteArrayInputStream, DataInputStream, InputStream}
+import java.nio.channels.Channels
+import java.nio.{BufferUnderflowException, ByteBuffer}
+
+final class ReusableDataReader() extends DataReader {
+  private[this] var data = new Array[Byte](32768)
+  private[this] var bb: ByteBuffer = ByteBuffer.wrap(data)
+  private[this] var size = 0
+  private[this] val reader: DataInputStream = {
+    val stream = new InputStream {
+      override def read(): Int = try {
+        bb.get & 0xff
+      } catch {
+        case _: BufferUnderflowException => -1
+      }
+      override def markSupported(): Boolean = false
+    }
+    new DataInputStream(stream)
+  }
+
+  private def nextPositivePowerOfTwo(target: Int): Int = 1 << -Integer.numberOfLeadingZeros(target - 1)
+
+  def reset(file: scala.reflect.io.AbstractFile): this.type = {
+    this.size = 0
+    file.sizeOption match {
+      case Some(size) =>
+        if (size > data.length) {
+          data = new Array[Byte](nextPositivePowerOfTwo(size))
+        } else {
+          java.util.Arrays.fill(data, 0.toByte)
+        }
+        val input = file.input
+        try {
+          var endOfInput = false
+          while (!endOfInput) {
+            val remaining = data.length - this.size
+            if (remaining == 0) endOfInput = true
+            else {
+              val read = input.read(data, this.size, remaining)
+              if (read < 0) endOfInput = true
+              else this.size += read
+            }
+          }
+          bb = ByteBuffer.wrap(data, 0, size)
+        } finally {
+          input.close()
+        }
+      case None =>
+        val input = file.input
+        try {
+          var endOfInput = false
+          while (!endOfInput) {
+            val remaining = data.length - size
+            if (remaining == 0) {
+              data = java.util.Arrays.copyOf(data, nextPositivePowerOfTwo(size))
+            }
+            val read = input.read(data, this.size, data.length - this.size)
+            if (read < 0) endOfInput = true
+            else this.size += read
+          }
+          bb = ByteBuffer.wrap(data, 0, size)
+        } finally {
+          input.close()
+        }
+    }
+    this
+  }
+
+  @throws(classOf[IndexOutOfBoundsException])
+  def nextByte: Byte = bb.get
+
+  def nextBytes(len: Int): Array[Byte] = {
+    val result = new Array[Byte](len)
+    reader.readFully(result)
+    result
+  }
+
+  def nextChar: Char = bb.getChar()
+
+  def nextInt: Int = bb.getInt()
+
+  def getChar(mybp: Int): Char = {
+    bb.getChar(mybp)
+  }
+
+  def getInt(mybp: Int): Int = {
+    bb.getInt(mybp)
+  }
+
+  def getLong(mybp: Int): Long = {
+    bb.getLong(mybp)
+  }
+
+  def getFloat(mybp: Int): Float = {
+    bb.getFloat(mybp)
+  }
+
+  def getDouble(mybp: Int): Double = {
+    bb.getDouble(mybp)
+  }
+
+  def skip(n: Int): Unit = {
+    bb.position(bb.position() + n)
+  }
+  def bp: Int = bb.position()
+  def bp_=(i: Int): Unit = {
+    try {
+      bb.position(i)
+    } catch {
+      case ex: IllegalArgumentException =>
+        throw ex
+    }
+  }
+
+  def getByte(mybp: Int): Byte = {
+    bb.get(mybp)
+  }
+  def getBytes(mybp: Int, bytes: Array[Byte]): Unit = {
+    val saved = bb.position()
+    bb.position(mybp)
+    try reader.readFully(bytes)
+    finally bb.position(saved)
+  }
+  def getUTF(mybp: Int, len: Int): String = {
+    val saved = bb.position()
+    val savedLimit = bb.limit()
+    bb.position(mybp)
+    bb.limit(mybp + len)
+    try reader.readUTF()
+    finally {
+      bb.limit(savedLimit)
+      bb.position(saved)
+    }
+  }
+}

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

@@ -24,7 +24,7 @@ import scala.collection.mutable.ListBuffer
 import util.{ Statistics, shortClassOfInstance, StatisticsStatics }
 import Flags._
 import scala.annotation.tailrec
-import scala.reflect.io.{ AbstractFile, NoAbstractFile }
+import scala.reflect.io.{AbstractFile, NoAbstractFile}
 import Variance._
 
 trait Symbols extends api.Symbols { self: SymbolTable =>