1 files changed, 35 insertions, 30 deletions

diff --git a/test/junit/scala/tools/nsc/backend/jvm/opt/InlineWarningTest.scala b/test/junit/scala/tools/nsc/backend/jvm/opt/InlineWarningTest.scala
index 029caa995c..1597c75a7e 100644
--- a/test/junit/scala/tools/nsc/backend/jvm/opt/InlineWarningTest.scala
+++ b/test/junit/scala/tools/nsc/backend/jvm/opt/InlineWarningTest.scala
@@ -13,7 +13,6 @@ import org.junit.Assert._
 
 import scala.tools.asm.tree._
 import scala.tools.asm.tree.analysis._
-import scala.tools.nsc.backend.jvm.opt.BytecodeUtils.AsmAnalyzer
 import scala.tools.nsc.io._
 import scala.tools.nsc.reporters.StoreReporter
 import scala.tools.testing.AssertUtil._
@@ -25,14 +24,15 @@ import AsmUtils._
 
 import BackendReporting._
 
-import scala.collection.convert.decorateAsScala._
+import scala.collection.JavaConverters._
 import scala.tools.testing.ClearAfterClass
 
 object InlineWarningTest extends ClearAfterClass.Clearable {
-  val argsNoWarn = "-Ybackend:GenBCode -Yopt:l:classpath"
+  val argsNoWarn = "-Yopt:l:classpath"
   val args = argsNoWarn + " -Yopt-warnings"
   var compiler = newCompiler(extraArgs = args)
-  def clear(): Unit = { compiler = null }
+  var compilerWarnAll = newCompiler(extraArgs = argsNoWarn + " -Yopt-warnings:_")
+  def clear(): Unit = { compiler = null; compilerWarnAll = null }
 }
 
 @RunWith(classOf[JUnit4])
@@ -40,8 +40,9 @@ class InlineWarningTest extends ClearAfterClass {
   ClearAfterClass.stateToClear = InlineWarningTest
 
   val compiler = InlineWarningTest.compiler
+  val compilerWarnAll = InlineWarningTest.compilerWarnAll
 
-  def compile(scalaCode: String, javaCode: List[(String, String)] = Nil, allowMessage: StoreReporter#Info => Boolean = _ => false): List[ClassNode] = {
+  def compile(scalaCode: String, javaCode: List[(String, String)] = Nil, allowMessage: StoreReporter#Info => Boolean = _ => false, compiler: Global = compiler): List[ClassNode] = {
     compileClasses(compiler)(scalaCode, javaCode, allowMessage)
   }
 
@@ -70,29 +71,6 @@ class InlineWarningTest extends ClearAfterClass {
   }
 
   @Test
-  def traitMissingImplClass(): Unit = {
-    val codeA = "trait T { @inline final def f = 1 }"
-    val codeB = "class C { def t1(t: T) = t.f }"
-
-    val removeImpl = (outDir: AbstractFile) => {
-      val f = outDir.lookupName("T$class.class", directory = false)
-      if (f != null) f.delete()
-    }
-
-    val warn =
-      """T::f()I is annotated @inline but cannot be inlined: the trait method call could not be rewritten to the static implementation method. Possible reason:
-        |The method f(LT;)I could not be found in the class T$class or any of its parents.
-        |Note that the following parent classes could not be found on the classpath: T$class""".stripMargin
-
-    var c = 0
-    compileSeparately(List(codeA, codeB), extraArgs = InlineWarningTest.args, afterEach = removeImpl, allowMessage = i => {c += 1; i.msg contains warn})
-    assert(c == 1, c)
-
-    // only summary here
-    compileSeparately(List(codeA, codeB), extraArgs = InlineWarningTest.argsNoWarn, afterEach = removeImpl, allowMessage = _.msg contains "there was one inliner warning")
-  }
-
-  @Test
   def handlerNonEmptyStack(): Unit = {
     val code =
       """class C {
@@ -125,12 +103,12 @@ class InlineWarningTest extends ClearAfterClass {
     val warns = List(
       """failed to determine if bar should be inlined:
         |The method bar()I could not be found in the class A or any of its parents.
-        |Note that the following parent classes are defined in Java sources (mixed compilation), no bytecode is available: A""".stripMargin,
+        |Note that the parent class A is defined in a Java source (mixed compilation), no bytecode is available.""".stripMargin,
 
       """B::flop()I is annotated @inline but could not be inlined:
         |Failed to check if B::flop()I can be safely inlined to B without causing an IllegalAccessError. Checking instruction INVOKESTATIC A.bar ()I failed:
         |The method bar()I could not be found in the class A or any of its parents.
-        |Note that the following parent classes are defined in Java sources (mixed compilation), no bytecode is available: A""".stripMargin)
+        |Note that the parent class A is defined in a Java source (mixed compilation), no bytecode is available.""".stripMargin)
 
     var c = 0
     val List(b) = compile(scalaCode, List((javaCode, "A.java")), allowMessage = i => {c += 1; warns.tail.exists(i.msg contains _)})
@@ -172,6 +150,33 @@ class InlineWarningTest extends ClearAfterClass {
   }
 
   @Test
+  def dontWarnWhenNotIlnineAnnotated(): Unit = {
+    val code =
+      """class M {
+        |  final def f(t: Int => Int) = {
+        |    @noinline def nested = 0
+        |    nested + t(1)
+        |  }
+        |  def t = f(x => x + 1)
+        |}
+        |
+        |class N {
+        |  def t(a: M) = a.f(x => x + 1)
+        |}
+      """.stripMargin
+    compile(code, allowMessage = _ => false) // no warnings allowed
+
+    val warn =
+      """M::f(Lscala/Function1;)I could not be inlined:
+        |The callee M::f(Lscala/Function1;)I contains the instruction INVOKESPECIAL M.nested$1 ()I
+        |that would cause an IllegalAccessError when inlined into class N""".stripMargin
+
+    var c = 0
+    compile(code, compiler = compilerWarnAll, allowMessage = i => { c += 1; i.msg contains warn })
+    assert(c == 1, c)
+  }
+
+  @Test
   def cannotMixStrictfp(): Unit = {
     val code =
       """import annotation.strictfp