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.

1 files changed, 10 insertions, 15 deletions

diff --git a/src/reflect/scala/reflect/runtime/JavaMirrors.scala b/src/reflect/scala/reflect/runtime/JavaMirrors.scala
index 6584d80de3..b7f229b6e5 100644
--- a/src/reflect/scala/reflect/runtime/JavaMirrors.scala
+++ b/src/reflect/scala/reflect/runtime/JavaMirrors.scala
@@ -807,31 +807,26 @@ private[scala] trait JavaMirrors extends internal.SymbolTable with api.JavaUnive
       //         field containing the cache for structural calls.
       if (mods.isStatic) module.moduleClass.orElse(clazz) else clazz
 
-  /** Methods which need to be treated with care
-   *  because they either are getSimpleName or call getSimpleName:
+  /**
+   * Certain method of the Java reflection api cannot be used on classfiles created by Scala.
+   * See the comment in test/files/jvm/javaReflection/Test.scala. The methods are
    *
    *    public String getSimpleName()
    *    public boolean isAnonymousClass()
    *    public boolean isLocalClass()
    *    public String getCanonicalName()
-   *
-   *  A typical manifestation:
-   *
-   *    // java.lang.Error: sOwner(class Test$A$1) has failed
-   *    // Caused by: java.lang.InternalError: Malformed class name
-   *    //        at java.lang.Class.getSimpleName(Class.java:1133)
-   *    //        at java.lang.Class.isAnonymousClass(Class.java:1188)
-   *    //        at java.lang.Class.isLocalClass(Class.java:1199)
-   *    // (see t5256c.scala for more details)
+   *    public boolean isSynthetic()
    *
    *  TODO - find all such calls and wrap them.
    *  TODO - create mechanism to avoid the recurrence of unwrapped calls.
    */
    implicit class RichClass(jclazz: jClass[_]) {
-      // `jclazz.isLocalClass` doesn't work because of problems with `getSimpleName`
-      // hence we have to approximate by removing the `isAnonymousClass` check
-//      def isLocalClass0: Boolean = jclazz.isLocalClass
-      def isLocalClass0: Boolean = jclazz.getEnclosingMethod != null || jclazz.getEnclosingConstructor != null
+      // As explained in the javaReflection test, Class.isLocalClass is true for all non-member
+      // nested classes in Scala. This is fine per se, however the implementation may throw an
+      // InternalError. We therefore re-implement it here.
+      // TODO: this method should be renamed to `isLocalOrAnonymousClass`.
+      // due to bin compat that's only possible in 2.12, we cannot introduce a new alias in 2.11.
+      def isLocalClass0: Boolean = jclazz.getEnclosingClass != null && !jclazz.isMemberClass
     }
 
     /**