Merge pull request #4296 from lrytz/t9105

Fixes and tests for InnerClass / EnclsoingMethod classfile attributes

8 files changed, 280 insertions, 74 deletions

diff --git a/src/compiler/scala/tools/nsc/CompilationUnits.scala b/src/compiler/scala/tools/nsc/CompilationUnits.scala
index 1a6843a249..6be1fda1b5 100644
--- a/src/compiler/scala/tools/nsc/CompilationUnits.scala
+++ b/src/compiler/scala/tools/nsc/CompilationUnits.scala
@@ -25,9 +25,9 @@ trait CompilationUnits { global: Global =>
   class CompilationUnit(val source: SourceFile) extends CompilationUnitContextApi { self =>
 
     /** the fresh name creator */
-    implicit val fresh: FreshNameCreator     = new FreshNameCreator
-    def freshTermName(prefix: String = "x$") = global.freshTermName(prefix)
-    def freshTypeName(prefix: String)        = global.freshTypeName(prefix)
+    implicit val fresh: FreshNameCreator                           = new FreshNameCreator
+    def freshTermName(prefix: String = nme.FRESH_TERM_NAME_PREFIX) = global.freshTermName(prefix)
+    def freshTypeName(prefix: String)                              = global.freshTypeName(prefix)
 
     /** the content of the compilation unit in tree form */
     var body: Tree = EmptyTree
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala
index a5f33aa786..27827015c3 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala
@@ -22,6 +22,31 @@ final class BCodeAsmCommon[G <: Global](val global: G) {
   }
 
   /**
+   * True for classes generated by the Scala compiler that are considered top-level in terms of
+   * the InnerClass / EnclosingMethod classfile attributes. See comment in BTypes.
+   */
+  def considerAsTopLevelImplementationArtifact(classSym: Symbol) = {
+    classSym.isImplClass || classSym.isSpecialized
+  }
+
+  /**
+   * Cache the value of delambdafy == "inline" for each run. We need to query this value many
+   * times, so caching makes sense.
+   */
+  object delambdafyInline {
+    private var runId = -1
+    private var value = false
+
+    def apply(): Boolean = {
+      if (runId != global.currentRunId) {
+        runId = global.currentRunId
+        value = settings.Ydelambdafy.value == "inline"
+      }
+      value
+    }
+  }
+
+  /**
    * 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
@@ -29,10 +54,68 @@ final class BCodeAsmCommon[G <: Global](val global: G) {
    */
   def isAnonymousOrLocalClass(classSym: Symbol): Boolean = {
     assert(classSym.isClass, s"not a class: $classSym")
-    // Here used to be an `assert(!classSym.isDelambdafyFunction)`: delambdafy lambda classes are
-    // always top-level. However, SI-8900 shows an example where the weak name-based implementation
-    // of isDelambdafyFunction failed (for a function declared in a package named "lambda").
-    classSym.isAnonymousClass || !classSym.originalOwner.isClass
+    val r = exitingPickler(classSym.isAnonymousClass) || !classSym.originalOwner.isClass
+    if (r && settings.Ybackend.value == "GenBCode") {
+      // this assertion only holds in GenBCode. lambda lift renames symbols and may accidentally
+      // introduce `$lambda` into a class name, making `isDelambdafyFunction` true. under GenBCode
+      // we prevent this, see `nonAnon` in LambdaLift.
+      // phase travel necessary: after flatten, the name includes the name of outer classes.
+      // if some outer name contains $lambda, a non-lambda class is considered lambda.
+      assert(exitingPickler(!classSym.isDelambdafyFunction), classSym.name)
+    }
+    r
+  }
+
+  /**
+   * The next enclosing definition in the source structure. Includes anonymous function classes
+   * under delambdafy:inline, even though they are only generated during UnCurry.
+   */
+  def nextEnclosing(sym: Symbol): Symbol = {
+    val origOwner = sym.originalOwner
+    // phase travel necessary: after flatten, the name includes the name of outer classes.
+    // if some outer name contains $anon, a non-anon class is considered anon.
+    if (delambdafyInline() && sym.rawowner.isAnonymousFunction) {
+      // SI-9105: special handling for anonymous functions under delambdafy:inline.
+      //
+      //   class C { def t = () => { def f { class Z } } }
+      //
+      //   class C { def t = byNameMethod { def f { class Z } } }
+      //
+      // In both examples, the method f lambda-lifted into the anonfun class.
+      //
+      // In both examples, the enclosing method of Z is f, the enclosing class is the anonfun.
+      // So nextEnclosing needs to return the following chain:  Z - f - anonFunClassSym - ...
+      //
+      // In the first example, the initial owner of f is a TermSymbol named "$anonfun" (note: not the anonFunClassSym!)
+      // In the second, the initial owner of f is t (no anon fun term symbol for by-name args!).
+      //
+      // In both cases, the rawowner of class Z is the anonFunClassSym. So the check in the `if`
+      // above makes sure we don't jump over the anonymous function in the by-name argument case.
+      //
+      // However, we cannot directly return the rawowner: if `sym` is Z, we need to include method f
+      // in the result. This is done by comparing the rawowners (read: lambdalift-targets) of `sym`
+      // and `sym.originalOwner`: if they are the same, then the originalOwner is "in between", and
+      // we need to return it.
+      // If the rawowners are different, the symbol was not in between. In the first example, the
+      // originalOwner of `f` is the anonfun-term-symbol, whose rawowner is C. So the nextEnclosing
+      // of `f` is its rawowner, the anonFunClassSym.
+      //
+      // In delambdafy:method we don't have that problem. The f method is lambda-lifted into C,
+      // not into the anonymous function class. The originalOwner chain is Z - f - C.
+      if (sym.originalOwner.rawowner == sym.rawowner) sym.originalOwner
+      else sym.rawowner
+    } else {
+      origOwner
+    }
+  }
+
+  def nextEnclosingClass(sym: Symbol): Symbol = {
+    if (sym.isClass) sym
+    else nextEnclosingClass(nextEnclosing(sym))
+  }
+
+  def classOriginallyNestedInClass(nestedClass: Symbol, enclosingClass: Symbol) ={
+    nextEnclosingClass(nextEnclosing(nestedClass)) == enclosingClass
   }
 
   /**
@@ -60,12 +143,27 @@ final class BCodeAsmCommon[G <: Global](val global: G) {
    */
   private def enclosingMethodForEnclosingMethodAttribute(classSym: Symbol): Option[Symbol] = {
     assert(classSym.isClass, classSym)
+
+    def doesNotExist(method: Symbol) = {
+      // (1) SI-9124, some trait methods don't exist in the generated interface. see comment in BTypes.
+      // (2) Value classes. Member methods of value classes exist in the generated box class. However,
+      //     nested methods lifted into a value class are moved to the companion object and don't exist
+      //     in the value class itself. We can identify such nested methods: the initial enclosing class
+      //     is a value class, but the current owner is some other class (the module class).
+      method.owner.isTrait && method.isImplOnly || { // (1)
+        val enclCls = nextEnclosingClass(method)
+        exitingPickler(enclCls.isDerivedValueClass) && method.owner != enclCls // (2)
+      }
+    }
+
     def enclosingMethod(sym: Symbol): Option[Symbol] = {
       if (sym.isClass || sym == NoSymbol) None
-      else if (sym.isMethod) Some(sym)
-      else enclosingMethod(sym.originalOwner)
+      else if (sym.isMethod) {
+        if (doesNotExist(sym)) None else Some(sym)
+      }
+      else enclosingMethod(nextEnclosing(sym))
     }
-    enclosingMethod(classSym.originalOwner)
+    enclosingMethod(nextEnclosing(classSym))
   }
 
   /**
@@ -74,11 +172,10 @@ final class BCodeAsmCommon[G <: Global](val global: G) {
    */
   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)
+    val r = nextEnclosingClass(nextEnclosing(classSym))
+    // this should be an assertion, but we are more cautious for now as it was introduced before the 2.11.6 minor release
+    if (considerAsTopLevelImplementationArtifact(r)) devWarning(s"enclosing class of $classSym should not be an implementation artifact class: $r")
+    r
   }
 
   final case class EnclosingMethodEntry(owner: String, name: String, methodDescriptor: String)
