Lazy val without local.

Now `synchronized` is erased specially to avoid boxing,
we can drop that work around.

Note that this does add an extra cast and getter
call on the slow path, but that likely doesn't matter.

```
class C { def foo = {lazy val x = {println("a"); "A" }; x } }
```

becomes

```
def foo(): String = {
  lazy <artifact> val x$lzy: scala.runtime.LazyRef[String] = new scala.runtime.LazyRef[String]();

  <artifact> private def x$lzycompute(): String =
    x$lzy.synchronized[String]{
      if (x$lzy.initialized())
        x$lzy.value() // NOTE: gets an `.asInstanceOf[String]` after erasure
      else
        {
          x$lzy.value_=({
            scala.Predef.println("a");
            "A"
          });
          x$lzy.initialized_=(true);
          x$lzy.value() // NOTE: gets an `.asInstanceOf[String]` after erasure
        }
    }

  lazy def x(): String =
    if (x$lzy.initialized())
      x$lzy.value() // NOTE: gets an `.asInstanceOf[String]` after erasure
    else
      x$lzycompute();

  x()
}
```

0 files changed, 0 insertions, 0 deletions