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.

2 files changed, 45 insertions, 165 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
     ""
   }
 }
diff --git a/test/files/jvm/innerClassAttribute/Test.scala b/test/files/jvm/innerClassAttribute/Test.scala
index 376b3c895b..ca50beae7f 100644
--- a/test/files/jvm/innerClassAttribute/Test.scala
+++ b/test/files/jvm/innerClassAttribute/Test.scala
@@ -78,9 +78,9 @@ object Test extends BytecodeTest {
     println(s"${e.outerClass} / ${e.name} / ${e.descriptor}")
   }
 
-  def lambdaClass(anonfunName: String, lambdaName: String): String = {
-    if (classpath.findClass(anonfunName).isDefined) anonfunName else lambdaName
-  }
+
+  val methodHandlesLookup = assertMember(_: InnerClassNode, "java/lang/invoke/MethodHandles", "Lookup", flags = publicStatic | Flags.ACC_FINAL)
+
 
   def testA1() = {
     val List(b1) = innerClassNodes("A1")
@@ -109,11 +109,7 @@ object Test extends BytecodeTest {
   }
 
   def testA4() = {
-    println("-- A4 --")
-    printInnerClassNodes("A4")
-    val fun = lambdaClass("A4$$anonfun$f$1", "A4$lambda$$f$1")
-    printInnerClassNodes(fun)
-    printEnclosingMethod(fun)
+    testInner("A4", methodHandlesLookup)
   }
 
   def testA5() = {
@@ -247,47 +243,11 @@ object Test extends BytecodeTest {
   }
 
   def testA19() = {
-    println("-- A19 --")
-
-    printInnerClassNodes("A19")
-
-    val fun1 = lambdaClass("A19$$anonfun$1", "A19$lambda$1")
-    val fun2 = lambdaClass("A19$$anonfun$2", "A19$lambda$2")
-    val fun3 = lambdaClass("A19$$anonfun$3", "A19$lambda$3")
-
-    printInnerClassNodes(fun1)
-    printInnerClassNodes(fun2)
-    printInnerClassNodes(fun3)
-
-    printEnclosingMethod(fun1)
-    printEnclosingMethod(fun2)
-    printEnclosingMethod(fun3)
+    testInner("A19", methodHandlesLookup)
   }
 
   def testA20() = {
-    println("-- A20 --")
-
-    printInnerClassNodes("A20")
-
-    val fun1 = lambdaClass("A20$$anonfun$4", "A20$lambda$1")
-    val fun2 = lambdaClass("A20$$anonfun$4$$anonfun$apply$1", "A20$lambda$$$nestedInAnonfun$5$1")
-    val fun3 = lambdaClass("A20$$anonfun$4$$anonfun$apply$2", "A20$lambda$$$nestedInAnonfun$5$2")
-    val fun4 = lambdaClass("A20$$anonfun$4$$anonfun$apply$2$$anonfun$apply$3", "A20$lambda$$$nestedInAnonfun$7$1")
-
-    println("fun1: attribute for itself and the two child closures `() => ()` and `() => () => 1`")
-    printInnerClassNodes(fun1)
-    println("fun2 () => (): itself and the outer closure")
-    printInnerClassNodes(fun2)
-    println("fun3 () => () => (): itself, the outer closure and its child closure")
-    printInnerClassNodes(fun3)
-    println("fun4: () => 1: itself and the two outer closures")
-    printInnerClassNodes(fun4)
-
-    println("enclosing: nested closures have outer class defined, but no outer method")
-    printEnclosingMethod(fun1)
-    printEnclosingMethod(fun2)
-    printEnclosingMethod(fun3)
-    printEnclosingMethod(fun4)
+    testInner("A20", methodHandlesLookup)
   }
 
   def testA21() = {
@@ -337,70 +297,30 @@ object Test extends BytecodeTest {
   }
 
   def testSI_9105() {
-    val isDelambdafyMethod = classpath.findClass("SI_9105$lambda$1").isDefined
-    if (isDelambdafyMethod) {
-      assertEnclosingMethod  ("SI_9105$A$3"          , "SI_9105", null , null)
-      assertEnclosingMethod  ("SI_9105$B$5"          , "SI_9105", "m$1", "()Ljava/lang/Object;")
-      assertEnclosingMethod  ("SI_9105$C$1"          , "SI_9105", null , null)
-      assertEnclosingMethod  ("SI_9105$D$1"          , "SI_9105", "met", "()Lscala/Function1;")
-      assertEnclosingMethod  ("SI_9105$E$1"          , "SI_9105", "m$3", "()Ljava/lang/Object;")
-      assertEnclosingMethod  ("SI_9105$F$1"          , "SI_9105", "met", "()Lscala/Function1;")
-      assertNoEnclosingMethod("SI_9105$lambda$$met$1")
-      assertNoEnclosingMethod("SI_9105$lambda$1")
-      assertNoEnclosingMethod("SI_9105")
-
-      assertLocal(innerClassNodes("SI_9105$A$3").head, "SI_9105$A$3", "A$3")
-      assertLocal(innerClassNodes("SI_9105$B$5").head, "SI_9105$B$5", "B$5")
-      assertLocal(innerClassNodes("SI_9105$C$1").head, "SI_9105$C$1", "C$1")
-      assertLocal(innerClassNodes("SI_9105$D$1").head, "SI_9105$D$1", "D$1")
-      assertLocal(innerClassNodes("SI_9105$E$1").head, "SI_9105$E$1", "E$1")
-      assertLocal(innerClassNodes("SI_9105$F$1").head, "SI_9105$F$1", "F$1")
-
-      // by-name
-      assertEnclosingMethod("SI_9105$G$1", "SI_9105", null , null)
-      assertEnclosingMethod("SI_9105$H$1", "SI_9105", "m$2", "()Ljava/lang/Object;")
-      assertEnclosingMethod("SI_9105$I$1", "SI_9105", null , null)
-      assertEnclosingMethod("SI_9105$J$1", "SI_9105", "bnM", "()I")
-      assertEnclosingMethod("SI_9105$K$2", "SI_9105", "m$4", "()Ljava/lang/Object;")
-      assertEnclosingMethod("SI_9105$L$1", "SI_9105", "bnM", "()I")
-
-      assert(innerClassNodes("SI_9105$lambda$$met$1").isEmpty)
-      assert(innerClassNodes("SI_9105$lambda$1").isEmpty)
-      assert(innerClassNodes("SI_9105").length == 12) // the 12 local classes
-    } else {
-      // comment in innerClassAttribute/Classes_1.scala explains the difference between A / C and D / F.
-      assertEnclosingMethod  ("SI_9105$$anonfun$5$A$3"    , "SI_9105$$anonfun$5"    , null          , null)
-      assertEnclosingMethod  ("SI_9105$$anonfun$5$B$5"    , "SI_9105$$anonfun$5"    , "m$1"         , "()Ljava/lang/Object;")
-      assertEnclosingMethod  ("SI_9105$$anonfun$5$C$1"    , "SI_9105$$anonfun$5"    , null          , null)
-      assertEnclosingMethod  ("SI_9105$$anonfun$met$1$D$1", "SI_9105$$anonfun$met$1", null          , null)
-      assertEnclosingMethod  ("SI_9105$$anonfun$met$1$E$1", "SI_9105$$anonfun$met$1", "m$3"         , "()Ljava/lang/Object;")
-      assertEnclosingMethod  ("SI_9105$$anonfun$met$1$F$1", "SI_9105$$anonfun$met$1", null          , null)
-      assertEnclosingMethod  ("SI_9105$$anonfun$5"        , "SI_9105"               , null          , null)
-      assertEnclosingMethod  ("SI_9105$$anonfun$met$1"    , "SI_9105"               , "met"         , "()Lscala/Function1;")
-      assertNoEnclosingMethod("SI_9105")
-
-      assertLocal(ownInnerClassNode("SI_9105$$anonfun$5$A$3"),     "SI_9105$$anonfun$5$A$3"    , "A$3")
-      assertLocal(ownInnerClassNode("SI_9105$$anonfun$5$B$5"),     "SI_9105$$anonfun$5$B$5"    , "B$5")
-      assertLocal(ownInnerClassNode("SI_9105$$anonfun$5$C$1"),     "SI_9105$$anonfun$5$C$1"    , "C$1")
-      assertLocal(ownInnerClassNode("SI_9105$$anonfun$met$1$D$1"), "SI_9105$$anonfun$met$1$D$1", "D$1")
-      assertLocal(ownInnerClassNode("SI_9105$$anonfun$met$1$E$1"), "SI_9105$$anonfun$met$1$E$1", "E$1")
-      assertLocal(ownInnerClassNode("SI_9105$$anonfun$met$1$F$1"), "SI_9105$$anonfun$met$1$F$1", "F$1")
-
-      // by-name
-      assertEnclosingMethod("SI_9105$$anonfun$6$G$1", "SI_9105$$anonfun$6", null, null)
-      assertEnclosingMethod("SI_9105$$anonfun$6$H$1", "SI_9105$$anonfun$6", "m$2", "()Ljava/lang/Object;")
-      assertEnclosingMethod("SI_9105$$anonfun$6$I$1", "SI_9105$$anonfun$6", null, null)
-      assertEnclosingMethod("SI_9105$$anonfun$bnM$1$J$1", "SI_9105$$anonfun$bnM$1", null, null)
-      assertEnclosingMethod("SI_9105$$anonfun$bnM$1$K$2", "SI_9105$$anonfun$bnM$1", "m$4", "()Ljava/lang/Object;")
-      assertEnclosingMethod("SI_9105$$anonfun$bnM$1$L$1", "SI_9105$$anonfun$bnM$1", null, null)
-
-      assertAnonymous(ownInnerClassNode("SI_9105$$anonfun$5"), "SI_9105$$anonfun$5")
-      assertAnonymous(ownInnerClassNode("SI_9105$$anonfun$met$1"), "SI_9105$$anonfun$met$1")
-
-      assert(innerClassNodes("SI_9105$$anonfun$5").length == 4)     // itself and three of the local classes
-      assert(innerClassNodes("SI_9105$$anonfun$met$1").length == 4) // itself and three of the local classes
-      assert(innerClassNodes("SI_9105").length == 4)                // the four anon funs
-    }
+    assertEnclosingMethod  ("SI_9105$A$3"          , "SI_9105", null , null)
+    assertEnclosingMethod  ("SI_9105$B$5"          , "SI_9105", "m$1", "()Ljava/lang/Object;")
+    assertEnclosingMethod  ("SI_9105$C$1"          , "SI_9105", null , null)
+    assertEnclosingMethod  ("SI_9105$D$1"          , "SI_9105", "met", "()Lscala/Function1;")
+    assertEnclosingMethod  ("SI_9105$E$1"          , "SI_9105", "m$3", "()Ljava/lang/Object;")
+    assertEnclosingMethod  ("SI_9105$F$1"          , "SI_9105", "met", "()Lscala/Function1;")
+    assertNoEnclosingMethod("SI_9105")
+
+    assertLocal(innerClassNodes("SI_9105$A$3").head, "SI_9105$A$3", "A$3")
+    assertLocal(innerClassNodes("SI_9105$B$5").head, "SI_9105$B$5", "B$5")
+    assertLocal(innerClassNodes("SI_9105$C$1").head, "SI_9105$C$1", "C$1")
+    assertLocal(innerClassNodes("SI_9105$D$1").head, "SI_9105$D$1", "D$1")
+    assertLocal(innerClassNodes("SI_9105$E$1").head, "SI_9105$E$1", "E$1")
+    assertLocal(innerClassNodes("SI_9105$F$1").head, "SI_9105$F$1", "F$1")
+
+    // by-name
+    assertEnclosingMethod("SI_9105$G$1", "SI_9105", null , null)
+    assertEnclosingMethod("SI_9105$H$1", "SI_9105", "m$2", "()Ljava/lang/Object;")
+    assertEnclosingMethod("SI_9105$I$1", "SI_9105", null , null)
+    assertEnclosingMethod("SI_9105$J$1", "SI_9105", "bnM", "()I")
+    assertEnclosingMethod("SI_9105$K$2", "SI_9105", "m$4", "()Ljava/lang/Object;")
+    assertEnclosingMethod("SI_9105$L$1", "SI_9105", "bnM", "()I")
+
+    assert(innerClassNodes("SI_9105").length == 13) // the 12 local classes, plus MethodHandles$Lookup
   }
 
   def testSI_9124() {
@@ -530,37 +450,8 @@ object Test extends BytecodeTest {
     testInner("NestedInValueClass$A$B", am, b)
     testInner("NestedInValueClass$A$C$2", am, c)
 
-    val isDelambdafyMethod = classpath.findClass("NestedInValueClass$A$lambda$$f$extension$1").isDefined
-    if (isDelambdafyMethod) {
-      List(
-        "NestedInValueClass$A$lambda$$g$2$1",
-        "NestedInValueClass$A$lambda$$f$extension$1",
-        "NestedInValueClass$A$lambda$$$nestedInAnonfun$13$1",
-        "NestedInValueClass$A$lambda$$NestedInValueClass$A$$$nestedInAnonfun$15$1").foreach(assertNoEnclosingMethod)
-      testInner("NestedInValueClass$A", a, am)
-      testInner("NestedInValueClass$A$", a, am, b, c)
-      testInner("NestedInValueClass$A$lambda$$g$2$1", am)
-      testInner("NestedInValueClass$A$lambda$$f$extension$1", am)
-      testInner("NestedInValueClass$A$lambda$$$nestedInAnonfun$13$1", am)
-      testInner("NestedInValueClass$A$lambda$$NestedInValueClass$A$$$nestedInAnonfun$15$1", am)
-    } else {
-      assertEnclosingMethod("NestedInValueClass$A$$anonfun$g$2$1"                         , "NestedInValueClass$A"                       , null, null)
-      assertEnclosingMethod("NestedInValueClass$A$$anonfun$g$2$1$$anonfun$apply$4"        , "NestedInValueClass$A$$anonfun$g$2$1"        , null, null)
-      assertEnclosingMethod("NestedInValueClass$A$$anonfun$f$extension$1"                 , "NestedInValueClass$A"                       , "f", "()Lscala/collection/immutable/List;")
-      assertEnclosingMethod("NestedInValueClass$A$$anonfun$f$extension$1$$anonfun$apply$5", "NestedInValueClass$A$$anonfun$f$extension$1", null, null)
-
-      val gfun    = assertAnonymous(_: I, "NestedInValueClass$A$$anonfun$g$2$1")
-      val ffun    = assertAnonymous(_: I, "NestedInValueClass$A$$anonfun$f$extension$1")
-      val gfunfun = assertAnonymous(_: I, "NestedInValueClass$A$$anonfun$g$2$1$$anonfun$apply$4")
-      val ffunfun = assertAnonymous(_: I, "NestedInValueClass$A$$anonfun$f$extension$1$$anonfun$apply$5")
-
-      testInner("NestedInValueClass$A", a, am, ffun, gfun)
-      testInner("NestedInValueClass$A$", a, am, ffun, gfun, b, c)
-      testInner("NestedInValueClass$A$$anonfun$g$2$1", a, am, gfun, gfunfun)
-      testInner("NestedInValueClass$A$$anonfun$g$2$1$$anonfun$apply$4", am, gfun, gfunfun)
-      testInner("NestedInValueClass$A$$anonfun$f$extension$1", a, am, ffun, ffunfun)
-      testInner("NestedInValueClass$A$$anonfun$f$extension$1$$anonfun$apply$5", am, ffun, ffunfun)
-    }
+    testInner("NestedInValueClass$A", a, am)
+    testInner("NestedInValueClass$A$", a, am, b, c, methodHandlesLookup)
   }
 
   def show(): Unit = {