Merge pull request #4296 from lrytz/t9105

Fixes and tests for InnerClass / EnclsoingMethod classfile attributes

2 files changed, 23 insertions, 1 deletions

diff --git a/src/reflect/scala/reflect/internal/StdNames.scala b/src/reflect/scala/reflect/internal/StdNames.scala
index c94ee996e4..f32b7326fe 100644
--- a/src/reflect/scala/reflect/internal/StdNames.scala
+++ b/src/reflect/scala/reflect/internal/StdNames.scala
@@ -112,6 +112,23 @@ trait StdNames {
     val ROOT: NameType                         = "<root>"
     val SPECIALIZED_SUFFIX: NameType           = "$sp"
 
+    val NESTED_IN: String                      = "$nestedIn"
+    val NESTED_IN_ANON_CLASS: String           = NESTED_IN + ANON_CLASS_NAME.toString.replace("$", "")
+    val NESTED_IN_ANON_FUN: String             = NESTED_IN + ANON_FUN_NAME.toString.replace("$", "")
+    val NESTED_IN_LAMBDA: String               = NESTED_IN + DELAMBDAFY_LAMBDA_CLASS_NAME.toString.replace("$", "")
+
+    /**
+     * Ensures that name mangling does not accidentally make a class respond `true` to any of
+     * isAnonymousClass, isAnonymousFunction, isDelambdafyFunction, e.g. by introducing "$anon".
+     */
+    def ensureNonAnon(name: String) = {
+      name
+        .replace(nme.ANON_CLASS_NAME.toString, NESTED_IN_ANON_CLASS)
+        .replace(nme.ANON_FUN_NAME.toString, NESTED_IN_ANON_FUN)
+        .replace(nme.DELAMBDAFY_LAMBDA_CLASS_NAME.toString, NESTED_IN_LAMBDA)
+    }
+
+
     // value types (and AnyRef) are all used as terms as well
     // as (at least) arguments to the @specialize annotation.
     final val Boolean: NameType = "Boolean"
diff --git a/src/reflect/scala/reflect/internal/Symbols.scala b/src/reflect/scala/reflect/internal/Symbols.scala
index d5fc52abbf..d23a102b28 100644
--- a/src/reflect/scala/reflect/internal/Symbols.scala
+++ b/src/reflect/scala/reflect/internal/Symbols.scala
@@ -66,14 +66,19 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
   // when under some flag. Define per-phase invariants for owner/owned relationships,
   // e.g. after flatten all classes are owned by package classes, there are lots and
   // lots of these to be declared (or more realistically, discovered.)
+  // could be private since 2.11.6, but left protected to avoid potential breakages (eg ensime)
   protected def saveOriginalOwner(sym: Symbol): Unit = {
     // some synthetic symbols have NoSymbol as owner initially
     if (sym.owner != NoSymbol) {
       if (originalOwnerMap contains sym) ()
-      else originalOwnerMap(sym) = sym.rawowner
+      else defineOriginalOwner(sym, sym.rawowner)
     }
   }
 
+  def defineOriginalOwner(sym: Symbol, owner: Symbol): Unit = {
+    originalOwnerMap(sym) = owner
+  }
+
   def symbolOf[T: WeakTypeTag]: TypeSymbol = weakTypeOf[T].typeSymbolDirect.asType
 
   abstract class SymbolContextApiImpl extends SymbolApi {