Add tests, refactor checking

Author: bishabosha

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

@@ -630,11 +630,6 @@ object Checking {
     }
   }
 
-  def optEnumCase(cls: Symbol)(using Context): Symbol =
-    (if cls.isAllOf(EnumCase) then cls
-    else if cls.isAnonymousClass && cls.owner.isAllOf(EnumCase) then cls.owner
-    else NoSymbol).filter(s => s.exists && s.owner.linkedClass.derivesFrom(defn.EnumClass))
-
   /** Check the inline override methods only use inline parameters if they override an inline parameter. */
   def checkInlineOverrideParameters(sym: Symbol)(using Context): Unit =
     lazy val params = sym.paramSymss.flatten
@@ -1086,9 +1081,8 @@ trait Checking {
 
   /** 1. Check that all case classes that extend `scala.Enum` are `enum` cases
    *  2. Check that case class `enum` cases do not extend java.lang.Enum.
-   *  3. Check that the firstParent derives from the declaring enum class.
    */
-  def checkEnum(cdef: untpd.TypeDef, cls: Symbol, enumCase: Symbol, firstParent: Symbol)(using Context): Boolean = {
+  def checkEnum(cdef: untpd.TypeDef, cls: Symbol, firstParent: Symbol)(using Context): Unit = {
     def isEnumAnonCls =
       cls.isAnonymousClass &&
       cls.owner.isTerm &&
@@ -1105,12 +1099,22 @@ trait Checking {
         // Unlike firstParent.derivesFrom(defn.EnumClass), this test allows inheriting from `Enum` by hand;
         // see enum-List-control.scala.
         report.error(ClassCannotExtendEnum(cls, firstParent), cdef.srcPos)
-    val enumCls = enumCase.owner.linkedClass
-    if !firstParent.derivesFrom(enumCls) then
-      report.error(i"enum case does not extend its enum $enumCls", enumCase.srcPos)
-      false
-    else
-      true
+  }
+
+  /** Check that the firstParent derives from the declaring enum class.
+   */
+  def checkEnumParent(cls: Symbol, firstParent: Symbol)(using Context): Boolean = {
+    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.srcPos)
+        false
+      else
+        true
+    !enumCase.exists || parentDerivesFrom(enumCase.owner.linkedClass)
   }
 
   /** Check that all references coming from enum cases in an enum companion object
@@ -1206,7 +1210,8 @@ trait Checking {
 
 trait ReChecking extends Checking {
   import tpd._
-  override def checkEnum(cdef: untpd.TypeDef, cls: Symbol, enumCase: Symbol, firstParent: Symbol)(using Context): Boolean = true
+  override def checkEnumParent(cls: Symbol, firstParent: Symbol)(using Context): Boolean = true
+  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 = ()
   override def checkEnumCaseRefsLegal(cdef: TypeDef, enumCtx: Context)(using Context): Unit = ()

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

@@ -2103,11 +2103,7 @@ class Typer extends Namer
     val parentsWithClass = ensureFirstTreeIsClass(parents.mapconserve(typedParent).filterConserve(!_.isEmpty), cdef.nameSpan)
     val parents1 = ensureConstrCall(cls, parentsWithClass)(using superCtx)
 
-    var forceEmptyBody: Boolean = false
-    val enumCaseDef = optEnumCase(cls)
-    if enumCaseDef.exists then
-      val firstParent = parents1.head.tpe.dealias.typeSymbol
-      forceEmptyBody = !checkEnum(cdef, cls, enumCaseDef, firstParent) // don't bother looking inside the template
+    lazy val firstParent = parents1.head.tpe.dealias.typeSymbol
 
     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))
@@ -2116,14 +2112,18 @@ class Typer extends Namer
     else {
       val dummy = localDummy(cls, impl)
       val body1 =
-        if forceEmptyBody then Nil
-        else addAccessorDefs(cls, typedStats(impl.body, dummy)(using ctx.inClassContext(self1.symbol))._1)
+        if checkEnumParent(cls, firstParent) then
+          addAccessorDefs(cls, typedStats(impl.body, dummy)(using ctx.inClassContext(self1.symbol))._1)
+        else
+          Nil
 
       checkNoDoubleDeclaration(cls)
       val impl1 = cpy.Template(impl)(constr1, parents1, Nil, self1, body1)
         .withType(dummy.termRef)
       if (!cls.isOneOf(AbstractOrTrait) && !ctx.isAfterTyper)
         checkRealizableBounds(cls, cdef.sourcePos.withSpan(cdef.nameSpan))
+      if cls.derivesFrom(defn.EnumClass) then
+        checkEnum(cdef, cls, firstParent)
       val cdef1 = assignType(cpy.TypeDef(cdef)(name, impl1), cls)
 
       val reportDynamicInheritance =

tests/neg/i6601.scala

@@ -7,4 +7,13 @@ object GADTs2 {
     case Lit[G](n: Int) extends Expr[G, Int]
         // case S[A, G](x:
   }
+  enum Covariant[+T] {
+    case Bottom extends AnyRef // error
+  }
+  enum Contravariant[-T] {
+    case Top extends AnyRef // error
+  }
+  enum Color {
+    case Red extends AnyRef // error
+  }
 }

tests/run/enum-values.scala

@@ -0,0 +1,58 @@
+enum Color:
+  case Red, Green, Blue
+
+enum Tag[T]:
+  case Int extends Tag[Int]
+  case String extends Tag[String]
+  case OfClass[T]()(using val tag: reflect.ClassTag[T]) extends Tag[T]
+
+enum Expr[-T >: Null]:
+  case EmptyTree extends Expr[Null]
+  case AnyTree
+
+enum ListLike[+T]:
+  case Cons(head: T, tail: ListLike[T])
+  case EmptyListLike
+
+enum TypeCtorsK[F[_]]:
+  case List       extends TypeCtorsK[List]
+  case Option     extends TypeCtorsK[Option]
+  case Const[T]() extends TypeCtorsK[[U] =>> T]
+
+enum MixedParams[F[_], G[X,Y] <: collection.Map[X,Y], T]:
+  case Foo extends MixedParams[List, collection.mutable.LinkedHashMap, Unit]
+
+@main def Test: Unit =
+  import Color._, Tag._, Expr._, ListLike._, TypeCtorsK._, MixedParams._
+  import reflect.Selectable.reflectiveSelectable
+
+  extension [A](t: A) def show = runtime.ScalaRunTime.stringOf(t)
+
+  val colors: Array[Color]             = Color.values
+  val tags: Array[Tag[?]]              = Tag.values
+  val exprs: Array[Expr[? >: Null]]    = Expr.values
+  val listlikes: Array[ListLike[?]]    = ListLike.values
+  val typeCtorsK: Array[TypeCtorsK[?]] = TypeCtorsK.values
+
+  val mixedParams: Array[MixedParams[?, ? <: [X, Y] =>> collection.Map[X, Y], ?]] = MixedParams.values
+
+  def sameAs[T](arr: Array[T], compare: T*): Unit =
+    assert(arr sameElements compare, s"${arr.show} does not correspond to ${compare.show}")
+
+  sameAs(colors,      Red, Green, Blue)
+  sameAs(tags,        Int, String)
+  sameAs(exprs,       EmptyTree, AnyTree)
+  sameAs(listlikes,   EmptyListLike)
+  sameAs(typeCtorsK,  List, Option)
+  sameAs(mixedParams, Foo)
+
+  def singleton[E <: AnyRef](value: E, name: String, companion: { def valueOf(s: String): E}) =
+    val lookup = companion.valueOf(name)
+    assert(value eq lookup, s"${value.show} is not identical to ${lookup.show}")
+
+  singleton(Green, "Green", Color)
+  singleton(String, "String", Tag)
+  singleton(AnyTree, "AnyTree", Expr)
+  singleton(EmptyListLike, "EmptyListLike", ListLike)
+  singleton(Option, "Option", TypeCtorsK)
+  singleton(Foo, "Foo", MixedParams)