Implement revised desugaring scheme

Author: odersky

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

@@ -355,7 +355,8 @@ object desugar {
     val originalVparamss = constr1.vparamss
     lazy val derivedEnumParams = enumClass.typeParams.map(derivedTypeParam)
     val impliedTparams =
-      if (isEnumCase && originalTparams.isEmpty)
+      if (isEnumCase && originalTparams.isEmpty &&
+          typeParamIsReferenced(enumClass.typeParams, originalVparamss, parents))
         derivedEnumParams.map(tdef => tdef.withFlags(tdef.mods.flags | PrivateLocal))
       else
         originalTparams

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

@@ -168,6 +168,47 @@ object DesugarEnums {
     }
   }
 
+  /** Is a type parameter in `tparams` referenced from an enum class case that has
+   *  given value parameters `vparamss` and given parents `parents`?
+   */
+  def typeParamIsReferenced(tparams: List[TypeSymbol], vparamss: List[List[ValDef]], parents: List[Tree])(implicit ctx: Context): Boolean = {
+
+    val searchRef = new untpd.TreeAccumulator[Boolean] {
+      var tparamNames = tparams.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 || {
+        tree match {
+          case Ident(name) => tparamNames.contains(name)
+          case LambdaTypeTree(lambdaParams, body) =>
+            underBinders(lambdaParams, foldOver(x, tree))
+          case RefinedTypeTree(parent, refinements) =>
+            val refinementDefs = refinements collect { case r: MemberDef => r }
+            underBinders(refinementDefs, foldOver(x, tree))
+          case _ => foldOver(x, tree)
+        }
+      }
+    }
+
+    def typeHasRef(tpt: Tree) = searchRef(false, tpt)
+    def valDefHasRef(vd: ValDef) = typeHasRef(vd.tpt)
+    def parentHasRef(parent: Tree): Boolean = parent match {
+      case Apply(fn, _) => parentHasRef(fn)
+      case TypeApply(_, targs) => targs.exists(typeHasRef)
+      case Select(nu, nme.CONSTRUCTOR) => parentHasRef(nu)
+      case New(tpt) => typeHasRef(tpt)
+      case parent if 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)
+  }
+
   /** A pair consisting of
    *   - the next enum tag
    *   - scaffolding containing the necessary definitions for singleton enum cases

tests/neg/enum-tparams.scala

@@ -0,0 +1,40 @@
+object Test {
+
+  enum Opt[+T] {
+    case S(x: T) extends Opt[T]
+    case I(x: Int) extends Opt[Int]
+    case V() extends Opt[`T`]
+    case P(x: List[T]) extends Opt[String]
+    case N extends Opt[Nothing]
+  }
+
+  type Id[_]
+
+  enum E[F[_], G[_]] {
+    case C1() extends E[[X] => X, Id]
+    case C2() extends E[[F] => F, Id]
+    case C3() extends E[[X] => { type Y = F[Int] }, Id]
+    case C4() extends E[[X] => { type F = Int }, Id]
+    case C5() extends E[[F] => G[Int], Id]
+  }
+
+  Opt.S[Int](1) // OK
+  Opt.S(1)      // OK
+  Opt.I[Int](1) // error: does not take type parameters
+  Opt.I(1)      // OK
+  Opt.V[Int]()  // OK
+  Opt.V()       // OK
+  Opt.P[Int](List(1, 2, 3)) // OK
+  Opt.P(List(1, 2, 3)) // OK
+
+  E.C1[List, Id]()  // error: does not take type parameters
+  E.C1()            // OK
+  E.C2[List, Id]()  // error: does not take type parameters
+  E.C2()            // OK
+  E.C3[List, Id]()  // OK
+  E.C3()            // OK
+  E.C4[List, Id]()  // error: does not take type parameters
+  E.C4()            // OK
+  E.C5[List, Id]()  // OK
+  E.C5()            // OK
+}