Add tests from #6314

Author: OlivierBlanvillain

tests/neg/6314-2.scala

@@ -0,0 +1,24 @@
+object G {
+  final class X
+  final class Y
+
+  opaque type Foo = Nothing // or X & Y
+  object Foo {
+    def apply[F[_]](fa: F[X & Foo]): F[Y & Foo] = fa
+  }
+
+  type Bar[A] = A match {
+    case X => String
+    case Y => Int
+  }
+
+  val a: Bar[X & Foo] = "hello"
+  val b: Bar[Y & Foo] = 1 // error
+
+  def main(args: Array[String]): Unit = {
+    val a: Bar[X & Foo] = "hello"
+    val i: Bar[Y & Foo] = Foo.apply[Bar](a)
+    val b: Int = i // error
+    println(b + 1)
+  }
+}

tests/neg/6314-3.scala

@@ -0,0 +1,24 @@
+object G {
+    trait Wizzle[L <: Int with Singleton] {
+        type Bar[A] = A match {
+            case 0 => String
+            case L => Int
+        }
+
+        def left(fa: String): Bar[0] = fa
+        def right(fa: Bar[L]): Int = fa // error
+
+        def center[F[_]](fa: F[0]): F[L]
+
+        def run: String => Int = left andThen center[Bar] andThen right
+    }
+
+    class Wozzle extends Wizzle[0] {
+        def center[F[_]](fa: F[0]): F[0] = fa
+    }
+
+    def main(args: Array[String]): Unit = {
+        val coerce: String => Int = (new Wozzle).run
+        println(coerce("hello") + 1)
+    }
+}

tests/neg/6314-4.scala

@@ -0,0 +1,28 @@
+object G {
+    trait Wizzle {
+        type X <: Int with Singleton
+        type Y <: Int with Singleton
+
+        type Bar[A] = A match {
+            case X => String
+            case Y => Int
+        }
+
+        def left(fa: String): Bar[X] = fa
+        def center[F[_]](fa: F[X]): F[Y]
+        def right(fa: Bar[Y]): Int = fa // error
+
+        def run: String => Int = left andThen center[Bar] andThen right
+    }
+
+    class Wozzle extends Wizzle {
+        type X = 0
+        type Y = 0
+        def center[F[_]](fa: F[X]): F[Y] = fa
+    }
+
+    def main(args: Array[String]): Unit = {
+        val coerce: String => Int = (new Wozzle).run
+        println(coerce("hello") + 1)
+    }
+}

tests/neg/6314-5.scala

@@ -0,0 +1,29 @@
+object G {
+  type Void <: Nothing
+  trait Wizzle {
+    type Razzle[+X >: Void]
+    type X = 0
+    type Y = 1
+
+    type Bar[A] = A match {
+      case Razzle[X] => String
+      case Razzle[Y] => Int
+    }
+
+    def left(fa: String): Bar[Razzle[X]] = fa
+    def center[F[_]](fa: F[Razzle[X]]): F[Razzle[Y]]
+    def right(fa: Bar[Razzle[Y]]): Int = fa // error
+
+    def run: String => Int = left andThen center[Bar] andThen right
+  }
+
+  class Wozzle extends Wizzle {
+    type Razzle[+X >: Void] = Int
+    def center[F[_]](fa: F[Razzle[X]]): F[Razzle[Y]] = fa
+  }
+
+  def main(args: Array[String]): Unit = {
+    val coerce: String => Int = (new Wozzle).run
+    println(coerce("hello") + 1)
+  }
+}

tests/neg/6314.scala

@@ -46,3 +46,28 @@ object Test2 {
     def right(fa: Bar[L]): Int = fa // error
   }
 }
+
+
+object Test3 {
+  type Bar[A] = A match {
+    case X => String
+    case Y => Int
+  }
+
+  trait XX {
+    type Foo
+
+    val a: Bar[X & Foo] = "hello"
+    val b: Bar[Y & Foo] = 1 // error
+
+    def apply(fa: Bar[X & Foo]): Bar[Y & Foo]
+
+    def boom: Int = apply(a) // error
+  }
+
+  trait YY extends XX {
+    type Foo = X & Y
+
+    def apply(fa: Bar[X & Foo]): Bar[Y & Foo] = fa
+  }
+}