Brought some structure to the classfileparser.

I run out of ways to describe this sort of work: removes
code which does too much, too verbosely and too explicitly,
using too much indirection and too much duplication. Replace
it with code which offers less of these things.

3 files changed, 356 insertions, 366 deletions

diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala
index 1e0e0797da..f8f6d1827e 100644
--- a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala
+++ b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala
@@ -12,9 +12,11 @@ import java.lang.Integer.toHexString
 import scala.collection.{ mutable, immutable }
 import scala.collection.mutable.{ ListBuffer, ArrayBuffer }
 import scala.annotation.switch
+import scala.reflect.internal.{ JavaAccFlags }
 import scala.reflect.internal.pickling.{PickleBuffer, ByteCodecs}
 import scala.tools.nsc.io.AbstractFile
 
+
 /** This abstract class implements a class file parser.
  *
  *  @author Martin Odersky
@@ -41,11 +43,31 @@ abstract class ClassfileParser {
   protected var classTParams = Map[Name,Symbol]()
   protected var srcfile0 : Option[AbstractFile] = None
   protected def moduleClass: Symbol = staticModule.moduleClass
+  private var sawPrivateConstructor = false
+
+  private def ownerForFlags(jflags: JavaAccFlags) = if (jflags.isStatic) moduleClass else clazz
 
   def srcfile = srcfile0
 
+  private def optimized         = global.settings.optimise.value
   private def currentIsTopLevel = !(currentClass.decodedName containsChar '$')
 
+  // u1, u2, and u4 are what these data types are called in the JVM spec.
+  // They are an unsigned byte, unsigned char, and unsigned int respectively.
+  // We bitmask u1 into an Int to make sure it's 0-255 (and u1 isn't used
+  // for much beyond tags) but leave u2 alone as it's already unsigned.
+  protected final def u1 = in.nextByte & 0xFF
+  protected final def u2 = in.nextChar
+  protected final def u4 = in.nextInt
+
+  private def readInnerClassFlags() = readClassFlags()
+  private def readClassFlags()      = JavaAccFlags classFlags u2
+  private def readMethodFlags()     = JavaAccFlags methodFlags u2
+  private def readFieldFlags()      = JavaAccFlags fieldFlags u2
+  private def readTypeName()        = readName().toTypeName
+  private def readName()            = pool getName u2
+  private def readType()            = pool getType u2
+
   private object unpickler extends scala.reflect.internal.pickling.UnPickler {
     val global: ClassfileParser.this.global.type = ClassfileParser.this.global
   }
@@ -107,60 +129,60 @@ abstract class ClassfileParser {
   }
 
   private def parseHeader() {
-    val magic = in.nextInt
+    val magic = u4
     if (magic != JAVA_MAGIC)
       abort(s"class file ${in.file} has wrong magic number 0x${toHexString(magic)}")
 
-    val minor, major = in.nextChar.toInt
+    val minor, major = u2
     if (major < JAVA_MAJOR_VERSION || major == JAVA_MAJOR_VERSION && minor < JAVA_MINOR_VERSION)
       abort(s"class file ${in.file} has unknown version $major.$minor, should be at least $JAVA_MAJOR_VERSION.$JAVA_MINOR_VERSION")
   }
 
   class ConstantPool {
-    private val len = in.nextChar
-    private val starts = new Array[Int](len)
-    private val values = new Array[AnyRef](len)
+    private val len          = u2
+    private val starts       = new Array[Int](len)
+    private val values       = new Array[AnyRef](len)
     private val internalized = new Array[Name](len)
 
     { var i = 1
       while (i < starts.length) {
         starts(i) = in.bp
         i += 1
-        (in.nextByte.toInt: @switch) match {
-          case CONSTANT_UTF8 | CONSTANT_UNICODE =>
-            in.skip(in.nextChar)
-          case CONSTANT_CLASS | CONSTANT_STRING | CONSTANT_METHODTYPE=>
-            in.skip(2)
-          case CONSTANT_METHODHANDLE =>
-            in.skip(3)
-          case CONSTANT_FIELDREF | CONSTANT_METHODREF | CONSTANT_INTFMETHODREF
-             | CONSTANT_NAMEANDTYPE | CONSTANT_INTEGER | CONSTANT_FLOAT
-             | CONSTANT_INVOKEDYNAMIC =>
-            in.skip(4)
-          case CONSTANT_LONG | CONSTANT_DOUBLE =>
-            in.skip(8)
-            i += 1
-          case _ =>
-            errorBadTag(in.bp - 1)
+        (u1.toInt: @switch) match {
+          case CONSTANT_UTF8 | CONSTANT_UNICODE                                => in skip u2
+          case CONSTANT_CLASS | CONSTANT_STRING | CONSTANT_METHODTYPE          => in skip 2
+          case CONSTANT_METHODHANDLE                                           => in skip 3
+          case CONSTANT_FIELDREF | CONSTANT_METHODREF | CONSTANT_INTFMETHODREF => in skip 4
+          case CONSTANT_NAMEANDTYPE | CONSTANT_INTEGER | CONSTANT_FLOAT        => in skip 4
+          case CONSTANT_INVOKEDYNAMIC                                          => in skip 4
+          case CONSTANT_LONG | CONSTANT_DOUBLE                                 => in skip 8 ; i += 1
+          case _                                                               => errorBadTag(in.bp - 1)
         }
       }
     }
 
-    /** Return the name found at given index. */
-    def getName(index: Int): Name = {
-      if (index <= 0 || len <= index)
-        errorBadIndex(index)
+    def recordAtIndex[T <: AnyRef](value: T, idx: Int): T = {
+      values(idx) = value
+      value
+    }
 
-      values(index) match {
+    def firstExpecting(index: Int, expected: Int): Int = {
+      val start = starts(index)
+      val first = in.buf(start).toInt
+      if (first == expected) start + 1
+      else this errorBadTag start
+    }
+
+    /** Return the name found at given index. */
+    def getName(index: Int): Name = (
+      if (index <= 0 || len <= index) errorBadIndex(index)
+      else values(index) match {
         case name: Name => name
-        case null   =>
-          val start = starts(index)
-          if (in.buf(start).toInt != CONSTANT_UTF8) errorBadTag(start)
-          val name = newTermName(in.buf, start + 3, in.getChar(start + 1))
-          values(index) = name
-          name
+        case _          =>
+          val start = firstExpecting(index, CONSTANT_UTF8)
+          recordAtIndex(newTermName(in.buf, start + 2, in.getChar(start)), index)
       }
-    }
+    )
 
     /** Return the name found at given index in the constant pool, with '/' replaced by '.'. */
     def getExternalName(index: Int): Name = {
@@ -175,28 +197,23 @@ abstract class ClassfileParser {
 
     def getClassSymbol(index: Int): Symbol = {
       if (index <= 0 || len <= index) errorBadIndex(index)
-      var c = values(index).asInstanceOf[Symbol]
-      if (c eq null) {
-        val start = starts(index)
-        if (in.buf(start).toInt != CONSTANT_CLASS) errorBadTag(start)
-        val name = getExternalName(in.getChar(start + 1))
-        if (nme.isModuleName(name))
-          c = rootMirror.getModuleByName(name.dropModule)
-        else
-          c = classNameToSymbol(name)
-
-        values(index) = c
+      values(index) match {
+        case sym: Symbol => sym
+        case _           =>
+          val result = getClassName(index) match {
+            case name if nme.isModuleName(name) => rootMirror getModuleByName name.dropModule
+            case name                           => classNameToSymbol(name)
+          }
+          recordAtIndex(result, index)
       }
-      c
     }
 
     /** Return the external name of the class info structure found at 'index'.
      *  Use 'getClassSymbol' if the class is sure to be a top-level class.
      */
     def getClassName(index: Int): Name = {
-      val start = starts(index)
-      if (in.buf(start).toInt != CONSTANT_CLASS) errorBadTag(start)
-      getExternalName(in.getChar(start + 1))
+      val start = firstExpecting(index, CONSTANT_CLASS)
+      getExternalName(in getChar start)
     }
 
     /** Return the symbol of the class member at `index`.
@@ -272,94 +289,66 @@ abstract class ClassfileParser {
      */
     private def getNameAndType(index: Int, ownerTpe: Type): (Name, Type) = {
       if (index <= 0 || len <= index) errorBadIndex(index)
-      var p = values(index).asInstanceOf[(Name, Type)]
-      if (p eq null) {
-        val start = starts(index)
-        if (in.buf(start).toInt != CONSTANT_NAMEANDTYPE) errorBadTag(start)
-        val name = getName(in.getChar(start + 1).toInt)
-        // create a dummy symbol for method types
-        val dummySym = ownerTpe.typeSymbol.newMethod(name.toTermName, ownerTpe.typeSymbol.pos)
-        var tpe  = getType(dummySym, in.getChar(start + 3).toInt)
-
-        // fix the return type, which is blindly set to the class currently parsed
-        if (name == nme.CONSTRUCTOR)
-          tpe match {
-            case MethodType(formals, restpe) =>
-              tpe = MethodType(formals, ownerTpe)
+      (values(index): @unchecked) match {
+        case p: ((Name, Type)) => p
+        case _                 =>
+          val start = firstExpecting(index, CONSTANT_NAMEANDTYPE)
+          val name = getName(in.getChar(start).toInt)
+          // create a dummy symbol for method types
+          val dummy = ownerTpe.typeSymbol.newMethod(name.toTermName, ownerTpe.typeSymbol.pos)
+          val tpe   = getType(dummy, in.getChar(start + 2).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)
+            case _                                                 => tpe
           }
-
-        p = (name, tpe)
+          ((name, restpe))
       }
-      p
     }
 
     /** Return the type of a class constant entry. Since
      *  arrays are considered to be class types, they might
      *  appear as entries in 'newarray' or 'cast' opcodes.
      */
-    def getClassOrArrayType(index: Int): Type = {
+    def getClassOrArrayType(index: Int): Type = (
       if (index <= 0 || len <= index) errorBadIndex(index)
-      val value = values(index)
-      var c: Type = null
-      if (value eq null) {
-        val start = starts(index)
-        if (in.buf(start).toInt != CONSTANT_CLASS) errorBadTag(start)
-        val name = getExternalName(in.getChar(start + 1))
-        if (name.charAt(0) == ARRAY_TAG) {
-          c = sigToType(null, name)
-          values(index) = c
-        } else {
-          val sym = classNameToSymbol(name)
-                  /*if (name.endsWith("$")) definitions.getModule(name.subName(0, name.length - 1))
-                    else if (name.endsWith("$class")) definitions.getModule(name)
-                    else definitions.getClass(name)*/
-          values(index) = sym
-          c = sym.tpe
-        }
-      } else c = value match {
-          case tp: Type => tp
-          case cls: Symbol => cls.tpe
+      else values(index) match {
+        case tp: Type    => tp
+        case cls: Symbol => cls.tpe_*
+        case _           =>
+          val name = getClassName(index)
+          name charAt 0 match {
+            case ARRAY_TAG => recordAtIndex(sigToType(null, name), index)
+            case _         => recordAtIndex(classNameToSymbol(name), index).tpe_*
+          }
       }
-      c
-    }
-
-    def getType(index: Int): Type = getType(null, index)
-
-    def getType(sym: Symbol, index: Int): Type =
-      sigToType(sym, getExternalName(index))
+    )
 
-    def getSuperClass(index: Int): Symbol =
-      if (index == 0) definitions.AnyClass else getClassSymbol(index)
+    def getType(index: Int): Type              = getType(null, index)
+    def getType(sym: Symbol, index: Int): Type = sigToType(sym, getExternalName(index))
+    def getSuperClass(index: Int): Symbol      = if (index == 0) AnyClass else getClassSymbol(index)
 
-    def getConstant(index: Int): Constant = {
+    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).toString
+        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)
+        case CONSTANT_CLASS   => getClassOrArrayType(index).typeSymbol.tpe_* // !!! Is this necessary or desirable?
+        case _                => errorBadTag(start)
+      })
+    }
+    def getConstant(index: Int): Constant = (
       if (index <= 0 || len <= index) errorBadIndex(index)
-      var value = values(index)
-      if (value eq null) {
-        val start = starts(index)
-        value = (in.buf(start).toInt: @switch) match {
-          case CONSTANT_STRING =>
-            Constant(getName(in.getChar(start + 1).toInt).toString)
-          case CONSTANT_INTEGER =>
-            Constant(in.getInt(start + 1))
-          case CONSTANT_FLOAT =>
-            Constant(in.getFloat(start + 1))
-          case CONSTANT_LONG =>
-            Constant(in.getLong(start + 1))
-          case CONSTANT_DOUBLE =>
-            Constant(in.getDouble(start + 1))
-          case CONSTANT_CLASS =>
-            getClassOrArrayType(index).typeSymbol
-          case _ =>
-            errorBadTag(start)
-        }
-        values(index) = value
+      else values(index) match {
+        case  const: Constant => const
+        case sym: Symbol      => Constant(sym.tpe_*)
+        case tpe: Type        => Constant(tpe)
+        case _                => recordAtIndex(createConstant(index), index)
       }
-      value match {
-        case  ct: Constant => ct
-        case cls: Symbol   => Constant(cls.tpe_*)
-        case arr: Type     => Constant(arr)
-      }
-    }
+    )
 
     private def getSubArray(bytes: Array[Byte]): Array[Byte] = {
       val decodedLength = ByteCodecs.decode(bytes)
@@ -368,46 +357,41 @@ abstract class ClassfileParser {
       arr
     }
 
-    def getBytes(index: Int): Array[Byte] = {
+    def getBytes(index: Int): Array[Byte] = (
       if (index <= 0 || len <= index) errorBadIndex(index)
-      var value = values(index).asInstanceOf[Array[Byte]]
-      if (value eq null) {
-        val start = starts(index)
-        if (in.buf(start).toInt != CONSTANT_UTF8) errorBadTag(start)
-        val len   = in.getChar(start + 1)
-        val bytes = new Array[Byte](len)
-        System.arraycopy(in.buf, start + 3, bytes, 0, len)
-        value = getSubArray(bytes)
-        values(index) = value
+      else values(index) match {
+        case xs: Array[Byte] => xs
+        case _               =>
+          val start = firstExpecting(index, CONSTANT_UTF8)
+          val len   = in getChar start
+          val bytes = new Array[Byte](len)
+          System.arraycopy(in.buf, start + 2, bytes, 0, len)
+          recordAtIndex(getSubArray(bytes), index)
       }
-      value
-    }
+    )
 
     def getBytes(indices: List[Int]): Array[Byte] = {
-      assert(!indices.isEmpty, indices)
-      var value = values(indices.head).asInstanceOf[Array[Byte]]
-      if (value eq null) {
-        val bytesBuffer = ArrayBuffer.empty[Byte]
-        for (index <- indices) {
-          if (index <= 0 || ConstantPool.this.len <= index) errorBadIndex(index)
-          val start = starts(index)
-          if (in.buf(start).toInt != CONSTANT_UTF8) errorBadTag(start)
-          val len = in.getChar(start + 1)
-          bytesBuffer ++= in.buf.view(start + 3, start + 3 + len)
-        }
-        value = getSubArray(bytesBuffer.toArray)
-        values(indices.head) = value
+      val head = indices.head
+      values(head) match {
+        case xs: Array[Byte] => xs
+        case _               =>
+          val arr: Array[Byte] = indices.toArray flatMap { index =>
+            if (index <= 0 || ConstantPool.this.len <= index) errorBadIndex(index)
+            val start = firstExpecting(index, CONSTANT_UTF8)
+            val len   = in getChar start
+            in.buf drop start + 2 take len
+          }
+          recordAtIndex(getSubArray(arr), head)
       }
-      value
     }
 
     /** Throws an exception signaling a bad constant index. */
     private def errorBadIndex(index: Int) =
-      throw new RuntimeException("bad constant pool index: " + index + " at pos: " + in.bp)
+      abort(s"bad constant pool index: $index at pos: ${in.bp}")
 
     /** Throws an exception signaling a bad tag at given address. */
     private def errorBadTag(start: Int) =
-      throw new RuntimeException("bad constant pool tag " + in.buf(start) + " at byte " + start)
+      abort("bad constant pool tag ${in.buf(start)} at byte $start")
   }
 
   /** Try to force the chain of enclosing classes for the given name. Otherwise
@@ -486,30 +470,27 @@ abstract class ClassfileParser {
       catch { case _: FatalError => loadClassSymbol(name) }
   }
 
-  var sawPrivateConstructor = false
-
   def parseClass() {
-    val jflags       = in.nextChar
-    val isAnnotation = hasAnnotation(jflags)
-    val sflags       = toScalaClassFlags(jflags)
-    val nameIdx      = in.nextChar
-    currentClass     = pool.getClassName(nameIdx)
+    val jflags   = readClassFlags()
+    val sflags   = jflags.toScalaFlags
+    val nameIdx  = u2
+    currentClass = pool.getClassName(nameIdx)
 
     /* Parse parents for Java classes. For Scala, return AnyRef, since the real type will be unpickled.
      * Updates the read pointer of 'in'. */
     def parseParents: List[Type] = {
       if (isScala) {
-        in.nextChar              // skip superclass
-        val ifaces = in.nextChar
-        in.bp += ifaces * 2     // .. and iface count interfaces
-        List(definitions.AnyRefClass.tpe) // dummy superclass, will be replaced by pickled information
+        u2                    // skip superclass
+        val ifaces = u2
+        in.bp += ifaces * 2   // .. and iface count interfaces
+        List(AnyRefClass.tpe) // dummy superclass, will be replaced by pickled information
       }
       else raiseLoaderLevel {
-        val superType = if (isAnnotation) { in.nextChar; definitions.AnnotationClass.tpe }
-                        else pool.getSuperClass(in.nextChar).tpe_*
-        val ifaceCount = in.nextChar
-        var ifaces = for (i <- List.range(0, ifaceCount)) yield pool.getSuperClass(in.nextChar).tpe_*
-        if (isAnnotation) ifaces = definitions.ClassfileAnnotationClass.tpe :: ifaces
+        val superType = if (jflags.isAnnotation) { u2; AnnotationClass.tpe }
+                        else pool.getSuperClass(u2).tpe_*
+        val ifaceCount = u2
+        var ifaces = for (i <- List.range(0, ifaceCount)) yield pool.getSuperClass(u2).tpe_*
+        if (jflags.isAnnotation) ifaces ::= ClassfileAnnotationClass.tpe
         superType :: ifaces
       }
     }
@@ -539,21 +520,20 @@ abstract class ClassfileParser {
     skipMembers() // methods
     if (!isScala) {
       clazz setFlag sflags
-      importPrivateWithinFromJavaFlags(clazz, jflags)
-      importPrivateWithinFromJavaFlags(staticModule, jflags)
-      clazz.setInfo(classInfo)
+      propagatePackageBoundary(jflags, clazz, staticModule)
+      clazz setInfo classInfo
       moduleClass setInfo staticInfo
-      staticModule.setInfo(moduleClass.tpe)
-      staticModule.setFlag(JAVA)
-      staticModule.moduleClass.setFlag(JAVA)
+      staticModule setInfo moduleClass.tpe
+      staticModule setFlag JAVA
+      staticModule.moduleClass setFlag JAVA
       // attributes now depend on having infos set already
       parseAttributes(clazz, classInfo)
 
       def queueLoad() {
         in.bp = curbp
-        0 until in.nextChar foreach (_ => parseField())
+        0 until u2 foreach (_ => parseField())
         sawPrivateConstructor = false
-        0 until in.nextChar foreach (_ => parseMethod())
+        0 until u2 foreach (_ => parseMethod())
         val needsConstructor = (
              !sawPrivateConstructor
           && !(instanceScope containsName nme.CONSTRUCTOR)
@@ -589,28 +569,28 @@ abstract class ClassfileParser {
   }
 
   def parseField() {
-    val jflags = in.nextChar
-    val sflags = toScalaFieldFlags(jflags)
-    if ((sflags & PRIVATE) != 0L && !global.settings.optimise) {
+    val jflags = readFieldFlags()
+    val sflags = jflags.toScalaFlags
+
+    if ((sflags & PRIVATE) != 0L && !optimized) {
       in.skip(4); skipAttributes()
     } else {
-      val name    = pool.getName(in.nextChar)
-      val info    = pool.getType(in.nextChar)
-      val sym     = getOwner(jflags).newValue(name.toTermName, NoPosition, sflags)
-      val isEnum  = (jflags & JAVA_ACC_ENUM) != 0
+      val name    = readName()
+      val info    = readType()
+      val sym     = ownerForFlags(jflags).newValue(name.toTermName, NoPosition, sflags)
 
       // Note: the info may be overrwritten later with a generic signature
       // parsed from SignatureATTR
       sym setInfo {
-        if (isEnum) ConstantType(Constant(sym))
+        if (jflags.isEnum) ConstantType(Constant(sym))
         else info
       }
-      importPrivateWithinFromJavaFlags(sym, jflags)
+      propagatePackageBoundary(jflags, sym)
       parseAttributes(sym, info)
-      getScope(jflags).enter(sym)
+      getScope(jflags) enter sym
 
       // sealed java enums
-      if (isEnum) {
+      if (jflags.isEnum) {
         val enumClass = sym.owner.linkedClassOfClass
         if (!enumClass.isSealed)
           enumClass setFlag (SEALED | ABSTRACT)
@@ -621,26 +601,27 @@ abstract class ClassfileParser {
   }
 
   def parseMethod() {
-    val jflags = in.nextChar.toInt
-    val sflags = toScalaMethodFlags(jflags)
-    if (isPrivate(jflags) && !global.settings.optimise) {
-      val name = pool.getName(in.nextChar)
+    val jflags = readMethodFlags()
+    val sflags = jflags.toScalaFlags
+    if (jflags.isPrivate && !optimized) {
+      val name = readName()
       if (name == nme.CONSTRUCTOR)
         sawPrivateConstructor = true
       in.skip(2); skipAttributes()
-    } else {
-      if ((sflags & PRIVATE) != 0L && global.settings.optimise) {
+    }
+    else {
+      if ((sflags & PRIVATE) != 0L && optimized) {
         in.skip(4); skipAttributes()
       } else {
-        val name = pool.getName(in.nextChar)
-        val sym = getOwner(jflags).newMethod(name.toTermName, NoPosition, sflags)
-        var info = pool.getType(sym, (in.nextChar))
+        val name = readName()
+        val sym = ownerForFlags(jflags).newMethod(name.toTermName, NoPosition, sflags)
+        var info = pool.getType(sym, u2)
         if (name == nme.CONSTRUCTOR)
           info match {
             case MethodType(params, restpe) =>
               // if this is a non-static inner class, remove the explicit outer parameter
               val newParams = innerClasses getEntry currentClass match {
-                case Some(entry) if !isScalaRaw && !isStatic(entry.jflags) =>
+                case Some(entry) if !isScalaRaw && !entry.jflags.isStatic =>
                   /* About `clazz.owner.isPackage` below: SI-5957
                    * For every nested java class A$B, there are two symbols in the scala compiler.
                    *  1. created by SymbolLoader, because of the existence of the A$B.class file, owner: package
@@ -657,13 +638,13 @@ abstract class ClassfileParser {
           }
         // Note: the info may be overrwritten later with a generic signature
         // parsed from SignatureATTR
-        sym.setInfo(info)
-        importPrivateWithinFromJavaFlags(sym, jflags)
+        sym setInfo info
+        propagatePackageBoundary(jflags, sym)
         parseAttributes(sym, info)
-        if ((jflags & JAVA_ACC_VARARGS) != 0) {
-          sym.setInfo(arrayToRepeated(sym.info))
-        }
-        getScope(jflags).enter(sym)
+        if (jflags.isVarargs)
+          sym modifyInfo arrayToRepeated
+
+        getScope(jflags) enter sym
       }
     }
   }
@@ -683,15 +664,15 @@ abstract class ClassfileParser {
     def sig2type(tparams: immutable.Map[Name,Symbol], skiptvs: Boolean): Type = {
       val tag = sig.charAt(index); index += 1
       tag match {
-        case BYTE_TAG   => definitions.ByteClass.tpe
-        case CHAR_TAG   => definitions.CharClass.tpe
-        case DOUBLE_TAG => definitions.DoubleClass.tpe
-        case FLOAT_TAG  => definitions.FloatClass.tpe
-        case INT_TAG    => definitions.IntClass.tpe
-        case LONG_TAG   => definitions.LongClass.tpe
-        case SHORT_TAG  => definitions.ShortClass.tpe
-        case VOID_TAG   => definitions.UnitClass.tpe
-        case BOOL_TAG   => definitions.BooleanClass.tpe
+        case BYTE_TAG   => ByteClass.tpe
+        case CHAR_TAG   => CharClass.tpe
+        case DOUBLE_TAG => DoubleClass.tpe
+        case FLOAT_TAG  => FloatClass.tpe
+        case INT_TAG    => IntClass.tpe
+        case LONG_TAG   => LongClass.tpe
+        case SHORT_TAG  => ShortClass.tpe
+        case VOID_TAG   => UnitClass.tpe
+        case BOOL_TAG   => BooleanClass.tpe
         case 'L' =>
           def processInner(tp: Type): Type = tp match {
             case TypeRef(pre, sym, args) if (!sym.isStatic) =>
@@ -716,7 +697,7 @@ abstract class ClassfileParser {
                           val tp = sig2type(tparams, skiptvs)
                           // sig2type seems to return AnyClass regardless of the situation:
                           // we don't want Any as a LOWER bound.
-                          if (tp.typeSymbol == definitions.AnyClass) TypeBounds.empty
+                          if (tp.typeSymbol == AnyClass) TypeBounds.empty
                           else TypeBounds.lower(tp)
                         case '*' => TypeBounds.empty
                       }
@@ -737,7 +718,7 @@ abstract class ClassfileParser {
               // or we'll create a boatload of needless existentials.
               else if (classSym.isMonomorphicType || classSym.unsafeTypeParams.isEmpty) tp
               // raw type - existentially quantify all type parameters
-              else logResult(s"raw type from $classSym")(definitions.unsafeClassExistentialType(classSym))
+              else logResult(s"raw type from $classSym")(unsafeClassExistentialType(classSym))
             case tp =>
               assert(sig.charAt(index) != '<', s"sig=$sig, index=$index, tp=$tp")
               tp
@@ -765,11 +746,11 @@ abstract class ClassfileParser {
           // NOTE that the comparison to Object only works for abstract types bounded by classes that are strict subclasses of Object
           // if the bound is exactly Object, it will have been converted to Any, and the comparison will fail
           // see also RestrictJavaArraysMap (when compiling java sources directly)
-          if (elemtp.typeSymbol.isAbstractType && !(elemtp <:< definitions.ObjectClass.tpe)) {
-            elemtp = intersectionType(List(elemtp, definitions.ObjectClass.tpe))
+          if (elemtp.typeSymbol.isAbstractType && !(elemtp <:< ObjectClass.tpe)) {
+            elemtp = intersectionType(List(elemtp, ObjectClass.tpe))
           }
 
-          definitions.arrayType(elemtp)
+          arrayType(elemtp)
         case '(' =>
           // we need a method symbol. given in line 486 by calling getType(methodSym, ..)
           assert(sym ne null, sig)
@@ -787,7 +768,7 @@ abstract class ClassfileParser {
         case 'T' =>
           val n = subName(';'.==).toTypeName
           index += 1
-          if (skiptvs) definitions.AnyClass.tpe
+          if (skiptvs) AnyClass.tpe
           else tparams(n).typeConstructor
       }
     } // sig2type(tparams, skiptvs)
@@ -840,24 +821,20 @@ abstract class ClassfileParser {
     GenPolyType(ownTypeParams, tpe)
   } // sigToType
 
-  class TypeParamsType(override val typeParams: List[Symbol]) extends LazyType with FlagAgnosticCompleter {
-    override def complete(sym: Symbol) { throw new AssertionError("cyclic type dereferencing") }
-  }
-
   def parseAttributes(sym: Symbol, symtype: Type) {
     def convertTo(c: Constant, pt: Type): Constant = {
-      if (pt.typeSymbol == definitions.BooleanClass && c.tag == IntTag)
+      if (pt.typeSymbol == BooleanClass && c.tag == IntTag)
         Constant(c.value != 0)
       else
         c convertTo pt
     }
     def parseAttribute() {
-      val attrName = pool.getName(in.nextChar).toTypeName
-      val attrLen = in.nextInt
+      val attrName = readTypeName()
+      val attrLen  = u4
       attrName match {
         case tpnme.SignatureATTR =>
           if (!isScala && !isScalaRaw) {
-            val sig = pool.getExternalName(in.nextChar)
+            val sig = pool.getExternalName(u2)
             val newType = sigToType(sym, sig)
             sym.setInfo(newType)
             if (settings.debug && settings.verbose)
@@ -872,10 +849,10 @@ abstract class ClassfileParser {
           in.skip(attrLen)
         case tpnme.DeprecatedATTR =>
           val arg = Literal(Constant("see corresponding Javadoc for more information."))
-          sym.addAnnotation(definitions.DeprecatedAttr, arg, Literal(Constant("")))
+          sym.addAnnotation(DeprecatedAttr, arg, Literal(Constant("")))
           in.skip(attrLen)
         case tpnme.ConstantValueATTR =>
-          val c = pool.getConstant(in.nextChar)
+          val c = pool.getConstant(u2)
           val c1 = convertTo(c, symtype)
           if (c1 ne null) sym.setInfo(ConstantType(c1))
           else println("failure to convert " + c + " to " + symtype); //debug
@@ -889,7 +866,7 @@ abstract class ClassfileParser {
           isScalaRaw = true
          // Attribute on methods of java annotation classes when that method has a default
         case tpnme.AnnotationDefaultATTR =>
-          sym.addAnnotation(definitions.AnnotationDefaultAttr)
+          sym.addAnnotation(AnnotationDefaultAttr)
           in.skip(attrLen)
         // Java annotations on classes / methods / fields with RetentionPolicy.RUNTIME
         case tpnme.RuntimeAnnotationATTR =>
@@ -919,7 +896,7 @@ abstract class ClassfileParser {
           parseExceptions(attrLen)
 
         case tpnme.SourceFileATTR =>
-          val srcfileLeaf = pool.getName(in.nextChar).toString.trim
+          val srcfileLeaf = readName().toString.trim
           val srcpath = sym.enclosingPackage match {
             case NoSymbol => srcfileLeaf
             case rootMirror.EmptyPackage => srcfileLeaf
@@ -932,8 +909,8 @@ abstract class ClassfileParser {
     }
 
     def parseAnnotArg: Option[ClassfileAnnotArg] = {
-      val tag = in.nextByte.toChar
-      val index = in.nextChar
+      val tag = u1
+      val index = u2
       tag match {
         case STRING_TAG =>
           Some(LiteralAnnotArg(Constant(pool.getName(index).toString)))
@@ -944,7 +921,7 @@ abstract class ClassfileParser {
           Some(LiteralAnnotArg(Constant(pool.getType(index))))
         case ENUM_TAG   =>
           val t = pool.getType(index)
-          val n = pool.getName(in.nextChar)
+          val n = readName()
           val s = t.typeSymbol.companionModule.info.decls.lookup(n)
           assert(s != NoSymbol, t)
           Some(LiteralAnnotArg(Constant(s)))
@@ -964,20 +941,20 @@ abstract class ClassfileParser {
     }
 
     def parseScalaSigBytes: Option[ScalaSigBytes] = {
-      val tag = in.nextByte.toChar
+      val tag = u1
       assert(tag == STRING_TAG, tag)
-      Some(ScalaSigBytes(pool getBytes in.nextChar))
+      Some(ScalaSigBytes(pool getBytes u2))
     }
 
     def parseScalaLongSigBytes: Option[ScalaSigBytes] = {
-      val tag = in.nextByte.toChar
+      val tag = u1
       assert(tag == ARRAY_TAG, tag)
-      val stringCount = in.nextChar
+      val stringCount = u2
       val entries =
         for (i <- 0 until stringCount) yield {
-          val stag = in.nextByte.toChar
+          val stag = u1
           assert(stag == STRING_TAG, stag)
-          in.nextChar.toInt
+          u2.toInt
         }
       Some(ScalaSigBytes(pool.getBytes(entries.toList)))
     }
@@ -987,20 +964,20 @@ abstract class ClassfileParser {
      */
     def parseAnnotation(attrNameIndex: Char): Option[AnnotationInfo] = try {
       val attrType = pool.getType(attrNameIndex)
-      val nargs = in.nextChar
+      val nargs = u2
       val nvpairs = new ListBuffer[(Name, ClassfileAnnotArg)]
       var hasError = false
       for (i <- 0 until nargs) {
-        val name = pool.getName(in.nextChar)
+        val name = readName()
         // The "bytes: String" argument of the ScalaSignature attribute is parsed specially so that it is
         // available as an array of bytes (the pickled Scala signature) instead of as a string. The pickled signature
         // is encoded as a string because of limitations in the Java class file format.
-        if ((attrType == definitions.ScalaSignatureAnnotation.tpe) && (name == nme.bytes))
+        if ((attrType == ScalaSignatureAnnotation.tpe) && (name == nme.bytes))
           parseScalaSigBytes match {
             case Some(c) => nvpairs += ((name, c))
             case None => hasError = true
           }
-        else if ((attrType == definitions.ScalaLongSignatureAnnotation.tpe) && (name == nme.bytes))
+        else if ((attrType == ScalaLongSignatureAnnotation.tpe) && (name == nme.bytes))
           parseScalaLongSigBytes match {
             case Some(c) => nvpairs += ((name, c))
             case None => hasError = true
@@ -1033,10 +1010,10 @@ abstract class ClassfileParser {
      * thrown by a method.
      */
     def parseExceptions(len: Int) {
-      val nClasses = in.nextChar
+      val nClasses = u2
       for (n <- 0 until nClasses) {
         // FIXME: this performs an equivalent of getExceptionTypes instead of getGenericExceptionTypes (SI-7065)
-        val cls = pool.getClassSymbol(in.nextChar.toInt)
+        val cls = pool.getClassSymbol(u2)
         // we call initialize due to the fact that we call Symbol.isMonomorphicType in addThrowsAnnotation
         // and that method requires Symbol to be forced to give the right answers, see SI-7107 for details
         cls.initialize
@@ -1047,13 +1024,13 @@ abstract class ClassfileParser {
     /* Parse a sequence of annotations and attaches them to the
      * current symbol sym, except for the ScalaSignature annotation that it returns, if it is available. */
     def parseAnnotations(len: Int): Option[AnnotationInfo] =  {
-      val nAttr = in.nextChar
+      val nAttr = u2
       var scalaSigAnnot: Option[AnnotationInfo] = None
       for (n <- 0 until nAttr)
-        parseAnnotation(in.nextChar) match {
-          case Some(scalaSig) if (scalaSig.atp == definitions.ScalaSignatureAnnotation.tpe) =>
+        parseAnnotation(u2) match {
+          case Some(scalaSig) if (scalaSig.atp == ScalaSignatureAnnotation.tpe) =>
             scalaSigAnnot = Some(scalaSig)
-          case Some(scalaSig) if (scalaSig.atp == definitions.ScalaLongSignatureAnnotation.tpe) =>
+          case Some(scalaSig) if (scalaSig.atp == ScalaLongSignatureAnnotation.tpe) =>
             scalaSigAnnot = Some(scalaSig)
           case Some(annot) =>
             sym.addAnnotation(annot)
@@ -1063,7 +1040,7 @@ abstract class ClassfileParser {
     }
 
     // begin parseAttributes
-    for (i <- 0 until in.nextChar) parseAttribute()
+    for (i <- 0 until u2) parseAttribute()
   }
 
   /** Enter own inner classes in the right scope. It needs the scopes to be set up,
@@ -1073,11 +1050,12 @@ abstract class ClassfileParser {
     def className(name: Name): Name =
       name.subName(name.lastPos('.') + 1, name.length)
 
-    def enterClassAndModule(entry: InnerClassEntry, file: AbstractFile, jflags: Int) {
+    def enterClassAndModule(entry: InnerClassEntry, file: AbstractFile) {
+      def jflags      = entry.jflags
       val completer   = new global.loaders.ClassfileLoader(file)
       val name        = entry.originalName
-      val sflags      = toScalaClassFlags(jflags)
-      val owner       = getOwner(jflags)
+      val sflags      = jflags.toScalaFlags
+      val owner       = ownerForFlags(jflags)
       val scope       = getScope(jflags)
       val innerClass  = owner.newClass(name.toTypeName, NoPosition, sflags) setInfo completer
       val innerModule = owner.newModule(name.toTermName, NoPosition, sflags) setInfo completer
@@ -1106,7 +1084,7 @@ abstract class ClassfileParser {
         val file = global.classPath.findSourceFile(entry.externalName.toString) getOrElse {
           throw new AssertionError(entry.externalName)
         }
-        enterClassAndModule(entry, file, entry.jflags)
+        enterClassAndModule(entry, file)
       }
     }
   }
@@ -1119,10 +1097,10 @@ abstract class ClassfileParser {
     skipSuperclasses()
     skipMembers() // fields
     skipMembers() // methods
-    val attrs = in.nextChar
+    val attrs = u2
     for (i <- 0 until attrs) {
-      val attrName = pool.getName(in.nextChar).toTypeName
-      val attrLen = in.nextInt
+      val attrName = readTypeName()
+      val attrLen = u4
       attrName match {
         case tpnme.SignatureATTR =>
           in.skip(attrLen)
@@ -1136,9 +1114,10 @@ abstract class ClassfileParser {
         case tpnme.ScalaATTR =>
           isScalaRaw = true
         case tpnme.InnerClassesATTR if !isScala =>
-          val entries = in.nextChar.toInt
+          val entries = u2
           for (i <- 0 until entries) {
-            val innerIndex, outerIndex, nameIndex, jflags = in.nextChar.toInt
+            val innerIndex, outerIndex, nameIndex = u2
+            val jflags = readInnerClassFlags()
             if (innerIndex != 0 && outerIndex != 0 && nameIndex != 0)
               innerClasses add InnerClassEntry(innerIndex, outerIndex, nameIndex, jflags)
           }
@@ -1150,14 +1129,13 @@ abstract class ClassfileParser {
   }
 
   /** An entry in the InnerClasses attribute of this class file. */
-  case class InnerClassEntry(external: Int, outer: Int, name: Int, jflags: Int) {
+  case class InnerClassEntry(external: Int, outer: Int, name: Int, jflags: JavaAccFlags) {
     def externalName = pool getClassName external
     def outerName    = pool getClassName outer
     def originalName = pool getName name
-    def isStatic     = ClassfileParser.this.isStatic(jflags)
     def isModule     = originalName.isTermName
-    def scope        = if (isStatic) staticScope else instanceScope
-    def enclosing    = if (isStatic) enclModule else enclClass
+    def scope        = if (jflags.isStatic) staticScope else instanceScope
+    def enclosing    = if (jflags.isStatic) enclModule else enclClass
 
     // The name of the outer class, without its trailing $ if it has one.
     private def strippedOuter = nme stripModuleSuffix outerName
@@ -1209,6 +1187,9 @@ abstract class ClassfileParser {
     }
   }
 
+  class TypeParamsType(override val typeParams: List[Symbol]) extends LazyType with FlagAgnosticCompleter {
+    override def complete(sym: Symbol) { throw new AssertionError("cyclic type dereferencing") }
+  }
   class LazyAliasType(alias: Symbol) extends LazyType with FlagAgnosticCompleter {
     override def complete(sym: Symbol) {
       sym setInfo createFromClonedSymbols(alias.initialize.typeParams, alias.tpe)(typeFun)
@@ -1216,16 +1197,16 @@ abstract class ClassfileParser {
   }
 
   def skipAttributes() {
-    var attrCount: Int = in.nextChar
+    var attrCount: Int = u2
     while (attrCount > 0) {
       in skip 2
-      in skip in.nextInt
+      in skip u4
       attrCount -= 1
     }
   }
 
   def skipMembers() {
-    var memberCount: Int = in.nextChar
+    var memberCount: Int = u2
     while (memberCount > 0) {
       in skip 6
       skipAttributes()
@@ -1235,17 +1216,10 @@ abstract class ClassfileParser {
 
   def skipSuperclasses() {
     in.skip(2) // superclass
-    val ifaces = in.nextChar
+    val ifaces = u2
     in.skip(2 * ifaces)
   }
 
-  protected def getOwner(flags: Int): Symbol =
-    if (isStatic(flags)) moduleClass else clazz
-
-  protected def getScope(flags: Int): Scope =
-    if (isStatic(flags)) staticScope else instanceScope
-
-  private def isPrivate(flags: Int)     = (flags & JAVA_ACC_PRIVATE) != 0
-  private def isStatic(flags: Int)      = (flags & JAVA_ACC_STATIC) != 0
-  private def hasAnnotation(flags: Int) = (flags & JAVA_ACC_ANNOTATION) != 0
+  protected def getScope(flags: JavaAccFlags): Scope =
+    if (flags.isStatic) staticScope else instanceScope
 }
diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala b/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala
index 80a810703c..50487ad123 100644
--- a/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala
+++ b/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala
@@ -10,6 +10,7 @@ package classfile
 import scala.collection.{ mutable, immutable }
 import mutable.ListBuffer
 import ClassfileConstants._
+import scala.reflect.internal.JavaAccFlags
 
 /** ICode reader from Java bytecode.
  *
@@ -45,26 +46,19 @@ abstract class ICodeReader extends ClassfileParser {
     (staticCode, instanceCode)
   }
 
-  /** If we're parsing a scala module, the owner of members is always
-   *  the module symbol.
-   */
-  override def getOwner(jflags: Int): Symbol =
-    if (isScalaModule) this.staticModule
-    else super.getOwner(jflags)
-
   override def parseClass() {
     this.instanceCode = new IClass(clazz)
     this.staticCode   = new IClass(staticModule)
 
-    in.nextChar
-    pool getClassSymbol in.nextChar
+    u2
+    pool getClassSymbol u2
     parseInnerClasses()
 
     in.skip(2)               // super class
-    in.skip(2 * in.nextChar) // interfaces
-    val fieldCount = in.nextChar
+    in.skip(2 * u2) // interfaces
+    val fieldCount = u2
     for (i <- 0 until fieldCount) parseField()
-    val methodCount = in.nextChar
+    val methodCount = u2
     for (i <- 0 until methodCount) parseMethod()
     instanceCode.methods = instanceCode.methods.reverse
     staticCode.methods = staticCode.methods.reverse
@@ -76,25 +70,31 @@ abstract class ICodeReader extends ClassfileParser {
     skipAttributes()
   }
 
-  private def parseMember(field: Boolean): (Int, Symbol) = {
-    val jflags   = in.nextChar
-    val name     = pool getName in.nextChar
-    val owner    = getOwner(jflags)
-    val dummySym = owner.newMethod(name.toTermName, owner.pos, toScalaMethodFlags(jflags))
+  private def parseMember(field: Boolean): (JavaAccFlags, Symbol) = {
+    val jflags   = JavaAccFlags(u2)
+    val name     = pool getName u2
+    /** If we're parsing a scala module, the owner of members is always
+     *  the module symbol.
+     */
+    val owner = (
+      if (isScalaModule) staticModule
+      else if (jflags.isStatic) moduleClass
+      else clazz
+    )
+    val dummySym = owner.newMethod(name.toTermName, owner.pos, jflags.toScalaFlags)
 
     try {
-      val ch  = in.nextChar
+      val ch  = u2
       val tpe = pool.getType(dummySym, ch)
 
       if ("<clinit>" == name.toString)
         (jflags, NoSymbol)
       else {
-        val owner = getOwner(jflags)
         var sym = owner.info.findMember(name, 0, 0, stableOnly = false).suchThat(old => sameType(old.tpe, tpe))
         if (sym == NoSymbol)
           sym = owner.info.findMember(newTermName(name + nme.LOCAL_SUFFIX_STRING), 0, 0, stableOnly = false).suchThat(_.tpe =:= tpe)
         if (sym == NoSymbol) {
-          sym = if (field) owner.newValue(name.toTermName, owner.pos, toScalaFieldFlags(jflags)) else dummySym
+          sym = if (field) owner.newValue(name.toTermName, owner.pos, jflags.toScalaFlags) else dummySym
           sym setInfoAndEnter tpe
           log(s"ICodeReader could not locate ${name.decode} in $owner.  Created ${sym.defString}.")
         }
@@ -126,9 +126,9 @@ abstract class ICodeReader extends ClassfileParser {
         this.method = new IMethod(sym)
         this.method.returnType = toTypeKind(sym.tpe.resultType)
         getCode(jflags).addMethod(this.method)
-        if ((jflags & JAVA_ACC_NATIVE) != 0)
+        if (jflags.isNative)
           this.method.native = true
-        val attributeCount = in.nextChar
+        val attributeCount = u2
         for (i <- 0 until attributeCount) parseAttribute()
       } else {
         debuglog("Skipping non-existent method.")
@@ -142,8 +142,8 @@ abstract class ICodeReader extends ClassfileParser {
   }
 
   def parseAttribute() {
-    val attrName = pool.getName(in.nextChar).toTypeName
-    val attrLen = in.nextInt
+    val attrName = pool.getName(u2).toTypeName
+    val attrLen = u4
     attrName match {
       case tpnme.CodeATTR =>
         parseByteCode()
@@ -187,9 +187,9 @@ abstract class ICodeReader extends ClassfileParser {
 
   /** Parse java bytecode into ICode */
   def parseByteCode() {
-    maxStack = in.nextChar
-    maxLocals = in.nextChar
-    val codeLength = in.nextInt
+    maxStack = u2
+    maxLocals = u2
+    val codeLength = u4
     val code = new LinearCode
 
     def parseInstruction() {
@@ -200,7 +200,7 @@ abstract class ICodeReader extends ClassfileParser {
       /* Parse 16 bit jump target. */
       def parseJumpTarget = {
         size += 2
-        val offset = in.nextChar.toShort
+        val offset = u2.toShort
         val target = pc + offset
         assert(target >= 0 && target < codeLength, "Illegal jump target: " + target)
         target
@@ -209,14 +209,13 @@ abstract class ICodeReader extends ClassfileParser {
       /* Parse 32 bit jump target. */
       def parseJumpTargetW: Int = {
         size += 4
-        val offset = in.nextInt
+        val offset = u4
         val target = pc + offset
         assert(target >= 0 && target < codeLength, "Illegal jump target: " + target + "pc: " + pc + " offset: " + offset)
         target
       }
 
-      val instr = toUnsignedByte(in.nextByte)
-      instr match {
+      u1 match {
         case JVM.nop => parseInstruction()
         case JVM.aconst_null => code emit CONSTANT(Constant(null))
         case JVM.iconst_m1   => code emit CONSTANT(Constant(-1))
@@ -235,17 +234,17 @@ abstract class ICodeReader extends ClassfileParser {
         case JVM.dconst_0    => code emit CONSTANT(Constant(0.0))
         case JVM.dconst_1    => code emit CONSTANT(Constant(1.0))
 
-        case JVM.bipush      => code.emit(CONSTANT(Constant(in.nextByte))); size += 1
-        case JVM.sipush      => code.emit(CONSTANT(Constant(in.nextChar))); size += 2
-        case JVM.ldc         => code.emit(CONSTANT(pool.getConstant(toUnsignedByte(in.nextByte)))); size += 1
-        case JVM.ldc_w       => code.emit(CONSTANT(pool.getConstant(in.nextChar))); size += 2
-        case JVM.ldc2_w      => code.emit(CONSTANT(pool.getConstant(in.nextChar))); size += 2
-        case JVM.iload       => code.emit(LOAD_LOCAL(code.getLocal(in.nextByte, INT)));    size += 1
-        case JVM.lload       => code.emit(LOAD_LOCAL(code.getLocal(in.nextByte, LONG)));   size += 1
-        case JVM.fload       => code.emit(LOAD_LOCAL(code.getLocal(in.nextByte, FLOAT)));  size += 1
-        case JVM.dload       => code.emit(LOAD_LOCAL(code.getLocal(in.nextByte, DOUBLE))); size += 1
+        case JVM.bipush      => code.emit(CONSTANT(Constant(u1))); size += 1
+        case JVM.sipush      => code.emit(CONSTANT(Constant(u2))); size += 2
+        case JVM.ldc         => code.emit(CONSTANT(pool.getConstant(u1))); size += 1
+        case JVM.ldc_w       => code.emit(CONSTANT(pool.getConstant(u2))); size += 2
+        case JVM.ldc2_w      => code.emit(CONSTANT(pool.getConstant(u2))); size += 2
+        case JVM.iload       => code.emit(LOAD_LOCAL(code.getLocal(u1, INT)));    size += 1
+        case JVM.lload       => code.emit(LOAD_LOCAL(code.getLocal(u1, LONG)));   size += 1
+        case JVM.fload       => code.emit(LOAD_LOCAL(code.getLocal(u1, FLOAT)));  size += 1
+        case JVM.dload       => code.emit(LOAD_LOCAL(code.getLocal(u1, DOUBLE))); size += 1
         case JVM.aload       =>
-          val local = in.nextByte.toInt; size += 1
+          val local = u1.toInt; size += 1
           if (local == 0 && !method.isStatic)
             code.emit(THIS(method.symbol.owner))
           else
@@ -285,11 +284,11 @@ abstract class ICodeReader extends ClassfileParser {
         case JVM.caload      => code.emit(LOAD_ARRAY_ITEM(CHAR))
         case JVM.saload      => code.emit(LOAD_ARRAY_ITEM(SHORT))
 
-        case JVM.istore      => code.emit(STORE_LOCAL(code.getLocal(in.nextByte, INT)));    size += 1
-        case JVM.lstore      => code.emit(STORE_LOCAL(code.getLocal(in.nextByte, LONG)));   size += 1
-        case JVM.fstore      => code.emit(STORE_LOCAL(code.getLocal(in.nextByte, FLOAT)));  size += 1
-        case JVM.dstore      => code.emit(STORE_LOCAL(code.getLocal(in.nextByte, DOUBLE))); size += 1
-        case JVM.astore      => code.emit(STORE_LOCAL(code.getLocal(in.nextByte, ObjectReference))); size += 1
+        case JVM.istore      => code.emit(STORE_LOCAL(code.getLocal(u1, INT)));    size += 1
+        case JVM.lstore      => code.emit(STORE_LOCAL(code.getLocal(u1, LONG)));   size += 1
+        case JVM.fstore      => code.emit(STORE_LOCAL(code.getLocal(u1, FLOAT)));  size += 1
+        case JVM.dstore      => code.emit(STORE_LOCAL(code.getLocal(u1, DOUBLE))); size += 1
+        case JVM.astore      => code.emit(STORE_LOCAL(code.getLocal(u1, ObjectReference))); size += 1
         case JVM.istore_0    => code.emit(STORE_LOCAL(code.getLocal(0, INT)))
         case JVM.istore_1    => code.emit(STORE_LOCAL(code.getLocal(1, INT)))
         case JVM.istore_2    => code.emit(STORE_LOCAL(code.getLocal(2, INT)))
@@ -373,9 +372,9 @@ abstract class ICodeReader extends ClassfileParser {
         case JVM.lxor        => code.emit(CALL_PRIMITIVE(Logical(XOR, LONG)))
         case JVM.iinc        =>
           size += 2
-          val local = code.getLocal(in.nextByte, INT)
+          val local = code.getLocal(u1, INT)
           code.emit(LOAD_LOCAL(local))
-          code.emit(CONSTANT(Constant(in.nextByte)))
+          code.emit(CONSTANT(Constant(u1)))
           code.emit(CALL_PRIMITIVE(Arithmetic(ADD, INT)))
           code.emit(STORE_LOCAL(local))
 
@@ -425,14 +424,14 @@ abstract class ICodeReader extends ClassfileParser {
           size += padding
           in.bp += padding
           assert((pc + size % 4) != 0, pc)
-/*          var byte1 = in.nextByte; size += 1;
-          while (byte1 == 0) { byte1 = in.nextByte; size += 1; }
-          val default = byte1 << 24 | in.nextByte << 16 | in.nextByte << 8 | in.nextByte;
+/*          var byte1 = u1; size += 1;
+          while (byte1 == 0) { byte1 = u1; size += 1; }
+          val default = byte1 << 24 | u1 << 16 | u1 << 8 | u1;
           size = size + 3
        */
-          val default = pc + in.nextInt; size += 4
-          val low  = in.nextInt
-          val high = in.nextInt
+          val default = pc + u4; size += 4
+          val low  = u4
+          val high = u4
           size += 8
           assert(low <= high, "Value low not <= high for tableswitch.")
 
@@ -445,13 +444,13 @@ abstract class ICodeReader extends ClassfileParser {
           size += padding
           in.bp += padding
           assert((pc + size % 4) != 0, pc)
-          val default = pc + in.nextInt; size += 4
-          val npairs = in.nextInt; size += 4
+          val default = pc + u4; size += 4
+          val npairs = u4; size += 4
           var tags: List[List[Int]] = Nil
           var targets: List[Int] = Nil
           var i = 0
           while (i < npairs) {
-            tags = List(in.nextInt) :: tags; size += 4
+            tags = List(u4) :: tags; size += 4
             targets = parseJumpTargetW :: targets; // parseJumpTargetW updates 'size' itself
             i += 1
           }
@@ -466,35 +465,35 @@ abstract class ICodeReader extends ClassfileParser {
         case JVM.return_     => code.emit(RETURN(UNIT))
 
         case JVM.getstatic    =>
-          val field = pool.getMemberSymbol(in.nextChar, static = true); size += 2
+          val field = pool.getMemberSymbol(u2, static = true); size += 2
           if (field.hasModuleFlag)
             code emit LOAD_MODULE(field)
           else
             code emit LOAD_FIELD(field, isStatic = true)
         case JVM.putstatic   =>
-          val field = pool.getMemberSymbol(in.nextChar, static = true); size += 2
+          val field = pool.getMemberSymbol(u2, static = true); size += 2
           code.emit(STORE_FIELD(field, isStatic = true))
         case JVM.getfield    =>
-          val field = pool.getMemberSymbol(in.nextChar, static = false); size += 2
+          val field = pool.getMemberSymbol(u2, static = false); size += 2
           code.emit(LOAD_FIELD(field, isStatic = false))
         case JVM.putfield    =>
-          val field = pool.getMemberSymbol(in.nextChar, static = false); size += 2
+          val field = pool.getMemberSymbol(u2, static = false); size += 2
           code.emit(STORE_FIELD(field, isStatic = false))
 
         case JVM.invokevirtual =>
-          val m = pool.getMemberSymbol(in.nextChar, static = false); size += 2
+          val m = pool.getMemberSymbol(u2, static = false); size += 2
           code.emit(CALL_METHOD(m, Dynamic))
         case JVM.invokeinterface  =>
-          val m = pool.getMemberSymbol(in.nextChar, static = false); size += 4
+          val m = pool.getMemberSymbol(u2, static = false); size += 4
           in.skip(2)
           code.emit(CALL_METHOD(m, Dynamic))
         case JVM.invokespecial   =>
-          val m = pool.getMemberSymbol(in.nextChar, static = false); size += 2
+          val m = pool.getMemberSymbol(u2, static = false); size += 2
           val style = if (m.name == nme.CONSTRUCTOR || m.isPrivate) Static(onInstance = true)
                       else SuperCall(m.owner.name)
           code.emit(CALL_METHOD(m, style))
         case JVM.invokestatic    =>
-          val m = pool.getMemberSymbol(in.nextChar, static = true); size += 2
+          val m = pool.getMemberSymbol(u2, static = true); size += 2
           if (isBox(m))
             code.emit(BOX(toTypeKind(m.info.paramTypes.head)))
           else if (isUnbox(m))
@@ -510,10 +509,10 @@ abstract class ICodeReader extends ClassfileParser {
           code.emit(INVOKE_DYNAMIC(poolEntry))
 
         case JVM.new_          =>
-          code.emit(NEW(REFERENCE(pool.getClassSymbol(in.nextChar))))
+          code.emit(NEW(REFERENCE(pool.getClassSymbol(u2))))
           size += 2
         case JVM.newarray      =>
-          val kind = in.nextByte match {
+          val kind = u1 match {
             case T_BOOLEAN => BOOL
             case T_CHAR    => CHAR
             case T_FLOAT   => FLOAT
@@ -527,35 +526,35 @@ abstract class ICodeReader extends ClassfileParser {
           code.emit(CREATE_ARRAY(kind, 1))
 
         case JVM.anewarray     =>
-          val tpe = pool.getClassOrArrayType(in.nextChar); size += 2
+          val tpe = pool.getClassOrArrayType(u2); size += 2
           code.emit(CREATE_ARRAY(toTypeKind(tpe), 1))
 
         case JVM.arraylength   => code.emit(CALL_PRIMITIVE(ArrayLength(ObjectReference))); // the kind does not matter
         case JVM.athrow        => code.emit(THROW(definitions.ThrowableClass))
         case JVM.checkcast     =>
-          code.emit(CHECK_CAST(toTypeKind(pool.getClassOrArrayType(in.nextChar)))); size += 2
+          code.emit(CHECK_CAST(toTypeKind(pool.getClassOrArrayType(u2)))); size += 2
         case JVM.instanceof    =>
-          code.emit(IS_INSTANCE(toTypeKind(pool.getClassOrArrayType(in.nextChar)))); size += 2
+          code.emit(IS_INSTANCE(toTypeKind(pool.getClassOrArrayType(u2)))); size += 2
         case JVM.monitorenter  => code.emit(MONITOR_ENTER())
         case JVM.monitorexit   => code.emit(MONITOR_EXIT())
         case JVM.wide          =>
           size += 1
-          toUnsignedByte(in.nextByte) match {
-            case JVM.iload  => code.emit(LOAD_LOCAL(code.getLocal(in.nextChar, INT)));    size += 2
-            case JVM.lload  => code.emit(LOAD_LOCAL(code.getLocal(in.nextChar, LONG)));   size += 2
-            case JVM.fload  => code.emit(LOAD_LOCAL(code.getLocal(in.nextChar, FLOAT)));  size += 2
-            case JVM.dload  => code.emit(LOAD_LOCAL(code.getLocal(in.nextChar, DOUBLE))); size += 2
-            case JVM.aload  => code.emit(LOAD_LOCAL(code.getLocal(in.nextChar, ObjectReference))); size += 2
-            case JVM.istore => code.emit(STORE_LOCAL(code.getLocal(in.nextChar, INT)));    size += 2
-            case JVM.lstore => code.emit(STORE_LOCAL(code.getLocal(in.nextChar, LONG)));   size += 2
-            case JVM.fstore => code.emit(STORE_LOCAL(code.getLocal(in.nextChar, FLOAT)));  size += 2
-            case JVM.dstore => code.emit(STORE_LOCAL(code.getLocal(in.nextChar, DOUBLE))); size += 2
-            case JVM.astore => code.emit(STORE_LOCAL(code.getLocal(in.nextChar, ObjectReference))); size += 2
+          u1 match {
+            case JVM.iload  => code.emit(LOAD_LOCAL(code.getLocal(u2, INT)));    size += 2
+            case JVM.lload  => code.emit(LOAD_LOCAL(code.getLocal(u2, LONG)));   size += 2
+            case JVM.fload  => code.emit(LOAD_LOCAL(code.getLocal(u2, FLOAT)));  size += 2
+            case JVM.dload  => code.emit(LOAD_LOCAL(code.getLocal(u2, DOUBLE))); size += 2
+            case JVM.aload  => code.emit(LOAD_LOCAL(code.getLocal(u2, ObjectReference))); size += 2
+            case JVM.istore => code.emit(STORE_LOCAL(code.getLocal(u2, INT)));    size += 2
+            case JVM.lstore => code.emit(STORE_LOCAL(code.getLocal(u2, LONG)));   size += 2
+            case JVM.fstore => code.emit(STORE_LOCAL(code.getLocal(u2, FLOAT)));  size += 2
+            case JVM.dstore => code.emit(STORE_LOCAL(code.getLocal(u2, DOUBLE))); size += 2
+            case JVM.astore => code.emit(STORE_LOCAL(code.getLocal(u2, ObjectReference))); size += 2
             case JVM.ret => sys.error("Cannot handle jsr/ret")
             case JVM.iinc =>
               size += 4
-              val local = code.getLocal(in.nextChar, INT)
-              code.emit(CONSTANT(Constant(in.nextChar)))
+              val local = code.getLocal(u2, INT)
+              code.emit(CONSTANT(Constant(u2)))
               code.emit(CALL_PRIMITIVE(Arithmetic(ADD, INT)))
               code.emit(STORE_LOCAL(local))
             case _ => sys.error("Invalid 'wide' operand")
@@ -563,8 +562,8 @@ abstract class ICodeReader extends ClassfileParser {
 
         case JVM.multianewarray =>
           size += 3
-          val tpe = toTypeKind(pool getClassOrArrayType in.nextChar)
-          val dim = in.nextByte
+          val tpe = toTypeKind(pool getClassOrArrayType u2)
+          val dim = u1
 //          assert(dim == 1, "Cannot handle multidimensional arrays yet.")
           code emit CREATE_ARRAY(tpe, dim)
 
@@ -590,14 +589,14 @@ abstract class ICodeReader extends ClassfileParser {
     pc = 0
     while (pc < codeLength) parseInstruction()
 
-    val exceptionEntries = in.nextChar.toInt
+    val exceptionEntries = u2.toInt
     code.containsEHs = (exceptionEntries != 0)
     var i = 0
     while (i < exceptionEntries) {
       // skip start end PC
       in.skip(4)
       // read the handler PC
-      code.jmpTargets += in.nextChar
+      code.jmpTargets += u2
       // skip the exception type
       in.skip(2)
       i += 1
@@ -633,10 +632,8 @@ abstract class ICodeReader extends ClassfileParser {
   /** Return the icode class that should include members with the given flags.
    *  There are two possible classes, the static part and the instance part.
    */
-  def getCode(flags: Int): IClass =
-    if (isScalaModule) staticCode
-    else if ((flags & JAVA_ACC_STATIC) != 0) staticCode
-    else instanceCode
+  def getCode(flags: JavaAccFlags): IClass =
+    if (isScalaModule || flags.isStatic) staticCode else instanceCode
 
   class LinearCode {
     val instrs: ListBuffer[(Int, Instruction)] = new ListBuffer
diff --git a/src/reflect/scala/reflect/internal/PrivateWithin.scala b/src/reflect/scala/reflect/internal/PrivateWithin.scala
index 9b99b94b41..7c4e9c7b48 100644
--- a/src/reflect/scala/reflect/internal/PrivateWithin.scala
+++ b/src/reflect/scala/reflect/internal/PrivateWithin.scala
@@ -2,6 +2,8 @@ package scala.reflect
 package internal
 
 import ClassfileConstants._
+import java.lang.{ Class => jClass }
+import java.lang.reflect.{ Member => jMember }
 
 trait PrivateWithin {
   self: SymbolTable =>
@@ -20,4 +22,21 @@ trait PrivateWithin {
 
     sym
   }
-}
\ No newline at end of file
+
+  def propagatePackageBoundary(c: jClass[_], syms: Symbol*): Unit =
+    propagatePackageBoundary(JavaAccFlags(c), syms: _*)
+  def propagatePackageBoundary(m: jMember, syms: Symbol*): Unit =
+    propagatePackageBoundary(JavaAccFlags(m), syms: _*)
+  def propagatePackageBoundary(jflags: JavaAccFlags, syms: Symbol*) {
+    if (jflags.hasPackageAccessBoundary)
+      syms foreach setPackageAccessBoundary
+  }
+
+  // protected in java means package protected. #3946
+  // See ticket #1687 for an example of when the enclosing top level class is NoSymbol;
+  // it apparently occurs when processing v45.3 bytecode.
+  def setPackageAccessBoundary(sym: Symbol): Symbol = (
+    if (sym.enclosingTopLevelClass eq NoSymbol) sym
+    else sym setPrivateWithin sym.enclosingTopLevelClass.owner
+  )
+}