Inline error messages.

Author: nicolasstucki

compiler/src/dotty/tools/dotc/reporting/diagnostic/ErrorMessageID.java

@@ -56,15 +56,6 @@ public enum ErrorMessageID {
     CyclicReferenceInvolvingID,
     CyclicReferenceInvolvingImplicitID,
     SuperQualMustBeParentID,
-    ErasedPhantomsSignatureCollisionID,
-    PhantomInheritanceID,
-    PhantomMixedBoundsID,
-    PhantomCrossedMixedBoundsID,
-    MatchPhantomID,
-    MatchOnPhantomID,
-    IfElsePhantomID,
-    PhantomIsInObjectID,
-    PhantomObjectIsInPackageOrObjectID,
     ;
 
     public int errorNumber() {

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

@@ -10,7 +10,6 @@ import Symbols._
 import Names._
 import NameOps._
 import Types._
-import Flags._
 import util.SourcePosition
 import config.Settings.Setting
 import interfaces.Diagnostic.{ERROR, INFO, WARNING}
@@ -134,7 +133,7 @@ object messages {
   }
 
   case class EmptyCatchBlock(tryBody: untpd.Tree)(implicit ctx: Context)
-  extends EmptyCatchOrFinallyBlock(tryBody, EmptyCatchBlockID) {
+ extends EmptyCatchOrFinallyBlock(tryBody, EmptyCatchBlockID) {
     val kind = "Syntax"
     val msg =
       hl"""|The ${"catch"} block does not contain a valid expression, try
@@ -1222,93 +1221,4 @@ object messages {
            |Attempting to define a field in a method signature after a varargs field is an error.
            |""".stripMargin
   }
-
-  case class ErasedPhantomsSignatureCollision(decls: Iterable[Symbol], erased: (Name, Type))(implicit ctx: Context)
-  extends Message(ErasedPhantomsSignatureCollisionID) {
-    val kind = "Phantom restriction"
-    val msg = em"After phantom erasure methods $methodsString will have the same signature: ${erased._1}${erased._2}"
-
-    private def methodsString = decls.map(decl => em"${decl.name}${decl.info}").mkString(", ")
-
-    val explanation =
-      hl"""|Phantom erasure removes all phantom parameters/arguments from methods and functions.
-           |""".stripMargin
-  }
-
-  case class PhantomInheritance(cdef: tpd.TypeDef)(implicit ctx: Context)
-  extends Message(PhantomInheritanceID) {
-    val kind = "Phantom restriction"
-    val msg = perfix + " cannot extend both Any and PhantomAny."
-
-    def perfix =
-      if (cdef.symbol.flags.is(Flags.Trait)) "A trait"
-      else if (cdef.symbol.flags.is(Flags.Abstract)) "An abstract class"
-      else "A class"
-
-    val explanation =
-      hl"""|""".stripMargin
-  }
-
-  case class PhantomMixedBounds(op: untpd.Ident)(implicit ctx: Context)
-  extends Message(PhantomMixedBoundsID) {
-    val kind = "Phantom restriction"
-    val msg = hl"Can not mix types of ${"Any"} and ${"Phantom.Any"} with ${op.show}."
-
-    val explanation =
-      hl"""|""".stripMargin
-  }
-
-  case class PhantomCrossedMixedBounds(lo: untpd.Tree, hi: untpd.Tree)(implicit ctx: Context)
-  extends Message(PhantomCrossedMixedBoundsID) {
-    val kind = "Phantom restriction"
-    val msg = hl"Type can not be bounded at the same time by types in the ${"Any"} and ${"Phantom.Any"} latices."
-
-    val explanation =
-      hl"""|""".stripMargin
-  }
-
-  case class MatchPhantom(tpdCase: tpd.CaseDef, expected: Type)(implicit ctx: Context) extends Message(MatchPhantomID) {
-    val kind = "Phantom restriction"
-    val msg = s"Pattern expected case to return a ${expected.show} but was ${tpdCase.tpe.show}"
-
-    val explanation =
-      hl"""|""".stripMargin
-  }
-
-
-  case class MatchOnPhantom()(implicit ctx: Context) extends Message(MatchOnPhantomID) {
-    val kind = "Phantom restriction"
-    val msg = "Cannot pattern match on phantoms"
-
-    val explanation =
-      hl"""|""".stripMargin
-  }
-
-  case class IfElsePhantom(thenp: tpd.Tree, elsep: tpd.Tree)(implicit ctx: Context) extends Message(IfElsePhantomID) {
-    val kind = "Phantom restriction"
-    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
-  }
-
-  case class PhantomIsInObject()(implicit ctx: Context) extends Message(PhantomIsInObjectID) {
-    val kind = "Phantom restriction"
-    val msg = s"Only ${"object"} can extend ${"scala.Phantom"}"
-
-    val explanation =
-      hl"""|""".stripMargin
-  }
-
-  case class PhantomObjectIsInPackageOrObject()(implicit ctx: Context) extends Message(PhantomObjectIsInPackageOrObjectID) {
-    val kind = "Phantom restriction"
-    val msg = s"An ${"object"} extending ${"scala.Phantom"} must be a top level ${"object"} or in another object"
-
-    val explanation =
-      hl"""|""".stripMargin
-  }
 }

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

@@ -658,8 +658,12 @@ 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.topType != elsep1.tpe.topType)
-      ctx.error(IfElsePhantom(thenp1, elsep1), tree.pos)
+    if (thenp1.tpe.topType != elsep1.tpe.topType) {
+      ctx.error(s"""if/else cannot have branches with types in different lattices:
+                   |  ${thenp1.tpe.show} of lattice ${thenp1.tpe.topType.show}
+                   |  ${elsep1.tpe.show} of lattice ${elsep1.tpe.topType.show}
+                """.stripMargin, tree.pos)
+    }
     val thenp2 :: elsep2 :: Nil = harmonize(thenp1 :: elsep1 :: Nil)
     assignType(cpy.If(tree)(cond1, thenp2, elsep2), thenp2, elsep2)
   }
