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

Author: DarkDimius

src/dotty/runtime/LazyHolders.scala

@@ -0,0 +1,40 @@
+package dotty.runtime
+
+/**
+ * Classes used as holders for local lazy vals
+ */
+class LazyInt(init: => Int) {
+  lazy val value = init
+}
+
+class LazyLong(init: => Long) {
+  lazy val value = init
+}
+
+class LazyBoolean(init: => Boolean) {
+  lazy val value = init
+}
+
+class LazyDouble(init: => Double) {
+  lazy val value = init
+}
+
+class LazyFloat(init: => Float) {
+  lazy val value = init
+}
+
+class LazyByte(init: => Byte) {
+  lazy val value = init
+}
+
+class LazyRef(init: => AnyRef) {
+  lazy val value = init
+}
+
+class LazyShort(init: => Short) {
+  lazy val value = init
+}
+
+class LazyChar(init: => Char) {
+  lazy val value = init
+}

src/dotty/runtime/LazyVals.scala

@@ -0,0 +1,79 @@
+package dotty.runtime
+
+import scala.annotation.tailrec
+
+/**
+ * Helper methods used in thread-safe lazy vals.
+ */
+object LazyVals {
+  private val unsafe = scala.concurrent.util.Unsafe.instance
+
+  final val BITS_PER_LAZY_VAL = 2
+  final val LAZY_VAL_MASK = 3
+
+  @inline def STATE(cur: Long, ord: Long) = (cur >> (ord * BITS_PER_LAZY_VAL)) & LAZY_VAL_MASK
+  @inline def CAS(t: Object, offset: Long, e: Long, v: Long, ord: Int) = {
+    val mask = ~(LAZY_VAL_MASK << ord * BITS_PER_LAZY_VAL)
+    val n = (e & mask) | (v << (ord * BITS_PER_LAZY_VAL))
+    compareAndSet(t, offset, e, n)
+  }
+  @inline def setFlag(t: Object, offset: Long, v: Int, ord: Int) = {
+    var retry = true
+    while (retry) {
+      val cur = get(t, offset)
+      if (STATE(cur, ord) == 1) retry = CAS(t, offset, cur, v, ord)
+      else {
+        // cur == 2, somebody is waiting on monitor
+        if (CAS(t, offset, cur, v, ord)) {
+          val monitor = getMonitor(t, ord)
+          monitor.synchronized {
+            monitor.notifyAll()
+          }
+          retry = false
+        }
+      }
+    }
+  }
+  @inline def wait4Notification(t: Object, offset: Long, cur: Long, ord: Int) = {
+    var retry = true
+    while (retry) {
+      val cur = get(t, offset)
+      val state = STATE(cur, ord)
+      if (state == 1) CAS(t, offset, cur, 2, ord)
+      else if (state == 2) {
+        val monitor = getMonitor(t, ord)
+        monitor.synchronized {
+          monitor.wait()
+        }
+      }
+      else retry = false
+    }
+  }
+
+  @inline def compareAndSet(t: Object, off: Long, e: Long, v: Long) = unsafe.compareAndSwapLong(t, off, e, v)
+  @inline def get(t: Object, off: Long) = unsafe.getLongVolatile(t, off)
+
+  val processors: Int = java.lang.Runtime.getRuntime.availableProcessors()
+  val base: Int = 8 * processors * processors
+  val monitors: Array[Object] = (0 to base).map {
+    x => new Object()
+  }.toArray
+
+  @inline def getMonitor(obj: Object, fieldId: Int = 0) = {
+    var id = (java.lang.System.identityHashCode(obj) + fieldId) % base
+    if (id < 0) id += base
+    monitors(id)
+  }
+
+  @inline def getOffset(obj: Object, name: String) = unsafe.objectFieldOffset(obj.getClass.getDeclaredField(name))
+
+  object Names {
+    final val state = "STATE"
+    final val cas = "CAS"
+    final val setFlag = "setFlag"
+    final val wait4Notification = "wait4Notification"
+    final val compareAndSet = "compareAndSet"
+    final val get = "get"
+    final val getOffset = "getOffset"
+  }
+}

src/dotty/tools/dotc/Compiler.scala

@@ -8,15 +8,19 @@ import Symbols._
 import typer.{FrontEnd, Typer, Mode, ImportInfo}
 import reporting.ConsoleReporter
 import dotty.tools.dotc.core.Phases.Phase
+import dotty.tools.dotc.transform.{LazyValsCreateCompanionObjects, LazyValTranformContext}
+import dotty.tools.dotc.transform.TreeTransforms.{TreeTransform, TreeTransformer}
+import dotty.tools.dotc.transform.PostTyperTransformers.PostTyperTransformer
 
 class Compiler {
 
-  def phases: List[Phase] = List(
-      new FrontEnd,
-      new transform.SamplePhase)
+
+  def phases: List[Phase] = List(new FrontEnd, new transform.SamplePhase)
 
   var runId = 1
-  def nextRunId = { runId += 1; runId }
+  def nextRunId = {
+    runId += 1; runId
+  }
 
   def rootContext(implicit ctx: Context): Context = {
     ctx.definitions.init(ctx)

src/dotty/tools/dotc/core/Definitions.scala

@@ -233,6 +233,7 @@ class Definitions {
   lazy val AnnotationDefaultAnnot = ctx.requiredClass("dotty.annotation.internal.AnnotationDefault")
   lazy val ThrowsAnnot = ctx.requiredClass("scala.throws")
   lazy val UncheckedAnnot = ctx.requiredClass("scala.unchecked")
+  lazy val VolatileAnnot = ctx.requiredClass("scala.volatile")
 
   // convenient one-parameter method types
   def methOfAny(tp: Type) = MethodType(List(AnyType), tp)
@@ -266,6 +267,7 @@ class Definitions {
   def JavaRepeatedParamType = JavaRepeatedParamClass.typeRef
   def ThrowableType = ThrowableClass.typeRef
   def OptionType = OptionClass.typeRef
+  def VolatileAnnotType = VolatileAnnot.typeRef
 
   def ClassType(arg: Type)(implicit ctx: Context) = {
     val ctype = ClassClass.typeRef

src/dotty/tools/dotc/core/StdNames.scala

@@ -221,6 +221,7 @@ object StdNames {
     val FAKE_LOCAL_THIS: N          = "this$"
     val IMPLCLASS_CONSTRUCTOR: N    = "$init$"
     val LAZY_LOCAL: N               = "$lzy"
+    val LAZY_FIELD_OFFSET: N        = "OFFSET$"
     val LAZY_SLOW_SUFFIX: N         = "$lzycompute"
     val LOCAL_SUFFIX: N             = " "
     val UNIVERSE_BUILD_PREFIX: N    = "$u.build."

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

@@ -25,7 +25,7 @@ abstract class CreateCompanionObjects(group: TreeTransformer, idx: Int) extends
 
   /** Given class definition should return true if companion object creation should be enforced
     */
-  def predicate(cls: TypeDef): Boolean
+  def predicate(cls: TypeDef)(implicit ctx:Context): Boolean
 
   override def transformStats(trees: List[Tree])(implicit ctx: Context, info: TransformerInfo): List[tpd.Tree] = {
     @tailrec