Fix #2663: More refined handling of enum case apply results

i2663 demonstrates that we do not always have a complete result type
for the `apply` method of an enum case. In that case our only recourse
is to add a generic widening method that upcasts the enum case class to the
enum base class.

Author: odersky

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

@@ -456,19 +456,14 @@ object desugar {
     // For all other classes, the parent is AnyRef.
     val companions =
       if (isCaseClass) {
-        def extractType(t: Tree): Tree = t match {
-          case Apply(t1, _) => extractType(t1)
-          case TypeApply(t1, ts) => AppliedTypeTree(extractType(t1), ts)
-          case Select(t1, nme.CONSTRUCTOR) => extractType(t1)
-          case New(t1) => t1
-          case t1 => t1
-        }
         // The return type of the `apply` method
-        val applyResultTpt =
-          if (isEnumCase)
-            if (parents.isEmpty) enumClassTypeRef
-            else parents.map(extractType).reduceLeft(AndTypeTree)
-          else TypeTree()
+        val (applyResultTpt, widenDefs) =
+          if (!isEnumCase)
+            (TypeTree(), Nil)
+          else if (parents.isEmpty || derivedTparams.isEmpty || enumClass.typeParams.isEmpty)
+            (enumClassTypeRef, Nil)
+          else
+            enumApplyResult(cdef, parents, derivedTparams, appliedRef(enumClassRef, derivedTparams))
 
         val parent =
           if (constrTparams.nonEmpty ||
@@ -479,11 +474,13 @@ object desugar {
             // todo: also use anyRef if constructor has a dependent method type (or rule that out)!
             (constrVparamss :\ (if (isEnumCase) applyResultTpt else classTypeRef)) (
               (vparams, restpe) => Function(vparams map (_.tpt), restpe))
+        def widenedCreatorExpr =
+          (creatorExpr /: widenDefs)((rhs, meth) => Apply(Ident(meth.name), rhs :: Nil))
         val applyMeths =
           if (mods is Abstract) Nil
           else
-            DefDef(nme.apply, derivedTparams, derivedVparamss, applyResultTpt, creatorExpr)
-              .withFlags(Synthetic | (constr1.mods.flags & DefaultParameterized)) :: Nil
+            DefDef(nme.apply, derivedTparams, derivedVparamss, applyResultTpt, widenedCreatorExpr)
+              .withFlags(Synthetic | (constr1.mods.flags & DefaultParameterized)) :: widenDefs
         val unapplyMeth = {
           val unapplyParam = makeSyntheticParameter(tpt = classTypeRef)
           val unapplyRHS = if (arity == 0) Literal(Constant(true)) else Ident(unapplyParam.name)

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

@@ -120,6 +120,52 @@ object DesugarEnums {
         TypeTree(), creator)
   }
 
+  /** The return type of an enum case apply method and any widening methods in which
+   *  the apply's right hand side will be wrapped. For parents of the form
+   *
+   *      extends E(args) with T1(args1) with ... TN(argsN)
+   *
+   *  and type parameters `tparams` the generated widen method is
+   *
+   *      def C$to$E[tparams](x$1: E[tparams] with T1 with ... TN) = x$1
+   *
+   *  @param cdef            The case definition
+   *  @param parents         The declared parents of the enum case
+   *  @param tparams         The type parameters of the enum case
+   *  @param appliedEnumRef  The enum class applied to `tparams`.
+   */
+  def enumApplyResult(
+      cdef: TypeDef,
+      parents: List[Tree],
+      tparams: List[TypeDef],
+      appliedEnumRef: Tree)(implicit ctx: Context): (Tree, List[DefDef]) = {
+
+    def extractType(t: Tree): Tree = t match {
+      case Apply(t1, _) => extractType(t1)
+      case TypeApply(t1, ts) => AppliedTypeTree(extractType(t1), ts)
+      case Select(t1, nme.CONSTRUCTOR) => extractType(t1)
+      case New(t1) => t1
+      case t1 => t1
+    }
+
+    val parentTypes = parents.map(extractType)
+    parentTypes.head match {
+      case parent: RefTree if parent.name == enumClass.name =>
+        // need a widen method to compute correct type parameters for enum base class
+        val widenParamType = (appliedEnumRef /: parentTypes.tail)(AndTypeTree)
+        val widenParam = makeSyntheticParameter(tpt = widenParamType)
+        val widenDef = DefDef(
+          name = s"${cdef.name}$$to$$${enumClass.name}".toTermName,
+          tparams = tparams,
+          vparamss = (widenParam :: Nil) :: Nil,
+          tpt = TypeTree(),
+          rhs = Ident(widenParam.name))
+        (TypeTree(), widenDef :: Nil)
+      case _ =>
+        (parentTypes.reduceLeft(AndTypeTree), Nil)
+    }
+  }
+
   /** A pair consisting of
    *   - the next enum tag
    *   - scaffolding containing the necessary definitions for singleton enum cases

tests/pos/i2663.scala

@@ -0,0 +1,14 @@
+trait Tr
+enum Foo[T](x: T) {
+  case Bar[T](y: T) extends Foo(y)
+  case Bas[T](y: Int) extends Foo(y)
+  case Bam[T](y: String) extends Foo(y) with Tr
+}
+object Test {
+  import Foo._
+  val bar: Foo[Boolean] = Bar(true)
+  val bas: Foo[Int] = Bas(1)
+  val bam: Foo[String] & Tr = Bam("")
+}
+
+