@@ -832,7 +836,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       case _ =>
         val sel1 = typedExpr(tree.selector)
         if (sel1.tpe.isPhantom)
-          ctx.error(MatchOnPhantom(), sel1.pos)
+          ctx.error("Cannot pattern match on phantoms", sel1.pos)
         val selType = widenForMatchSelector(
             fullyDefinedType(sel1.tpe, "pattern selector", tree.pos))
 
@@ -869,7 +873,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     if (tpdCases.nonEmpty) {
       val top = tpdCases.head.tpe.topType
       for (tpdCase <- tpdCases if tpdCase.tpe.topType != top)
-        ctx.error(MatchPhantom(tpdCase, top), tpdCase.pos)
+        ctx.error(s"Pattern expected case to return a ${top.show} but was ${tpdCase.tpe.show}", tpdCase.pos)
     }
 
     tpdCases
@@ -1356,9 +1360,9 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
 
     if (cls.classParents.exists(_.classSymbol eq defn.PhantomClass)) {
       if (!cls.is(Module))
-        ctx.error(PhantomIsInObject(), cdef.pos)
+        ctx.error("Only object can extend scala.Phantom", cdef.pos)
       else if (!cls.owner.is(Module) && !cls.owner.is(Package))
-        ctx.error(PhantomObjectIsInPackageOrObject(), cdef.pos)
+        ctx.error("An object extending scala.Phantom must be a top level object or in another object.", cdef.pos)
     }
 
     // check value class constraints
@@ -1672,17 +1676,23 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
      *  this includes Phantom.Any of different universes.
      */
     def checkedTops(tree: untpd.Tree): Set[Type] = {
-      def checkedTops2(tree1: untpd.Tree, tree2: untpd.Tree, msg: => Message, pos: Position): Set[Type] = {
-        val allTops = checkedTops(tree1) union checkedTops(tree2)
-        if (allTops.size > 1)
-          ctx.error(msg, tree.pos)
-        allTops
-      }
       tree match {
         case TypeBoundsTree(lo, hi) =>
-          checkedTops2(lo, hi, PhantomCrossedMixedBounds(lo, hi), tree.pos)
+          val allTops = checkedTops(hi) union checkedTops(lo)
+          if (allTops.size <= 1) allTops
+          else {
+            ctx.error("Type can not be bounded at the same time by types in different latices: " +
+                allTops.map(_.show).mkString(", "), tree.pos)
+            Set.empty
+          }
         case untpd.InfixOp(left, op, right) =>
-          checkedTops2(left, right, PhantomCrossedMixedBounds(left, right), tree.pos)
+          val allTops = checkedTops(left) union checkedTops(right)
+          if (allTops.size <= 1) allTops
+          else {
+            ctx.error(s"Can not use ${op.show} mix types of different lattices: " +
+                allTops.map(_.show).mkString(", "), tree.pos)
+            Set.empty
+          }
         case EmptyTree => Set.empty
         case _ => Set(tree.typeOpt.topType)
       }