allow await-free lazy vals

[retronym]

[lihaoyi]

I don't know if anyone's still reading this, but I just found myself wanting this, so here's my +1 to it being supported =)

[retronym]

+1 duly noted.

Here's the status quo. If I lift the restriction, and run:

import scala.async.internal.AsyncId._
async {
  var x = 0
  lazy val y = { x = 1; 42 }
  assert(x == 0, x)
  val z = await(1)
  y + x
}

We generate invalid code:

Caused by: java.lang.ClassFormatError: Duplicate method name&signature in class file __wrapper$1$f1d09519aa0244cc87024ba0460d82c3/__wrapper$1$f1d09519aa0244cc87024ba0460d82c3$stateMachine$macro$8$1

The macro expansion looks like:

[[syntax trees at end of                     typer]] // <no source file>
package __wrapper$1$f1d09519aa0244cc87024ba0460d82c3#12514 {
  object __wrapper$1$f1d09519aa0244cc87024ba0460d82c3#12516 extends Object#10 {
    def <init>#12521(): __wrapper$1$f1d09519aa0244cc87024ba0460d82c3#12515.__wrapper$1$f1d09519aa0244cc87024ba0460d82c3#12517.type = {
      __wrapper$1$f1d09519aa0244cc87024ba0460d82c3#12517.super.<init>#673();
      ()
    };
    def wrapper#12522(): Any#15 = {
      import scala#13.async#2463.internal#2520.AsyncId#2523._;
      {
        class stateMachine$macro$8#12790 extends AnyRef#140 with scala#14.util#12140.Try#12151[Any#15] => Unit#142 with () => Unit#142 {
          <synthetic> <stable> private[this] var await$macro$10$macro$11#12786: Int#391 = 0;
          <stable> private[this] var x$macro$12#12527: Int#391 = 0;
          <stable> lazy <artifact> private[this] var y$lzy$macro$13#12529: Int#391 = _;
          <stable> <accessor> lazy private[this] def y$macro$14#12528: Int#391 = {
            stateMachine$macro$8#12790.this.y$lzy$macro$13#12529 = 0;
            stateMachine$macro$8#12790.this.y$lzy$macro$13#12529
          };
          <stable> <accessor> lazy private[this] def y$macro$14#12528: Int#391 = {
            stateMachine$macro$8#12790.this.y$lzy$macro$13#12529 = {
              stateMachine$macro$8#12790.this.x$macro$12#12527 = 1;
              42
            };
            stateMachine$macro$8#12790.this.y$lzy$macro$13#12529
          };
          def <init>#12791(): stateMachine$macro$8#12790 = {
            stateMachine$macro$8#12790.super.<init>#673();
            ()
          };
          private[this] var state#12792: Int#391 = 0;
          private[this] val result#12794: scala#14.async#2464.internal#2521.IdentityFutureSystem#7579.Prom#7581[Int#391] = new scala#14.async#2464.internal#2521.IdentityFutureSystem#7579.Prom#7581[Int#391]();
          <stable> <accessor> def result#12793: scala#14.async#2464.internal#2521.IdentityFutureSystem#7579.Prom#7581[Int#391] = stateMachine$macro$8#12790.this.result#12794;
          private[this] val execContext#12796: Unit#142 = ();
          <stable> <accessor> def execContext#12795: Unit#142 = stateMachine$macro$8#12790.this.execContext#12796;
          def resume#12797(): Unit#142 = try {
            stateMachine$macro$8#12790.this.state#12792 match {
              case 0 => {
                ();
                stateMachine$macro$8#12790.this.x$macro$12#12527 = 0;
                stateMachine$macro$8#12790.this.y$lzy$macro$13#12529 = <empty>;
                scala#14.this.Predef#1924.assert#1980(stateMachine$macro$8#12790.this.x$macro$12#12527.==#425(0), stateMachine$macro$8#12790.this.x$macro$12#12527);
                <synthetic> val awaitable$macro$9#12785: Int#391(1) = 1;
                {
                  this.apply#12798(Success#12321.apply#12391[Int#391](awaitable$macro$9#12785));
                  ()
                };
                ()
              }
              case 1 => {
                stateMachine$macro$8#12790.this.result#12793.a_=#7585(Success#12321.apply#12391[Int#391]({
  val z#12530: Int#391 = stateMachine$macro$8#12790.this.await$macro$10$macro$11#12786;
  stateMachine$macro$8#12790.this.y$macro$14#12528.+#539(stateMachine$macro$8#12790.this.x$macro$12#12527)
}).get#12354);
                ()
              }
            }
          } catch {
            case (throwable#12836 @ _) if NonFatal#12144.apply#12406(throwable#12836) => {
              stateMachine$macro$8#12790.this.result#12793.a_=#7585(Failure#12318.apply#12457[Int#391](throwable#12836).get#12420);
              ()
            }
          };
          def apply#12798(tr#12804: scala#14.util#12140.Try#12151[Any#15]): Unit#142 = stateMachine$macro$8#12790.this.state#12792 match {
            case 0 => {
              if (tr#12804.isFailure#12261)
                {
                  stateMachine$macro$8#12790.this.result#12793.a_=#7585(tr#12804.asInstanceOf#723[scala#14.util#12140.Try#12151[Int#391]].get#12269);
                  ()
                }
              else
                {
                  stateMachine$macro$8#12790.this.await$macro$10$macro$11#12786 = tr#12804.get#12269.asInstanceOf#723[Int#391];
                  stateMachine$macro$8#12790.this.state#12792 = 1;
                  stateMachine$macro$8#12790.this.resume#12797()
                };
              ()
            }
          };
          def apply#12799: Unit#142 = stateMachine$macro$8#12790.this.resume#12797();
          private[this] val extra#12801: Unit#142 = ();
          <stable> <accessor> def extra#12800: Unit#142 = stateMachine$macro$8#12790.this.extra#12801
        };
        val stateMachine$macro$8#12841: stateMachine$macro$8#12790 = new stateMachine$macro$8#12790();
        stateMachine$macro$8#12841.apply#12799();
        stateMachine$macro$8#12841.result#12793.a#7584
      }
    }
  }
}

[retronym]

Notice that def y$macro$14#12528 is added twice to the tree.

[retronym]

If we're unable to cajole the lazy val rewriting to do cope with our transformed trees, we will be able to sidestep the issue by rewriting:

  var x = 0
  lazy val y = { x = 1; 42 }
  assert(x == 0, x)
  val z = await(1)
  val result = y + z
  assert(x == 1, x)
  result

as:

  class LazyRef[A](f: () => A) { lazy val value = f() }
  var x = 0
  val y$lazy = new LazyRef(() => {x = 1; 42 })
  assert(x == 0, x)
  val z = await(1)
  val result = y$lazy.value + z
  assert(x == 1, x)
  result

The rewritten code is accepted by async and has the right semantics.

[retronym]

Good news: the problem was just a dumb bug in the macro, and not some fundamental problem with transforming lazy locals into lazy fields.

[retronym]

I've just published 0.9.1 that includes this fix.