Simplify and correctify calculation of the InnerClass attribute

The InnerClass attribute needs to contain an entry for every nested
class that is defined or referenced in a class. Details are in a
doc comment in BTypes.scala.

Instead of collecting ClassBTypes of nested classes into a hash map
during code generation, traverse the class before writing it out to
disk. The previous approach was incorrect as soon as the generated
bytecode was modified by the optimzier (DCE, inlining).

Fixes https://github.com/scala/scala-dev/issues/21.

11 files changed, 234 insertions, 153 deletions

diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala
index c4eb6e1b42..a1d930d794 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala
@@ -464,7 +464,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
 
         case ClazzTag   =>
           val toPush: BType = {
-            toTypeKind(const.typeValue) match {
+            typeToBType(const.typeValue) match {
               case kind: PrimitiveBType => boxedClassOfPrimitive(kind)
               case kind => kind
             }
@@ -475,7 +475,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
           val sym       = const.symbolValue
           val ownerName = internalName(sym.owner)
           val fieldName = sym.javaSimpleName.toString
-          val fieldDesc = toTypeKind(sym.tpe.underlying).descriptor
+          val fieldDesc = typeToBType(sym.tpe.underlying).descriptor
           mnode.visitFieldInsn(
             asm.Opcodes.GETSTATIC,
             ownerName,
@@ -588,7 +588,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
           mnode.visitVarInsn(asm.Opcodes.ALOAD, 0)
           genLoadArguments(args, paramTKs(app))
           genCallMethod(fun.symbol, invokeStyle, app.pos)
-          generatedType = asmMethodType(fun.symbol).returnType
+          generatedType = methodBTypeFromSymbol(fun.symbol).returnType
 
         // 'new' constructor call: Note: since constructors are
         // thought to return an instance of what they construct,
@@ -638,18 +638,18 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
           val attachment = app.attachments.get[delambdafy.LambdaMetaFactoryCapable].get
           genLoadArguments(args, paramTKs(app))
           genInvokeDynamicLambda(attachment.target, attachment.arity, attachment.functionalInterface)
-          generatedType = asmMethodType(fun.symbol).returnType
+          generatedType = methodBTypeFromSymbol(fun.symbol).returnType
 
         case Apply(fun @ _, List(expr)) if currentRun.runDefinitions.isBox(fun.symbol) =>
           val nativeKind = tpeTK(expr)
           genLoad(expr, nativeKind)
           val MethodNameAndType(mname, methodType) = asmBoxTo(nativeKind)
           bc.invokestatic(BoxesRunTime.internalName, mname, methodType.descriptor, app.pos)
-          generatedType = boxResultType(fun.symbol) // was toTypeKind(fun.symbol.tpe.resultType)
+          generatedType = boxResultType(fun.symbol) // was typeToBType(fun.symbol.tpe.resultType)
 
         case Apply(fun @ _, List(expr)) if currentRun.runDefinitions.isUnbox(fun.symbol) =>
           genLoad(expr)
-          val boxType = unboxResultType(fun.symbol) // was toTypeKind(fun.symbol.owner.linkedClassOfClass.tpe)
+          val boxType = unboxResultType(fun.symbol) // was typeToBType(fun.symbol.owner.linkedClassOfClass.tpe)
           generatedType = boxType
           val MethodNameAndType(mname, methodType) = asmUnboxTo(boxType)
           bc.invokestatic(BoxesRunTime.internalName, mname, methodType.descriptor, app.pos)
@@ -728,7 +728,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
 
             genNormalMethodCall()
 
-            generatedType = asmMethodType(sym).returnType
+            generatedType = methodBTypeFromSymbol(sym).returnType
           }
 
       }
@@ -958,7 +958,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
           asm.Opcodes.GETSTATIC,
           mbt.internalName /* + "$" */ ,
           strMODULE_INSTANCE_FIELD,
-          mbt.descriptor // for nostalgics: toTypeKind(module.tpe).descriptor
+          mbt.descriptor // for nostalgics: typeToBType(module.tpe).descriptor
         )
       }
     }
@@ -1037,7 +1037,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
       val receiver = if (useMethodOwner) methodOwner else hostSymbol
       val jowner   = internalName(receiver)
       val jname    = method.javaSimpleName.toString
-      val bmType   = asmMethodType(method)
+      val bmType   = methodBTypeFromSymbol(method)
       val mdescr   = bmType.descriptor
 
       def initModule() {
@@ -1309,16 +1309,16 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
         new asm.Handle(if (lambdaTarget.hasFlag(Flags.STATIC)) asm.Opcodes.H_INVOKESTATIC else asm.Opcodes.H_INVOKEVIRTUAL,
           classBTypeFromSymbol(lambdaTarget.owner).internalName,
           lambdaTarget.name.toString,
-          asmMethodType(lambdaTarget).descriptor)
+          methodBTypeFromSymbol(lambdaTarget).descriptor)
       val receiver = if (isStaticMethod) Nil else lambdaTarget.owner :: Nil
       val (capturedParams, lambdaParams) = lambdaTarget.paramss.head.splitAt(lambdaTarget.paramss.head.length - arity)
       // Requires https://github.com/scala/scala-java8-compat on the runtime classpath
-      val invokedType = asm.Type.getMethodDescriptor(asmType(functionalInterface), (receiver ::: capturedParams).map(sym => toTypeKind(sym.info).toASMType): _*)
+      val invokedType = asm.Type.getMethodDescriptor(asmType(functionalInterface), (receiver ::: capturedParams).map(sym => typeToBType(sym.info).toASMType): _*)
 
