Make CaptguredVars use prepareForUnit instead of init.

Required some refactoring. Instead of transformSym we now
transform ValDefs as we prepare for them. The previous scheme
could not control directly whetrher transformSym or collectCaptured would
run first. Turns out that init ran before collectCaptured but
prepareForUnit did not, leading to test failures in pos/capturedvars.

Author: odersky

src/dotty/tools/dotc/transform/CapturedVars.scala

@@ -17,7 +17,7 @@ import SymUtils._
 import collection.{ mutable, immutable }
 import collection.mutable.{ LinkedHashMap, LinkedHashSet, TreeSet }
 
-class CapturedVars extends MiniPhaseTransform with SymTransformer { thisTransform =>
+class CapturedVars extends MiniPhaseTransform with IdentityDenotTransformer { thisTransform =>
   import ast.tpd._
 
   /** the following two members override abstract members in Transform */
@@ -44,16 +44,10 @@ class CapturedVars extends MiniPhaseTransform with SymTransformer { thisTransfor
     }
   }
 
-  override def init(implicit ctx: Context, info: TransformerInfo): Unit =
+  override def prepareForUnit(tree: Tree)(implicit ctx: Context) = {
     (new CollectCaptured)(ctx.withPhase(thisTransform)).runOver(ctx.compilationUnit.tpdTree)
-
-  override def transformSym(sd: SymDenotation)(implicit ctx: Context): SymDenotation =
-    if (captured(sd.symbol)) {
-      val newd = sd.copySymDenotation(
-        info = refCls(sd.info.classSymbol, sd.hasAnnotation(defn.VolatileAnnot)).typeRef)
-      newd.removeAnnotation(defn.VolatileAnnot)
-      newd
-    } else sd
+    this
+  }
 
   /** The {Volatile|}{Int|Double|...|Object}Ref class corresponding to the class `cls`,
    *  depending on whether the reference should be @volatile
@@ -68,6 +62,17 @@ class CapturedVars extends MiniPhaseTransform with SymTransformer { thisTransfor
     refCls(oldInfo.classSymbol, vble.isVolatile).typeRef
   }
 
+  override def prepareForValDef(vdef: ValDef)(implicit ctx: Context) = {
+    val sym = vdef.symbol
+    if (captured contains sym) {
+      val newd = sym.denot(ctx.withPhase(thisTransform)).copySymDenotation(
+        info = refCls(sym.info.classSymbol, sym.hasAnnotation(defn.VolatileAnnot)).typeRef)
+      newd.removeAnnotation(defn.VolatileAnnot)
+      newd.installAfter(thisTransform)
+    }
+    this
+  }
+
   override def transformValDef(vdef: ValDef)(implicit ctx: Context, info: TransformerInfo): Tree = {
     val vble = vdef.symbol
     if (captured contains vble) {