Refined fix

Widening methods need to be given derived versions of the type parameters of
the original enum class instead of the case class. This required some new
infrastructure to define a deribed type tree from a symbol instead of an
original TypeDef.

Author: odersky

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

@@ -92,6 +92,10 @@ object desugar {
     cpy.TypeDef(tdef)(
       rhs = new DerivedFromParamTree() withPos tdef.rhs.pos watching tdef)
 
+  /** A derived type definition watching `sym` */
+  def derivedTypeParam(sym: TypeSymbol)(implicit ctx: Context): TypeDef =
+    TypeDef(sym.name, new DerivedFromParamTree().watching(sym)).withFlags(TypeParam)
+
   /** A value definition copied from `vdef` with a tpt typetree derived from it */
   def derivedTermParam(vdef: ValDef) =
     cpy.ValDef(vdef)(
@@ -462,8 +466,10 @@ object desugar {
             (TypeTree(), Nil)
           else if (parents.isEmpty || enumClass.typeParams.isEmpty)
             (enumClassTypeRef, Nil)
-          else
-            enumApplyResult(cdef, parents, derivedTparams, appliedRef(enumClassRef, derivedTparams))
+          else {
+            val tparams = enumClass.typeParams.map(derivedTypeParam)
+            enumApplyResult(cdef, parents, tparams, appliedRef(enumClassRef, tparams))
+          }
 
         val parent =
           if (constrTparams.nonEmpty ||

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

@@ -227,6 +227,12 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
       this
     }
 
+    /** Install the derived type tree as a dependency on `sym` */
+    def watching(sym: Symbol): this.type = {
+      pushAttachment(OriginalSymbol, sym)
+      this
+    }
+
     /** A hook to ensure that all necessary symbols are completed so that
      *  OriginalSymbol attachments are propagated to this tree
      */
@@ -240,7 +246,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
    *  from the symbol in this type. These type trees have marker trees
    *  TypeRefOfSym or InfoOfSym as their originals.
    */
-  val References = new Property.Key[List[Tree]]
+  val References = new Property.Key[List[DerivedTypeTree]]
 
   /** Property key for TypeTrees marked with TypeRefOfSym or InfoOfSym
    *  which contains the symbol of the original tree from which this

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

@@ -228,11 +228,7 @@ class Namer { typer: Typer =>
 
   /** Record `sym` as the symbol defined by `tree` */
   def recordSym(sym: Symbol, tree: Tree)(implicit ctx: Context): Symbol = {
-    val refs = tree.attachmentOrElse(References, Nil)
-    if (refs.nonEmpty) {
-      tree.removeAttachment(References)
-      refs foreach (_.pushAttachment(OriginalSymbol, sym))
-    }
+    for (refs <- tree.removeAttachment(References); ref <- refs) ref.watching(sym)
     tree.pushAttachment(SymOfTree, sym)
     sym
   }

tests/pos/i2663.scala

@@ -3,12 +3,14 @@ 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
+  case Baz[S, 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("")
+  val baz: Foo[String] & Tr = Baz("")
 }