-      val constrainedType = new MethodBType(lambdaParams.map(p => toTypeKind(p.tpe)), toTypeKind(lambdaTarget.tpe.resultType)).toASMType
+      val constrainedType = new MethodBType(lambdaParams.map(p => typeToBType(p.tpe)), typeToBType(lambdaTarget.tpe.resultType)).toASMType
       val sam = functionalInterface.info.decls.find(_.isDeferred).getOrElse(functionalInterface.info.member(nme.apply))
       val samName = sam.name.toString
-      val samMethodType = asmMethodType(sam).toASMType
+      val samMethodType = methodBTypeFromSymbol(sam).toASMType
 
       val flags = LambdaMetafactory.FLAG_SERIALIZABLE | LambdaMetafactory.FLAG_MARKERS
 
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala
index bc3bdfc6ba..864d403e39 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala
@@ -192,20 +192,18 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
   }
 
   /*
-   * Populates the InnerClasses JVM attribute with `refedInnerClasses`.
-   * In addition to inner classes mentioned somewhere in `jclass` (where `jclass` is a class file being emitted)
-   * `refedInnerClasses` should contain those inner classes defined as direct member classes of `jclass`
-   * but otherwise not mentioned in `jclass`.
+   * Populates the InnerClasses JVM attribute with `refedInnerClasses`. See also the doc on inner
+   * classes in BTypes.scala.
    *
-   * `refedInnerClasses` may contain duplicates,
-   * need not contain the enclosing inner classes of each inner class it lists (those are looked up for consistency).
+   * `refedInnerClasses` may contain duplicates, need not contain the enclosing inner classes of
+   * each inner class it lists (those are looked up and included).
    *
-   * This method serializes in the InnerClasses JVM attribute in an appropriate order,
-   * not necessarily that given by `refedInnerClasses`.
+   * This method serializes in the InnerClasses JVM attribute in an appropriate order, not
+   * necessarily that given by `refedInnerClasses`.
    *
    * can-multi-thread
    */
