Rework async expression wrapping

Wrap the async expression in `locally { ... }` to force value class boxing. This seems to work better than `{ ... }: Any`, which ends up with `Function` trees typed with `Any` which violoates an assumption in `delambdafy`.
scala · lrytz · Jun 18, 2020 · Feb 1, 2019 · Jan 30, 2019 · Dec 7, 2018
commit 7f22119a95b4e72713a04a707d8fd11c5d64b2b0
diff --git a/src/compiler/scala/tools/nsc/transform/UnCurry.scala b/src/compiler/scala/tools/nsc/transform/UnCurry.scala
@@ -408,7 +408,7 @@ abstract class UnCurry extends InfoTransform
       /* Transform tree `t` to { def f = t; f } where `f` is a fresh name */
       def liftTree(tree: Tree) = {
         debuglog("lifting tree at: " + (tree.pos))
-        val sym = currentOwner.newMethod(unit.freshTermName("liftedTree"), tree.pos)
+        val sym = currentOwner.newMethod(unit.freshTermName(nme.LIFTED_TREE), tree.pos, Flag.ARTIFACT)
         sym.setInfo(MethodType(List(), tree.tpe))
         tree.changeOwner(currentOwner, sym)
         localTyper.typedPos(tree.pos)(Block(

diff --git a/src/compiler/scala/tools/nsc/transform/async/AsyncAnalysis.scala b/src/compiler/scala/tools/nsc/transform/async/AsyncAnalysis.scala
@@ -40,7 +40,10 @@ trait AsyncAnalysis extends TransformUtils  {
     }
 
     override def nestedMethod(defDef: DefDef): Unit = {
-      reportUnsupportedAwait(defDef, "nested method")
+      if (defDef.symbol.isArtifact && defDef.name.startsWith(nme.LIFTED_TREE))
+        reportUnsupportedAwait(defDef, "try/catch")
+      else
+        reportUnsupportedAwait(defDef, "nested method")
     }
 
     override def byNameArgument(arg: Tree): Unit = {

diff --git a/src/compiler/scala/tools/nsc/transform/async/AsyncPhase.scala b/src/compiler/scala/tools/nsc/transform/async/AsyncPhase.scala
@@ -47,7 +47,7 @@ abstract class AsyncPhase extends Transform with TypingTransformers with AnfTran
     method.updateAttachment(new AsyncAttachment(awaitMethod, postAnfTransform, stateDiagram))
     // Wrap in `{ expr: Any }` to force value class boxing before calling `completeSuccess`, see test/async/run/value-class.scala
     deriveDefDef(method) { rhs =>
-      Block(Typed(rhs.updateAttachment(SuppressPureExpressionWarning), TypeTree(definitions.AnyTpe)), Literal(Constant(())))
+      Block(Apply(gen.mkAttributedRef(definitions.Predef_locally), rhs :: Nil), Literal(Constant(())))
     }.updateAttachment(ChangeOwnerAttachment(owner))
   }
 
@@ -116,7 +116,7 @@ abstract class AsyncPhase extends Transform with TypingTransformers with AnfTran
         case dd: DefDef if dd.hasAttachment[AsyncAttachment] =>
           val asyncAttachment = dd.getAndRemoveAttachment[AsyncAttachment].get
           val asyncBody = (dd.rhs: @unchecked) match {
-            case blk@Block(stats, Literal(Constant(()))) => treeCopy.Block(blk, stats.init, stats.last).setType(stats.last.tpe)
+            case blk@Block(Apply(qual, body :: Nil) :: Nil, Literal(Constant(()))) => body
           }
 
           atOwner(dd, dd.symbol) {

diff --git a/src/reflect/scala/reflect/internal/Definitions.scala b/src/reflect/scala/reflect/internal/Definitions.scala
@@ -378,6 +378,7 @@ trait Definitions extends api.StandardDefinitions {
     lazy val PredefModule               = requiredModule[scala.Predef.type]
          def Predef_wrapArray(tp: Type) = getMemberMethod(PredefModule, wrapArrayMethodName(tp))
          def Predef_???                 = getMemberMethod(PredefModule, nme.???)
+         def Predef_locally             = getMemberMethod(PredefModule, nme.locally)
     def isPredefMemberNamed(sym: Symbol, name: Name) = (
       (sym.name == name) && (sym.owner == PredefModule.moduleClass)
     )

diff --git a/src/reflect/scala/reflect/internal/StdNames.scala b/src/reflect/scala/reflect/internal/StdNames.scala
@@ -130,6 +130,7 @@ trait StdNames {
     val NESTED_IN_LAMBDA: String               = NESTED_IN + DELAMBDAFY_LAMBDA_CLASS_NAME.toString.replace("$", "")
 
     val NON_LOCAL_RETURN_KEY_STRING: String    = "nonLocalReturnKey"
+    val LIFTED_TREE: String                    = "liftedTree"
 
     /**
      * Ensures that name mangling does not accidentally make a class respond `true` to any of
@@ -745,6 +746,7 @@ trait StdNames {
     val lang: NameType                 = "lang"
     val length: NameType               = "length"
     val lengthCompare: NameType        = "lengthCompare"
+    val locally: NameType              = "locally"
     val longHash: NameType             = "longHash"
     val macroContext : NameType        = "c"
     val main: NameType                 = "main"
@@ -1126,6 +1128,7 @@ trait StdNames {
     val reflParamsCacheName: NameType = "reflParams$Cache"
     val reflMethodName: NameType      = "reflMethod$Method"
     val argument: NameType            = "<argument>"
+    val liftedTree: String            = "liftedTree"
 
   }
 

diff --git a/src/reflect/scala/reflect/internal/Trees.scala b/src/reflect/scala/reflect/internal/Trees.scala
@@ -478,7 +478,14 @@ trait Trees extends api.Trees {
   case class ArrayValue(elemtpt: Tree, elems: List[Tree]) extends TermTree
 
   case class Function(vparams: List[ValDef], body: Tree)
-       extends SymTree with TermTree with FunctionApi
+       extends SymTree with TermTree with FunctionApi {
+
+    override def tpe_=(tp: Type): Unit = {
+      if (!definitions.isFunctionType(tp))
+        new Throwable().printStackTrace()
+      super.setType(tp)
+    }
+  }
   object Function extends FunctionExtractor
 
   case class Assign(lhs: Tree, rhs: Tree)

diff --git a/test/async/run/lambda.flags b/test/async/run/lambda.flags
@@ -0,0 +1 @@
+-Xasync
diff --git a/test/async/run/lambda.scala b/test/async/run/lambda.scala
@@ -0,0 +1,16 @@
+import scala.tools.partest.async.OptionAwait._
+//import org.junit.Assert._
+
+object Test {
+  def main(args: Array[String]): Unit = {
+     lambda()
+  }
+
+  private def lambda() = {
+    val l = optionally{
+      value(Some(1))
+      (a: String) => a.length
+    }.get
+    //assertEquals(1, l("a"))
+  }
+}