Eagerly read from the constant pool as a basis for lazy types java class/method

I've used lazy types for field/method/class infos, which is analagous to what we
do in `Unpickler` for scala originated types.  We read all data needed by the
inner class table and the type completers from the pool eagerly, but still be
lazy about interning strings to Names and completion of the field/method
types themselves.

This fixes some long standing spurious cyclic errors:

Manually tested with:

```
$ scalac -cp $(coursier fetch -q -p com.datastax.cassandra:dse-driver:1.0.0) test.scala
test.scala:2: error: illegal cyclic reference involving class Cluster
	new com.datastax.driver.dse.DseCluster.Builder()
                                               ^
one error found

$ /code/scala/build/quick/bin/scalac -cp $(coursier fetch -q -p com.datastax.cassandra:dse-driver:1.0.0) test.scala

$ cat test.scala
class Test {
	new com.datastax.driver.dse.DseCluster.Builder()
}
```

```
class Test {
  new com.datastax.driver.dse.DseCluster.Builder()
}
```

It subsumes `-Ybreak-cycles`. I was to compile `pos/cycle{-jsoup,}` without the experimental
`-Ybreak-cycles`. I've removed the entire `-Ybreak-cycles` option and supporting code.

It also subsumes the existing implementation related to cycle avoidance
(`queueLoad` / `raiseLoaderLevel`.)

Descriptor, signature, constant, and param names are made available to the field/method lazy
completer which can use them if and when the symbol is completed.

After classfile parsing the constant pool is discarded (some entries are of course captured by
the lazy type completers.)

Fixes scala/bug#3809

Author: retronym

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

@@ -14,8 +14,10 @@ package scala.tools.nsc
 package symtab
 package classfile
 
-import java.lang.Float.intBitsToFloat
+import java.io.{ByteArrayInputStream, DataInputStream}
 import java.lang.Double.longBitsToDouble
+import java.lang.Float.intBitsToFloat
+import java.util
 
 import scala.tools.nsc.io.AbstractFile
 
@@ -25,11 +27,13 @@ import scala.tools.nsc.io.AbstractFile
  * @author Philippe Altherr
  * @version 1.0, 23/03/2004
  */
-class AbstractFileReader(val file: AbstractFile) {
+final class AbstractFileReader(buf0: Array[Byte]) extends DataReader {
+  private[this] var buf = buf0
 
-  /** the buffer containing the file
-   */
-  val buf: Array[Byte] = file.toByteArray
+  @deprecated("Use other constructor", "2.13.0")
+  def this(file: AbstractFile) {
+    this(file.toByteArray)
+  }
 
   /** the current input pointer
    */
@@ -62,17 +66,25 @@ class AbstractFileReader(val file: AbstractFile) {
     ((nextByte & 0xff) << 24) + ((nextByte & 0xff) << 16) +
     ((nextByte & 0xff) <<  8) +  (nextByte & 0xff)
 
+  /** extract a byte at position bp from buf
+   */
+  def getByte(mybp: Int): Byte =
+    buf(mybp)
+
+  def getBytes(mybp: Int, bytes: Array[Byte]): Unit = {
+    System.arraycopy(buf, mybp, bytes, 0, bytes.length)
+  }
 
   /** extract a character at position bp from buf
    */
   def getChar(mybp: Int): Char =
-    (((buf(mybp) & 0xff) << 8) + (buf(mybp+1) & 0xff)).toChar
+    (((getByte(mybp) & 0xff) << 8) + (getByte(mybp+1) & 0xff)).toChar
 
   /** extract an integer at position bp from buf
    */
   def getInt(mybp: Int): Int =
-    ((buf(mybp  ) & 0xff) << 24) + ((buf(mybp+1) & 0xff) << 16) +
-    ((buf(mybp+2) & 0xff) << 8) + (buf(mybp+3) & 0xff)
+    ((getByte(mybp) & 0xff) << 24) + ((getByte(mybp + 1) & 0xff) << 16) +
+    ((getByte(mybp + 2) & 0xff) << 8) + (getByte(mybp + 3) & 0xff)
 
   /** extract a long integer at position bp from buf
    */
@@ -87,8 +99,11 @@ class AbstractFileReader(val file: AbstractFile) {
    */
   def getDouble(mybp: Int): Double = longBitsToDouble(getLong(mybp))
 
+  def getUTF(mybp: Int, len: Int): String = {
+    new DataInputStream(new ByteArrayInputStream(buf, mybp, len)).readUTF
+  }
+
   /** skip next 'n' bytes
    */
   def skip(n: Int): Unit = { bp += n }
-
 }

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

@@ -0,0 +1,89 @@
+/*
+ * 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.{DataInputStream, InputStream}
+import java.nio.{BufferUnderflowException, ByteBuffer}
+
+
+final class ByteBufferDataReader(data0: ByteBuffer) extends DataReader {
+  private[this] var data = data0
+  private[this] val stream = new InputStream {
+    override def read(): Int = try {
+      data.get & 0xff
+    } catch {
+      case _: BufferUnderflowException => -1
+    }
+    override def markSupported(): Boolean = false
+  }
+  private[this] val reader = new DataInputStream(stream)
+  @throws(classOf[IndexOutOfBoundsException])
+  def nextByte: Byte = data.get
+
+  def nextBytes(len: Int): Array[Byte] = {
+    val result = new Array[Byte](len)
+    reader.readFully(result)
+    result
+  }
+
+  def nextChar: Char = data.getChar()
+
+  def nextInt: Int = data.getInt()
+
+  def getChar(mybp: Int): Char = {
+    data.getChar(mybp)
+  }
+
+  def getInt(mybp: Int): Int = {
+    data.getInt(mybp)
+  }
+
+  def getLong(mybp: Int): Long = {
+    data.getLong(mybp)
+  }
+
+  def getFloat(mybp: Int): Float = {
+    data.getFloat(mybp)
+  }
+
+  def getDouble(mybp: Int): Double = {
+    data.getDouble(mybp)
+  }
+
+  def skip(n: Int): Unit = {
+    data.position(data.position() + n)
+  }
+  def bp: Int = data.position()
+  def bp_=(i: Int): Unit = data.position(i)
+
+  def getByte(mybp: Int): Byte = {
+    data.get(mybp)
+  }
+  def getBytes(mybp: Int, bytes: Array[Byte]): Unit = {
+    val saved = data.position
+    data.position(mybp)
+    try reader.readFully(bytes)
+    finally data.position(saved)
+  }
+  def getUTF(mybp: Int, len: Int): String = {
+    val saved = data.position
+    val savedLimit = data.limit()
+    data.position(mybp)
+    data.limit(mybp + len)
+    try reader.readUTF()
+    finally {
+      data.limit(savedLimit)
+      data.position(saved)
+    }
+  }
+}