Typer fixes

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

@@ -1517,19 +1517,30 @@ class Typer extends Namer
 
     val seenParents = mutable.Set[Symbol]()
 
+    var parentIsEnumClass = false
+    // Since enums are classes and Namer checks that classes don't extend multiple classes, we can only have one
+    // violation.
+    var enumParentOpt: Option[Symbol] = None
+
     def typedParent(tree: untpd.Tree): Tree = {
       var result = if (tree.isType) typedType(tree)(superCtx) else typedExpr(tree)(superCtx)
       val psym = result.tpe.dealias.typeSymbol
       if (seenParents.contains(psym) && !cls.isRefinementClass)
         ctx.error(i"$psym is extended twice", tree.pos)
       seenParents += psym
       if (tree.isType) {
+        checkSimpleKinded(result) // Not needed for constructor calls, as type arguments will be inferred.
         if (psym.is(Trait) && !cls.is(Trait) && !cls.superClass.isSubClass(psym))
           result = maybeCall(result, psym, psym.primaryConstructor.info)
       }
       else checkParentCall(result, cls)
       checkTraitInheritance(psym, cls, tree.pos)
       if (cls is Case) checkCaseInheritance(psym, cls, tree.pos)
+      if (psym == defn.EnumClass)
+        parentIsEnumClass = true
+      else if (psym.derivesFrom(defn.EnumClass))
+        enumParentOpt = Some(psym)
+
       result
     }
 
@@ -1576,6 +1587,12 @@ class Typer extends Namer
       if (!cls.is(AbstractOrTrait) && !ctx.isAfterTyper)
         checkRealizableBounds(cls, cdef.namePos)
       if (cls.is(Case) && cls.derivesFrom(defn.EnumClass)) checkEnum(cdef, cls)
+      if (parentIsEnumClass) {
+        for (enumParent <- enumParentOpt)
+          //Tricky to phrase; language taken from "case-to-case inheritance is prohibited".
+          ctx.error(s"Enum ${cls.name} has enum ancestor ${enumParent.name}, but enum-to-enum inheritance is prohibited", cdef.pos)
+      }
+
       val cdef1 = assignType(cpy.TypeDef(cdef)(name, impl1), cls)
       if (ctx.phase.isTyper && cdef1.tpe.derivesFrom(defn.DynamicClass) && !ctx.dynamicsEnabled) {
         val isRequired = parents1.exists(_.tpe.isRef(defn.DynamicClass))

tests/neg/i5008.scala

@@ -0,0 +1,5 @@
+enum Foo { case A }
+enum Bar { case A }
+enum Baz extends Foo { case Z } // error
+
+enum Quux extends Foo with Bar { case Z } // error

tests/neg/i5010.scala

@@ -0,0 +1 @@
+class i0 extends Function0 // error