Tests for compilation with various -opt-inline-from settings

Author: lrytz

src/compiler/scala/tools/nsc/backend/jvm/opt/InlinerHeuristics.scala

@@ -11,6 +11,7 @@ import java.util.regex.Pattern
 
 import scala.annotation.tailrec
 import scala.collection.JavaConverters._
+import scala.collection.generic.Clearable
 import scala.tools.asm.Opcodes
 import scala.tools.asm.tree.{AbstractInsnNode, MethodInsnNode, MethodNode}
 import scala.tools.nsc.backend.jvm.BTypes.InternalName
@@ -21,7 +22,17 @@ class InlinerHeuristics[BT <: BTypes](val bTypes: BT) {
   import bTypes._
   import callGraph._
 
-  val inlineSourceMatcher = new InlineSourceMatcher(compilerSettings.optInlineFrom.value)
+  // Hack to read the `optInlineFrom` once per run. It happens at the end of a run though..
+  // We use it in InlineSourceMatcherTest so we can change the setting without a new Global.
+  // Better, general idea here: https://github.com/scala/scala/pull/5825#issuecomment-291542859
+  object HasMatcher extends Clearable {
+    recordPerRunCache(this)
+    private def build() = new InlineSourceMatcher(compilerSettings.optInlineFrom.value)
+    var m: InlineSourceMatcher = build()
+    override def clear(): Unit = m = build()
+  }
+
+  def inlineSourceMatcher = HasMatcher.m
 
   final case class InlineRequest(callsite: Callsite, post: List[InlineRequest], reason: String) {
     // invariant: all post inline requests denote callsites in the callee of the main callsite

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

@@ -8,9 +8,20 @@ import org.junit.runners.JUnit4
 import scala.tools.nsc.backend.jvm.BTypes.InternalName
 import scala.tools.nsc.backend.jvm.opt.InlineSourceMatcherTest._
 import scala.tools.nsc.backend.jvm.opt.InlinerHeuristics._
+import scala.tools.testing.BytecodeTesting
+import scala.tools.testing.BytecodeTesting._
 
 @RunWith(classOf[JUnit4])
-class InlineSourceMatcherTest {
+class InlineSourceMatcherTest extends BytecodeTesting {
+  import compiler._
+
+  override def compilerArgs = "-opt:l:inline -opt-warnings"
+  def setInlineFrom(s: String): Unit = {
+    global.settings.optInlineFrom.value = s
+    // the setting is read once per run
+    global.perRunCaches.clearAll()
+  }
+
   case class E(regex: String, negated: Boolean = false, terminal: Boolean = true)
 
   def check(pat: String, expect: E*): InlineSourceMatcher = {
@@ -158,6 +169,63 @@ class InlineSourceMatcherTest {
       m.d("a/C")
     }
   }
+
+  @Test
+  def inlineFromSameClass(): Unit = {
+    val code =
+      """class C {
+        |  @inline final def f = 1
+        |  def t = f
+        |}
+      """.stripMargin
+
+    def n(): Unit = assertInvoke(getMethod(compileClass(code), "t"), "C", "f")
+    def y(): Unit = assertNoInvoke(getMethod(compileClass(code), "t"))
+
+    setInlineFrom(""); n()
+    setInlineFrom("C"); y()
+    setInlineFrom("**:!**.C"); n()
+    setInlineFrom("**:!**.C:C"); y()
+  }
+
+  @Test
+  def inlineFromPackages(): Unit = {
+    val code =
+      """package a { class C {
+        |  object D { @inline def f = 1 }
+        |  @inline final def f = 2
+        |}}
+        |package b { class E { import a._
+        |  def t1(c: C) = c.f
+        |  def t2(c: C) = c.D.f
+        |}}
+      """.stripMargin
+
+    {
+      setInlineFrom("")
+      val List(_, _, e) = compileClasses(code)
+      assertInvoke(getMethod(e, "t1"), "a/C", "f")
+      assertInvoke(getMethod(e, "t2"), "a/C$D$", "f")
+    }
+    {
+      setInlineFrom("a.C")
+      val List(_, _, e) = compileClasses(code)
+      assertNoInvoke(getMethod(e, "t1"))
+      assertInvoke(getMethod(e, "t2"), "a/C$D$", "f")
+    }
+    {
+      setInlineFrom("a.C*")
+      val List(_, _, e) = compileClasses(code)
+      assertNoInvoke(getMethod(e, "t1"))
+      assertDoesNotInvoke(getMethod(e, "t2"), "f") // t2 still has an invocation to the getter `D`
+    }
+    {
+      setInlineFrom("a.C*:!a.C*$")
+      val List(_, _, e) = compileClasses(code)
+      assertNoInvoke(getMethod(e, "t1"))
+      assertInvoke(getMethod(e, "t2"), "a/C$D$", "f")
+    }
+  }
 }
 
 object InlineSourceMatcherTest {