change checking: now add missing enum parent to class

an error is reported when an enum does not have a parent
the missing enum class is then added as a parent with appropriate
type arguments.

The body of the enum implementation class will now always
be typechecked

Author: bishabosha

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

@@ -1102,21 +1102,31 @@ trait Checking {
         report.error(ClassCannotExtendEnum(cls, firstParent), cdef.sourcePos)
   }
 
-  /** Check that the firstParent derives from the declaring enum class.
+  /** Check that the firstParent derives from the declaring enum class, if not, adds it as a parent after emitting an
+   *  error.
    */
-  def checkEnumParent(cls: Symbol, firstParent: Symbol)(using Context): Boolean = {
+  def checkEnumParent(cls: Symbol, firstParent: Symbol)(using Context): Unit =
+
+    extension (sym: Symbol) def typeRefApplied(using Context): Type =
+      typeRef.appliedTo(typeParams.map(_.info.loBound))
+
+    def ensureParentDerivesFrom(enumCase: Symbol)(using Context) =
+      val enumCls = enumCase.owner.linkedClass
+      if !firstParent.derivesFrom(enumCls) then
+        report.error(i"enum case does not extend its enum $enumCls", enumCase.sourcePos)
+        cls.info match
+          case info: ClassInfo =>
+            cls.info = info.derivedClassInfo(classParents = enumCls.typeRefApplied :: info.classParents)
+          case _ =>
+
     val enumCase =
       if cls.isAllOf(EnumCase) then cls
       else if cls.isAnonymousClass && cls.owner.isAllOf(EnumCase) then cls.owner
       else NoSymbol
-    def parentDerivesFrom(enumCls: Symbol)(using Context) =
-      if !firstParent.derivesFrom(enumCls) then
-        report.error(i"enum case does not extend its enum $enumCls", enumCase.sourcePos)
-        false
-      else
-        true
-    !enumCase.exists || parentDerivesFrom(enumCase.owner.linkedClass)
-  }
+    if enumCase.exists then
+      ensureParentDerivesFrom(enumCase)
+
+  end checkEnumParent
 
   /** Check that all references coming from enum cases in an enum companion object
    *  are legal.
@@ -1211,7 +1221,7 @@ trait Checking {
 
 trait ReChecking extends Checking {
   import tpd._
-  override def checkEnumParent(cls: Symbol, firstParent: Symbol)(using Context): Boolean = true
+  override def checkEnumParent(cls: Symbol, firstParent: Symbol)(using Context): Unit = ()
   override def checkEnum(cdef: untpd.TypeDef, cls: Symbol, firstParent: Symbol)(using Context): Unit = ()
   override def checkRefsLegal(tree: tpd.Tree, badOwner: Symbol, allowed: (Name, Symbol) => Boolean, where: String)(using Context): Unit = ()
   override def checkFullyAppliedType(tree: Tree)(using Context): Unit = ()

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

@@ -2070,20 +2070,17 @@ class Typer extends Namer
     val constr1 = typed(constr).asInstanceOf[DefDef]
     val parentsWithClass = ensureFirstTreeIsClass(parents.mapconserve(typedParent).filterConserve(!_.isEmpty), cdef.nameSpan)
     val parents1 = ensureConstrCall(cls, parentsWithClass)(using superCtx)
+    val firstParent = parents1.head.tpe.dealias.typeSymbol
 
-    lazy val firstParent = parents1.head.tpe.dealias.typeSymbol
+    checkEnumParent(cls, firstParent)
 
     val self1 = typed(self)(using ctx.outer).asInstanceOf[ValDef] // outer context where class members are not visible
     if (self1.tpt.tpe.isError || classExistsOnSelf(cls.unforcedDecls, self1))
       // fail fast to avoid typing the body with an error type
       cdef.withType(UnspecifiedErrorType)
     else {
       val dummy = localDummy(cls, impl)
-      val body1 =
-        if checkEnumParent(cls, firstParent) then
-          addAccessorDefs(cls, typedStats(impl.body, dummy)(using ctx.inClassContext(self1.symbol))._1)
-        else
-          Nil
+      val body1 = addAccessorDefs(cls, typedStats(impl.body, dummy)(using ctx.inClassContext(self1.symbol))._1)
 
       checkNoDoubleDeclaration(cls)
       val impl1 = cpy.Template(impl)(constr1, parents1, Nil, self1, body1)

tests/neg/i6601.scala

@@ -16,4 +16,7 @@ object GADTs2 {
   enum Color {
     case Red extends AnyRef // error
   }
+  enum Parameterized[T](x: T) {
+    case Foo extends AnyRef // error
+  }
 }