fixed several problems with cyclic references u...

fixed several problems with cyclic references uncovered by experimenting
with collections. Added early type definitions.

1 files changed, 38 insertions, 0 deletions

diff --git a/test/files/pos/bug1279a.scala b/test/files/pos/bug1279a.scala
new file mode 100644
index 0000000000..7568d3afcd
--- /dev/null
+++ b/test/files/pos/bug1279a.scala
@@ -0,0 +1,38 @@
+// providing the type parameter in the recursive call to all4Impl
+// avoids the problem
+
+
+// covariant linked list
+abstract class M
+{ self =>
+
+    type T
+    final type selfType = M {type T <: self.T}
+    type actualSelfType >: self.type <: 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)
+}
+
+object Unrelated
+{
+   def all4Impl[U](first: M {type T <: U}): Stream[M {type T <: U}] = Stream.cons(first, all4Impl(first.next))
+
+// compiles successfully
+//      def all4Impl[U](first: M {type T <: U}): Stream[M {type T <: U}] = Stream.cons(first, all4Impl[U](first.next))
+}