@@ -92,11 +189,22 @@ final class BCodeAsmCommon[G <: Global](val global: G) {
    * 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)})")
+    // trait impl classes are always top-level, see comment in BTypes
+    if (isAnonymousOrLocalClass(classSym) && !considerAsTopLevelImplementationArtifact(classSym)) {
+      val enclosingClass = enclosingClassForEnclosingMethodAttribute(classSym)
+      val methodOpt = enclosingMethodForEnclosingMethodAttribute(classSym) match {
+        case some @ Some(m) =>
+          if (m.owner != enclosingClass) {
+            // This should never happen. In case it does, it prevents emitting an invalid
+            // EnclosingMethod attribute: if the attribute specifies an enclosing method,
+            // it needs to exist in the specified enclosing class.
+            devWarning(s"the owner of the enclosing method ${m.locationString} should be the same as the enclosing class $enclosingClass")
+            None
+          } else some
+        case none => none
+      }
       Some(EnclosingMethodEntry(
-        classDesc(enclosingClassForEnclosingMethodAttribute(classSym)),
+        classDesc(enclosingClass),
         methodOpt.map(_.javaSimpleName.toString).orNull,
         methodOpt.map(methodDesc).orNull))
     } else {
@@ -121,11 +229,13 @@ final class BCodeAsmCommon[G <: Global](val global: G) {
    * 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.
+   *
+   * Impl classes are always considered top-level, see comment in BTypes.
    */
-  def memberClassesOf(classSymbol: Symbol): List[Symbol] = classSymbol.info.decls.collect({
-    case sym if sym.isClass =>
+  def memberClassesForInnerClassTable(classSymbol: Symbol): List[Symbol] = classSymbol.info.decls.collect({
+    case sym if sym.isClass && !considerAsTopLevelImplementationArtifact(sym) =>
       sym
-    case sym if sym.isModule =>
+    case sym if sym.isModule && !considerAsTopLevelImplementationArtifact(sym) => // impl classes get the lateMODULE flag in mixin
       val r = exitingPickler(sym.moduleClass)
       assert(r != NoSymbol, sym.fullLocationString)
       r
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala
index 8d1c37532e..ccee230191 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala
@@ -362,8 +362,8 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
       else if (sym == definitions.NullClass) RT_NULL
       else {
        val r = classBTypeFromSymbol(sym)
-        if (r.isNestedClass) innerClassBufferASM += r
-        r
+       if (r.isNestedClass) innerClassBufferASM += r
+       r
       }
     }
 
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala
index a9bce82acd..a194fe8fe4 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala
@@ -527,7 +527,7 @@ abstract class BTypes {
    * 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"
+   * NOTE: When an EnclosingMethod attribute is requried (local and anonymous classes), the "outer"
    * field in the InnerClass table must be null.
    *
    * Fields:
@@ -634,6 +634,28 @@ abstract class BTypes {
    *     }
    *   }
    *
+   *
+   * Traits Members
+   * --------------
+   *
+   * Some trait methods don't exist in the generated interface, but only in the implementation class
+   * (private methods in traits for example). Since EnclosingMethod expresses a source-level property,
+   * but the source-level enclosing method doesn't exist in the classfile, we the enclosing method
+   * is null (the enclosing class is still emitted).
+   * See BCodeAsmCommon.considerAsTopLevelImplementationArtifact
+   *
+   *
+   * Implementation Classes, Specialized Classes, Delambdafy:method closure classes
+   * ------------------------------------------------------------------------------
+   *
+   * Trait implementation classes and specialized classes are always considered top-level. Again,
+   * the InnerClass / EnclosingMethod attributes describe a source-level properties. The impl
+   * classes are compilation artifacts.
+   *
+   * The same is true for delambdafy:method closure classes. These classes are generated at
+   * top-level in the delambdafy phase, no special support is required in the backend.
+   *
+   *
    * Mirror Classes
    * --------------
    *
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
index 94f9b585d9..2af665d31c 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
@@ -125,39 +125,71 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
      * 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
+
       // 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 = {
-        val nested = exitingPhase(currentRun.lambdaliftPhase)(memberClassesOf(classSym))
+        val allNested = exitingPhase(currentRun.lambdaliftPhase)(memberClassesForInnerClassTable(classSym))
+        val nested = {
+          // Classes nested in value classes are nested in the companion at this point. For InnerClass /
+          // EnclosingMethod, we use the value class as the outer class. So we remove nested classes
+          // from the companion that were originally nested in the value class.
+          if (exitingPickler(linkedClass.isDerivedValueClass)) allNested.filterNot(classOriginallyNestedInClass(_, linkedClass))
+          else allNested
+        }
+
         if (isTopLevelModuleClass(classSym)) {
           // For Java compatibility, member classes of top-level objects are treated as members of
           // the top-level companion class, see comment below.
-          val members = exitingPickler(memberClassesOf(classSym))
+          val members = exitingPickler(memberClassesForInnerClassTable(classSym))
           nested diff members
         } else {
           nested
         }
       }
 
-      // If this is a top-level class, the member classes of the companion object 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: for Java compatibility, the
-      // InnerClass attribute for D has "C" (NOT the module class "C$") as the outer class of D
-      // (done by buildNestedInfo). 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
+      val companionModuleMembers = if (considerAsTopLevelImplementationArtifact(classSym)) Nil else {
+        // If this is a top-level non-impl (*) class, the member classes of the companion object 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: for Java compatibility, the
+        // InnerClass attribute for D has "C" (NOT the module class "C$") as the outer class of D
+        // (done by buildNestedInfo). 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$.
+        //
+        // (*) We exclude impl classes: if the classfile for the impl class exists on the classpath,
+        // a linkedClass symbol is found for which isTopLevelModule is true, so we end up searching
+        // members of that weird impl-class-module-class-symbol. that search probably cannot return
+        // any classes, but it's better to exclude it.
+        val javaCompatMembers = {
+          if (linkedClass != NoSymbol && isTopLevelModuleClass(linkedClass))
+          // phase travel to exitingPickler: this makes sure that memberClassesForInnerClassTable only sees member
+          // classes, not local classes of the companion module (E in the exmaple) that were lifted by lambdalift.
+            exitingPickler(memberClassesForInnerClassTable(linkedClass))
+          else
+            Nil
+        }
+
+        // Classes nested in value classes are nested in the companion at this point. For InnerClass /
+        // EnclosingMethod we use the value class as enclosing class. Here we search nested classes
+        // in the companion that were originally nested in the value class, and we add them as nested
+        // in the value class.
+        val valueClassCompanionMembers = {
+          if (linkedClass != NoSymbol && exitingPickler(classSym.isDerivedValueClass)) {
+            val moduleMemberClasses = exitingPhase(currentRun.lambdaliftPhase)(memberClassesForInnerClassTable(linkedClass))
+            moduleMemberClasses.filter(classOriginallyNestedInClass(_, classSym))
+          } else
+            Nil
+        }
+
+        javaCompatMembers ++ valueClassCompanionMembers
       }
 
       nestedClasses ++ companionModuleMembers
@@ -191,7 +223,8 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
     assert(innerClassSym.isClass, s"Cannot build NestedInfo for non-class symbol $innerClassSym")
 
     val isTopLevel = innerClassSym.rawowner.isPackageClass
-    if (isTopLevel) None
+    // impl classes are considered top-level, see comment in BTypes
+    if (isTopLevel || considerAsTopLevelImplementationArtifact(innerClassSym)) None
     else {
       // See comment in BTypes, when is a class marked static in the InnerClass table.
       val isStaticNestedClass = isOriginallyStaticOwner(innerClassSym.originalOwner)
@@ -227,7 +260,9 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
       }
 
       val innerName: Option[String] = {
-        if (innerClassSym.isAnonymousClass || innerClassSym.isAnonymousFunction) None
+        // phase travel necessary: after flatten, the name includes the name of outer classes.
+        // if some outer name contains $anon, a non-anon class is considered anon.
+        if (exitingPickler(innerClassSym.isAnonymousClass || innerClassSym.isAnonymousFunction)) None
         else Some(innerClassSym.rawname + innerClassSym.moduleSuffix) // moduleSuffix for module classes
       }
 
@@ -246,7 +281,7 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
     classBTypeFromInternalName.getOrElse(internalName, {
       val c = ClassBType(internalName)
       // class info consistent with BCodeHelpers.genMirrorClass
-      val nested = exitingPickler(memberClassesOf(moduleClassSym)) map classBTypeFromSymbol
+      val nested = exitingPickler(memberClassesForInnerClassTable(moduleClassSym)) map classBTypeFromSymbol
       c.info = ClassInfo(
         superClass = Some(ObjectReference),
         interfaces = Nil,
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala
index abe3bc512c..707336e5de 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala
@@ -595,7 +595,8 @@ abstract class GenASM extends SubComponent with BytecodeWriters { self =>
           val x = innerClassSymbolFor(s)
           if(x ne NoSymbol) {
             assert(x.isClass, "not an inner-class symbol")
-            val isInner = !x.rawowner.isPackageClass
+            // impl classes are considered top-level, see comment in BTypes
+            val isInner = !considerAsTopLevelImplementationArtifact(s) && !x.rawowner.isPackageClass
             if (isInner) {
               innerClassBuffer += x
               collectInnerClass(x.rawowner)
@@ -692,30 +693,55 @@ abstract class GenASM extends SubComponent with BytecodeWriters { self =>
         }
       }
 
-      def innerName(innerSym: Symbol): String =
-        if (innerSym.isAnonymousClass || innerSym.isAnonymousFunction)
-          null
-        else
-          innerSym.rawname + innerSym.moduleSuffix
+      def innerName(innerSym: Symbol): String = {
+        // phase travel necessary: after flatten, the name includes the name of outer classes.
+        // if some outer name contains $anon, a non-anon class is considered anon.
+        if (exitingPickler(innerSym.isAnonymousClass || innerSym.isAnonymousFunction)) null
+        else innerSym.rawname + innerSym.moduleSuffix
+      }
+
+      val linkedClass = exitingPickler(csym.linkedClassOfClass) // linkedCoC does not work properly in late phases
 
       innerClassBuffer ++= {
-        val members = exitingPickler(memberClassesOf(csym))
+        val members = exitingPickler(memberClassesForInnerClassTable(csym))
         // lambdalift makes all classes (also local, anonymous) members of their enclosing class
-        val allNested = exitingPhase(currentRun.lambdaliftPhase)(memberClassesOf(csym))
+        val allNested = exitingPhase(currentRun.lambdaliftPhase)(memberClassesForInnerClassTable(csym))
+        val nested = {
+          // Classes nested in value classes are nested in the companion at this point. For InnerClass /
+          // EnclosingMethod, we use the value class as the outer class. So we remove nested classes
+          // from the companion that were originally nested in the value class.
+          if (exitingPickler(linkedClass.isDerivedValueClass)) allNested.filterNot(classOriginallyNestedInClass(_, linkedClass))
+          else allNested
+        }
 
-        // for the mirror class, we take the members of the companion module class (Java compat,
-        // see doc in BTypes.scala). for module classes, we filter out those members.
-        if (isMirror)  members
-        else if (isTopLevelModule(csym)) allNested diff members
-        else allNested
-      }
+        // for the mirror class, we take the members of the companion module class (Java compat, see doc in BTypes.scala).
+        // for module classes, we filter out those members.
+        if (isMirror) members
+        else if (isTopLevelModule(csym)) nested diff members
+        else nested
+      }
+
+      if (!considerAsTopLevelImplementationArtifact(csym)) {
+        // If this is a top-level non-impl class, add members of the companion object. These are the
+        // classes for which we change the InnerClass entry to allow using them from Java.
+        // We exclude impl classes: if the classfile for the impl class exists on the classpath, a
+        // linkedClass symbol is found for which isTopLevelModule is true, so we end up searching
+        // members of that weird impl-class-module-class-symbol. that search probably cannot return
+        // any classes, but it's better to exclude it.
+        if (linkedClass != NoSymbol && isTopLevelModule(linkedClass)) {
+          // phase travel to exitingPickler: this makes sure that memberClassesForInnerClassTable only
+          // sees member classes, not local classes that were lifted by lambdalift.
+          innerClassBuffer ++= exitingPickler(memberClassesForInnerClassTable(linkedClass))
+        }
 
-      // If this is a top-level class, add members of the companion object.
-      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))
+        // Classes nested in value classes are nested in the companion at this point. For InnerClass /
+        // EnclosingMethod we use the value class as enclosing class. Here we search nested classes
+        // in the companion that were originally nested in the value class, and we add them as nested
+        // in the value class.
+        if (linkedClass != NoSymbol && exitingPickler(csym.isDerivedValueClass)) {
+          val moduleMemberClasses = exitingPhase(currentRun.lambdaliftPhase)(memberClassesForInnerClassTable(linkedClass))
+          innerClassBuffer ++= moduleMemberClasses.filter(classOriginallyNestedInClass(_, csym))
+        }
       }
 
       val allInners: List[Symbol] = innerClassBuffer.toList filterNot deadCode.elidedClosures
diff --git a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala
index a703542587..5e2fe21eec 100644
--- a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala
+++ b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala
@@ -250,21 +250,30 @@ abstract class LambdaLift extends InfoTransform {
         debuglog("renaming in %s: %s => %s".format(sym.owner.fullLocationString, originalName, sym.name))
       }
 
+      // make sure that the name doesn't make the symbol accidentally `isAnonymousClass` (et.al) by
+      // introducing `$anon` in its name. to be cautious, we don't make this change in the default
+      // backend under 2.11.x, so only in GenBCode.
+      def nonAnon(s: String) = if (settings.Ybackend.value == "GenBCode") nme.ensureNonAnon(s) else s
+
       def newName(sym: Symbol): Name = {
         val originalName = sym.name
         def freshen(prefix: String): Name =
           if (originalName.isTypeName) unit.freshTypeName(prefix)
           else unit.freshTermName(prefix)
 
+        val join = nme.NAME_JOIN_STRING
         if (sym.isAnonymousFunction && sym.owner.isMethod) {
-          freshen(sym.name + nme.NAME_JOIN_STRING + sym.owner.name + nme.NAME_JOIN_STRING)
+          freshen(sym.name + join + nonAnon(sym.owner.name.toString) + join)
         } else {
+          val name = freshen(sym.name + join)
           // SI-5652 If the lifted symbol is accessed from an inner class, it will be made public. (where?)
-          //         Generating a unique name, mangled with the enclosing class name, avoids a VerifyError
-          //         in the case that a sub-class happens to lifts out a method with the *same* name.
-          val name = freshen("" + sym.name + nme.NAME_JOIN_STRING)
-          if (originalName.isTermName && !sym.enclClass.isImplClass && calledFromInner(sym)) nme.expandedName(name.toTermName, sym.enclClass)
-          else name
+          //         Generating a unique name, mangled with the enclosing full class name (including
+          //         package - subclass might have the same name), avoids a VerifyError in the case
+          //         that a sub-class happens to lifts out a method with the *same* name.
+          if (originalName.isTermName && !sym.enclClass.isImplClass && calledFromInner(sym))
+            newTermNameCached(nonAnon(sym.enclClass.fullName('$')) + nme.EXPAND_SEPARATOR_STRING + name)
+          else
+            name
         }
       }
 
diff --git a/src/compiler/scala/tools/nsc/transform/UnCurry.scala b/src/compiler/scala/tools/nsc/transform/UnCurry.scala
index 3544dc9966..e1cf53059a 100644
--- a/src/compiler/scala/tools/nsc/transform/UnCurry.scala
+++ b/src/compiler/scala/tools/nsc/transform/UnCurry.scala
@@ -225,6 +225,10 @@ abstract class UnCurry extends InfoTransform
           if (inlineFunctionExpansion || !canUseDelamdafyMethod) {
             val parents = addSerializable(abstractFunctionForFunctionType(fun.tpe))
             val anonClass = fun.symbol.owner newAnonymousFunctionClass(fun.pos, inConstructorFlag) addAnnotation SerialVersionUIDAnnotation
+            // The original owner is used in the backend for the EnclosingMethod attribute. If fun is
+            // nested in a value-class method, its owner was already changed to the extension method.
+            // Saving the original owner allows getting the source structure from the class symbol.
+            defineOriginalOwner(anonClass, fun.symbol.originalOwner)
             anonClass setInfo ClassInfoType(parents, newScope, anonClass)
 
             val applyMethodDef = mkMethod(anonClass, nme.apply)