Provide for watching term references

We have the DerivedTypeTree abstraction to generate a TypeTree
during desugaring that watches a symbol that does not yet exist.
We now need to generalize this so that we can also create term references
(i.e. term idents) that watch a symbol. The necessity comes from enums
an enum like

    enum Color { case C1; ...; case Cn; ... }

needs to be expanded to

    sealed abstract class Color {
      import Color.{C1, ..., Cn}
      ...
    }
    object Color { case class C1; ...; case class Cn }

Otherwise the `...` in class `Color` could not refer to the cases. The problem is
that we cannot simply write an untyped ident `Color` in the import clause, because
a different `Color` might be defined or inherited in the `enum`, so we would get
a wrong binding. We need to refer to the `Color` companion object as a symbol, but
this one does not yet exist at the point where we expand. Hence the need for
a new mechanism.

An added complexity comes from the fact that these references go to the ValDef part
of a synthesized companion objects. But these objects might be merged with user-defined
ones later. We have to make sure that References attachments are correctly passed along
in such merges.

Author: odersky

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

@@ -33,11 +33,15 @@ object desugar {
 // ----- DerivedTypeTrees -----------------------------------
 
   class SetterParamTree extends DerivedTypeTree {
-    def derivedType(sym: Symbol)(implicit ctx: Context) = sym.info.resultType
+    def derivedTree(sym: Symbol)(implicit ctx: Context) = tpd.TypeTree(sym.info.resultType)
   }
 
   class TypeRefTree extends DerivedTypeTree {
-    def derivedType(sym: Symbol)(implicit ctx: Context) = sym.typeRef
+    def derivedTree(sym: Symbol)(implicit ctx: Context) = tpd.TypeTree(sym.typeRef)
+  }
+
+  class TermRefTree extends DerivedTypeTree {
+    def derivedTree(sym: Symbol)(implicit ctx: Context) = tpd.ref(sym)
   }
 
   /** A type tree that computes its type from an existing parameter.
@@ -73,7 +77,7 @@ object desugar {
      *
      *       parameter name  ==  reference name ++ suffix
      */
-    def derivedType(sym: Symbol)(implicit ctx: Context) = {
+    def derivedTree(sym: Symbol)(implicit ctx: Context) = {
       val relocate = new TypeMap {
         val originalOwner = sym.owner
         def apply(tp: Type) = tp match {
@@ -91,7 +95,7 @@ object desugar {
             mapOver(tp)
         }
       }
-      relocate(sym.info)
+      tpd.TypeTree(relocate(sym.info))
     }
   }
 

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

@@ -228,8 +228,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
      */
     def ensureCompletions(implicit ctx: Context): Unit = ()
 
-    /** The method that computes the type of this tree */
-    def derivedType(originalSym: Symbol)(implicit ctx: Context): Type
+    /** The method that computes the tree with the derived type */
+    def derivedTree(originalSym: Symbol)(implicit ctx: Context): tpd.Tree
   }
 
     /** Property key containing TypeTrees whose type is computed

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

@@ -526,6 +526,13 @@ class Namer { typer: Typer =>
       mdef.putAttachment(ExpandedTree, Thicket(trees.filter(_ != tree)))
     }
 
+    /** Transfer all references to `from` to `to` */
+    def transferReferences(from: ValDef, to: ValDef): Unit = {
+      val fromRefs = from.removeAttachment(References).getOrElse(Nil)
+      val toRefs = to.removeAttachment(References).getOrElse(Nil)
+      to.putAttachment(References, fromRefs ++ toRefs)
+    }
+
     /** Merge the module class `modCls` in the expanded tree of `mdef` with the given stats */
     def mergeModuleClass(mdef: Tree, modCls: TypeDef, stats: List[Tree]): TypeDef = {
       var res: TypeDef = null
@@ -580,9 +587,12 @@ class Namer { typer: Typer =>
               case vdef @ ValDef(name, _, _) if valid(vdef) =>
                 moduleValDef.get(name) match {
                   case Some((stat1, vdef1)) =>
-                    if (vdef.mods.is(Synthetic) && !vdef1.mods.is(Synthetic))
+                    if (vdef.mods.is(Synthetic) && !vdef1.mods.is(Synthetic)) {
+                      transferReferences(vdef, vdef1)
                       removeInExpanded(stat, vdef)
+                    }
                     else if (!vdef.mods.is(Synthetic) && vdef1.mods.is(Synthetic)) {
+                      transferReferences(vdef1, vdef)
                       removeInExpanded(stat1, vdef1)
                       moduleValDef(name) = (stat, vdef)
                     }

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

@@ -1152,7 +1152,7 @@ class Typer extends Namer
         tree.ensureCompletions
         tree.getAttachment(untpd.OriginalSymbol) match {
           case Some(origSym) =>
-            TypeTree(tree.derivedType(origSym)).withPos(tree.pos)
+            tree.derivedTree(origSym).withPos(tree.pos)
             // btw, no need to remove the attachment. The typed
             // tree is different from the untyped one, so the
             // untyped tree is no longer accessed after all