Fix some tests, move others to pending/

Move run/t8960 to pending

It tests the serialVersionUID field on closure classes. The field
doesn't exist for indyLambda closures.

See https://issues.scala-lang.org/browse/SI-9373

Move some reify tests to pending

They fail at runtime in GenBCode since scala is built with indyLambda
enabled:

java.lang.AssertionError: assertion failed: Bad superClass for trait JFunction1: class Any
  at scala.tools.nsc.Global.assert(Global.scala:261)
  at scala.tools.nsc.backend.jvm.BTypesFromSymbols.setClassInfo(BTypesFromSymbols.scala:228)

Noted in https://issues.scala-lang.org/browse/SI-9374

force t6546 to GenASM - no closure elimination in GenBCode yet

Noted in https://issues.scala-lang.org/browse/SI-9364.

Fix or disable some tests that fail because of the old optimizer

The old inliner fails more often when the library is built with
indylambda.

Noted in https://issues.scala-lang.org/browse/SI-9374.

Example: List.foreach

➜  sandbox git:(jfun) ✗ qs -Ybackend:GenASM -optimize -Yinline-warnings
Welcome to Scala version 2.12.0-20150630-220939-1cb032d806 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_45).
Type in expressions to have them evaluated.
Type :help for more information.

scala> List(1,2,3).foreach(x => x + 1)
<console>:11: warning: Could not inline required method foreach because bytecode unavailable.
       List(1,2,3).foreach(x => x + 1)
                          ^
<console>:11: warning: At the end of the day, could not inline @inline-marked method foreach
       List(1,2,3).foreach(x => x + 1)
                          ^

Upate a number of tests for having indyLambda enabled

The delambdafyLambdaClassNames tests was removed, there's nothing to
tests with indyLambda.

1 files changed, 13 insertions, 24 deletions

diff --git a/test/files/jvm/innerClassAttribute/Classes_1.scala b/test/files/jvm/innerClassAttribute/Classes_1.scala
index 62c7d94d90..2b690bdd7b 100644
--- a/test/files/jvm/innerClassAttribute/Classes_1.scala
+++ b/test/files/jvm/innerClassAttribute/Classes_1.scala
@@ -187,41 +187,30 @@ trait A24 extends A24Base {
 }
 
 class SI_9105 {    
-  // the EnclosingMethod attributes depend on the delambdafy strategy (inline vs method)
-
-                                       //  outerClass-inline   enclMeth-inline   outerClass-method   enclMeth-method
+                                       //      outerClass       enclMeth
   val fun = (s: String) => {
-    class A                            //     closure             null (*)            SI_9105           null
-    def m: Object = { class B; new B } //     closure              m$1                SI_9105            m$1
-    val f: Object = { class C; new C } //     closure             null (*)            SI_9105           null
+    class A                            //        SI_9105           null
+    def m: Object = { class B; new B } //        SI_9105            m$1
+    val f: Object = { class C; new C } //        SI_9105           null
   }
   def met = (s: String) => {
-    class D                            //     closure             null (*)            SI_9105            met
-    def m: Object = { class E; new E } //     closure              m$1                SI_9105            m$1
-    val f: Object = { class F; new F } //     closure             null (*)            SI_9105            met
+    class D                            //        SI_9105            met
+    def m: Object = { class E; new E } //        SI_9105            m$1
+    val f: Object = { class F; new F } //        SI_9105            met
   }
 
-  // (*) the originalOwner chain of A (similar for D) is: SI_9105.fun.$anonfun-value.A
-  //     we can get to the anonfun-class (created by uncurry), but not to the apply method.
-  //
-  //     for C and F, the originalOwner chain is fun.$anonfun-value.f.C. at later phases, the rawowner of f is
-  //     an apply$sp method of the closure class. we could use that as enclosing method, but it would be unsystematic
-  //     (A / D don't have an encl meth either), and also strange to use the $sp, which is a compilation artifact.
-  //     So using `null` looks more like the situation in the source code: C / F are nested classes of the anon-fun, and
-  //     there's no method in between.
-
   def byName(op: => Any) = 0
 
   val bnV = byName {
-    class G                            //     closure             null (*)            SI_9105           null
-    def m: Object = { class H; new H } //     closure              m$1                SI_9105            m$1
-    val f: Object = { class I; new I } //     closure             null (*)            SI_9105           null
+    class G                            //        SI_9105           null
+    def m: Object = { class H; new H } //        SI_9105            m$1
+    val f: Object = { class I; new I } //        SI_9105           null
     ""
   }
   def bnM = byName {
-    class J                            //     closure             null (*)            SI_9105            bnM
-    def m: Object = { class K; new K } //     closure              m$1                SI_9105            m$1
-    val f: Object = { class L; new L } //     closure             null (*)            SI_9105            bnM
+    class J                            //        SI_9105            bnM
+    def m: Object = { class K; new K } //        SI_9105            m$1
+    val f: Object = { class L; new L } //        SI_9105            bnM
     ""
   }
 }