Generate static forwarders for object members in companion interface

We used to disable generation of static forwarders when a object had a
trait as a companion, as one could not add methods with bodies to an
interface in JVM 6.

The JVM lifted this restriction to support default methods in interfaces,
so we can lift the restriction on static forwarders, too.

I've only commited the test using the default backend (GenBCode), but
I've also made the change and manaully verified the test works under
the soon-to-be-removed GenASM.

```
% qscalac -Ybackend:GenASM test/files/run/trait-static-forwarder/forwarders.scala && javac -d . -classpath . test/files/run/trait-static-forwarder/Test.java && qscala Test
./T.class: warning: Cannot find annotation method 'bytes()' in type 'ScalaSignature': class file for scala.reflect.ScalaSignature not found
1 warning
42
```

Fixes scala/scala-dev#59

I had to disable use of the lambda deserialization refletion cache
when in interfaces, as this change revealed a latent design issue
with our lambda deserialization approach. Disabling the cache isn't
a correctness problem, but hampers performance.

Author: retronym

src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala

@@ -180,7 +180,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers {
 
       } else {
 
-        val skipStaticForwarders = (claszSymbol.isInterface || settings.noForwarders)
+        val skipStaticForwarders = settings.noForwarders
         if (!skipStaticForwarders) {
           val lmoc = claszSymbol.companionModule
           // add static forwarders if there are no name conflicts; see bugs #363 and #1735

src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala

@@ -1304,7 +1304,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters { self =>
         for (constructor <- c.lookupStaticCtor) {
           addStaticInit(Some(constructor))
         }
-        val skipStaticForwarders = (c.symbol.isInterface || settings.noForwarders)
+        val skipStaticForwarders = settings.noForwarders
         if (!skipStaticForwarders) {
           val lmoc = c.symbol.companionModule
           // add static forwarders if there are no name conflicts; see bugs #363 and #1735

src/compiler/scala/tools/nsc/backend/jvm/analysis/BackendUtils.scala

@@ -64,6 +64,9 @@ class BackendUtils[BT <: BTypes](val btypes: BT) {
    *   return scala.runtime.LambdaDeserializer.deserializeLambda(MethodHandles.lookup(), cache, l);
    * }
    */
+  // TODO the cache can't be emitted if we're in an interface, is it acceptable to pay for a method handle
+  // lookup for each call? We could use a more global cache (e.g. in LambdaDeserializer), but then we have to
+  // worry about using weak references to avoid classloader leaks.
   def addLambdaDeserialize(classNode: ClassNode): Unit = {
     val cw = classNode
     import scala.tools.asm.Opcodes._
@@ -76,16 +79,21 @@ class BackendUtils[BT <: BTypes](val btypes: BT) {
     // 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 isInterface = (classNode.access | ACC_INTERFACE) != 0
+    if (isInterface){
       val fv = cw.visitField(ACC_PRIVATE + ACC_STATIC + ACC_SYNTHETIC, "$deserializeLambdaCache$", "Ljava/util/Map;", null, null)
       fv.visitEnd()
     }
 
     {
       val mv = cw.visitMethod(ACC_PRIVATE + ACC_STATIC + ACC_SYNTHETIC, "$deserializeLambda$", "(Ljava/lang/invoke/SerializedLambda;)Ljava/lang/Object;", 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;")
+      if (isInterface)
+        mv.visitInsn(ACONST_NULL)
+      else {
+        // javaBinaryName returns the internal name of a class. Also used in BTypesFromsymbols.classBTypeFromSymbol.
+        mv.visitFieldInsn(GETSTATIC, classNode.name, "$deserializeLambdaCache$", "Ljava/util/Map;")
+      }
       mv.visitVarInsn(ASTORE, 1)
       mv.visitVarInsn(ALOAD, 1)
       val l0 = new Label()

test/files/run/trait-static-forwarder.check

@@ -0,0 +1 @@
+42

test/files/run/trait-static-forwarder/Test.java

@@ -0,0 +1,5 @@
+public final class Test {
+    public static void main(String... args) {
+        System.out.println(T.foo());
+    }
+}

test/files/run/trait-static-forwarder/forwarders.scala

@@ -0,0 +1,5 @@
+trait T
+
+object T {
+  def foo = 42
+}