-  final def addInnerClassesASM(jclass: asm.ClassVisitor, refedInnerClasses: List[ClassBType]) {
+  final def addInnerClasses(jclass: asm.ClassVisitor, refedInnerClasses: List[ClassBType]) {
     val allNestedClasses = refedInnerClasses.flatMap(_.enclosingNestedClassesChain.get).distinct
 
     // sorting ensures nested classes are listed after their enclosing class thus satisfying the Eclipse Java compiler
@@ -311,78 +309,28 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
     final val emitLines  = debugLevel >= 2
     final val emitVars   = debugLevel >= 3
 
-    /*
-     *  Contains class-symbols that:
-     *    (a) are known to denote inner classes
-     *    (b) are mentioned somewhere in the class being generated.
-     *
-     *  In other words, the lifetime of `innerClassBufferASM` is associated to "the class being generated".
-     */
-    final val innerClassBufferASM = mutable.Set.empty[ClassBType]
-
     /**
-     * The class internal name for a given class symbol. If the symbol describes a nested class, the
-     * ClassBType is added to the innerClassBufferASM.
+     * The class internal name for a given class symbol.
      */
     final def internalName(sym: Symbol): String = {
       // For each java class, the scala compiler creates a class and a module (thus a module class).
-      // If the `sym` is a java module class, we use the java class instead. This ensures that we
-      // register the class (instead of the module class) in innerClassBufferASM.
+      // If the `sym` is a java module class, we use the java class instead. This ensures that the
+      // ClassBType is created from the main class (instead of the module class).
       // The two symbols have the same name, so the resulting internalName is the same.
       // Phase travel (exitingPickler) required for SI-6613 - linkedCoC is only reliable in early phases (nesting)
       val classSym = if (sym.isJavaDefined && sym.isModuleClass) exitingPickler(sym.linkedClassOfClass) else sym
-      getClassBTypeAndRegisterInnerClass(classSym).internalName
+      classBTypeFromSymbol(classSym).internalName
     }
 
     /**
-     * The ClassBType for a class symbol. If the class is nested, the ClassBType is added to the
-     * innerClassBufferASM.
-     *
-     * TODO: clean up the way we track referenced inner classes.
-     * doing it during code generation is not correct when the optimizer changes the code.
+     * The jvm descriptor of a type.
      */
-    final def getClassBTypeAndRegisterInnerClass(sym: Symbol): ClassBType = {
-      val r = classBTypeFromSymbol(sym)
-      if (r.isNestedClass.get) innerClassBufferASM += r
-      r
-    }
+    final def descriptor(t: Type): String = typeToBType(t).descriptor
 
     /**
-     * The BType for a type reference. If the result is a ClassBType for a nested class, it is added
-     * to the innerClassBufferASM.
-     * TODO: clean up the way we track referenced inner classes.
+     * The jvm descriptor for a symbol.
      */
-    final def toTypeKind(t: Type): BType = typeToBType(t) match {
-      case c: ClassBType if c.isNestedClass.get =>
-        innerClassBufferASM += c
-        c
-      case r => r
-    }
-
-    /**
-     * Class components that are nested classes are added to the innerClassBufferASM.
-     * TODO: clean up the way we track referenced inner classes.
-     */
-    final def asmMethodType(msym: Symbol): MethodBType = {
-      val r = methodBTypeFromSymbol(msym)
-      (r.returnType :: r.argumentTypes) foreach {
-        case c: ClassBType if c.isNestedClass.get => innerClassBufferASM += c
-        case _ =>
-      }
-      r
-    }
-
-    /**
-     * The jvm descriptor of a type. If `t` references a nested class, its ClassBType is added to
-     * the innerClassBufferASM.
-     */
-    final def descriptor(t: Type):   String = { toTypeKind(t).descriptor   }
-
-    /**
-     * The jvm descriptor for a symbol. If `sym` represents a nested class, its ClassBType is added
-     * to the innerClassBufferASM.
-     */
-    final def descriptor(sym: Symbol): String = { getClassBTypeAndRegisterInnerClass(sym).descriptor }
+    final def descriptor(sym: Symbol): String = classBTypeFromSymbol(sym).descriptor
 
   } // end of trait BCInnerClassGen
 
@@ -421,7 +369,7 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
               case StringTag  =>
                 assert(const.value != null, const) // TODO this invariant isn't documented in `case class Constant`
                 av.visit(name, const.stringValue)  // `stringValue` special-cases null, but that execution path isn't exercised for a const with StringTag
-              case ClazzTag   => av.visit(name, toTypeKind(const.typeValue).toASMType)
+              case ClazzTag   => av.visit(name, typeToBType(const.typeValue).toASMType)
               case EnumTag =>
                 val edesc  = descriptor(const.tpe) // the class descriptor of the enumeration class.
                 val evalue = const.symbolValue.name.toString // value the actual enumeration value.
@@ -561,7 +509,7 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
     private def addForwarder(isRemoteClass: Boolean, jclass: asm.ClassVisitor, module: Symbol, m: Symbol) {
       val moduleName     = internalName(module)
       val methodInfo     = module.thisType.memberInfo(m)
-      val paramJavaTypes: List[BType] = methodInfo.paramTypes map toTypeKind
+      val paramJavaTypes: List[BType] = methodInfo.paramTypes map typeToBType
       // val paramNames     = 0 until paramJavaTypes.length map ("x_" + _)
 
       /* Forwarders must not be marked final,
@@ -580,7 +528,7 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
       val (throws, others) = m.annotations partition (_.symbol == definitions.ThrowsClass)
       val thrownExceptions: List[String] = getExceptions(throws)
 
-      val jReturnType = toTypeKind(methodInfo.resultType)
+      val jReturnType = typeToBType(methodInfo.resultType)
       val mdesc = MethodBType(paramJavaTypes, jReturnType).descriptor
       val mirrorMethodName = m.javaSimpleName.toString
       val mirrorMethod: asm.MethodVisitor = jclass.visitMethod(
@@ -605,7 +553,7 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
         index += jparamType.size
       }
 
-      mirrorMethod.visitMethodInsn(asm.Opcodes.INVOKEVIRTUAL, moduleName, mirrorMethodName, asmMethodType(m).descriptor, false)
+      mirrorMethod.visitMethodInsn(asm.Opcodes.INVOKEVIRTUAL, moduleName, mirrorMethodName, methodBTypeFromSymbol(m).descriptor, false)
       mirrorMethod.visitInsn(jReturnType.typedOpcode(asm.Opcodes.IRETURN))
 
       mirrorMethod.visitMaxs(0, 0) // just to follow protocol, dummy arguments
@@ -709,7 +657,6 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
     def genMirrorClass(moduleClass: Symbol, cunit: CompilationUnit): asm.tree.ClassNode = {
       assert(moduleClass.isModuleClass)
       assert(moduleClass.companionClass == NoSymbol, moduleClass)
-      innerClassBufferASM.clear()
       this.cunit = cunit
 
       val bType = mirrorClassClassBType(moduleClass)
@@ -732,9 +679,6 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
 
       addForwarders(isRemote(moduleClass), mirrorClass, bType.internalName, moduleClass)
 
-      innerClassBufferASM ++= bType.info.get.nestedClasses
-      addInnerClassesASM(mirrorClass, innerClassBufferASM.toList)
-
       mirrorClass.visitEnd()
 
       ("" + moduleClass.name) // this side-effect is necessary, really.
@@ -758,18 +702,15 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
 
       def javaSimpleName(s: Symbol): String = { s.javaSimpleName.toString }
 
-      innerClassBufferASM.clear()
-
-      val flags = javaFlags(cls)
+      val beanInfoType = beanInfoClassClassBType(cls)
 
-      val beanInfoName  = (internalName(cls) + "BeanInfo")
       val beanInfoClass = new asm.tree.ClassNode
       beanInfoClass.visit(
         classfileVersion,
-        flags,
-        beanInfoName,
+        beanInfoType.info.get.flags,
+        beanInfoType.internalName,
         null, // no java-generic-signature
-        "scala/beans/ScalaBeanInfo",
+        ScalaBeanInfoReference.internalName,
         EMPTY_STRING_ARRAY
       )
 
@@ -848,9 +789,6 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
       constructor.visitMaxs(0, 0) // just to follow protocol, dummy arguments
       constructor.visitEnd()
 
-      innerClassBufferASM ++= classBTypeFromSymbol(cls).info.get.nestedClasses
-      addInnerClassesASM(beanInfoClass, innerClassBufferASM.toList)
-
       beanInfoClass.visitEnd()
 
       beanInfoClass
@@ -879,8 +817,7 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
      * must-single-thread
      */
     def legacyAddCreatorCode(clinit: asm.MethodVisitor, cnode: asm.tree.ClassNode, thisName: String) {
-      // this tracks the inner class in innerClassBufferASM, if needed.
-      val androidCreatorType = getClassBTypeAndRegisterInnerClass(AndroidCreatorClass)
+      val androidCreatorType = classBTypeFromSymbol(AndroidCreatorClass)
       val tdesc_creator = androidCreatorType.descriptor
 
       cnode.visitField(
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala
index b22fdf7c2c..7b42d85dd8 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala
@@ -72,14 +72,12 @@ abstract class BCodeSkelBuilder extends BCodeHelpers {
     def paramTKs(app: Apply): List[BType] = {
       val Apply(fun, _)  = app
       val funSym = fun.symbol
-      (funSym.info.paramTypes map toTypeKind) // this tracks mentioned inner classes (in innerClassBufferASM)
+      funSym.info.paramTypes map typeToBType
     }
 
-    def symInfoTK(sym: Symbol): BType = {
-      toTypeKind(sym.info) // this tracks mentioned inner classes (in innerClassBufferASM)
-    }
+    def symInfoTK(sym: Symbol): BType = typeToBType(sym.info)
 
-    def tpeTK(tree: Tree): BType = { toTypeKind(tree.tpe) }
+    def tpeTK(tree: Tree): BType = typeToBType(tree.tpe)
 
     def log(msg: => AnyRef) {
       global synchronized { global.log(msg) }
@@ -91,7 +89,6 @@ abstract class BCodeSkelBuilder extends BCodeHelpers {
 
     def genPlainClass(cd: ClassDef) {
       assert(cnode == null, "GenBCode detected nested methods.")
-      innerClassBufferASM.clear()
 
       claszSymbol       = cd.symbol
       isCZParcelable    = isAndroidParcelableClass(claszSymbol)
@@ -118,7 +115,6 @@ abstract class BCodeSkelBuilder extends BCodeHelpers {
 
       addClassFields()
 
-      innerClassBufferASM ++= classBType.info.get.nestedClasses
       gen(cd.impl)
 
 
@@ -130,8 +126,6 @@ abstract class BCodeSkelBuilder extends BCodeHelpers {
       if (shouldAddLambdaDeserialize)
         backendUtils.addLambdaDeserialize(cnode)
 
-      addInnerClassesASM(cnode, innerClassBufferASM.toList)
-
       cnode.visitAttribute(classBType.inlineInfoAttribute.get)
 
       if (AsmUtils.traceClassEnabled && cnode.name.contains(AsmUtils.traceClassPattern))
@@ -147,11 +141,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers {
 
       val bType = classBTypeFromSymbol(claszSymbol)
       val superClass = bType.info.get.superClass.getOrElse(ObjectReference).internalName
-      val interfaceNames = bType.info.get.interfaces map {
-        case classBType =>
-          if (classBType.isNestedClass.get) { innerClassBufferASM += classBType }
-          classBType.internalName
-      }
+      val interfaceNames = bType.info.get.interfaces.map(_.internalName)
 
       val flags = javaFlags(claszSymbol)
 
@@ -164,7 +154,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers {
         cnode.visitSource(cunit.source.toString, null /* SourceDebugExtension */)
       }
 
-      enclosingMethodAttribute(claszSymbol, internalName, asmMethodType(_).descriptor) match {
+      enclosingMethodAttribute(claszSymbol, internalName, methodBTypeFromSymbol(_).descriptor) match {
         case Some(EnclosingMethodEntry(className, methodName, methodDescriptor)) =>
           cnode.visitOuterClass(className, methodName, methodDescriptor)
         case _ => ()
@@ -536,7 +526,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers {
         if (isMethSymStaticCtor) CLASS_CONSTRUCTOR_NAME
         else jMethodName
 
-      val mdesc = asmMethodType(methSymbol).descriptor
+      val mdesc = methodBTypeFromSymbol(methSymbol).descriptor
       mnode = cnode.visitMethod(
         flags,
         bytecodeName,
@@ -560,7 +550,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers {
 
       methSymbol  = dd.symbol
       jMethodName = methSymbol.javaSimpleName.toString
-      returnType  = asmMethodType(dd.symbol).returnType
+      returnType  = methodBTypeFromSymbol(dd.symbol).returnType
       isMethSymStaticCtor = methSymbol.isStaticConstructor
 
       resetMethodBookkeeping(dd)
@@ -689,7 +679,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers {
         val callee = methSymbol.enclClass.primaryConstructor
         val jname  = callee.javaSimpleName.toString
         val jowner = internalName(callee.owner)
-        val jtype  = asmMethodType(callee).descriptor
+        val jtype  = methodBTypeFromSymbol(callee).descriptor
         insnModB   = new asm.tree.MethodInsnNode(asm.Opcodes.INVOKESPECIAL, jowner, jname, jtype, false)
       }
 
@@ -698,7 +688,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers {
       // android creator code
       if (isCZParcelable) {
         // add a static field ("CREATOR") to this class to cache android.os.Parcelable$Creator
-        val andrFieldDescr = getClassBTypeAndRegisterInnerClass(AndroidCreatorClass).descriptor
+        val andrFieldDescr = classBTypeFromSymbol(AndroidCreatorClass).descriptor
         cnode.visitField(
           asm.Opcodes.ACC_STATIC | asm.Opcodes.ACC_FINAL,
           "CREATOR",
@@ -710,7 +700,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers {
         val callee = definitions.getMember(claszSymbol.companionModule, androidFieldName)
         val jowner = internalName(callee.owner)
         val jname  = callee.javaSimpleName.toString
-        val jtype  = asmMethodType(callee).descriptor
+        val jtype  = methodBTypeFromSymbol(callee).descriptor
         insnParcA  = new asm.tree.MethodInsnNode(asm.Opcodes.INVOKESTATIC, jowner, jname, jtype, false)
         // PUTSTATIC `thisName`.CREATOR;
         insnParcB  = new asm.tree.FieldInsnNode(asm.Opcodes.PUTSTATIC, thisName, "CREATOR", andrFieldDescr)
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala
index 92aaf991bf..f5816a4f95 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala
@@ -157,7 +157,7 @@ abstract class BTypes {
       val res = ClassBType(internalName)
       byteCodeRepository.classNode(internalName) match {
         case Left(msg) => res.info = Left(NoClassBTypeInfoMissingBytecode(msg)); res
-        case Right(c)  => setClassInfoFromParsedClassfile(c, res)
+        case Right(c)  => setClassInfoFromClassNode(c, res)
       }
     })
   }
@@ -167,11 +167,11 @@ abstract class BTypes {
    */
   def classBTypeFromClassNode(classNode: ClassNode): ClassBType = {
     classBTypeFromInternalName.getOrElse(classNode.name, {
-      setClassInfoFromParsedClassfile(classNode, ClassBType(classNode.name))
+      setClassInfoFromClassNode(classNode, ClassBType(classNode.name))
     })
   }
 
-  private def setClassInfoFromParsedClassfile(classNode: ClassNode, classBType: ClassBType): ClassBType = {
+  private def setClassInfoFromClassNode(classNode: ClassNode, classBType: ClassBType): ClassBType = {
     val superClass = classNode.superName match {
       case null =>
         assert(classNode.name == ObjectReference.internalName, s"class with missing super type: ${classNode.name}")
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
index 79b5e6a2fb..2ccf6d6b59 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
@@ -256,13 +256,6 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
     /* The InnerClass table of a class C must contain all nested classes of C, even if they are only
      * declared but not otherwise referenced in C (from the bytecode or a method / field signature).
      * We collect them here.
-     *
-     * Nested classes that are also referenced in C will be added to the innerClassBufferASM during
-     * code generation, but those duplicates will be eliminated when emitting the InnerClass
-     * attribute.
-     *
-     * Why do we need to collect classes into innerClassBufferASM at all? To collect references to
-     * nested classes, but NOT nested in C, that are used within C.
      */
     val nestedClassSymbols = {
       val linkedClass = exitingPickler(classSym.linkedClassOfClass) // linkedCoC does not work properly in late phases
@@ -455,7 +448,7 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
   }
 
   /**
-   * For top-level objects without a companion class, the compilere generates a mirror class with
+   * For top-level objects without a companion class, the compiler generates a mirror class with
    * static forwarders (Java compat). There's no symbol for the mirror class, but we still need a
    * ClassBType (its info.nestedClasses will hold the InnerClass entries, see comment in BTypes).
    */
@@ -477,6 +470,21 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
     })
   }
 
+  def beanInfoClassClassBType(mainClass: Symbol): ClassBType = {
+    val internalName = mainClass.javaBinaryName.toString + "BeanInfo"
+    classBTypeFromInternalName.getOrElse(internalName, {
+      val c = ClassBType(internalName)
+      c.info = Right(ClassInfo(
+        superClass = Some(ScalaBeanInfoReference),
+        interfaces = Nil,
+        flags = javaFlags(mainClass),
+        nestedClasses = Nil,
+        nestedInfo = None,
+        inlineInfo = EmptyInlineInfo))
+      c
+    })
+  }
+
   /**
    * True for module classes of package level objects. The backend will generate a mirror class for
    * such objects.
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/CoreBTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/CoreBTypes.scala
index 48e43c74f4..8d55b9952e 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/CoreBTypes.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/CoreBTypes.scala
@@ -29,7 +29,7 @@ import scala.annotation.switch
 class CoreBTypes[BTFS <: BTypesFromSymbols[_ <: Global]](val bTypes: BTFS) {
   import bTypes._
   import global._
-  import rootMirror.{requiredClass, getClassIfDefined}
+  import rootMirror.{requiredClass, requiredModule, getClassIfDefined}
   import definitions._
 
   /**
@@ -116,6 +116,11 @@ class CoreBTypes[BTFS <: BTypesFromSymbols[_ <: Global]](val bTypes: BTFS) {
   lazy val classCastExceptionReference : ClassBType = classBTypeFromSymbol(ClassCastExceptionClass)   // java/lang/ClassCastException
   lazy val javaUtilMapReference        : ClassBType = classBTypeFromSymbol(JavaUtilMap)               // java/util/Map
   lazy val javaUtilHashMapReference    : ClassBType = classBTypeFromSymbol(JavaUtilHashMap)           // java/util/HashMap
+  lazy val ScalaBeanInfoReference      : ClassBType = classBTypeFromSymbol(requiredClass[scala.beans.ScalaBeanInfo])
+  lazy val jliSerializedLambda         : ClassBType = classBTypeFromSymbol(requiredClass[java.lang.invoke.SerializedLambda])
+  lazy val jliMethodHandles            : ClassBType = classBTypeFromSymbol(requiredClass[java.lang.invoke.MethodHandles])
+  lazy val jliMethodHandlesLookup      : ClassBType = classBTypeFromSymbol(exitingPickler(rootMirror.getRequiredClass("java.lang.invoke.MethodHandles.Lookup")))
+  lazy val srLambdaDeserializer        : ClassBType = classBTypeFromSymbol(requiredModule[scala.runtime.LambdaDeserializer.type].moduleClass)
 
   lazy val srBooleanRef : ClassBType = classBTypeFromSymbol(requiredClass[scala.runtime.BooleanRef])
   lazy val srByteRef    : ClassBType = classBTypeFromSymbol(requiredClass[scala.runtime.ByteRef])
@@ -214,6 +219,11 @@ trait CoreBTypesProxyGlobalIndependent[BTS <: BTypes] {
   def jioSerializableReference: ClassBType
   def javaUtilHashMapReference: ClassBType
   def javaUtilMapReference    : ClassBType
+
+  def jliSerializedLambda     : ClassBType
+  def jliMethodHandles        : ClassBType
+  def jliMethodHandlesLookup  : ClassBType
+  def srLambdaDeserializer    : ClassBType
 }
 
 /**
@@ -264,6 +274,11 @@ final class CoreBTypesProxy[BTFS <: BTypesFromSymbols[_ <: Global]](val bTypes:
   def classCastExceptionReference : ClassBType = _coreBTypes.classCastExceptionReference
   def javaUtilMapReference        : ClassBType = _coreBTypes.javaUtilMapReference
   def javaUtilHashMapReference    : ClassBType = _coreBTypes.javaUtilHashMapReference
+  def ScalaBeanInfoReference      : ClassBType = _coreBTypes.ScalaBeanInfoReference
+  def jliSerializedLambda         : ClassBType = _coreBTypes.jliSerializedLambda
+  def jliMethodHandles            : ClassBType = _coreBTypes.jliMethodHandles
+  def jliMethodHandlesLookup      : ClassBType = _coreBTypes.jliMethodHandlesLookup
+  def srLambdaDeserializer        : ClassBType = _coreBTypes.srLambdaDeserializer
 
   def srBooleanRef : ClassBType = _coreBTypes.srBooleanRef
   def srByteRef    : ClassBType = _coreBTypes.srByteRef
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala
index e1a724f1cb..35e4db33bc 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala
@@ -245,6 +245,11 @@ abstract class GenBCode extends BCodeSyncAndTry {
         BackendStats.timed(BackendStats.methodOptTimer)(localOpt.methodOptimizations(classNode))
       }
 
+      def setInnerClasses(classNode: ClassNode): Unit = if (classNode != null) {
+        classNode.innerClasses.clear()
+        addInnerClasses(classNode, bTypes.backendUtils.collectNestedClasses(classNode))
+      }
+
       def run() {
         runGlobalOptimizations()
 
@@ -257,6 +262,9 @@ abstract class GenBCode extends BCodeSyncAndTry {
           else {
             try {
               localOptimizations(item.plain)
+              setInnerClasses(item.plain)
+              setInnerClasses(item.mirror)
+              setInnerClasses(item.bean)
               addToQ3(item)
           } catch {
               case e: java.lang.RuntimeException if e.getMessage != null && (e.getMessage contains "too large!") =>
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/analysis/BackendUtils.scala b/src/compiler/scala/tools/nsc/backend/jvm/analysis/BackendUtils.scala
index 793235c131..16eb376571 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/analysis/BackendUtils.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/analysis/BackendUtils.scala
@@ -2,12 +2,14 @@ package scala.tools.nsc
 package backend.jvm
 package analysis
 
-import scala.tools.asm.Label
+import scala.annotation.switch
+import scala.tools.asm.{Handle, Type, Label}
 import scala.tools.asm.tree._
 import scala.tools.asm.tree.analysis.{Frame, BasicInterpreter, Analyzer, Value}
 import scala.tools.nsc.backend.jvm.BTypes._
 import scala.tools.nsc.backend.jvm.opt.BytecodeUtils._
 import java.lang.invoke.LambdaMetafactory
+import scala.collection.mutable
 import scala.collection.convert.decorateAsJava._
 import scala.collection.convert.decorateAsScala._
 
@@ -67,41 +69,45 @@ class BackendUtils[BT <: BTypes](val btypes: BT) {
   def addLambdaDeserialize(classNode: ClassNode): Unit = {
     val cw = classNode
     import scala.tools.asm.Opcodes._
+    import btypes.coreBTypes._
 
-    // Need to force creation of BTypes for these as `getCommonSuperClass` is called on
-    // automatically computing the max stack size (`visitMaxs`) during method writing.
-    btypes.coreBTypes.javaUtilHashMapReference
-    btypes.coreBTypes.javaUtilMapReference
+    // Make sure to reference the ClassBTypes of all types that are used in the code generated
+    // here (e.g. java/util/Map) are initialized. Initializing a ClassBType adds it to the
+    // `classBTypeFromInternalName` map. When writing the classfile, the asm ClassWriter computes
+    // stack map frames and invokes the `getCommonSuperClass` method. This method expects all
+    // ClassBTypes mentioned in the source code to exist in the map.
 
-    // This is fine, even if `visitInnerClass` was called before for MethodHandles.Lookup: duplicates are not emitted.
-    cw.visitInnerClass("java/lang/invoke/MethodHandles$Lookup", "java/lang/invoke/MethodHandles", "Lookup", ACC_PUBLIC + ACC_FINAL + ACC_STATIC)
+    val mapDesc = javaUtilMapReference.descriptor
+    val nilLookupDesc = MethodBType(Nil, jliMethodHandlesLookup).descriptor
+    val serlamObjDesc = MethodBType(jliSerializedLambda :: Nil, ObjectReference).descriptor
+    val lookupMapSerlamObjDesc = MethodBType(jliMethodHandlesLookup :: javaUtilMapReference :: jliSerializedLambda :: Nil, ObjectReference).descriptor
 
     {
-      val fv = cw.visitField(ACC_PRIVATE + ACC_STATIC + ACC_SYNTHETIC, "$deserializeLambdaCache$", "Ljava/util/Map;", null, null)
+      val fv = cw.visitField(ACC_PRIVATE + ACC_STATIC + ACC_SYNTHETIC, "$deserializeLambdaCache$", mapDesc, null, null)
       fv.visitEnd()
     }
 
     {
-      val mv = cw.visitMethod(ACC_PRIVATE + ACC_STATIC + ACC_SYNTHETIC, "$deserializeLambda$", "(Ljava/lang/invoke/SerializedLambda;)Ljava/lang/Object;", null, null)
+      val mv = cw.visitMethod(ACC_PRIVATE + ACC_STATIC + ACC_SYNTHETIC, "$deserializeLambda$", serlamObjDesc, null, null)
       mv.visitCode()
       // javaBinaryName returns the internal name of a class. Also used in BTypesFromsymbols.classBTypeFromSymbol.
-      mv.visitFieldInsn(GETSTATIC, classNode.name, "$deserializeLambdaCache$", "Ljava/util/Map;")
+      mv.visitFieldInsn(GETSTATIC, classNode.name, "$deserializeLambdaCache$", mapDesc)
       mv.visitVarInsn(ASTORE, 1)
       mv.visitVarInsn(ALOAD, 1)
       val l0 = new Label()
       mv.visitJumpInsn(IFNONNULL, l0)
-      mv.visitTypeInsn(NEW, "java/util/HashMap")
+      mv.visitTypeInsn(NEW, javaUtilHashMapReference.internalName)
       mv.visitInsn(DUP)
-      mv.visitMethodInsn(INVOKESPECIAL, "java/util/HashMap", "<init>", "()V", false)
+      mv.visitMethodInsn(INVOKESPECIAL, javaUtilHashMapReference.internalName, "<init>", "()V", false)
       mv.visitVarInsn(ASTORE, 1)
       mv.visitVarInsn(ALOAD, 1)
-      mv.visitFieldInsn(PUTSTATIC, classNode.name, "$deserializeLambdaCache$", "Ljava/util/Map;")
+      mv.visitFieldInsn(PUTSTATIC, classNode.name, "$deserializeLambdaCache$", mapDesc)
       mv.visitLabel(l0)
-      mv.visitFieldInsn(GETSTATIC, "scala/runtime/LambdaDeserializer$", "MODULE$", "Lscala/runtime/LambdaDeserializer$;")
-      mv.visitMethodInsn(INVOKESTATIC, "java/lang/invoke/MethodHandles", "lookup", "()Ljava/lang/invoke/MethodHandles$Lookup;", false)
+      mv.visitFieldInsn(GETSTATIC, srLambdaDeserializer.internalName, "MODULE$", srLambdaDeserializer.descriptor)
+      mv.visitMethodInsn(INVOKESTATIC, jliMethodHandles.internalName, "lookup", nilLookupDesc, false)
       mv.visitVarInsn(ALOAD, 1)
       mv.visitVarInsn(ALOAD, 0)
-      mv.visitMethodInsn(INVOKEVIRTUAL, "scala/runtime/LambdaDeserializer$", "deserializeLambda", "(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/util/Map;Ljava/lang/invoke/SerializedLambda;)Ljava/lang/Object;", false)
+      mv.visitMethodInsn(INVOKEVIRTUAL, srLambdaDeserializer.internalName, "deserializeLambda", lookupMapSerlamObjDesc, false)
       mv.visitInsn(ARETURN)
       mv.visitEnd()
     }
@@ -133,4 +139,121 @@ class BackendUtils[BT <: BTypes](val btypes: BT) {
     }
     (result, map, hasSerializableClosureInstantiation)
   }
+
+  /**
+   * Visit the class node and collect all referenced nested classes.
+   */
+  def collectNestedClasses(classNode: ClassNode): List[ClassBType] = {
+    val innerClasses = mutable.Set.empty[ClassBType]
+
+    def visitInternalName(internalName: InternalName): Unit = if (internalName != null) {
+      val t = classBTypeFromParsedClassfile(internalName)
+      if (t.isNestedClass.get) innerClasses += t
+    }
+
+    // either an internal/Name or [[Linternal/Name; -- there are certain references in classfiles
+    // that are either an internal name (without the surrounding `L;`) or an array descriptor
+    // `[Linternal/Name;`.
+    def visitInternalNameOrArrayReference(ref: String): Unit = if (ref != null) {
+      val bracket = ref.lastIndexOf('[')
+      if (bracket == -1) visitInternalName(ref)
+      else if (ref.charAt(bracket + 1) == 'L') visitInternalName(ref.substring(bracket + 2, ref.length - 1))
+    }
+
+    // we are only interested in the class references in the descriptor, so we can skip over
+    // primitves and the brackets of array descriptors
+    def visitDescriptor(desc: String): Unit = (desc.charAt(0): @switch) match {
+      case '(' =>
+        val internalNames = mutable.ListBuffer.empty[String]
+        var i = 1
+        while (i < desc.length) {
+          if (desc.charAt(i) == 'L') {
+            val start = i + 1 // skip the L
+            while (desc.charAt(i) != ';') i += 1
+            internalNames append desc.substring(start, i)
+          }
+          // skips over '[', ')', primitives
+          i += 1
+        }
+        internalNames foreach visitInternalName
+
+      case 'L' =>
+        visitInternalName(desc.substring(1, desc.length - 1))
+
+      case '[' =>
+        visitInternalNameOrArrayReference(desc)
+
+      case _ => // skip over primitive types
+    }
+
+    def visitConstant(const: AnyRef): Unit = const match {
+      case t: Type => visitDescriptor(t.getDescriptor)
+      case _ =>
+    }
+
+    // in principle we could references to annotation types, as they only end up as strings in the
+    // constant pool, not as class references. however, the java compiler still includes nested
+    // annotation classes in the innerClass table, so we do the same. explained in detail in the
+    // large comment in class BTypes.
+    def visitAnnotation(annot: AnnotationNode): Unit = {
+      visitDescriptor(annot.desc)
+      if (annot.values != null) annot.values.asScala foreach visitConstant
+    }
+
+    def visitAnnotations(annots: java.util.List[_ <: AnnotationNode]) = if (annots != null) annots.asScala foreach visitAnnotation
+    def visitAnnotationss(annotss: Array[java.util.List[AnnotationNode]]) = if (annotss != null) annotss foreach visitAnnotations
+
+    def visitHandle(handle: Handle): Unit = {
+      visitInternalNameOrArrayReference(handle.getOwner)
+      visitDescriptor(handle.getDesc)
+    }
+
+    visitInternalName(classNode.name)
+    innerClasses ++= classBTypeFromParsedClassfile(classNode.name).info.get.nestedClasses
+
+    visitInternalName(classNode.superName)
+    classNode.interfaces.asScala foreach visitInternalName
+    visitInternalName(classNode.outerClass)
+
+    visitAnnotations(classNode.visibleAnnotations)
+    visitAnnotations(classNode.visibleTypeAnnotations)
+    visitAnnotations(classNode.invisibleAnnotations)
+    visitAnnotations(classNode.invisibleTypeAnnotations)
+
+    for (f <- classNode.fields.asScala) {
+      visitDescriptor(f.desc)
+      visitAnnotations(f.visibleAnnotations)
+      visitAnnotations(f.visibleTypeAnnotations)
+      visitAnnotations(f.invisibleAnnotations)
+      visitAnnotations(f.invisibleTypeAnnotations)
+    }
+
+    for (m <- classNode.methods.asScala) {
+      visitDescriptor(m.desc)
+
+      visitAnnotations(m.visibleAnnotations)
+      visitAnnotations(m.visibleTypeAnnotations)
+      visitAnnotations(m.invisibleAnnotations)
+      visitAnnotations(m.invisibleTypeAnnotations)
+      visitAnnotationss(m.visibleParameterAnnotations)
+      visitAnnotationss(m.invisibleParameterAnnotations)
+      visitAnnotations(m.visibleLocalVariableAnnotations)
+      visitAnnotations(m.invisibleLocalVariableAnnotations)
+
+      m.exceptions.asScala foreach visitInternalName
+      for (tcb <- m.tryCatchBlocks.asScala) visitInternalName(tcb.`type`)
+
+      val iter = m.instructions.iterator()
+      while (iter.hasNext) iter.next() match {
+        case ti: TypeInsnNode           => visitInternalNameOrArrayReference(ti.desc)
+        case fi: FieldInsnNode          => visitInternalNameOrArrayReference(fi.owner); visitDescriptor(fi.desc)
+        case mi: MethodInsnNode         => visitInternalNameOrArrayReference(mi.owner); visitDescriptor(mi.desc)
+        case id: InvokeDynamicInsnNode  => visitDescriptor(id.desc); visitHandle(id.bsm); id.bsmArgs foreach visitConstant
+        case ci: LdcInsnNode            => visitConstant(ci.cst)
+        case ma: MultiANewArrayInsnNode => visitDescriptor(ma.desc)
+        case _ =>
+      }
+    }
+    innerClasses.toList
+  }
 }
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/BytecodeUtils.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/BytecodeUtils.scala
index 65a8c45813..25c088955f 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/opt/BytecodeUtils.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/BytecodeUtils.scala
@@ -20,7 +20,7 @@ import scala.collection.convert.decorateAsScala._
 object BytecodeUtils {
 
   // http://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.9.1
-  final val maxJVMMethodSize         = 65535
+  final val maxJVMMethodSize = 65535
 
   // 5% margin, more than enough for the instructions added by the inliner (store / load args, null check for instance methods)
   final val maxMethodSizeAfterInline = maxJVMMethodSize - (maxJVMMethodSize / 20)
diff --git a/test/files/jvm/innerClassAttribute/Classes_1.scala b/test/files/jvm/innerClassAttribute/Classes_1.scala
index 2b690bdd7b..5b821d43f8 100644
--- a/test/files/jvm/innerClassAttribute/Classes_1.scala
+++ b/test/files/jvm/innerClassAttribute/Classes_1.scala
@@ -13,7 +13,7 @@ object A3 {
 
 class A4 {
   def f(l: List[String]): List[String] = {
-    l map (_ + "1")
+    l map (_ + "1") : @noinline // inlining adds a reference to the nested class scala/collection/generic/GenTraversableFactory$GenericCanBuildFrom
   }
 }
 
@@ -274,8 +274,8 @@ object NestedInValueClass {
   class A(val arg: String) extends AnyVal {
     // A has InnerClass entries for the two closures (and for A and A$). not for B / C
     def f = {
-      def g = List().map(x => ((s: String) => x)) // outer class A, no outer method (g is moved to the companion, doesn't exist in A)
-      g.map(x => ((s: String) => x))              // outer class A, outer method f
+      def g = List().map(x => ((s: String) => x)): @noinline // outer class A, no outer method (g is moved to the companion, doesn't exist in A)
+      g.map(x => ((s: String) => x)): @noinline              // outer class A, outer method f
     }
     // statements and field declarations are not allowed in value classes
   }
diff --git a/test/files/jvm/innerClassAttribute/Test.scala b/test/files/jvm/innerClassAttribute/Test.scala
index 702e5e279a..903d08f72d 100644
--- a/test/files/jvm/innerClassAttribute/Test.scala
+++ b/test/files/jvm/innerClassAttribute/Test.scala
@@ -23,7 +23,7 @@ object Test extends BytecodeTest {
 
   def testInner(cls: String, fs: (InnerClassNode => Unit)*) = {
     val ns = innerClassNodes(cls)
-    assert(ns.length == fs.length, ns)
+    assert(ns.length == fs.length, ns.map(_.name))
     (ns zip fs.toList) foreach { case (n, f) => f(n) }
   }