5 files changed, 149 insertions, 0 deletions
diff --git a/test/pending/neg/t7886.scala b/test/pending/neg/t7886.scala
new file mode 100644
index 0000000000..55d80a0a43
--- /dev/null
+++ b/test/pending/neg/t7886.scala
@@ -0,0 +1,22 @@
+trait Covariant[+A]
+trait Contra[-A] { def accept(p: A): Unit }
+trait Invariant[A] extends Covariant[A] with Contra[A]
+
+case class Unravel[A](m: Contra[A], msg: A)
+
+object Test extends Covariant[Any] {
+  def g(m: Contra[Any]): Unit = m accept 5
+  def f(x: Any): Unit = x match {
+    case Unravel(m, msg) => g(m)
+    case _               =>
+  }
+  def main(args: Array[String]) {
+    f(Unravel[String](new Contra[String] { def accept(x: String) = x.length }, ""))
+  }
+}
+// java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
+//   at Test$$anon$1.accept(a.scala:18)
+//   at Test$.g(a.scala:13)
+//   at Test$.f(a.scala:15)
+//   at Test$.main(a.scala:18)
+//   at Test.main(a.scala)
diff --git a/test/pending/neg/t7886b.scala b/test/pending/neg/t7886b.scala
new file mode 100644
index 0000000000..1db8be9821
--- /dev/null
+++ b/test/pending/neg/t7886b.scala
@@ -0,0 +1,23 @@
+trait Covariant[+A]
+trait Contra[-A] { def accept(p: A): Unit }
+trait Invariant[A] extends Covariant[A] with Contra[A]
+
+trait T
+case class Unravel[A](m: Contra[A], msg: A) extends T
+
+object Test extends Covariant[Any] {
+  def g(m: Contra[Any]): Unit = m accept 5
+  def f(x: T): Unit = x match {
+    case Unravel(m, msg) => g(m)
+    case _               =>
+  }
+  def main(args: Array[String]) {
+    f(Unravel[String](new Contra[String] { def accept(x: String) = x.length }, ""))
+  }
+}
+// java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
+//   at Test$$anon$1.accept(a.scala:18)
+//   at Test$.g(a.scala:13)
+//   at Test$.f(a.scala:15)
+//   at Test$.main(a.scala:18)
+//   at Test.main(a.scala)
diff --git a/test/pending/pos/pattern-typing.scala b/test/pending/pos/pattern-typing.scala
new file mode 100644
index 0000000000..7286cc38af
--- /dev/null
+++ b/test/pending/pos/pattern-typing.scala
@@ -0,0 +1,29 @@
+import scala.language.higherKinds
+
+trait Bound[B]
+
+package p1 {
+  case class Sub[B <: Bound[B]](p: B)
+  object Test {
+    def g[A](x: Bound[A]) = ()
+    def f(x: Any) = x match { case Sub(p) => g(p) }
+  }
+}
+
+package p2 {
+  trait Traversable[+A] { def head: A = ??? }
+  trait Seq[+A] extends Traversable[A] { def length: Int = ??? }
+
+  case class SubHK[B <: Bound[B], CC[X] <: Traversable[X]](xs: CC[B])
+  class MyBound extends Bound[MyBound]
+  class MySeq extends Seq[MyBound]
+
+  object Test {
+    def g[B](x: Bound[B]) = ()
+
+    def f1(x: Any) = x match { case SubHK(xs) => xs }
+    def f2[B <: Bound[B], CC[X] <: Traversable[X]](sub: SubHK[B, CC]): CC[B] = sub match { case SubHK(xs) => xs }
+    def f3 = g(f1(SubHK(new MySeq)).head)
+    def f4 = g(f2(SubHK(new MySeq)).head)
+  }
+}
diff --git a/test/pending/pos/t1786.scala b/test/pending/pos/t1786.scala
new file mode 100644
index 0000000000..6299eb9eae
--- /dev/null
+++ b/test/pending/pos/t1786.scala
@@ -0,0 +1,27 @@
+/** This a consequence of the current type checking algorithm, where bounds are checked only after variables are instantiated.
+ * I believe this will change once we go to contraint-based type inference.
+ * Alternatively, we can pursue a more extensive fix to SI-6169
+ *
+ * The below code shows a compiler flaw in that the wildcard "_" as value for a bounded type parameter either
+ * breaks the boundary - as it result in Any - or doesn't evaluate to the boundary (as I'd hoped it to be).
+*/
+
+class SomeClass(val intValue:Int)
+class MyClass[T <: SomeClass](val myValue:T)
+class Flooz[A >: Null <: SomeClass, T >: Null <: A](var value: T)
+
+class A {
+  def f1(i:MyClass[_])                       = i.myValue.intValue
+  def f2(i:MyClass[_ <: SomeClass])          = i.myValue.intValue
+  // def f3[T](i: MyClass[T])                   = i.myValue.intValue
+  def f4[T <: SomeClass](i: MyClass[T])      = i.myValue.intValue
+  // def f5[T >: Null](i: MyClass[T])           = i.myValue.intValue
+  // def f6[T >: Null <: String](i: MyClass[T]) = i.myValue.intValue + i.myValue.charAt(0)
+
+  // def g1[A, T](x: Flooz[A, T]) = { x.value = null ; x.value.intValue }
+  def g2(x: Flooz[_, _]) = { x.value = null ; x.value.intValue }
+
+  class MyClass2(x: MyClass[_]) { val p = x.myValue.intValue }
+  // class MyClass3[T <: String](x: MyClass[T]) { val p = x.myValue.intValue + x.myValue.length }
+  // class MyClass4[T >: Null](x: MyClass[T]) { val p = x.myValue.intValue }
+}
diff --git a/test/pending/pos/t5459.scala b/test/pending/pos/t5459.scala
new file mode 100644
index 0000000000..971e6f896d
--- /dev/null
+++ b/test/pending/pos/t5459.scala
@@ -0,0 +1,48 @@
+trait A1
+trait A2
+trait A3
+trait L1 extends A1 with A2 with A3
+
+object Test {
+  trait T1[-A <: A1]
+  trait T2[-A >: L1]
+  trait T3[ A <: A1]
+  trait T4[ A >: L1]
+  trait T5[+A <: A1]
+  trait T6[+A >: L1]
+
+  def f1(x: T1[_]) = x
+  def f2(x: T2[_]) = x
+  def f3(x: T3[_]) = x
+  def f4(x: T4[_]) = x
+  def f5(x: T5[_]) = x
+  def f6(x: T6[_]) = x
+  // a.scala:22: error: type arguments [Any] do not conform to trait T5's type parameter bounds [+A <: A1]
+  //   def f5(x: T5[_]) = x
+  //       ^
+
+  def g1(x: T1[_ <: A1]) = x
+  def g2(x: T2[_ >: L1]) = x
+  def g3(x: T3[_ <: A1]) = x
+  def g4(x: T4[_ >: L1]) = x
+  def g5(x: T5[_ <: A1]) = x
+  def g6(x: T6[_ >: L1]) = x
+
+  def q1(x: T1[_ >: L1]) = x
+  def q2(x: T2[_ <: A1]) = x
+  def q3(x: T3[_ >: L1]) = x
+  def q4(x: T4[_ <: A1]) = x
+  def q5(x: T5[_ >: L1]) = x
+  def q6(x: T6[_ <: A1]) = x
+  // a.scala:41: error: type arguments [Any] do not conform to trait T5's type parameter bounds [+A <: A1]
+  //   def q5(x: T5[_ >: L1]) = x
+  //       ^
+  // two errors found
+
+  def h1(x: T1[_ >: L1 <: A1]) = x
+  def h2(x: T2[_ >: L1 <: A1]) = x
+  def h3(x: T3[_ >: L1 <: A1]) = x
+  def h4(x: T4[_ >: L1 <: A1]) = x
+  def h5(x: T5[_ >: L1 <: A1]) = x
+  def h6(x: T6[_ >: L1 <: A1]) = x
+}