Merge pull request #67 from retronym/ticket/52-lazy-val

Allow lazy vals without await in the initializer

Author: phaller

src/main/scala/scala/async/internal/AsyncAnalysis.scala

@@ -60,9 +60,8 @@ trait AsyncAnalysis {
           super.traverse(tree)
         case Return(_)                                        =>
           c.abort(tree.pos, "return is illegal within a async block")
-        case ValDef(mods, _, _, _) if mods.hasFlag(Flag.LAZY) =>
-          // TODO lift this restriction
-          c.abort(tree.pos, "lazy vals are illegal within an async block")
+        case DefDef(mods, _, _, _, _, _) if mods.hasFlag(Flag.LAZY) && containsAwait =>
+          reportUnsupportedAwait(tree, "lazy val initializer")
         case CaseDef(_, guard, _) if guard exists isAwait     =>
           // TODO lift this restriction
           reportUnsupportedAwait(tree, "pattern guard")

src/main/scala/scala/async/internal/AsyncTransform.scala

@@ -57,8 +57,7 @@ trait AsyncTransform {
       val template = Template(List(tryToUnit, typeOf[() => Unit]).map(TypeTree(_)), emptyValDef, body)
 
       val t = ClassDef(NoMods, name.stateMachineT, Nil, template)
-      typingTransform(atPos(macroPos)(Block(t :: Nil, Literal(Constant(())))))((tree, api) => api.typecheck(tree))
-      t
+      typecheckClassDef(t)
     }
 
     val stateMachineClass = stateMachine.symbol
@@ -211,4 +210,12 @@ trait AsyncTransform {
     }
     result
   }
+
+  def typecheckClassDef(cd: ClassDef): ClassDef = {
+    val Block(cd1 :: Nil, _) = typingTransform(atPos(macroPos)(Block(cd :: Nil, Literal(Constant(())))))(
+      (tree, api) =>
+        api.typecheck(tree)
+    )
+    cd1.asInstanceOf[ClassDef]
+  }
 }

src/test/scala/scala/async/neg/NakedAwait.scala

@@ -163,10 +163,10 @@ class NakedAwait {
 
   @Test
   def lazyValIllegal() {
-    expectError("lazy vals are illegal") {
+    expectError("await must not be used under a lazy val initializer") {
       """
         | import _root_.scala.async.internal.AsyncId._
-        | def foo(): Any = async { val x = { lazy val y = 0; y } }
+        | def foo(): Any = async { val x = { lazy val y = await(0); y } }
         | ()
         |
         |""".stripMargin

src/test/scala/scala/async/run/lazyval/LazyValSpec.scala

@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.async
+package run
+package lazyval
+
+import org.junit.Test
+import scala.async.internal.AsyncId._
+
+class LazyValSpec {
+  @Test
+  def lazyValAllowed() {
+    val result = async {
+      var x = 0
+      lazy val y = { x += 1; 42 }
+      assert(x == 0, x)
+      val z = await(1)
+      val result = y + x
+      assert(x == 1, x)
+      identity(y)
+      assert(x == 1, x)
+      result
+    }
+    result mustBe 43
+  }
+}
+