Check for illegal references to enum type parameters

Author: odersky

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

@@ -355,11 +355,14 @@ object desugar {
     val originalVparamss = constr1.vparamss
     lazy val derivedEnumParams = enumClass.typeParams.map(derivedTypeParam)
     val impliedTparams =
-      if (isEnumCase && originalTparams.isEmpty &&
-          typeParamIsReferenced(enumClass.typeParams, originalVparamss, parents))
-        derivedEnumParams.map(tdef => tdef.withFlags(tdef.mods.flags | PrivateLocal))
-      else
-        originalTparams
+      if (isEnumCase) {
+        val tparamReferenced = typeParamIsReferenced(
+            enumClass.typeParams, originalTparams, originalVparamss, parents)
+        if (originalTparams.isEmpty && (parents.isEmpty || tparamReferenced))
+          derivedEnumParams.map(tdef => tdef.withFlags(tdef.mods.flags | PrivateLocal))
+        else originalTparams
+      }
+      else originalTparams
     val constrTparams = impliedTparams.map(toDefParam)
     val constrVparamss =
       if (originalVparamss.isEmpty) { // ensure parameter list is non-empty
@@ -739,8 +742,11 @@ object desugar {
 
     if (mods is Package)
       PackageDef(Ident(moduleName), cpy.ModuleDef(mdef)(nme.PACKAGE, impl).withMods(mods &~ Package) :: Nil)
-    else if (isEnumCase)
+    else if (isEnumCase) {
+      typeParamIsReferenced(enumClass.typeParams, Nil, Nil, impl.parents)
+        // used to check there are no illegal references to enum's type parameters in parents
       expandEnumModule(moduleName, impl, mods, mdef.span)
+    }
     else {
       val clsName = moduleName.moduleClassName
       val clsRef = Ident(clsName)

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

@@ -168,22 +168,34 @@ object DesugarEnums {
     }
   }
 
-  /** Is a type parameter in `tparams` referenced from an enum class case that has
-   *  given value parameters `vparamss` and given parents `parents`?
+  /** Is a type parameter in `enumTypeParams` referenced from an enum class case that has
+   *  given type parameters `caseTypeParams`, value parameters `vparamss` and parents `parents`?
+   *  Issues an error if that is the case but the reference is illegal.
+   *  The reference could be illegal for two reasons:
+   *   - explicit type parameters are given
+   *   - it's a value case, i.e. no value parameters are given
    */
-  def typeParamIsReferenced(tparams: List[TypeSymbol], vparamss: List[List[ValDef]], parents: List[Tree])(implicit ctx: Context): Boolean = {
+  def typeParamIsReferenced(
+    enumTypeParams: List[TypeSymbol],
+    caseTypeParams: List[TypeDef],
+    vparamss: List[List[ValDef]],
+    parents: List[Tree])(implicit ctx: Context): Boolean = {
 
-    val searchRef = new untpd.TreeAccumulator[Boolean] {
-      var tparamNames = tparams.map(_.name).toSet[Name]
+    object searchRef extends UntypedTreeAccumulator[Boolean] {
+      var tparamNames = enumTypeParams.map(_.name).toSet[Name]
       def underBinders(binders: List[MemberDef], op: => Boolean): Boolean = {
         val saved = tparamNames
         tparamNames = tparamNames -- binders.map(_.name)
         try op
         finally tparamNames = saved
       }
-      def apply(x: Boolean, tree: Tree)(implicit ctx: Context) = x || {
+      def apply(x: Boolean, tree: Tree)(implicit ctx: Context): Boolean = x || {
         tree match {
-          case Ident(name) => tparamNames.contains(name)
+          case Ident(name) =>
+            val matches = tparamNames.contains(name)
+            if (matches && (caseTypeParams.nonEmpty || vparamss.isEmpty))
+              ctx.error(i"illegal reference to type parameter $name from enum case", tree.sourcePos)
+            matches
           case LambdaTypeTree(lambdaParams, body) =>
             underBinders(lambdaParams, foldOver(x, tree))
           case RefinedTypeTree(parent, refinements) =>
@@ -192,9 +204,11 @@ object DesugarEnums {
           case _ => foldOver(x, tree)
         }
       }
+      def apply(tree: Tree)(implicit ctx: Context): Boolean =
+        underBinders(caseTypeParams, apply(false, tree))
     }
 
-    def typeHasRef(tpt: Tree) = searchRef(false, tpt)
+    def typeHasRef(tpt: Tree) = searchRef(tpt)
     def valDefHasRef(vd: ValDef) = typeHasRef(vd.tpt)
     def parentHasRef(parent: Tree): Boolean = parent match {
       case Apply(fn, _) => parentHasRef(fn)
@@ -204,9 +218,7 @@ object DesugarEnums {
       case parent => parent.isType && typeHasRef(parent)
     }
 
-    parents.isEmpty ||  // a parent class that refers to type parameters will be generated in this case
-    vparamss.exists(_.exists(valDefHasRef)) ||
-    parents.exists(parentHasRef)
+    vparamss.exists(_.exists(valDefHasRef)) || parents.exists(parentHasRef)
   }
 
   /** A pair consisting of

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

@@ -1419,7 +1419,7 @@ object Trees {
       }
 
       def foldMoreCases(x: X, tree: Tree)(implicit ctx: Context): X = {
-        assert(ctx.reporter.errorsReported || ctx.mode.is(Mode.Interactive))
+        assert(ctx.reporter.errorsReported || ctx.mode.is(Mode.Interactive), tree)
           // In interactive mode, errors might come from previous runs.
           // In case of errors it may be that typed trees point to untyped ones.
           // The IDE can still traverse inside such trees, either in the run where errors

docs/docs/reference/enums/desugarEnums.md

@@ -127,6 +127,9 @@ map into case classes or vals.
    as one of the `enumValues` of the enumeration (see below). `$values` is a
    compiler-defined private value in the companion object.
 
+   It is an error if a value case refers to a type parameter of the enclosing `enum`
+   in a type argument of `<parents>`.
+
 9. A class case
 
        case C <params> extends <parents>
@@ -145,6 +148,11 @@ map into case classes or vals.
    where `n` is the ordinal number of the case in the companion object,
    starting from 0.
 
+   It is an error if a value case refers to a type parameter of the enclosing `enum`
+   in a parameter type in `<params>` or in a type argument of `<parents>`, unless that parameter is already
+   a type parameter of the case, i.e. the parameter name is defined in `<params>`.
+
+
 ### Translation of Enumerations
 
 Non-generic enums `E` that define one or more singleton cases

tests/neg/enums.scala

@@ -24,6 +24,12 @@ enum E4 {
 case class C4() extends E4 // error: cannot extend enum
 case object O4 extends E4 // error: cannot extend enum
 
+enum Captured[T] {
+  case Case1[U](x: T) extends Captured[U] // error: illegal reference to type parameter T from enum case
+  case Case2[U]()     extends Captured[T] // error: illegal reference to type parameter T from enum case
+  case Case3          extends Captured[T] // error: illegal reference to type parameter T from enum case
+}
+
 enum Option[+T] derives Eql {
   case Some(x: T)
   case None