5 files changed, 44 insertions, 8 deletions
diff --git a/test/files/pos/t7584.scala b/test/files/pos/t7584.scala
new file mode 100644
index 0000000000..52d127ecb9
--- /dev/null
+++ b/test/files/pos/t7584.scala
@@ -0,0 +1,11 @@
+object Test {
+  def fold[A, B](f: (A, => B) => B) = ???
+  def f[A, B](x: A, y: B): B = ???
+  def bip[A, B] = fold[A, B]((x, y) => f(x, y))
+  def bop[A, B] = fold[A, B](f)
+
+  // these work:
+  fold[Int, Int]((x, y) => f(x, y))
+  fold[Int, Int](f)
+}
+
diff --git a/test/files/run/t6308.scala b/test/files/run/t6308.scala
index bcd89359b0..d23cd6e13e 100644
--- a/test/files/run/t6308.scala
+++ b/test/files/run/t6308.scala
@@ -1,21 +1,25 @@
 import scala.{specialized => sp}
 
+// NOTE: `{ val c = caller; print(""); c }` is used instead of a simple `caller`,
+//       because we want to prevent tail-call optimization from eliding the stack-
+//       frames we want to inspect.
+
 object Test {
   def caller = new Exception().getStackTrace()(1).getMethodName
-  def f1[@sp(Int) A](a: A, b: Any)             = caller
-  def f2[@sp(Int) A, B](a: A, b: String)       = caller
-  def f3[B, @sp(Int) A](a: A, b: List[B])      = caller
-  def f4[B, @sp(Int) A](a: A, b: List[(A, B)]) = caller
+  def f1[@sp(Int) A](a: A, b: Any)             = { val c = caller; print(""); c }
+  def f2[@sp(Int) A, B](a: A, b: String)       = { val c = caller; print(""); c }
+  def f3[B, @sp(Int) A](a: A, b: List[B])      = { val c = caller; print(""); c }
+  def f4[B, @sp(Int) A](a: A, b: List[(A, B)]) = { val c = caller; print(""); c }
 
-  def f5[@sp(Int) A, B <: Object](a: A, b: B)  = caller
+  def f5[@sp(Int) A, B <: Object](a: A, b: B)  = { val c = caller; print(""); c }
 
   // `uncurryTreeType` calls a TypeMap on the call to this method and we end up with new
   // type parameter symbols, which are not found in `TypeEnv.includes(typeEnv(member), env)`
   // in `specSym`. (One of `uncurry`'s tasks is to expand type aliases in signatures.)
   type T = Object
-  def todo1[@sp(Int) A, B <: T](a: A, b: String)           = caller
-  def todo2[@sp(Int) A, B <: AnyRef](a: A, b: String)      = caller
-  def todo3[B <: List[A], @specialized(Int) A](a: A, b: B) = caller
+  def todo1[@sp(Int) A, B <: T](a: A, b: String)           = { val c = caller; print(""); c }
+  def todo2[@sp(Int) A, B <: AnyRef](a: A, b: String)      = { val c = caller; print(""); c }
+  def todo3[B <: List[A], @specialized(Int) A](a: A, b: B) = { val c = caller; print(""); c }
 
   def main(args: Array[String]) {
     val s = ""
diff --git a/test/files/run/t7584.check b/test/files/run/t7584.check
new file mode 100644
index 0000000000..9f53e5dde5
--- /dev/null
+++ b/test/files/run/t7584.check
@@ -0,0 +1,6 @@
+no calls
+call A
+a
+call B twice
+b
+b
diff --git a/test/files/run/t7584.flags b/test/files/run/t7584.flags
new file mode 100644
index 0000000000..e8fb65d50c
--- /dev/null
+++ b/test/files/run/t7584.flags
@@ -0,0 +1 @@
+-Xfatal-warnings
+\ No newline at end of file
diff --git a/test/files/run/t7584.scala b/test/files/run/t7584.scala
new file mode 100644
index 0000000000..6d7f4f7ebb
--- /dev/null
+++ b/test/files/run/t7584.scala
@@ -0,0 +1,14 @@
+// Test case added to show the behaviour of functions with
+// by-name parameters.  The evaluation behaviour was already correct.
+//
+// We did flush out a spurious "pure expression does nothing in statement position"
+// warning, hence -Xfatal-warnings in the flags file.
+object Test extends App {
+  def foo(f: (=> Int, => Int) => Unit) = f({println("a"); 0}, {println("b"); 1})
+  println("no calls")
+  foo((a, b) => ())
+  println("call A")
+  foo((a, b) => a)
+  println("call B twice")
+  foo((a, b) => {b; b})
+}