Disallow refinements of types or methods that do not appear in parent.

We planned this for a long time but never implemented it. Instead, we sometimes
issued an erro in Splitter, namely if reflection would have been needed to access the
member. It turns out that some tests (e.g. neg/t625) fail -Ycheck (we knew that before
and disabled) but also fail Pickling because they generate orhpan PolyParams. So rather
than patching this up it seems now is a good time to enforce the restriction for real.

1 files changed, 70 insertions, 0 deletions

diff --git a/tests/neg/structural.scala b/tests/neg/structural.scala
new file mode 100644
index 000000000..1d2506290
--- /dev/null
+++ b/tests/neg/structural.scala
@@ -0,0 +1,70 @@
+package p1 {
+
+object test123 {
+  type A = { def a: Int }
+  def f(a: A): A = a
+}
+
+object structural2 {
+  type A = { def a: Int }
+
+  type B = {
+    def b: Int
+  }
+
+  type AB = A & B
+
+  def f(ab: AB): AB = ab
+
+  f(new {
+    def a = 43
+    def b = 42
+  })
+}
+}
+
+package p2 {
+object RClose {
+  type ReflectCloseable = { def close(): Unit }
+  def withReflectCloseable[T <: ReflectCloseable, R](s: T)(action: T => R): R =
+    try {
+      action(s)
+    } finally {
+      s.close()
+    }
+}
+}
+
+package p3 {
+object Test {
+  def idMap[C[_],T](m: { def map[U](f: T => U): C[U] }): C[T] = m.map(t => t)
+
+  def main(args: Array[String]): Unit = {
+    idMap(Some(5))
+    idMap(Responder.constant(5))
+  }
+}
+}
+package p4 {
+
+trait A { self: Any { def p: Any } =>
+  def f(b: => Unit): Unit = {}
+  f { p } // error: cannot access member 'p' from structural type
+}
+}
+
+package p5 {
+// t2810
+object Test {
+  val closeable1: { def close(): Unit } = new scala.io.Source { val iter: Iterator[Char] = "".iterator }
+  val closeable2: { def close(): Unit } = new java.io.Closeable { def close() = {} }
+}
+}
+
+package p6 {
+
+  class Refinements {
+    val y: C { val x: T; type T }  // was adeprecated warning: illegal forward reference in refinement; now illegal
+  }
+
+}