Nailed down the "impossible match" logic.

I will again defer to a comment.

/** Given classes A and B, can it be shown that nothing which is
 *  an A will ever be a subclass of something which is a B? This
 *  entails not only showing that !(A isSubClass B) but that the
 *  same is true of all their subclasses.  Restated for symmetry:
 *  the same value cannot be a member of both A and B.
 *
 *   1) A must not be a subclass of B, nor B of A (the trivial check)
 *   2) One of A or B must be completely knowable (see isKnowable)
 *   3) Assuming A is knowable, the proposition is true if
 *      !(A' isSubClass B) for all A', where A' is a subclass of A.
 *
 *  Due to symmetry, the last condition applies as well in reverse.
 */

1 files changed, 93 insertions, 0 deletions

diff --git a/test/files/neg/unchecked-abstract.scala b/test/files/neg/unchecked-abstract.scala
new file mode 100644
index 0000000000..5b915755f4
--- /dev/null
+++ b/test/files/neg/unchecked-abstract.scala
@@ -0,0 +1,93 @@
+trait Con[-X]
+trait Inv[X]
+trait Cov[+X]
+
+abstract class M {
+  type H
+  type L <: H
+  type T >: L <: H
+
+  def h1(x: Con[H]) = {
+    /* nowarn */ println(x.isInstanceOf[Con[H]])
+    /* nowarn */ println(x.isInstanceOf[Con[T]])
+    /* nowarn */ println(x.isInstanceOf[Con[L]])
+  }
+  def h2(x: Con[T]) = {
+    /*   warn */ println(x.isInstanceOf[Con[H]])
+    /* nowarn */ println(x.isInstanceOf[Con[T]])
+    /* nowarn */ println(x.isInstanceOf[Con[L]])
+  }
+  def h3(x: Con[L]) = {
+    /*   warn */ println(x.isInstanceOf[Con[H]])
+    /*   warn */ println(x.isInstanceOf[Con[T]])
+    /* nowarn */ println(x.isInstanceOf[Con[L]])
+  }
+  def h4(x: Inv[H]) = {
+    /* nowarn */ println(x.isInstanceOf[Inv[H]])
+    /*   warn */ println(x.isInstanceOf[Inv[T]])
+    /*   warn */ println(x.isInstanceOf[Inv[L]])
+  }
+  def h5(x: Inv[T]) = {
+    /*   warn */ println(x.isInstanceOf[Inv[H]])
+    /* nowarn */ println(x.isInstanceOf[Inv[T]])
+    /*   warn */ println(x.isInstanceOf[Inv[L]])
+  }
+  def h6(x: Inv[L]) = {
+    /*   warn */ println(x.isInstanceOf[Inv[H]])
+    /*   warn */ println(x.isInstanceOf[Inv[T]])
+    /* nowarn */ println(x.isInstanceOf[Inv[L]])
+  }
+  def h7(x: Cov[H]) = {
+    /* nowarn */ println(x.isInstanceOf[Cov[H]])
+    /*   warn */ println(x.isInstanceOf[Cov[T]])
+    /*   warn */ println(x.isInstanceOf[Cov[L]])
+  }
+  def h8(x: Cov[T]) = {
+    /* nowarn */ println(x.isInstanceOf[Cov[H]])
+    /* nowarn */ println(x.isInstanceOf[Cov[T]])
+    /*   warn */ println(x.isInstanceOf[Cov[L]])
+  }
+  def h9(x: Cov[L]) = {
+    /* nowarn */ println(x.isInstanceOf[Cov[H]])
+    /* nowarn */ println(x.isInstanceOf[Cov[T]])
+    /* nowarn */ println(x.isInstanceOf[Cov[L]])
+  }
+}
+
+object Test extends M {
+  type H = Any
+  type T = Int
+  type L = Nothing
+
+  val conh = new Con[H] { }
+  val cont = new Con[T] { }
+  val conl = new Con[L] { }
+
+  val invh = new Inv[H] { }
+  val invt = new Inv[T] { }
+  val invl = new Inv[L] { }
+
+  val covh = new Cov[H] { }
+  val covt = new Cov[T] { }
+  val covl = new Cov[L] { }
+
+  def main(args: Array[String]): Unit = {
+    h1(conh)
+    h2(conh)
+    h2(cont)
+    h3(conh)
+    h3(cont)
+    h3(conl)
+
+    h4(invh)
+    h5(invt)
+    h6(invl)
+
+    h7(covh)
+    h7(covt)
+    h7(covl)
+    h8(covt)
+    h8(covl)
+    h9(covl)
+  }
+}