Fix scala#6570

Author: OlivierBlanvillain

compiler/src/dotty/tools/dotc/core/TypeComparer.scala

@@ -2136,6 +2136,20 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
   /** Returns last check's debug mode, if explicitly enabled. */
   def lastTrace(): String = ""
 
+  /** Is `tp` an empty type?
+   *
+   *  `true` implies that we found a proof; uncertainty default to `false`.
+   */
+  def provablyEmpty(tp: Type): Boolean =
+    tp.dealias match {
+      case tp if tp.isBottomType => true
+      case AndType(tp1, tp2) => disjoint(tp1, tp2)
+      case OrType(tp1, tp2) => provablyEmpty(tp1) && provablyEmpty(tp2)
+      case tp: RefinedType => provablyEmpty(tp.parent)
+      case tp: TypeRef => provablyEmpty(tp.prefix)
+      case _ => false
+    }
+
   /** Are `tp1` and `tp2` disjoint types?
    *
    *  `true` implies that we found a proof; uncertainty default to `false`.
@@ -2419,6 +2433,7 @@ class TrackingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
       }.apply(tp)
 
       val defn.MatchCase(pat, body) = cas1
+
       if (isSubType(scrut, pat))
         // `scrut` is a subtype of `pat`: *It's a Match!*
         Some {
@@ -2433,7 +2448,7 @@ class TrackingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
       else if (isSubType(widenAbstractTypes(scrut), widenAbstractTypes(pat)))
         Some(NoType)
       else if (disjoint(scrut, pat))
-        // We found a proof that `scrut` and  `pat` are incompatible.
+        // We found a proof that `scrut` and `pat` are incompatible.
         // The search continues.
         None
       else
@@ -2445,7 +2460,10 @@ class TrackingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
       case Nil => NoType
     }
 
-    inFrozenConstraint(recur(cases))
+    if (provablyEmpty(scrut))
+      NoType
+    else
+      inFrozenConstraint(recur(cases))
   }
 }
 

compiler/src/dotty/tools/dotc/transform/patmat/Space.scala

@@ -527,17 +527,8 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
           val sym1 = if (sym.is(ModuleClass)) sym.sourceModule else sym
           val refined = ctx.refineUsingParent(tp, sym1)
 
-          def inhabited(tp: Type): Boolean =
-            tp.dealias match {
-              case AndType(tp1, tp2) => !ctx.typeComparer.disjoint(tp1, tp2)
-              case OrType(tp1, tp2) => inhabited(tp1) || inhabited(tp2)
-              case tp: RefinedType => inhabited(tp.parent)
-              case tp: TypeRef => inhabited(tp.prefix)
-              case _ => true
-            }
-
-          if (inhabited(refined)) refined
-          else NoType
+          if (ctx.typeComparer.provablyEmpty(refined)) NoType
+          else refined
         } filter(_.exists)
 
         debug.println(s"${tp.show} decomposes to [${parts.map(_.show).mkString(", ")}]")

tests/neg/6314-1.scala

@@ -18,7 +18,7 @@ object G {
   }
 
   def main(args: Array[String]): Unit = {
-    val a: Bar[X & Y] = "hello"
+    val a: Bar[X & Y] = "hello" // error
     val i: Bar[Y & Foo] = Foo.apply[Bar](a)
     val b: Int = i // error
     println(b + 1)

tests/neg/6314-2.scala

@@ -12,11 +12,11 @@ object G {
     case Y => Int
   }
 
-  val a: Bar[X & Foo] = "hello"
+  val a: Bar[X & Foo] = "hello" // error
   val b: Bar[Y & Foo] = 1 // error
 
   def main(args: Array[String]): Unit = {
-    val a: Bar[X & Foo] = "hello"
+    val a: Bar[X & Foo] = "hello" // error
     val i: Bar[Y & Foo] = Foo.apply[Bar](a)
     val b: Int = i // error
     println(b + 1)

tests/neg/6570.scala

@@ -0,0 +1,109 @@
+object Base {
+  trait Trait1
+  trait Trait2
+  type N[t] = t match {
+    case String => Trait1
+    case Int => Trait2
+  }
+}
+import Base._
+
+object UpperBoundParametricVariant {
+  trait Cov[+T]
+  type M[t] = t match {
+    case Cov[x] => N[x]
+  }
+
+  trait Root[A] {
+    def thing: M[A]
+  }
+
+  trait Child[A <: Cov[Int]] extends Root[A]
+
+  // we reduce `M[T]` to `Trait2`, even though we cannot be certain of that
+  def foo[T <: Cov[Int]](c: Child[T]): Trait2 = c.thing
+
+  class Asploder extends Child[Cov[String & Int]] {
+    def thing = new Trait1 {} // error
+  }
+
+  def explode = foo(new Asploder) // ClassCastException
+}
+
+object InheritanceVariant {
+  // allows binding a variable to the UB of a type member
+  type Trick[a] = { type A <: a }
+  type M[t] = t match { case Trick[a] => N[a] }
+
+  trait Root {
+    type B
+    def thing: M[B]
+  }
+
+  trait Child extends Root { type B <: { type A <: Int } }
+
+  def foo(c: Child): Trait2 = c.thing
+
+  class Asploder extends Child {
+    type B = { type A = String & Int }
+    def thing = new Trait1 {} // error
+  }
+}
+
+object ThisTypeVariant {
+  type Trick[a] = { type A <: a }
+  type M[t] = t match { case Trick[a] => N[a] }
+
+  trait Root {
+    def thing: M[this.type]
+  }
+
+  trait Child extends Root { type A <: Int }
+
+  def foo(c: Child): Trait2 = c.thing
+
+  class Asploder extends Child {
+    type A = String & Int
+    def thing = new Trait1 {} // error
+  }
+}
+
+object ParametricVariant {
+  type Trick[a] = { type A <: a }
+  type M[t] = t match { case Trick[a] => N[a] }
+
+  trait Root[B] {
+    def thing: M[B]
+  }
+
+  trait Child[B <: { type A <: Int }] extends Root[B]
+
+  def foo[T <: { type A <: Int }](c: Child[T]): Trait2 = c.thing
+
+  class Asploder extends Child[{ type A = String & Int }] {
+    def thing = new Trait1 {} // error
+  }
+
+  def explode = foo(new Asploder)
+}
+
+object UpperBoundVariant {
+  trait Cov[+T]
+  type M[t] = t match { case Cov[t] => N[t] }
+
+  trait Root {
+    type A
+    def thing: M[A]
+  }
+
+  trait Child extends Root { type A <: Cov[Int] }
+
+  def foo(c: Child): Trait2 = c.thing
+
+  class Asploder extends Child {
+    type A = Cov[String & Int]
+    def thing = new Trait1 {} // error
+  }
+
+  def explode = foo(new Asploder)
+}