Fix InnerClass / EnclosingMethod attributes

This commit seems bigger than it is. Most of it is tests, and moving
some code around. The actual changes are small, but a bit subtle.

The InnerClass and EnclosingMethod attributes should now be close to
the JVM spec (which is summarized in BTypes.scala). New tests make
sure that changes to these attributes, and changes to the way Java
reflection sees Scala classfiles, don't go unnoticed.

A new file, BCodeAsmCommon, holds code that's shared between the two
backend (it could hold more, future work).

In general, the difficulty with emitting InnerClass / EnclosingMethod
is that we need to find out source-level properties. We need to make
sure to do enough phase-travelling, and work around destructive
changes to the ownerchain in lambdalift (we use originalOwner a lot).

The change to JavaMirrors is prompted by the change to the
EnclosingMethod attribute, which changes Java reflection's answer to
getEnclosingMethod and getEnclosingConstructor. Classes defined in
field initializers no longer have an enclosing method, just an
enclosing class, which broke an assumption in JavaMirrors.

There's one change in erasure. Before this change, when an object
declaration implements / overrides a method, and a bridge is required,
then the bridge method was actually a ModuleSymbol (it would get the
lateMETHOD flag and be emitted as a method anyway). This is confusing,
when iterating through the members of a class, you can find two
modules with the same name, and one of them doesn't have a module
class. Now, such bridge methods will be MethodSymbols.

Removed Symbol.originalEnclosingMethod, that is a backend thing and
doesn't need to live in the symbol API.

8 files changed, 254 insertions, 174 deletions

diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala
new file mode 100644
index 0000000000..e5b4c4a6c2
--- /dev/null
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala
@@ -0,0 +1,130 @@
+/* NSC -- new Scala compiler
+ * Copyright 2005-2014 LAMP/EPFL
+ * @author  Martin Odersky
+ */
+
+package scala.tools.nsc.backend.jvm
+
+import scala.tools.nsc.Global
+import PartialFunction._
+
+/**
+ * This trait contains code shared between GenBCode and GenASM that depends on types defined in
+ * the compiler cake (Global).
+ */
+final class BCodeAsmCommon[G <: Global](val global: G) {
+  import global._
+
+  /**
+   * True if `classSym` is an anonymous class or a local class. I.e., false if `classSym` is a
+   * member class. This method is used to decide if we should emit an EnclosingMethod attribute.
+   * It is also used to decide whether the "owner" field in the InnerClass attribute should be
+   * null.
+   */
+  def isAnonymousOrLocalClass(classSym: Symbol): Boolean = {
+    def isDelambdafyLambdaClass(classSym: Symbol): Boolean = {
+      classSym.isAnonymousFunction && (settings.Ydelambdafy.value == "method")
+    }
+
+    assert(classSym.isClass, s"not a class: $classSym")
+
+    !isDelambdafyLambdaClass(classSym) &&
+      (classSym.isAnonymousClass || !classSym.originalOwner.isClass)
+  }
+
+  /**
+   * Returns the enclosing method for non-member classes. In the following example
+   *
+   * class A {
+   *   def f = {
+   *     class B {
+   *       class C
+   *     }
+   *   }
+   * }
+   *
+   * the method returns Some(f) for B, but None for C, because C is a member class. For non-member
+   * classes that are not enclosed by a method, it returns None:
+   *
+   * class A {
+   *   { class B }
+   * }
+   *
+   * In this case, for B, we return None.
+   *
+   * The EnclosingMethod attribute needs to be added to non-member classes (see doc in BTypes).
+   * This is a source-level property, so we need to use the originalOwner chain to reconstruct it.
+   */
+  private def enclosingMethodForEnclosingMethodAttribute(classSym: Symbol): Option[Symbol] = {
+    assert(classSym.isClass, classSym)
+    def enclosingMethod(sym: Symbol): Option[Symbol] = {
+      if (sym.isClass || sym == NoSymbol) None
+      else if (sym.isMethod) Some(sym)
+      else enclosingMethod(sym.originalOwner)
+    }
+    enclosingMethod(classSym.originalOwner)
+  }
+
+  /**
+   * The enclosing class for emitting the EnclosingMethod attribute. Since this is a source-level
+   * property, this method looks at the originalOwner chain. See doc in BTypes.
+   */
+  private def enclosingClassForEnclosingMethodAttribute(classSym: Symbol): Symbol = {
+    assert(classSym.isClass, classSym)
+    def enclosingClass(sym: Symbol): Symbol = {
+      if (sym.isClass) sym
+      else enclosingClass(sym.originalOwner)
+    }
+    enclosingClass(classSym.originalOwner)
+  }
+
+  final case class EnclosingMethodEntry(owner: String, name: String, methodDescriptor: String)
+
+  /**
+   * If data for emitting an EnclosingMethod attribute. None if `classSym` is a member class (not
+   * an anonymous or local class). See doc in BTypes.
+   *
+   * The class is parametrized by two functions to obtain a bytecode class descriptor for a class
+   * symbol, and to obtain a method signature descriptor fro a method symbol. These function depend
+   * on the implementation of GenASM / GenBCode, so they need to be passed in.
+   */
+  def enclosingMethodAttribute(classSym: Symbol, classDesc: Symbol => String, methodDesc: Symbol => String): Option[EnclosingMethodEntry] = {
+    if (isAnonymousOrLocalClass(classSym)) {
+      val methodOpt = enclosingMethodForEnclosingMethodAttribute(classSym)
+      debuglog(s"enclosing method for $classSym is $methodOpt (in ${methodOpt.map(_.enclClass)})")
+      Some(EnclosingMethodEntry(
+        classDesc(enclosingClassForEnclosingMethodAttribute(classSym)),
+        methodOpt.map(_.javaSimpleName.toString).orNull,
+        methodOpt.map(methodDesc).orNull))
+    } else {
+      None
+    }
+  }
+
+  /**
+   * This is basically a re-implementation of sym.isStaticOwner, but using the originalOwner chain.
+   *
+   * The problem is that we are interested in a source-level property. Various phases changed the
+   * symbol's properties in the meantime, mostly lambdalift modified (destructively) the owner.
+   * Therefore, `sym.isStatic` is not what we want. For example, in
+   *   object T { def f { object U } }
+   * the owner of U is T, so UModuleClass.isStatic is true. Phase travel does not help here.
+   */
+  def isOriginallyStaticOwner(sym: Symbol): Boolean = {
+    sym.isPackageClass || sym.isModuleClass && isOriginallyStaticOwner(sym.originalOwner)
+  }
+
+  /**
+   * The member classes of a class symbol. Note that the result of this method depends on the
+   * current phase, for example, after lambdalift, all local classes become member of the enclosing
+   * class.
+   */
+  def memberClassesOf(classSymbol: Symbol): List[Symbol] = classSymbol.info.decls.collect({
+    case sym if sym.isClass =>
+      sym
+    case sym if sym.isModule =>
+      val r = exitingPickler(sym.moduleClass)
+      assert(r != NoSymbol, sym.fullLocationString)
+      r
+  })(collection.breakOut)
+}
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala
index 2e629485a0..397171049f 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala
@@ -23,8 +23,8 @@ import scala.tools.asm
 abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
   import global._
   import definitions._
-  import bCodeICodeCommon._
   import bTypes._
