Add test cases

Author: OlivierBlanvillain

compiler/test/dotc/pos-test-pickling.blacklist

@@ -26,6 +26,7 @@ matchtype.scala
 i7087.scala
 i7868.scala
 i7872.scala
+6709.scala
 
 # Opaque type
 i5720.scala

tests/neg/6709.scala

@@ -0,0 +1,58 @@
+object Test {
+  type M[X] = X match {
+    case Int => String
+    case Double => Int
+  }
+
+  def m_OK[X](x: X): M[X] = x match {
+    case _: Int    => ""
+    case _: Double => 1
+  }
+
+  def m_error0[X](x: X): M[X] = x match {
+    case Some(i: Int) => "" // error
+    case _: Double => 1     // error
+  }
+
+  def m_error1[X](x: X): M[X] = x match {
+    case s: String => "" // error
+    case _: Double => 1  // error
+  }
+
+  def m_error2[X](x: X): M[X] = x match {
+    case _: Double => 1  // error
+    case _: Int    => "" // error
+  }
+
+  def m_error3[X](x: X): M[X] = x match {
+    case _: Int => "" // error
+  }
+
+  def m_error4[X](x: X): M[X] = x match {
+    case _: Int    => ""   // error
+    case _: Double => 1    // error
+    case _: String => true // error
+  }
+
+  def m_error5[X](x: X): M[X] = x match {
+    case _: Int if true => "" // error
+    case _: Double      => 1  // error
+  }
+
+  case class Blah[A, B](a: A, b: B)
+
+  type LeafElem[X] = X match {
+    case Array[t]   => t
+    case Blah[a, b] => a
+  }
+
+  def leafElem_ok[X](x: X): LeafElem[X] = x match {
+    case y: Array[t]   => y.apply(0)
+    case y: Blah[a, b] => y.a
+  }
+
+  def leafElem_error[X](x: X): LeafElem[X] = x match {
+    case y: Array[t]   => 0   // error
+    case y: Blah[a, b] => y.b // error
+  }
+}

tests/pos/6709.scala

@@ -0,0 +1,71 @@
+object Foo {
+  type LeafElem[X] = X match {
+    case String      => Char
+    case Array[t]    => LeafElem[t]
+    case Iterable[t] => LeafElem[t]
+    case AnyVal      => X
+  }
+
+  def leafElem[X](x: X): LeafElem[X] =
+    x match {
+      case x: String      => x.charAt(0)
+      case x: Array[t]    => leafElem(x(0))
+      case x: Iterable[t] => leafElem(x.head)
+      case _: AnyVal      => x
+    }
+
+  def leafElem2[X](x: X): LeafElem[X] =
+    x match {
+      case _: String   => leafElem[X](x)
+      case w: Array[t] => leafElem[X](x)
+    }
+}
+
+object Bar {
+  import compiletime.S
+
+  type Plus[A <: Int, B <: Int] <: Int =
+    A match {
+      case 0    => B
+      case S[p] => S[Plus[p, B]]
+    }
+
+  def plus[A <: Int, B <: Int](a: A, b: B): Plus[A, B] =
+    a match {
+      case _: 0    => b
+      case a: S[p] => succ(plus(pred(a), b))
+    }
+
+  def pred[X <: Int](x: S[X]): X = (x - 1).asInstanceOf
+  def succ[X <: Int](x: X): S[X] = (x + 1).asInstanceOf
+
+  val nine: 9 = plus[4, 5](4, 5)
+}
+
+object Main {
+  enum BinNat {
+    case Zero
+    // 2n + 1
+    case Odd[N <: BinNat](n: N)
+    // 2(n + 1)
+    case Even[N <: BinNat](n: N)
+  }
+
+  import BinNat._
+
+  type Inc[N <: BinNat] <: BinNat =
+    N match {
+      case Zero.type => Odd[Zero.type]
+      case Odd[n]    => Even[n]
+      case Even[n]   => Odd[Inc[n]]
+    }
+
+  def inc[N <: BinNat](b: N): Inc[N] =
+    b match {
+      case _: Zero.type => new Odd(Zero)
+      case o: Odd[n]    => new Even(o.n)
+      case e: Even[n]   =>
+        // 2(n + 1) + 1 = 2(inc(n)) + 1
+        new Odd(inc(e.n))
+    }
+}