From 990eff8a5905a3b3120bf1c150e218792acd8822 Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Thu, 5 Nov 2015 15:24:48 +0100
Subject: Drop test that lower bound must be a subtype of upper bound.

As discussed in #780 and #525, the test is not needed. This makes
t1279a compile, which got moved now to pos. Fixes #780 and #915.
It also makes scala.List compile. Review by @smarter.
---
 tests/pos/bounds.scala |  7 +++++++
 tests/pos/t1279a.scala | 39 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 46 insertions(+)
 create mode 100644 tests/pos/t1279a.scala

(limited to 'tests/pos')

diff --git a/tests/pos/bounds.scala b/tests/pos/bounds.scala
index 26bc84a1b..625359f74 100644
--- a/tests/pos/bounds.scala
+++ b/tests/pos/bounds.scala
@@ -9,3 +9,10 @@ object ListMap {
   def empty[X, Y] = new ListMap[X, Y]
   def apply[A1, B2](elems: Tuple2[A1, B2]*): Map[A1, B2] = empty[A1,B2].++(elems.iterator)
 }
+
+class Test[A] {
+
+  def f[B >: A <: AnyRef](x: A): AnyRef = (x: B)
+  def g[B >: String <: Int](x: B): Int = x
+
+}
diff --git a/tests/pos/t1279a.scala b/tests/pos/t1279a.scala
new file mode 100644
index 000000000..6d768d435
--- /dev/null
+++ b/tests/pos/t1279a.scala
@@ -0,0 +1,39 @@
+// covariant linked list
+abstract class M {
+  self: M =>
+
+  type T
+  final type selfType = M {type T <: self.T}
+  type actualSelfType >: self.type <: selfType // this no longer compiles because self.type is not a subtype of selfType
+
+  def next: selfType
+
+  // I don't understand why this doesn't compile, but that's a separate matter
+  // error: method all2 cannot be accessed in M.this.selfType
+  // because its instance type => Stream[M{type T <: M.this.selfType#T}]
+  // contains a malformed type: M.this.selfType#T
+  def all2: Stream[M {type T <: self.T}] = Stream.cons(self: actualSelfType, next.all2)
+
+  // compiles successfully
+  def all3: Stream[M {type T <: self.T}] = all3Impl(self: actualSelfType)
+  private def all3Impl(first: M {type T <: self.T}): Stream[M {type T <: self.T}] = Stream.cons(first, all3Impl(first.next))
+
+  def all4: Stream[M {type T <: self.T}] = Unrelated.all4Impl[T](self: actualSelfType)
+}
+
+// TODO!!! fix this bug for real, it compiles successfully, but weird types are inferred
+object Unrelated {
+  // compiles successfully
+  def all4Impl[U](first: M {type T <: U}): Stream[M {type T <: U}] = Stream.cons(first, all4Impl[U](first.next))
+
+  // should compile successfully without the [U], but:
+  // def all4ImplFail[U](first: M {type T <: U}): Stream[M {type T <: U}] = Stream.cons(first, all4ImplFail(first.next))
+  //
+  // test/files/pos/t1279a.scala:31: error: type mismatch;
+  //  found   : first.selfType
+  //     (which expands to)  M{type T <: first.T}
+  //  required: M{type T <: Nothing}
+  //   def all4ImplFail[U](first: M {type T <: U}): Stream[M {type T <: U}] = Stream.cons(first, all4ImplFail(first.next))
+  //                                                                                                                ^
+  // one error found
+}
-- 
cgit v1.2.3