+  import bCodeICodeCommon._
   import coreBTypes._
 
   /*
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala
index 18a9bad1b7..aed3654b2c 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala
@@ -789,55 +789,6 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
         new java.lang.Long(id)
       ).visitEnd()
     }
-
-    /*
-     * @param owner internal name of the enclosing class of the class.
-     *
-     * @param name the name of the method that contains the class.
-
-     * @param methodType the method that contains the class.
-     */
-    case class EnclMethodEntry(owner: String, name: String, methodType: BType)
-
-    /*
-     * @return null if the current class is not internal to a method
-     *
-     * Quoting from JVMS 4.7.7 The EnclosingMethod Attribute
-     *   A class must have an EnclosingMethod attribute if and only if it is a local class or an anonymous class.
-     *   A class may have no more than one EnclosingMethod attribute.
-     *
-     * must-single-thread
-     */
-    def getEnclosingMethodAttribute(clazz: Symbol): EnclMethodEntry = { // JVMS 4.7.7
-
-      def newEEE(eClass: Symbol, m: Symbol) = {
-        EnclMethodEntry(
-          internalName(eClass),
-          m.javaSimpleName.toString,
-          asmMethodType(m)
-        )
-      }
-
-      var res: EnclMethodEntry = null
-      val sym = clazz.originalEnclosingMethod
-      if (sym.isMethod) {
-        debuglog(s"enclosing method for $clazz is $sym (in ${sym.enclClass})")
-        res = newEEE(sym.enclClass, sym)
-      } else if (clazz.isAnonymousClass) {
-        val enclClass = clazz.rawowner
-        assert(enclClass.isClass, enclClass)
-        val sym = enclClass.primaryConstructor
-        if (sym == NoSymbol) {
-          log(s"Ran out of room looking for an enclosing method for $clazz: no constructor here: $enclClass.")
-        } else {
-          debuglog(s"enclosing method for $clazz is $sym (in $enclClass)")
-          res = newEEE(enclClass, sym)
-        }
-      }
-
-      res
-    }
-
   } // end of trait BCClassGen
 
   /* basic functionality for class file building of plain, mirror, and beaninfo classes. */
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala
index 5d187168db..d58368b19d 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala
@@ -19,8 +19,6 @@ import scala.collection.mutable
  *
  */
 abstract class BCodeIdiomatic extends SubComponent {
-  protected val bCodeICodeCommon: BCodeICodeCommon[global.type] = new BCodeICodeCommon(global)
-
   val bTypes = new BTypesFromSymbols[global.type](global)
 
   import global._
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala
index 3f3c0d0620..4592031a31 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala
@@ -27,6 +27,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers {
   import global._
   import bTypes._
   import coreBTypes._
+  import bCodeAsmCommon._
 
   /*
    * There's a dedicated PlainClassBuilder for each CompilationUnit,
@@ -153,10 +154,10 @@ abstract class BCodeSkelBuilder extends BCodeHelpers {
         cnode.visitSource(cunit.source.toString, null /* SourceDebugExtension */)
       }
 
