Fix error on if/match with phantoms of different lattices.

Author: nicolasstucki

compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala

@@ -1298,9 +1298,9 @@ object messages {
       hl"""|""".stripMargin
   }
 
-  case class MatchPhantom()(implicit ctx: Context) extends Message(MatchPhantomID) {
+  case class MatchPhantom(tpdCase: tpd.CaseDef, expected: Type)(implicit ctx: Context) extends Message(MatchPhantomID) {
     val kind = "Phantom restriction"
-    val msg = "Pattern matches cannot return phantom and non phantoms"
+    val msg = s"Pattern expected case to return a ${expected.show} but was ${tpdCase.tpe.show}"
 
     val explanation =
       hl"""|""".stripMargin
@@ -1315,9 +1315,13 @@ object messages {
       hl"""|""".stripMargin
   }
 
-  case class IfElsePhantom()(implicit ctx: Context) extends Message(IfElsePhantomID) {
+  case class IfElsePhantom(thenp: tpd.Tree, elsep: tpd.Tree)(implicit ctx: Context) extends Message(IfElsePhantomID) {
     val kind = "Phantom restriction"
-    val msg = "Cannot yield a phantom type in one of the if branches and not in the other one."
+    val msg =
+      s"""if/else cannot have branches with types in different lattices:
+         |  ${thenp.tpe.show} of lattice ${thenp.tpe.topType.show}
+         |  ${elsep.tpe.show} of lattice ${elsep.tpe.topType.show}
+       """.stripMargin
 
     val explanation =
       hl"""|""".stripMargin

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -651,8 +651,8 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     val cond1 = typed(tree.cond, defn.BooleanType)
     val thenp1 = typed(tree.thenp, pt.notApplied)
     val elsep1 = typed(tree.elsep orElse (untpd.unitLiteral withPos tree.pos), pt.notApplied)
-    if (thenp1.tpe.isPhantom != elsep1.tpe.isPhantom)
-      ctx.error(IfElsePhantom(), tree.pos)
+    if (thenp1.tpe.topType != elsep1.tpe.topType)
+      ctx.error(IfElsePhantom(thenp1, elsep1), tree.pos)
     val thenp2 :: elsep2 :: Nil = harmonize(thenp1 :: elsep1 :: Nil)
     assignType(cpy.If(tree)(cond1, thenp2, elsep2), thenp2, elsep2)
   }
@@ -858,9 +858,11 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
 
     val tpdCases = cases mapconserve (typedCase(_, pt, selType, gadtSyms))
 
-    val phantomBranches = tpdCases.count(_.body.tpe.isPhantom)
-    if (phantomBranches != 0 && phantomBranches != tpdCases.size)
-      ctx.error(MatchPhantom(), tpdCases.head.pos)
+    if (tpdCases.nonEmpty) {
+      val top = tpdCases.head.tpe.topType
+      for (tpdCase <- tpdCases if tpdCase.tpe.topType != top)
+        ctx.error(MatchPhantom(tpdCase, top), tpdCase.pos)
+    }
 
     tpdCases
   }

tests/neg/phantom-expr.scala

@@ -1,6 +1,7 @@
 
 class Foo {
   import Boo._
+  import Boo1._
 
   type Blinky <: BooAny
   type Inky <: BooAny
@@ -9,15 +10,36 @@ class Foo {
   val inky = Boo.boo[Inky]
 
   val b = true
-  def fooIf1 = if (b) { blinky } else { "" } // error
-  def fooIf2 = if (b) { "" } else { blinky } // error
+  def fooIf1 =
+    if (b) blinky // error
+    else ""
 
-  def fooMatch1 = blinky match { case _: Blinky => () } // error
-  def fooMatch2 = 1 match { case 1 => 2 case _ => blinky } // error
+  def fooIf2 =
+    if (b) "" // error
+    else blinky
+
+  def fooIf3 =
+    if (b) boo1 // error
+    else blinky
+
+  def fooMatch1 = blinky match { // error
+    case _: Blinky => ()
+  }
+  def fooMatch2 = 1 match { case 1 => 2
+    case _ => blinky // error
+  }
+  def fooMatch3 = 1 match {
+    case 1 => boo1
+    case _ => blinky // error
+  }
 }
 
 object Boo extends Phantom {
   type BooAny = this.Any
   def boo[B <: BooAny]: B = assume[B]
 }
 
+object Boo1 extends Phantom {
+  type Boo1Any = this.Any
+  def boo1: Boo1Any = assume[Boo1Any]
+}