refactor: change Message kind into an enum instead of a String

While digging into Diagnostics there wasn't an easy way to tell all the
available `kind`s that there could be since they were just a string
value. So this small changes just makes the `kind` field in `Message` a
`MessageKind` which is an enum of all the types of message kinds that
exist.

Author: ckipp01

compiler/src/dotty/tools/dotc/reporting/Message.scala

@@ -51,7 +51,7 @@ abstract class Message(val errorId: ErrorMessageID) { self =>
     * This will be printed as "$kind Error", "$kind Warning", etc, on the first
     * line of the message.
     */
-  def kind: String
+  def kind: MessageKind
 
   /** The explanation should provide a detailed description of why the error
     * occurred and use examples from the user's own code to illustrate how to
@@ -140,7 +140,7 @@ abstract class Message(val errorId: ErrorMessageID) { self =>
 class NoExplanation(msgFn: => String) extends Message(ErrorMessageID.NoExplanationID) {
   def msg: String = msgFn
   def explain: String = ""
-  val kind: String = ""
+  val kind: MessageKind = MessageKind.NoKind
 
   override def toString(): String = msg
 }

compiler/src/dotty/tools/dotc/reporting/MessageKind.scala

@@ -0,0 +1,25 @@
+package dotty.tools.dotc.reporting
+
+/** The various message kinds that can be used inside of a Message
+ *  @param name What will be pontentially displayed to the user
+ */
+enum MessageKind(name: String):
+  case NoKind extends MessageKind("No Kind")
+  case Syntax extends MessageKind("Syntax")
+  case Type extends MessageKind("Type")
+  case TypeMismatch extends MessageKind("Type Mismatch")
+  case Naming extends MessageKind("Naming")
+  case Declaration extends MessageKind("Declaration")
+  case NotFound extends MessageKind("Not Found")
+  case PatternMatch extends MessageKind("Pattern Match")
+  case Cyclic extends MessageKind("Cyclic")
+  case Reference extends MessageKind("Reference")
+  case DocComment extends MessageKind("Doc Comment")
+  case LossyConversion extends MessageKind("Lossy Conversion")
+  case PatternMatchExhaustivity extends MessageKind("Pattern Match Exhaustivity")
+  case MatchCaseUnreachable extends MessageKind("Match Case Unreachable")
+  case Compatibility extends MessageKind("Compatibility")
+  case PotentialIssue extends MessageKind("Potential Issue")
+
+  override def toString: String = name
+end MessageKind

compiler/src/dotty/tools/dotc/reporting/MessageRendering.scala

@@ -177,8 +177,8 @@ trait MessageRendering {
           s"[E${"0" * (3 - errorNumber.toString.length) + errorNumber}] "
         } else ""
       val kind =
-        if (message.kind == "") diagnosticString
-        else s"${message.kind} $diagnosticString"
+        if (message.kind == MessageKind.NoKind) diagnosticString
+        else s"${message.kind.toString} $diagnosticString"
       val title =
         if fileAndPos.isEmpty then s"$errId$kind:" // this happens in dotty.tools.repl.ScriptedTests // TODO add name of source or remove `:` (and update test files)
         else s"$errId$kind: $fileAndPos"

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

@@ -40,42 +40,42 @@ import transform.SymUtils._
   */
 
   abstract class SyntaxMsg(errorId: ErrorMessageID) extends Message(errorId):
-    def kind = "Syntax"
+    def kind = MessageKind.Syntax
 
   abstract class TypeMsg(errorId: ErrorMessageID) extends Message(errorId):
-    def kind = "Type"
+    def kind = MessageKind.Type
 
   trait ShowMatchTrace(tps: Type*)(using Context) extends Message:
     override def msgSuffix: String = matchReductionAddendum(tps*)
 
   abstract class TypeMismatchMsg(found: Type, expected: Type)(errorId: ErrorMessageID)(using Context)
   extends Message(errorId), ShowMatchTrace(found, expected):
-    def kind = "Type Mismatch"
+    def kind = MessageKind.TypeMismatch
     def explain = err.whyNoMatchStr(found, expected)
     override def canExplain = true
 
   abstract class NamingMsg(errorId: ErrorMessageID) extends Message(errorId):
-    def kind = "Naming"
+    def kind = MessageKind.Naming
 
   abstract class DeclarationMsg(errorId: ErrorMessageID) extends Message(errorId):
-    def kind = "Declaration"
+    def kind = MessageKind.Declaration
 
   /** A simple not found message (either for idents, or member selection.
    *  Messages of this class are sometimes dropped in favor of other, more
    *  specific messages.
    */
   abstract class NotFoundMsg(errorId: ErrorMessageID) extends Message(errorId):
-    def kind = "Not Found"
+    def kind = MessageKind.NotFound
     def name: Name
 
   abstract class PatternMatchMsg(errorId: ErrorMessageID) extends Message(errorId):
-    def kind = "Pattern Match"
+    def kind = MessageKind.PatternMatch
 
   abstract class CyclicMsg(errorId: ErrorMessageID) extends Message(errorId):
-    def kind = "Cyclic"
+    def kind = MessageKind.Cyclic
 
   abstract class ReferenceMsg(errorId: ErrorMessageID) extends Message(errorId):
-    def kind = "Reference"
+    def kind = MessageKind.Reference
 
   abstract class EmptyCatchOrFinallyBlock(tryBody: untpd.Tree, errNo: ErrorMessageID)(using Context)
   extends SyntaxMsg(EmptyCatchOrFinallyBlockID) {
@@ -638,7 +638,7 @@ import transform.SymUtils._
 
   class ProperDefinitionNotFound()(using Context)
   extends Message(ProperDefinitionNotFoundID) {
-    def kind: String = "Doc Comment"
+    def kind = MessageKind.DocComment
     def msg = em"""Proper definition was not found in ${hl("@usecase")}"""
 
     def explain = {
@@ -818,14 +818,14 @@ import transform.SymUtils._
 
   class LossyWideningConstantConversion(sourceType: Type, targetType: Type)(using Context)
   extends Message(LossyWideningConstantConversionID):
-    def kind = "Lossy Conversion"
+    def kind = MessageKind.LossyConversion
     def msg = em"""|Widening conversion from $sourceType to $targetType loses precision.
                    |Write `.to$targetType` instead.""".stripMargin
     def explain = ""
 
   class PatternMatchExhaustivity(uncoveredFn: => String, hasMore: Boolean)(using Context)
   extends Message(PatternMatchExhaustivityID) {
-    def kind = "Pattern Match Exhaustivity"
+    def kind = MessageKind.PatternMatchExhaustivity
     lazy val uncovered = uncoveredFn
     def msg =
       val addendum = if hasMore then "(More unmatched cases are elided)" else ""
@@ -856,7 +856,7 @@ import transform.SymUtils._
 
   class MatchCaseUnreachable()(using Context)
   extends Message(MatchCaseUnreachableID) {
-    def kind = "Match case Unreachable"
+    def kind = MessageKind.MatchCaseUnreachable
     def msg = "Unreachable case"
     def explain = ""
   }
@@ -1783,7 +1783,7 @@ import transform.SymUtils._
 
   class FailureToEliminateExistential(tp: Type, tp1: Type, tp2: Type, boundSyms: List[Symbol], classRoot: Symbol)(using Context)
     extends Message(FailureToEliminateExistentialID) {
-    def kind: String = "Compatibility"
+    def kind = MessageKind.Compatibility
     def msg =
       val originalType = ctx.printer.dclsText(boundSyms, "; ").show
       em"""An existential type that came from a Scala-2 classfile for $classRoot
@@ -2228,7 +2228,7 @@ import transform.SymUtils._
 
   class PureExpressionInStatementPosition(stat: untpd.Tree, val exprOwner: Symbol)(using Context)
     extends Message(PureExpressionInStatementPositionID) {
-    def kind = "Potential Issue"
+    def kind = MessageKind.PotentialIssue
     def msg = "A pure expression does nothing in statement position; you may be omitting necessary parentheses"
     def explain =
       em"""The pure expression $stat doesn't have any side effect and its result is not assigned elsewhere.

compiler/test/dotty/tools/dotc/reporting/TestMessageLaziness.scala

@@ -16,7 +16,7 @@ class TestMessageLaziness extends DottyTest {
   }
 
   case class LazyError() extends Message(ErrorMessageID.LazyErrorId) {
-    val kind = "Test"
+    val kind = MessageKind.NoKind
     def msg = throw new Error("Didn't stay lazy.")
     def explain = ""
   }