SI-7899 Allow by-name inference under -Yinfer-by-name

As usual, the hole has been exploited in the wild. While you
can't abstract over by-name-ness without running into the
ClassCastException or an un-applied Function0, there are cases
like the enclosed test where you can tiptoe around those
cases.

I've proposed a small change to Scalaz to avoid tripping over
this problem:

   https://github.com/scalaz/scalaz/pull/562/files

But this commit I've also added a transitional flag, -Yinfer-by-name,
that they could use to back-publish older versions without code
changes. It is also an insurance policy for other projects that
might be exploiting the same hole.

1 files changed, 24 insertions, 0 deletions

diff --git a/test/files/run/t7899-regression.scala b/test/files/run/t7899-regression.scala
new file mode 100644
index 0000000000..67d38cdd1d
--- /dev/null
+++ b/test/files/run/t7899-regression.scala
@@ -0,0 +1,24 @@
+import language.higherKinds
+
+object Test {
+  trait Monad[M[_]] {
+    def foo[A](ma: M[A])(f: M[A] => Any) = f(ma)
+  }
+  implicit def function1Covariant[T]: Monad[({type l[a] = (T => a)})#l] =
+    new Monad[({type l[a] = (T => a)})#l] {}
+
+  def main(args: Array[String]) {
+    // inference of T = (=> Any) here was outlawed by SI-7899 / 8ed7099
+    // but this pattern is used in Scalaz in just a few places and caused
+    // a regression.
+    //
+    // Inference of a by-name type doesn't *always* lead to a ClassCastException,
+    // it only gets there if a method in generic code accepts a parameter of
+    // that type.
+    //
+    // We need to introduce the stricter inference rules gradually, probably
+    // with a warning.
+    val m = implicitly[Monad[({type f[+x] = (=> Any) => x})#f]]
+    assert(m.foo[Int]((x => 0))(f => f(???)) == 0)
+  }
+}