Merge pull request scala#4916 from lrytz/restoreASMTests

Restore backend tests that were removed together with GenASM

Author: lrytz

test/junit/scala/collection/immutable/SetTests.scala renamed to test/junit/scala/collection/immutable/SetTest.scala

@@ -6,7 +6,7 @@ import org.junit.runner.RunWith
 import org.junit.runners.JUnit4
 
 @RunWith(classOf[JUnit4])
-class SetTests {
+class SetTest {
   @Test
   def test_SI8346_toSet_soundness(): Unit = {
     val any2stringadd = "Disabled string conversions so as not to get confused!"

test/junit/scala/issues/BytecodeTests.scala renamed to test/junit/scala/issues/BytecodeTest.scala

@@ -11,15 +11,15 @@ import scala.collection.JavaConverters._
 import scala.tools.partest.ASMConverters._
 import scala.tools.testing.ClearAfterClass
 
-object BytecodeTests extends ClearAfterClass.Clearable {
+object BytecodeTest extends ClearAfterClass.Clearable {
   var compiler = newCompiler()
   def clear(): Unit = { compiler = null }
 }
 
 @RunWith(classOf[JUnit4])
-class BytecodeTests extends ClearAfterClass {
-  ClearAfterClass.stateToClear = BytecodeTests
-  val compiler = BytecodeTests.compiler
+class BytecodeTest extends ClearAfterClass {
+  ClearAfterClass.stateToClear = BytecodeTest
+  val compiler = BytecodeTest.compiler
 
   @Test
   def t8731(): Unit = {
@@ -107,7 +107,6 @@ class BytecodeTests extends ClearAfterClass {
 
     import Opcodes._
     val expected = List(
-      LineNumber(3, Label(0)),
       LineNumber(4, Label(0)),
       LineNumber(5, Label(5)),
       Jump(IFNE, Label(11)),

test/junit/scala/reflect/ClassTag.scala renamed to test/junit/scala/reflect/ClassTagTest.scala

@@ -1,4 +1,3 @@
-
 package scala.sys.process
 
 import org.junit.runner.RunWith

test/junit/scala/sys/process/t7350.scala

@@ -48,7 +48,7 @@ object CodeGenTools {
     resetOutput(compiler)
     compiler
   }
-  
+
   def newCompilerWithoutVirtualOutdir(defaultArgs: String = "-usejavacp", extraArgs: String = ""): Global = {
     val settings = new Settings()
     val args = (CommandLineParser tokenize defaultArgs) ++ (CommandLineParser tokenize extraArgs)

test/junit/scala/tools/nsc/backend/jvm/CodeGenTools.scala

@@ -1468,4 +1468,52 @@ class InlinerTest extends ClearAfterClass {
     assertEquals(casts("t5"), Nil)
     assertEquals(casts("t6"), Nil)
   }
+
+  @Test
+  def inlineFromSealed(): Unit = {
+    val code =
+      """sealed abstract class Foo {
+        |  @inline def bar(x: Int) = x + 1
+        |}
+        |object Foo {
+        |  def mkFoo(): Foo = new Baz2
+        |}
+        |
+        |object Baz1 extends Foo
+        |final class Baz2 extends Foo
+        |
+        |object Test {
+        |  def f = Foo.mkFoo() bar 10
+        |}
+      """.stripMargin
+
+    val cls = compile(code)
+    val test = cls.find(_.name == "Test$").get
+    assertEquals(
+      getSingleMethod(test, "f").instructions.summary,
+      List(GETSTATIC, "mkFoo",
+        BIPUSH, ISTORE,
+        IFNONNULL, ACONST_NULL, ATHROW, -1 /*label*/,
+        ILOAD, ICONST_1, IADD, IRETURN))
+  }
+
+  @Test // a test taken from the test suite for the 2.11 inliner
+  def oldInlineHigherOrderTest(): Unit = {
+    val code =
+      """class C {
+        |  private var debug = false
+        |  @inline private def ifelse[T](cond: => Boolean, ifPart: => T, elsePart: => T): T = if (cond) ifPart else elsePart
+        |  final def t = ifelse(debug, 1, 2)
+        |}
+      """.stripMargin
+    val List(c) = compile(code)
+    val t = getSingleMethod(c, "t")
+
+    // box-unbox will clean it up
+    assertEquals(getSingleMethod(c, "t").instructions.summary,
+      List(
+        ALOAD, "C$$$anonfun$1", IFEQ /*A*/,
+        "C$$$anonfun$2", IRETURN,
+        -1 /*A*/, "C$$$anonfun$3", IRETURN))
+  }
 }

test/junit/scala/tools/nsc/backend/jvm/opt/InlinerTest.scala

@@ -8,16 +8,18 @@ import org.junit.Test
 import scala.tools.asm.Opcodes._
 import org.junit.Assert._
 
+import scala.tools.asm.tree.ClassNode
 import scala.tools.nsc.backend.jvm.AsmUtils._
 import scala.tools.testing.AssertUtil._
 
 import CodeGenTools._
 import scala.tools.partest.ASMConverters
 import ASMConverters._
 import scala.tools.testing.ClearAfterClass
+import scala.collection.convert.decorateAsScala._
 
 object MethodLevelOptsTest extends ClearAfterClass.Clearable {
-  var methodOptCompiler = newCompiler(extraArgs = "-Ybackend:GenBCode -Yopt:l:method")
+  var methodOptCompiler = newCompiler(extraArgs = "-Yopt:l:method")
   def clear(): Unit = { methodOptCompiler = null }
 }
 
@@ -29,6 +31,8 @@ class MethodLevelOptsTest extends ClearAfterClass {
 
   def wrapInDefault(code: Instruction*) = List(Label(0), LineNumber(1, Label(0))) ::: code.toList ::: List(Label(1))
 
+  def locals(c: ClassNode, m: String) = findAsmMethod(c, m).localVariables.asScala.toList.map(l => (l.name, l.index)).sortBy(_._2)
+
   @Test
   def eliminateEmptyTry(): Unit = {
     val code = "def f = { try {} catch { case _: Throwable => 0; () }; 1 }"
@@ -559,4 +563,182 @@ class MethodLevelOptsTest extends ClearAfterClass {
       getSingleMethod(c, "t").instructions.dropNonOp,
       List(VarOp(ALOAD, 1), Jump(IFNULL, Label(6)), Op(ICONST_1), Op(IRETURN), Label(6), Op(ICONST_0), Op(IRETURN)))
   }
+
+  @Test
+  def t5313(): Unit = {
+    val code =
+      """class C {
+        |  def randomBoolean = scala.util.Random.nextInt % 2 == 0
+        |
+        |  // 3 stores to kept1 (slot 1), 1 store to result (slot 2)
+        |  def t1 = {
+        |    var kept1 = new Object
+        |    val result = new java.lang.ref.WeakReference(kept1)
+        |    kept1 = null // we can't eliminate this assignment because result can observe
+        |                 // when the object has no more references. See SI-5313
+        |    kept1 = new Object // could eliminate this one with a more elaborate analysis (we know it contains null)
+        |                       // however, such is not implemented: if a var is live, then stores are kept.
+        |    result
+        |  }
+        |
+        |  // only two variables are live: kept2 and kept3. they end up on slots 1 and 2.
+        |  // kept2 has 2 stores, kept3 has 1 store.
+        |  def t2 = {
+        |    var erased2 = null    // we can eliminate this store because it's never used
+        |    val erased3 = erased2 // and this
+        |    var erased4 = erased2 // and this
+        |    val erased5 = erased4 // and this
+        |    var kept2: Object = new Object // ultimately can't be eliminated
+        |    while(randomBoolean) {
+        |      val kept3 = kept2
+        |      kept2 = null // this can't, because it clobbers kept2, which is used
+        |      erased4 = null // safe to eliminate
+        |      println(kept3)
+        |    }
+        |    0
+        |  }
+        |
+        |  def t3 = {
+        |    var kept4 = new Object // have to keep, it's used
+        |    try
+        |      println(kept4)
+        |    catch {
+        |      case _ : Throwable => kept4 = null // have to keep, it clobbers kept4 which is used
+        |    }
+        |    0
+        |  }
+        |
+        |  def t4 = {
+        |    var kept5 = new Object
+        |    print(kept5)
+        |    kept5 = null // can't eliminate it's a clobber and it's used
+        |    print(kept5)
+        |    kept5 = null // eliminated by nullness analysis (store null to a local that is known to be null)
+        |    0
+        |  }
+        |
+        |  def t5 = {
+        |    while(randomBoolean) {
+        |      var kept6: AnyRef = null // not used, but have to keep because it clobbers the next used store
+        |                               // on the back edge of the loop
+        |      kept6 = new Object // used
+        |      println(kept6)
+        |    }
+        |    0
+        |  }
+        |}
+      """.stripMargin
+
+    val List(c) = compileClasses(methodOptCompiler)(code)
+    def stores(m: String) = getSingleMethod(c, m).instructions.filter(_.opcode == ASTORE)
+
+    assertEquals(locals(c, "t1"), List(("this",0), ("kept1",1), ("result",2)))
+    assert(stores("t1") == List(VarOp(ASTORE, 1), VarOp(ASTORE, 2), VarOp(ASTORE, 1), VarOp(ASTORE, 1)),
+      textify(findAsmMethod(c, "t1")))
+
+    assertEquals(locals(c, "t2"), List(("this",0), ("kept2",1), ("kept3",2)))
+    assert(stores("t2") == List(VarOp(ASTORE, 1), VarOp(ASTORE, 2), VarOp(ASTORE, 1)),
+      textify(findAsmMethod(c, "t2")))
+
+    assertEquals(locals(c, "t3"), List(("this",0), ("kept4",1)))
+    assert(stores("t3") == List(VarOp(ASTORE, 1), VarOp(ASTORE, 1)),
+      textify(findAsmMethod(c, "t3")))
+
+    assertEquals(locals(c, "t4"), List(("this",0), ("kept5",1)))
+    assert(stores("t4") == List(VarOp(ASTORE, 1), VarOp(ASTORE, 1)),
+      textify(findAsmMethod(c, "t4")))
+
+    assertEquals(locals(c, "t5"), List(("this",0), ("kept6",1)))
+    assert(stores("t5") == List(VarOp(ASTORE, 1), VarOp(ASTORE, 1)),
+      textify(findAsmMethod(c, "t5")))
+  }
+
+  @Test
+  def testCpp(): Unit = {
+    // copied from an old test (run/test-cpp.scala)
+    val code =
+      """class C {
+        |  import scala.util.Random._
+        |
+        |  def t1(x: Int) = {
+        |    val y = x
+        |    println(y)
+        |  }
+        |
+        |  def t2 = {
+        |    val x = 2
+        |    val y = x
+        |    println(y)
+        |  }
+        |
+        |  def t3 = {
+        |    val x = this
+        |    val y = x
+        |    println(y)
+        |  }
+        |
+        |  def f = nextInt
+        |
+        |  def t4 = {
+        |    val x = f
+        |    val y = x
+        |    println(y)
+        |  }
+        |
+        |  def t5 = {
+        |    var x = nextInt
+        |    var y = x
+        |    println(y)
+        |
+        |    y = nextInt
+        |    x = y
+        |    println(x)
+        |  }
+        |}
+      """.stripMargin
+
+    val List(c) = compileClasses(methodOptCompiler)(code)
+    assertEquals(locals(c, "t1"), List(("this", 0), ("x", 1)))
+
+    assertEquals(locals(c, "t2"), List(("this", 0), ("x", 1)))
+    // we don't have constant propagation (yet).
+    // the local var can't be optimized as a store;laod sequence, there's a GETSTATIC between the two
+    assertEquals(
+      textify(findAsmMethod(c, "t2")),
+      getSingleMethod(c, "t2").instructions.dropNonOp.map(_.opcode),
+      List(
+        ICONST_2, ISTORE,
+        GETSTATIC,           // Predef.MODULE$
+        ILOAD, INVOKESTATIC, // boxToInteger
+        INVOKEVIRTUAL,       // println
+        RETURN))
+
+    assertEquals(locals(c, "t3"), List(("this", 0)))
+    assertEquals(locals(c, "t4"), List(("this", 0), ("x", 1)))
+    assertEquals(locals(c, "t5"), List(("this", 0), ("x", 1)))
+  }
+
+  @Test
+  def t7006(): Unit = {
+    val code =
+      """class C {
+        |  def t: Unit = {
+        |    try {
+        |      val x = 3
+        |    } finally {
+        |      print("hello")
+        |    }
+        |    while(true) { }
+        |  }
+        |}
+      """.stripMargin
+    val List(c) = compileClasses(methodOptCompiler)(code)
+    val t = getSingleMethod(c, "t")
+    assertEquals(t.handlers, Nil)
+    assertEquals(locals(c, "t"), List(("this", 0)))
+    assertEquals(t.instructions.summary,
+      List(
+        GETSTATIC, LDC, "print",
+        -1, GOTO))
+  }
 }