LazyVals phase.

Creates accessors for lazy vals:
1) lazy local vals are rewritten to dotty.runtime.Lazy*** holders
2) for a non-volatile field lazy val create a non-thread-safe accessor and flag:
2.a) if lazy val type indicates that val is not nullable, uses null value as a flag
2.b) else uses boolean flag for sake of performance, method size, and
allowing more jvm optimizations
3) for a volatile field lazy val use double locking scheme, that guaranties no
spurious deadlocks, using long bits as bitmaps and creating companion
objects to store offsets needed for unsafe methods.

Conflicts:
	test/dotc/tests.scala

1 files changed, 6 insertions, 2 deletions

diff --git a/src/dotty/tools/dotc/transform/TreeTransform.scala b/src/dotty/tools/dotc/transform/TreeTransform.scala
index ecbe8daaf..3e29af0e4 100644
--- a/src/dotty/tools/dotc/transform/TreeTransform.scala
+++ b/src/dotty/tools/dotc/transform/TreeTransform.scala
@@ -113,13 +113,16 @@ object TreeTransforms {
     def transformStats(trees: List[Tree])(implicit ctx: Context, info: TransformerInfo): List[Tree] = trees
 
     /** Transform tree using all transforms of current group (including this one) */
-    def transform(tree: Tree)(implicit ctx: Context): Tree = group.transform(tree)
+    def transform(tree: Tree)(implicit ctx: Context, info: TransformerInfo): Tree = group.transform(tree, info, 0)
 
     /** Transform subtree using all transforms following the current one in this group */
     def transformFollowingDeep(tree: Tree)(implicit ctx: Context, info: TransformerInfo): Tree = group.transform(tree, info, idx + 1)
 
     /** Transform single node using all transforms following the current one in this group */
     def transformFollowing(tree: Tree)(implicit ctx: Context, info: TransformerInfo): Tree = group.transformSingle(tree, idx + 1)
+
+    /** perform context-dependant initialization */
+    def init(implicit ctx:Context): Unit = {}
   }
 
   val NoTransform = new TreeTransform(null, -1)
@@ -402,7 +405,7 @@ object TreeTransforms {
       var nxCopied = false
       var result = info.transformers
       var resultNX = info.nx
-      var i = mutationPlan(cur)
+      var i = mutationPlan(0) // if TreeTransform.transform() method didn't exist we could have used mutationPlan(cur)
       val l = result.length
       var allDone = i < l
       while (i < l) {
@@ -459,6 +462,7 @@ object TreeTransforms {
 
     def transform(t: Tree)(implicit ctx: Context): Tree = {
       val initialTransformations = transformations.zipWithIndex.map(x => x._1(this, x._2))
+      initialTransformations.foreach(_.init)
       transform(t, new TransformerInfo(initialTransformations, new NXTransformations(initialTransformations)), 0)
     }