Fix AST transformations of by-name parameters

project/Build.scala

@@ -96,6 +96,7 @@ object CoroutinesBuild extends MechaRepoBuild {
       "org.scalatest" % "scalatest_2.11" % "2.2.6" % "test",
       "org.scala-lang.modules" %% "scala-parser-combinators" % "1.0.2",
       "org.scala-lang" % "scala-reflect" % "2.11.4",
+      "org.scala-lang" % "scala-compiler" % "2.11.4",
       "org.scala-lang.modules" % "scala-async_2.11" % "0.9.5" % "bench"
     )
     case _ => Nil

src/main/scala/org/coroutines/AstCanonicalization.scala

@@ -8,7 +8,6 @@ import scala.language.experimental.macros
 import scala.reflect.macros.whitebox.Context
 
 
-
 /** Transforms the coroutine body into three address form with restricted control flow
  *  that contains only try-catch statements, while loops, if-statements, value and
  *  variable declarations, pattern matches, nested blocks and function calls.
@@ -90,7 +89,7 @@ trait AstCanonicalization[C <: Context] {
       val localvarname = TermName(c.freshName("x"))
       val decls = List(
         q"var $localvarname = null.asInstanceOf[Boolean]",
-        q""" 
+        q"""
           ..$conddecls
           if ($condident) {
             ..$thendecls
@@ -122,6 +121,48 @@ trait AstCanonicalization[C <: Context] {
       (decls, q"$localvarname")
     case q"$selector[..$tpts](...$paramss)" if tpts.length > 0 || paramss.length > 0 =>
       // application
+
+      // We first need to see which parameters, if any, are by-name. Those that are
+      // should not be canonicalized.
+
+      // Maps to the parameter lists, saying whether or not they are by-name.
+      val byNameParams: immutable.Seq[immutable.Seq[Boolean]] = {
+        // Check that `selector` has a non-trivial symbol. If it doesn't, we assume
+        // that there were no by-name parameters.
+        if (selector.symbol != null && selector.symbol != NoSymbol) {
+          val paramLists = selector.symbol.asMethod.paramLists
+
+          // This value does not contain repeated parameters.
+          val noRepeatedParamsSeq = paramLists.map { currentParamList =>
+            currentParamList.map { param => param.asTerm.isByNameParam }
+          }
+
+          // Check that parameters were both passed in to and requested by the method.
+          if (paramss.length > 0 && noRepeatedParamsSeq.length > 0) {
+            // Initially, we assume that no parameters were repeated.
+            var paramsSeq = noRepeatedParamsSeq
+
+            /** If the number of passed-in parameters is greater than the number of
+             *  parameters needed by the method, then we assume that there are repeated
+             *  parameters.
+             *
+             *  This problem is fixed by appending the last value in
+             *  `noRepeatedParamsSeq` to `paramsSeq`. This is done until the number of
+             *  parameters are equal.
+             */
+            while (paramss(0).length > paramsSeq(0).length) {
+              val newHead = paramsSeq(0) :+ paramsSeq(0).last
+              val newTail = paramsSeq.tail
+              paramsSeq = newHead :: newTail
+            }
+            paramsSeq
+          } else {
+            noRepeatedParamsSeq
+          }
+        } else {
+          immutable.Seq.fill(1, paramss(0).length)(false)
+        }
+      }
       val (rdecls, newselector) = selector match {
         case q"$r.$method" =>
           val (rdecls, rident) = canonicalize(r)
@@ -130,10 +171,34 @@ trait AstCanonicalization[C <: Context] {
           (Nil, q"$method")
       }
       for (tpt <- tpts) disallowCoroutinesIn(tpt)
-      val (pdeclss, pidents) = paramss.map(_.map(canonicalize).unzip).unzip
+
+      // Canonicalize parameters that are not by-name.
+      val paramsByNameUnmodified = {
+        val modifiedParamLists = mutable.Seq.fill[
+          List[(List[c.universe.Tree], c.universe.Tree)]](paramss.length)(null)
+
+        // Canonicalize each parameter list.
+        for (i <- 0 until paramss.length) {
+          val modifiedParams = mutable.Seq.fill[
+            (List[c.universe.Tree], c.universe.Tree)](paramss(i).length)(null)
+          for (j <- 0 until modifiedParams.length) {
+            if (byNameParams(i)(j)) {
+              modifiedParams(j) = (List(q""), paramss(i)(j))
+            } else {
+              modifiedParams(j) = canonicalize(paramss(i)(j))
+            }
+          }
+          modifiedParamLists(i) = modifiedParams.toList
+        }
+        modifiedParamLists.toList
+      }
+      val pdeclss =
+        paramsByNameUnmodified.map((_.map(tuple => tuple._1)))
+          .flatten.flatten.filter{ decl => decl != q"" }
+      val pidents = paramsByNameUnmodified.map((_.map(tuple => tuple._2)))
       val localvarname = TermName(c.freshName("x"))
       val localvartree = q"val $localvarname = $newselector[..$tpts](...$pidents)"
-      (rdecls ++ pdeclss.flatten.flatten ++ List(localvartree), q"$localvarname")
+      (rdecls ++ pdeclss ++ List(localvartree), q"$localvarname")
     case q"$r[..$tpts]" if tpts.length > 0 =>
       // type application
       for (tpt <- tpts) disallowCoroutinesIn(tpt)

src/test/scala/org/coroutines/async-await-tests.scala

@@ -7,7 +7,6 @@ import scala.annotation.unchecked.uncheckedVariance
 import scala.concurrent._
 import scala.concurrent.duration._
 import scala.concurrent.ExecutionContext.Implicits.global
-import scala.language.{ reflectiveCalls, postfixOps }
 import scala.util.Success
 
 
@@ -237,15 +236,14 @@ class AsyncAwaitTest extends FunSuite with Matchers {
     val fut = AsyncAwaitTest.async(coroutine { () =>
       Option(new ParamWrapper("value!")) match {
         case Some(valueHolder) =>
-          AsyncAwaitTest.await(Future(doAThing(valueHolder)))
+          AsyncAwaitTest.await(doAThing(valueHolder))
         case None =>
           None
       }
     })
 
     val result = Await.result(fut, 5 seconds)
-    assert(result.asInstanceOf[Future[ParamWrapper[String]]].value ==
-      Some(Success(None)))
+    assert(result == None)
   }
 
   // Source: https://git.io/vr7NW
@@ -309,25 +307,47 @@ class AsyncAwaitTest extends FunSuite with Matchers {
     assert(result == 103)
   }
 
-  // Source: https://git.io/vrFj3
+  /** Source: https://git.io/vrFj3
+   *  Modified so that there is no coroutine passed as a by-name parameter. For more
+   *  information, see https://git.io/vKkM5.
+   */
   test("nested await as bare expression") {
     val c = async(coroutine { () =>
-      await(Future(await(Future("")).isEmpty))
+      val emptyString = await(Future(""))
+      await(Future(emptyString.isEmpty))
     })
     val result = Await.result(c, 5 seconds)
     assert(result == true)
   }
 
-  // Source: https://git.io/vrAnM
+  /** Source: https://git.io/vrAnM
+   *  Modified so that there is no coroutine passed as a by-name parameter. For more
+   *  information, see https://git.io/vKkM5.
+   */
   test("nested await in block") {
     val c = async(coroutine { () =>
       ()
-      await(Future(await(Future("")).isEmpty))
+      val emptyString = await(Future(""))
+      await(Future(emptyString.isEmpty))
     })
     val result = Await.result(c, 5 seconds)
     assert(result == true)
   }
 
+  /** Source: https://git.io/vrAlJ
+   *  Modified so that there is no coroutine passed as a by-name parameter. For more
+   *  information, see https://git.io/vKkM5.
+   */
+  test("by-name expressions aren't lifted") {
+    def foo(ignored: => Any, b: Int) = b
+    val c = async(coroutine { () =>
+      val innerValue = await(Future(1))
+      await(Future(foo(???, innerValue)))
+    })
+    val result = Await.result(c, 5 seconds)
+    assert(result == 1)
+  }
+
   // Source: https://git.io/vrhTe
   test("named and default arguments respect evaluation order") {
     var i = 0