Port more Desugar errors to the new scheme

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -558,7 +558,7 @@ object desugar {
       else if (originalTparams.isEmpty)
         appliedRef(enumClassRef)
       else {
-        ctx.error(i"explicit extends clause needed because both enum case and enum class have type parameters"
+        ctx.error(TypedCaseDoesNotExplicitlyExtendTypedEnum(enumClass, cdef)
             , cdef.sourcePos.startPos)
         appliedTypeTree(enumClassRef, constrTparams map (_ => anyRef))
       }
@@ -979,7 +979,7 @@ object desugar {
     if (name.isEmpty) name = name.likeSpaced(inventGivenOrExtensionName(impl))
     if (ctx.owner == defn.ScalaPackageClass && defn.reservedScalaClassNames.contains(name.toTypeName)) {
       def kind = if (name.isTypeName) "class" else "object"
-      ctx.error(em"illegal redefinition of standard $kind $name", mdef.sourcePos)
+      ctx.error(IllegalRedefinitionOfStandardKind(kind, name), mdef.sourcePos)
       name = name.errorName
     }
     name

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

@@ -155,7 +155,9 @@ enum ErrorMessageID extends java.lang.Enum[ErrorMessageID] {
     CaseClassMissingNonImplicitParamListID,
     EnumerationsShouldNotBeEmptyID,
     AbstractCannotBeUsedForObjectsID,
-    ModifierRedundantForObjectsID
+    ModifierRedundantForObjectsID,
+    TypedCaseDoesNotExplicitlyExtendTypedEnumID,
+    IllegalRedefinitionOfStandardKindID
 
   def errorNumber = ordinal - 2
 }

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

@@ -2450,4 +2450,30 @@ object messages {
            | ${hl("object")} ${mdef.name} { }
            |""".stripMargin
   }
+
+  case class TypedCaseDoesNotExplicitlyExtendTypedEnum(enumDef: Symbol, caseDef: untpd.TypeDef)(implicit ctx: Context)
+    extends Message(TypedCaseDoesNotExplicitlyExtendTypedEnumID) {
+    val kind: String = "Syntax"
+    val msg: String = i"explicit extends clause needed because both enum case and enum class have type parameters"
+
+    val explanation: String =
+      em"""Enumerations where the enum class as well as the enum case have type parameters need
+          |an explicit extends.
+          |for example:
+          | ${hl("enum")} ${enumDef.name}[T] {
+          |  ${hl("case")} ${caseDef.name}[U](u: U) ${hl("extends")} ${enumDef.name}[U]
+          | }
+          |""".stripMargin
+  }
+
+  case class IllegalRedefinitionOfStandardKind(kindType: String, name: Name)(implicit ctx: Context)
+    extends Message(IllegalRedefinitionOfStandardKindID) {
+    val kind: String = "Syntax"
+    val msg: String = em"illegal redefinition of standard $kindType $name"
+
+    val explanation: String =
+      em"""| "$name" is a standard Scala core `$kindType`
+           | Please choose a different name to avoid conflicts
+           |""".stripMargin
+  }
 }

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

@@ -1783,4 +1783,39 @@ class ErrorMessagesTests extends ErrorMessagesTest {
         assertEquals("sealed modifier is redundant for objects", errorMsg)
         assertEquals("Foo", mdef.name.toString)
       }
+
+  @Test def enumAndCaseWithTypesNeedExplicitExtends =
+    checkMessagesAfter(RefChecks.name) {
+      """
+        |enum E[T,U,V] {
+        |  case C[X,Y,Z](x: X, y: Y, z: Z)
+        |}
+      """.stripMargin
+    }
+      .expect { (ictx, messages) ⇒
+        implicit val ctx: Context = ictx
+        assertMessageCount(1, messages)
+        val errorMsg = messages.head.msg
+        val TypedCaseDoesNotExplicitlyExtendTypedEnum(enumDef, caseDef) :: Nil = messages
+        assertEquals("explicit extends clause needed because both enum case and enum class have type parameters", errorMsg)
+        assertEquals("E", enumDef.name.toString)
+        assertEquals("C", caseDef.name.toString)
+      }
+
+  @Test def illegalRedefinitionOfStandardKind =
+    checkMessagesAfter(RefChecks.name) {
+      """ package scala {
+        |   class Any()
+        | }
+      """.stripMargin
+    }
+      .expect { (ictx, messages) ⇒
+        implicit val ctx: Context = ictx
+        assertMessageCount(1, messages)
+        val errorMsg = messages.head.msg
+        val IllegalRedefinitionOfStandardKind(kind, name) :: Nil = messages
+        assertEquals("illegal redefinition of standard class Any", errorMsg)
+        assertEquals("class", kind)
+        assertEquals("Any", name.toString)
+      }
 }

tests/neg/enumWithType.check

@@ -0,0 +1,6 @@
+-- [E148] Syntax Error: tests/neg/enumWithType.scala:2:2 ---------------------------------------------------------------
+2 |  case C[U](u: U) // error
+  |  ^
+  |  explicit extends clause needed because both enum case and enum class have type parameters
+
+longer explanation available when compiling with `-explain`

tests/neg/enumWithType.scala

@@ -0,0 +1,3 @@
+enum E[T] {
+  case C[U](u: U) // error
+}

tests/neg/scalaStandardRedefinition.check

@@ -0,0 +1,6 @@
+-- [E149] Syntax Error: tests/neg/scalaStandardRedefinition.scala:2:8 --------------------------------------------------
+2 |  class Any() // error
+  |  ^^^^^^^^^^^
+  |  illegal redefinition of standard class Any
+
+longer explanation available when compiling with `-explain`

tests/neg/scalaStandardRedefinition.scala

@@ -0,0 +1,3 @@
+package scala {
+  class Any() // error
+}