Fields does bitmaps & synch for lazy vals & modules

Essentially, we fuse mixin and lazyvals into the fields phase.
With fields mixing in trait members into subclasses, we
have all info needed to compute bitmaps, and thus we can
synthesize the synchronisation logic as well.

By doing this before erasure we get better signatures,
and before specialized means specialized lazy vals work now.
Mixins is now almost reduced to its essence: implementing
super accessors and forwarders. It still synthesizes
accessors for param accessors and early init trait vals.

Concretely, trait lazy vals are mixed into subclasses
with the needed synchronization logic in place, as do
lazy vals in classes and methods. Similarly, modules
are initialized using double checked locking.
Since the code to initialize a module is short,
we do not emit compute methods for modules (anymore).

For simplicity, local lazy vals do not get a compute method either.

The strange corner case of constant-typed final lazy vals
is resolved in favor of laziness, by no longer assigning
a constant type to a lazy val (see widenIfNecessary in namers).
If you explicitly ask for something lazy, you get laziness;
with the constant-typedness implicit, it yields to the
conflicting `lazy` modifier because it is explicit.

  Co-Authored-By: Lukas Rytz <lukas@lightbend.com>
  Fixes scala/scala-dev#133

Inspired by dotc, desugar a local `lazy val x = rhs` into

```
val x$lzy = new scala.runtime.LazyInt()
def x(): Int = {
    x$lzy.synchronized {
      if (!x$lzy.initialized) {
        x$lzy.initialized = true
        x$lzy.value = rhs
      }
      x$lzy.value
    }
}
```

Note that the 2.11 decoding (into a local variable and a bitmap) also
creates boxes for local lazy vals, in fact two for each lazy val:

```
def f = {
  lazy val x = 0
  x
}
```

desugars to

```
public int f() {
    IntRef x$lzy = IntRef.zero();
    VolatileByteRef bitmap$0 = VolatileByteRef.create((byte)0);
    return this.x$1(x$lzy, bitmap$0);
}

private final int x$lzycompute$1(IntRef x$lzy$1, VolatileByteRef bitmap$0$1) {
    C c = this;
    synchronized (c) {
        if ((byte)(bitmap$0$1.elem & 1) == 0) {
            x$lzy$1.elem = 0;
            bitmap$0$1.elem = (byte)(bitmap$0$1.elem | 1);
        }
        return x$lzy$1.elem;
    }
}

private final int x$1(IntRef x$lzy$1, VolatileByteRef bitmap$0$1) {
    return (byte)(bitmap$0$1.elem & 1) == 0 ?
      this.x$lzycompute$1(x$lzy$1, bitmap$0$1) : x$lzy$1.elem;
}
```

An additional problem with the above encoding is that the `lzycompute`
method synchronizes on `this`. In connection with the new lambda
encoding that no longer generates anonymous classes, captured lazy vals
no longer synchronize on the lambda object.

The new encoding solves this problem (scala/scala-dev#133)
by synchronizing on the lazy holder.

Currently, we don't exploit the fact that the initialized field
is `@volatile`, because it's not clear the performance is needed
for local lazy vals (as they are not contended, and as soon as
the VM warms up, biased locking should deal with that)

Note, be very very careful when moving to double-checked locking,
as this needs a different variation than the one we use for
class-member lazy vals. A read of a volatile field of a class
does not necessarily impart any knowledge about a "subsequent" read
of another non-volatile field of the same object. A pair of
volatile reads and write can be used to implement a lock, but it's
not clear if the complexity is worth an unproven performance gain.
(Once the performance gain is proven, let's change the encoding.)

  - don't explicitly init bitmap in bytecode
  - must apply method to () explicitly after uncurry

1 files changed, 2 insertions, 10 deletions

diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala
index af866e1a6f..32c446e16a 100644
--- a/src/compiler/scala/tools/nsc/Global.scala
+++ b/src/compiler/scala/tools/nsc/Global.scala
@@ -516,17 +516,11 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
     val runsRightAfter = Some("erasure")
   } with PostErasure
 
-  // phaseName = "lazyvals"
-  object lazyVals extends {
-    val global: Global.this.type = Global.this
-    val runsAfter = List("erasure")
-    val runsRightAfter = None
-  } with LazyVals
 
   // phaseName = "lambdalift"
   object lambdaLift extends {
     val global: Global.this.type = Global.this
-    val runsAfter = List("lazyvals")
+    val runsAfter = List("erasure")
     val runsRightAfter = None
   } with LambdaLift
 
@@ -620,13 +614,12 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
       pickler                 -> "serialize symbol tables",
       refChecks               -> "reference/override checking, translate nested objects",
       uncurry                 -> "uncurry, translate function values to anonymous classes",
-      fields                  -> "synthesize accessors and fields",
+      fields                  -> "synthesize accessors and fields, including bitmaps for lazy vals",
       tailCalls               -> "replace tail calls by jumps",
       specializeTypes         -> "@specialized-driven class and method specialization",
       explicitOuter           -> "this refs to outer pointers",
       erasure                 -> "erase types, add interfaces for traits",
       postErasure             -> "clean up erased inline classes",
-      lazyVals                -> "allocate bitmaps, translate lazy vals into lazified defs",
       lambdaLift              -> "move nested functions to top level",
       constructors            -> "move field definitions into constructors",
       mixer                   -> "mixin composition",
@@ -1258,7 +1251,6 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
     val explicitouterPhase           = phaseNamed("explicitouter")
     val erasurePhase                 = phaseNamed("erasure")
     val posterasurePhase             = phaseNamed("posterasure")
-    // val lazyvalsPhase                = phaseNamed("lazyvals")
     val lambdaliftPhase              = phaseNamed("lambdalift")
     // val constructorsPhase            = phaseNamed("constructors")
     val flattenPhase                 = phaseNamed("flatten")