-      val enclM = getEnclosingMethodAttribute(claszSymbol)
-      if (enclM != null) {
-        val EnclMethodEntry(className, methodName, methodType) = enclM
-        cnode.visitOuterClass(className, methodName, methodType.descriptor)
+      enclosingMethodAttribute(claszSymbol, internalName, asmMethodType(_).descriptor) match {
+        case Some(EnclosingMethodEntry(className, methodName, methodDescriptor)) =>
+          cnode.visitOuterClass(className, methodName, methodDescriptor)
+        case _ => ()
       }
 
       val ssa = getAnnotPickle(thisName, claszSymbol)
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala
index 389dbe43eb..7bf61b4f51 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala
@@ -403,9 +403,11 @@ abstract class BTypes {
    * Fields in the InnerClass entries:
    *  - inner class: the (nested) class C we are talking about
    *  - outer class: the class of which C is a member. Has to be null for non-members, i.e. for
-   *                 local and anonymous classes.
+   *                 local and anonymous classes. NOTE: this co-incides with the presence of an
+   *                 EnclosingMethod attribute (see below)
    *  - inner name:  A string with the simple name of the inner class. Null for anonymous classes.
-   *  - flags:       access property flags, details in JVMS, table in 4.7.6.
+   *  - flags:       access property flags, details in JVMS, table in 4.7.6. Static flag: see
+   *                 discussion below.
    *
    *
    * Note 1: when a nested class is present in the InnerClass attribute, all of its enclosing
@@ -446,6 +448,13 @@ abstract class BTypes {
    * JVMS 4.7.7: the attribute must be present "if and only if it represents a local class
    * or an anonymous class" (i.e. not for member classes).
    *
+   * The attribute is mis-named, it should be called "EnclosingClass". It has to be defined for all
+   * local and anonymous classes, no matter if there is an enclosing method or not. Accordingly, the
+   * "class" field (see below) must be always defined, while the "method" field may be null.
+   *
+   * NOTE: When a EnclosingMethod attribute is requried (local and anonymous classes), the "outer"
+   * field in the InnerClass table must be null.
+   *
    * Fields:
    *  - class:  the enclosing class
    *  - method: the enclosing method (or constructor). Null if the class is not enclosed by a
@@ -456,9 +465,8 @@ abstract class BTypes {
    *            Note: the field is required for anonymous classes defined within local variable
    *            initializers (within a method), Java example below (**).
    *
-   *            Currently, the Scala compiler sets "method" to the class constructor for classes
-   *            defined in initializer blocks or field initializers. This is probably OK, since the
-   *            Scala compiler desugars these statements into to the primary constructor.
+   *            For local and anonymous classes in initializer blocks or field initializers, and
+   *            class-level anonymous classes, the scala compiler sets the "method" field to null.
    *
    *
    * (*)
@@ -520,30 +528,37 @@ abstract class BTypes {
    * STATIC flag
    * -----------
    *
-   * Java: static nested classes have the "static" flag in the InnerClass attribute. This is not the
-   * case for local classes defined within a static method, even though such classes, as they are
-   * defined in a static context, don't take an "outer" instance.
-   * Non-static nested classes (inner classes, including local classes defined in a non-static
-   * method) take an "outer" instance on construction.
+   * Java: static member classes have the static flag in the InnerClass attribute, for example B in
+   *   class A { static class B { } }
+   *
+   * The spec is not very clear about when the static flag should be emitted. It says: "Marked or
+   * implicitly static in source."
+   *
+   * The presence of the static flag does NOT coincide with the absence of an "outer" field in the
+   * class. The java compiler never puts the static flag for local classes, even if they don't have
+   * an outer pointer:
+   *
+   *   class A {
+   *     void f()        { class B {} }
+   *     static void g() { calss C {} }
+   *   }
+   *
+   * B has an outer pointer, C doesn't. Both B and C are NOT marked static in the InnerClass table.
+   *
+   * It seems sane to follow the same principle in the Scala compiler. So:
    *
-   * Scala: Explicitouter adds an "outer" parameter to nested classes, except for classes defined
-   * in a static context, i.e. when all outer classes are module classes.
    *   package p
    *   object O1 {
-   *     class C1 // static
-   *     object O2 {
+   *     class C1 // static inner class
+   *     object O2 { // static inner module
    *       def f = {
-   *         class C2 { // static
-   *           class C3 // non-static, needs outer
+   *         class C2 { // non-static inner class, even though there's no outer pointer
+   *           class C3 // non-static, has an outer pointer
    *         }
    *       }
    *     }
    *   }
    *
-   * Int the InnerClass attribute, the `static` flag is added for all classes defined in a static
-   * context, i.e. also for C2. This is different than in Java.
-   *
-   *
    * Mirror Classes
    * --------------
    *
@@ -799,7 +814,12 @@ abstract class BTypes {
    *                            to the InnerClass table, enclosing nested classes are also added.
    * @param outerName           The outerName field in the InnerClass entry, may be None.
    * @param innerName           The innerName field, may be None.
-   * @param isStaticNestedClass True if this is a static nested class (not inner class).
+   * @param isStaticNestedClass True if this is a static nested class (not inner class) (*)
+   *
+   * (*) Note that the STATIC flag in ClassInfo.flags, obtained through javaFlags(classSym), is not
+   * correct for the InnerClass entry, see javaFlags. The static flag in the InnerClass describes
+   * a source-level propety: if the class is in a static context (does not have an outer pointer).
+   * This is checked when building the NestedInfo.
    */
   case class NestedInfo(enclosingClass: ClassBType,
                         outerName: Option[String],
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
index da3244ba23..0e2f938602 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
@@ -24,6 +24,10 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
   import global._
   import definitions._
 
+  val bCodeICodeCommon: BCodeICodeCommon[global.type] = new BCodeICodeCommon(global)
+  val bCodeAsmCommon: BCodeAsmCommon[global.type] = new BCodeAsmCommon(global)
+  import bCodeAsmCommon._
+
   // Why the proxy, see documentation of class [[CoreBTypes]].
   val coreBTypes = new CoreBTypesProxy[this.type](this)
   import coreBTypes._
@@ -114,45 +118,63 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
 
     val flags = javaFlags(classSym)
 
-    def classOrModuleClass(sym: Symbol): Symbol = {
-      if      (sym.isClass)  sym
-      else if (sym.isModule) sym.moduleClass
-      else                   NoSymbol
-    }
-
-    /* The InnerClass table must contain all nested classes. Local or anonymous classes (not
-     * members) are referenced from the emitted code of the class, so they are in innerClassBuffer.
+    /* 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.
      *
-     * TODO @lry check the above. For example: class C { def foo = { class D; 0 } }, is D added?
+     * 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.
      *
-     * For member classes however, there might be no reference at all in the code of the class.
-     * The JMV spec still requires those classes to be added to the InnerClass table, so we collect
-     * them here.
+     * Why doe 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 memberClassSymbols = exitingErasure {
-      // time travel to a time before lambdalift (which lifts local classes up to the class, making them members)
-      for (sym <- List(classSym, classSym.linkedClassOfClass);
-           memberClass <- sym.info.decls.map(classOrModuleClass) if memberClass.isClass)
-      yield memberClass
+    val nestedClassSymbols = {
+      // The lambdalift phase lifts all nested classes to the enclosing class, so if we collect
+      // member classes right after lambdalift, we obtain all nested classes, including local and
+      // anonymous ones.
+      val nestedClasses = exitingPhase(currentRun.lambdaliftPhase)(memberClassesOf(classSym))
+
+      // If this is a top-level class, and it has a companion object, the member classes of the
+      // companion are added as members of the class. For example:
+      //   class C { }
+      //   object C {
+      //     class D
+      //     def f = { class E }
+      //   }
+      // The class D is added as a member of class C. The reason is that the InnerClass attribute
+      // for D will containt class "C" and NOT the module class "C$" as the outer class of D.
+      // This is done by buildNestedInfo, the reason is Java compatibility, see comment in BTypes.
+      // For consistency, the InnerClass entry for D needs to be present in C - to Java it looks
+      // like D is a member of C, not C$.
+      val linkedClass = exitingPickler(classSym.linkedClassOfClass) // linkedCoC does not work properly in late phases
+      val companionModuleMembers = {
+        // phase travel to exitingPickler: this makes sure that memberClassesOf only sees member classes,
+        // not local classes of the companion module (E in the exmaple) that were lifted by lambdalift.
+        if (isTopLevelModuleClass(linkedClass)) exitingPickler(memberClassesOf(linkedClass))
+        else Nil
+      }
+
+      nestedClasses ++ companionModuleMembers
     }
 
     /**
      * For nested java classes, the scala compiler creates both a class and a module (and therefore
-     * a module class) symbol. For example, in `class A { class B {} }`, the memberClassSymbols
+     * a module class) symbol. For example, in `class A { class B {} }`, the nestedClassSymbols
      * for A contain both the class B and the module class B.
      * Here we get rid of the module class B, making sure that the class B is present.
      */
-    val memberClassSymbolsNoJavaModuleClasses = memberClassSymbols.filter(s => {
+    val nestedClassSymbolsNoJavaModuleClasses = nestedClassSymbols.filter(s => {
       if (s.isJavaDefined && s.isModuleClass) {
-        // We could also search in memberClassSymbols for s.linkedClassOfClass, but sometimes that
+        // We could also search in nestedClassSymbols for s.linkedClassOfClass, but sometimes that
         // returns NoSymbol, so it doesn't work.
-        val nb = memberClassSymbols.count(mc => mc.name == s.name && mc.owner == s.owner)
-        assert(nb == 2, s"Java member module without member class: $s - $memberClassSymbols")
+        val nb = nestedClassSymbols.count(mc => mc.name == s.name && mc.owner == s.owner)
+        assert(nb == 2, s"Java member module without member class: $s - $nestedClassSymbols")
         false
       } else true
     })
 
-    val memberClasses = memberClassSymbolsNoJavaModuleClasses.map(classBTypeFromSymbol)
+    val memberClasses = nestedClassSymbolsNoJavaModuleClasses.map(classBTypeFromSymbol)
 
     val nestedInfo = buildNestedInfo(classSym)
 
@@ -207,10 +229,8 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
     val isNested = !innerClassSym.rawowner.isPackageClass
     if (!isNested) None
     else {
-      // Phase travel to a time where the owner chain is in its original form. Example:
-      //   object T { def f { class C } }
-      // C is an inner class (not a static nested class), see InnerClass summary in BTypes.
-      val isStaticNestedClass = enteringPickler(innerClassSym.isStatic)
+      // See comment in BTypes, when is a class marked static in the InnerClass table.
+      val isStaticNestedClass = isOriginallyStaticOwner(innerClassSym.originalOwner)
 
       // After lambdalift (which is where we are), the rawowoner field contains the enclosing class.
       val enclosingClassSym = {
@@ -220,15 +240,20 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
           // nested class, the symbol for D is nested in the module class C (not in the class C).
           // For the InnerClass attribute, we use the class symbol C, which represents the situation
           // in the source code.
-          assert(innerClassSym.isStatic, innerClassSym.rawowner)
-          innerClassSym.rawowner.linkedClassOfClass
+
+          // Cannot use innerClassSym.isStatic: this method looks at the owner, which is a package
+          // at this pahse (after lambdalift, flatten).
+          assert(isOriginallyStaticOwner(innerClassSym.originalOwner), innerClassSym.originalOwner)
+
+          // phase travel for linkedCoC - does not always work in late phases
+          exitingPickler(innerClassSym.rawowner.linkedClassOfClass)
         }
         else innerClassSym.rawowner
       }
       val enclosingClass: ClassBType = classBTypeFromSymbol(enclosingClassSym)
 
       val outerName: Option[String] = {
-        if (innerClassSym.originalEnclosingMethod != NoSymbol) {
+        if (isAnonymousOrLocalClass(innerClassSym)) {
           None
         } else {
           val outerName = innerClassSym.rawowner.javaBinaryName
@@ -266,23 +291,10 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
    * for such objects will get a MODULE$ flag and a corresponding static initializer.
    */
   final def isStaticModuleClass(sym: Symbol): Boolean = {
-    /* The implementation of this method is tricky because it is a source-level property. Various
-     * phases changed the symbol's properties in the meantime.
-     *
-     * (1) Phase travel to to pickler is required to exclude implementation classes; they have the
+    /* (1) Phase travel to to pickler is required to exclude implementation classes; they have the
      * lateMODULEs after mixin, so isModuleClass would be true.
-     *
-     * (2) We cannot use `sym.isStatic` because lambdalift modified (destructively) the owner. For
-     * example, in
-     *   object T { def f { object U } }
-     * the owner of U is T, so UModuleClass.isStatic is true. Phase travel does not help here.
-     * So we basically re-implement `sym.isStaticOwner`, but using the original owner chain.
+     * (2) isStaticModuleClass is a source-level property. See comment on isOriginallyStaticOwner.
      */
-
-    def isOriginallyStaticOwner(sym: Symbol): Boolean = {
-      sym.isPackageClass || sym.isModuleClass && isOriginallyStaticOwner(sym.originalOwner)
-    }
-
     exitingPickler { // (1)
       sym.isModuleClass &&
       isOriginallyStaticOwner(sym.originalOwner) // (2)
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala
index 2392033760..2593903b9d 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala
@@ -26,6 +26,9 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM {
   import icodes.opcodes._
   import definitions._
 
+  val bCodeAsmCommon: BCodeAsmCommon[global.type] = new BCodeAsmCommon(global)
+  import bCodeAsmCommon._
+
   // Strangely I can't find this in the asm code
   // 255, but reserving 1 for "this"
   final val MaximumJvmParameters = 254
@@ -621,7 +624,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM {
        * That means non-member classes (anonymous). See Section 4.7.5 in the JVMS.
        */
       def outerName(innerSym: Symbol): String = {
-        if (innerSym.originalEnclosingMethod != NoSymbol)
+        if (isAnonymousOrLocalClass(innerSym))
           null
         else {
           val outerName = javaName(innerSym.rawowner)
@@ -636,13 +639,16 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM {
         else
           innerSym.rawname + innerSym.moduleSuffix
 
-      // add inner classes which might not have been referenced yet
-      // TODO @lry according to the spec, all nested classes should be added, also local and
-      // anonymous. This seems to add only member classes - or not? it's exitingErasure, so maybe
-      // local / anonymous classes have been lifted by lambdalift. are they in the "decls" though?
-      exitingErasure {
-        for (sym <- List(csym, csym.linkedClassOfClass); m <- sym.info.decls.map(innerClassSymbolFor) if m.isClass)
-          innerClassBuffer += m
+      // This collects all inner classes of csym, including local and anonymous: lambdalift makes
+      // them members of their enclosing class.
+      innerClassBuffer ++= exitingPhase(currentRun.lambdaliftPhase)(memberClassesOf(csym))
+
+      // Add members of the companion object (if top-level). why, see comment in BTypes.scala.
+      val linkedClass = exitingPickler(csym.linkedClassOfClass) // linkedCoC does not work properly in late phases
+      if (isTopLevelModule(linkedClass)) {
+        // phase travel to exitingPickler: this makes sure that memberClassesOf only sees member classes,
+        // not local classes that were lifted by lambdalift.
+        innerClassBuffer ++= exitingPickler(memberClassesOf(linkedClass))
       }
 
       val allInners: List[Symbol] = innerClassBuffer.toList filterNot deadCode.elidedClosures
@@ -656,7 +662,8 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM {
         // sort them so inner classes succeed their enclosing class to satisfy the Eclipse Java compiler
         for (innerSym <- allInners sortBy (_.name.length)) { // TODO why not sortBy (_.name.toString()) ??
           val flagsWithFinal: Int = mkFlags(
-            if (innerSym.rawowner.hasModuleFlag) asm.Opcodes.ACC_STATIC else 0,
+            // See comment in BTypes, when is a class marked static in the InnerClass table.
+            if (isOriginallyStaticOwner(innerSym.originalOwner)) asm.Opcodes.ACC_STATIC else 0,
             javaFlags(innerSym),
             if(isDeprecated(innerSym)) asm.Opcodes.ACC_DEPRECATED else 0 // ASM pseudo-access flag
           ) & (INNER_CLASSES_FLAGS | asm.Opcodes.ACC_DEPRECATED)
@@ -1222,10 +1229,10 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM {
                            null /* SourceDebugExtension */)
       }
 
-      val enclM = getEnclosingMethodAttribute()
-      if(enclM != null) {
-        val EnclMethodEntry(className, methodName, methodType) = enclM
-        jclass.visitOuterClass(className, methodName, methodType.getDescriptor)
+      enclosingMethodAttribute(clasz.symbol, javaName, javaType(_).getDescriptor) match {
+        case Some(EnclosingMethodEntry(className, methodName, methodDescriptor)) =>
+          jclass.visitOuterClass(className, methodName, methodDescriptor)
+        case _ => ()
       }
 
       // typestate: entering mode with valid call sequences:
@@ -1286,45 +1293,6 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM {
       writeIfNotTooBig("" + c.symbol.name, thisName, jclass, c.symbol)
     }
 
-    /**
-     * @param owner internal name of the enclosing class of the class.
-     *
-     * @param name the name of the method that contains the class.
-
-     * @param methodType the method that contains the class.
-     */
-    case class EnclMethodEntry(owner: String, name: String, methodType: asm.Type)
-
-    /**
-     * @return null if the current class is not internal to a method
-     *
-     * Quoting from JVMS 4.7.7 The EnclosingMethod Attribute
-     *   A class must have an EnclosingMethod attribute if and only if it is a local class or an anonymous class.
-     *   A class may have no more than one EnclosingMethod attribute.
-     *
-     */
-    private def getEnclosingMethodAttribute(): EnclMethodEntry = { // JVMS 4.7.7
-      var res: EnclMethodEntry = null
-      val clazz = clasz.symbol
-      val sym = clazz.originalEnclosingMethod
-      if (sym.isMethod) {
-        debuglog("enclosing method for %s is %s (in %s)".format(clazz, sym, sym.enclClass))
-        res = EnclMethodEntry(javaName(sym.enclClass), javaName(sym), javaType(sym))
-      } else if (clazz.isAnonymousClass) {
-        val enclClass = clazz.rawowner
-        assert(enclClass.isClass, enclClass)
-        val sym = enclClass.primaryConstructor
-        if (sym == NoSymbol) {
-          log("Ran out of room looking for an enclosing method for %s: no constructor here.".format(enclClass))
-        } else {
-          debuglog("enclosing method for %s is %s (in %s)".format(clazz, sym, enclClass))
-          res = EnclMethodEntry(javaName(enclClass), javaName(sym), javaType(sym))
-        }
-      }
-
-      res
-    }
-
     def genField(f: IField) {
       debuglog("Adding field: " + f.symbol.fullName)