Merge pull request #3516 from adriaanm/t8177

 SI-8177 co-evolve more than just RefinedTypes 

4 files changed, 0 insertions, 148 deletions

diff --git a/test/files/neg/t0764.check b/test/files/neg/t0764.check
deleted file mode 100644
index 6156b52712..0000000000
--- a/test/files/neg/t0764.check
+++ /dev/null
@@ -1,7 +0,0 @@
-t0764.scala:13: error: type mismatch;
- found   : Node{type T = _1.type} where val _1: Node{type T = NextType}
- required: Node{type T = Main.this.AType}
-    (which expands to)  Node{type T = Node{type T = NextType}}
-	new Main[AType]( (value: AType).prepend )
-                                        ^
-one error found
diff --git a/test/files/neg/t0764.scala b/test/files/neg/t0764.scala
deleted file mode 100644
index f2cc65cf7d..0000000000
--- a/test/files/neg/t0764.scala
+++ /dev/null
@@ -1,14 +0,0 @@
-class Top[A] {
-	type AType = A
-}
-
-trait Node { outer =>
-	type T <: Node
-	def prepend = new Node { type T = outer.type }
-}
-
-class Main[NextType <: Node](value: Node { type T = NextType })
-	extends Top[Node { type T = NextType }] {
-
-	new Main[AType]( (value: AType).prepend )
-}
diff --git a/test/files/neg/t0764b.check b/test/files/neg/t0764b.check
deleted file mode 100644
index d74a9efbfe..0000000000
--- a/test/files/neg/t0764b.check
+++ /dev/null
@@ -1,63 +0,0 @@
-t0764b.scala:27: error: type mismatch;
- found   : p1.t0764.Node{type T = p1.t0764.<refinement>.type}
- required: p1.t0764.NodeAlias[p1.t0764.NodeAlias[A]]
-    (which expands to)  p1.t0764.Node{type T = p1.t0764.Node{type T = A}}
-      private[this] def f1 = new Main1(v.prepend)                        // fail
-                                         ^
-t0764b.scala:28: error: type mismatch;
- found   : p1.t0764.Node{type T = p1.t0764.<refinement>.type}
- required: p1.t0764.NodeAlias[p1.t0764.NodeAlias[A]]
-    (which expands to)  p1.t0764.Node{type T = p1.t0764.Node{type T = A}}
-      private[this] def f2 = new Main1[NodeAlias[A]](v.prepend)          // fail
-                                                       ^
-t0764b.scala:29: error: type mismatch;
- found   : p1.t0764.Node{type T = p1.t0764.<refinement>.type}
- required: p1.t0764.NodeAlias[p1.t0764.Node{type T = A}]
-    (which expands to)  p1.t0764.Node{type T = p1.t0764.Node{type T = A}}
-      private[this] def f3 = new Main1[Node { type T = A }](v.prepend)   // fail
-                                                              ^
-t0764b.scala:34: error: type mismatch;
- found   : p1.t0764.Node{type T = p1.t0764.<refinement>.type}
- required: p1.t0764.Node{type T = p1.t0764.Node{type T = A}}
-      private[this] def f1 = new Main2(v.prepend)                        // fail
-                                         ^
-t0764b.scala:35: error: type mismatch;
- found   : p1.t0764.Node{type T = p1.t0764.<refinement>.type}
- required: p1.t0764.Node{type T = p1.t0764.NodeAlias[A]}
-    (which expands to)  p1.t0764.Node{type T = p1.t0764.Node{type T = A}}
-      private[this] def f2 = new Main2[NodeAlias[A]](v.prepend)          // fail
-                                                       ^
-t0764b.scala:36: error: type mismatch;
- found   : p1.t0764.Node{type T = p1.t0764.<refinement>.type}
- required: p1.t0764.Node{type T = p1.t0764.Node{type T = A}}
-      private[this] def f3 = new Main2[Node { type T = A }](v.prepend)   // fail
-                                                              ^
-t0764b.scala:52: error: type mismatch;
- found   : p2.t0764.Node{type T = p2.t0764.<refinement>.type}
- required: p2.t0764.NodeAlias[p2.t0764.NodeAlias[A]]
-    (which expands to)  p2.t0764.Node{type T = p2.t0764.Node{type T = A}}
-      private[this] def f2 = new Main1[NodeAlias[A]](v.prepend)          // fail
-                                                       ^
-t0764b.scala:53: error: type mismatch;
- found   : p2.t0764.Node{type T = p2.t0764.<refinement>.type}
- required: p2.t0764.NodeAlias[p2.t0764.Node{type T = A}]
-    (which expands to)  p2.t0764.Node{type T = p2.t0764.Node{type T = A}}
-      private[this] def f3 = new Main1[Node { type T = A }](v.prepend)   // fail
-                                                              ^
-t0764b.scala:58: error: type mismatch;
- found   : p2.t0764.Node{type T = p2.t0764.<refinement>.type}
- required: p2.t0764.Node{type T = p2.t0764.Node{type T = A}}
-      private[this] def f1 = new Main2(v.prepend)                        // fail
-                                         ^
-t0764b.scala:59: error: type mismatch;
- found   : p2.t0764.Node{type T = p2.t0764.<refinement>.type}
- required: p2.t0764.Node{type T = p2.t0764.NodeAlias[A]}
-    (which expands to)  p2.t0764.Node{type T = p2.t0764.Node{type T = A}}
-      private[this] def f2 = new Main2[NodeAlias[A]](v.prepend)          // fail
-                                                       ^
-t0764b.scala:60: error: type mismatch;
- found   : p2.t0764.Node{type T = p2.t0764.<refinement>.type}
- required: p2.t0764.Node{type T = p2.t0764.Node{type T = A}}
-      private[this] def f3 = new Main2[Node { type T = A }](v.prepend)   // fail
-                                                              ^
-11 errors found
diff --git a/test/files/neg/t0764b.scala b/test/files/neg/t0764b.scala
deleted file mode 100644
index 4ad5ecdc03..0000000000
--- a/test/files/neg/t0764b.scala
+++ /dev/null
@@ -1,64 +0,0 @@
-/** Note that this should compile! It's a neg test to track the
-behavior. If you have broken this test by making it compile, that
-means you have fixed it and it should be moved to pos.
-**/
-
-// In all cases when calling "prepend" the receiver 'v'
-// has static type NodeAlias[A] or (equivalently) Node { type T = A }.
-// Since prepend explicitly returns the singleton type of the receiver,
-// the return type of prepend in all cases is "v.type", and so the call
-// to "new Main" can be parameterized with any of the following, in order
-// of decreasing specificity with a tie for second place:
-//
-//   new Main[v.type](v.prepend)
-//   new Main[NodeAlias[A]](v.prepend)
-//   new Main[Node { type T = A }](v.prepend)
-//   new Main(v.prepend)
-
-package p1 {
-  object t0764 {
-    type NodeAlias[A] = Node { type T = A }
-    trait Node { outer =>
-      type T <: Node
-      def prepend: Node { type T = outer.type } = ???
-    }
-
-    class Main1[A <: Node](v: NodeAlias[A]) {
-      private[this] def f1 = new Main1(v.prepend)                        // fail
-      private[this] def f2 = new Main1[NodeAlias[A]](v.prepend)          // fail
-      private[this] def f3 = new Main1[Node { type T = A }](v.prepend)   // fail
-      private[this] def f4 = new Main1[v.type](v.prepend)                // ok
-    }
-
-    class Main2[A <: Node](v: Node { type T = A }) {
-      private[this] def f1 = new Main2(v.prepend)                        // fail
-      private[this] def f2 = new Main2[NodeAlias[A]](v.prepend)          // fail
-      private[this] def f3 = new Main2[Node { type T = A }](v.prepend)   // fail
-      private[this] def f4 = new Main2[v.type](v.prepend)                // ok
-    }
-  }
-}
-
-package p2 {
-  object t0764 {
-    type NodeAlias[A] = Node { type T = A }
-    trait Node { outer =>
-      type T <: Node
-      def prepend: NodeAlias[outer.type] = ???
-    }
-
-    class Main1[A <: Node](v: NodeAlias[A]) {
-      private[this] def f1 = new Main1(v.prepend)                        // ok!  <<========== WOT
-      private[this] def f2 = new Main1[NodeAlias[A]](v.prepend)          // fail
-      private[this] def f3 = new Main1[Node { type T = A }](v.prepend)   // fail
-      private[this] def f4 = new Main1[v.type](v.prepend)                // ok
-    }
-
-    class Main2[A <: Node](v: Node { type T = A }) {
-      private[this] def f1 = new Main2(v.prepend)                        // fail
-      private[this] def f2 = new Main2[NodeAlias[A]](v.prepend)          // fail
-      private[this] def f3 = new Main2[Node { type T = A }](v.prepend)   // fail
-      private[this] def f4 = new Main2[v.type](v.prepend)                // ok
-    }
-  }
-}