Fix scala#3876: Implement Expr.AsFunction

Author: nicolasstucki

compiler/src/dotty/tools/dotc/core/quoted/PickledQuotes.scala

@@ -1,17 +1,19 @@
 package dotty.tools.dotc.core.quoted
 
 import dotty.tools.dotc.ast.Trees._
-import dotty.tools.dotc.ast.{tpd, untpd}
+import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.config.Printers._
 import dotty.tools.dotc.core.Constants.Constant
 import dotty.tools.dotc.core.Contexts._
 import dotty.tools.dotc.core.Decorators._
 import dotty.tools.dotc.core.Flags._
+import dotty.tools.dotc.core.NameKinds
 import dotty.tools.dotc.core.StdNames._
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.tasty.{TastyPickler, TastyPrinter, TastyString}
 import dotty.tools.dotc.interpreter.RawQuoted
 
+import scala.quoted.Expr.FunctionAppliedTo
 import scala.reflect.ClassTag
 
 object PickledQuotes {
@@ -33,8 +35,14 @@ object PickledQuotes {
 
   /** Transform the expression into its fully spliced Tree */
   def quotedToTree(expr: quoted.Quoted)(implicit ctx: Context): Tree = expr match {
-    case expr: quoted.TastyQuoted => unpickleQuote(expr)
-    case expr: quoted.Liftable.ConstantExpr[_] => Literal(Constant(expr.value))
+    case expr: quoted.TastyQuoted =>
+      unpickleQuote(expr)
+    case expr: quoted.Liftable.ConstantExpr[_] =>
+      Literal(Constant(expr.value))
+    case expr: RawQuoted =>
+      expr.tree
+    case expr: FunctionAppliedTo[_, _] =>
+      functionAppliedTo(quotedToTree(expr.f), quotedToTree(expr.x))
     case expr: quoted.Type.TaggedPrimitive[_] =>
       val tpe = expr.ct match {
         case ClassTag.Unit => defn.UnitType
@@ -47,7 +55,6 @@ object PickledQuotes {
         case ClassTag.Double => defn.FloatType
       }
       TypeTree(tpe)
-    case expr: RawQuoted => expr.tree
   }
 
   /** Unpickle the tree contained in the TastyQuoted */
@@ -111,4 +118,28 @@ object PickledQuotes {
     }
     tree
   }
+
+  private def functionAppliedTo(f: Tree, x: Tree)(implicit ctx: Context): Tree = {
+    val x1 = SyntheticValDef(NameKinds.UniqueName.fresh("x".toTermName), x)
+    def x1Ref() = ref(x1.symbol)
+    def rec(f: Tree): Tree = f match {
+      case Block((ddef: DefDef) :: Nil, _: Closure) =>
+        new TreeMap() {
+          private val paramSym = ddef.vparamss.head.head.symbol
+          override def transform(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree = tree match {
+            case tree: Ident if tree.symbol == paramSym => x1Ref().withPos(tree.pos)
+            case _ => super.transform(tree)
+          }
+        }.transform(ddef.rhs)
+      case Block(stats, expr) =>
+        val applied = rec(expr)
+        if (stats.isEmpty) applied
+        else Block(stats, applied)
+      case Inlined(call, bindings, expansion) =>
+        Inlined(call, bindings, rec(expansion))
+      case _ =>
+        f.select(nme.apply).appliedTo(x1Ref())
+    }
+    Block(x1 :: Nil, rec(f))
+  }
 }

library/src/scala/quoted/Expr.scala

@@ -13,6 +13,8 @@ object Expr {
     ev.toExpr(x)
 
   implicit class AsFunction[T, U](private val f: Expr[T => U]) extends AnyVal {
-    def apply(x: Expr[T]): Expr[U] = ???
+    def apply(x: Expr[T]): Expr[U] = new FunctionAppliedTo[T, U](f, x)
   }
+
+  final class FunctionAppliedTo[T, U] private[Expr](val f: Expr[T => U], val x: Expr[T]) extends Expr[U]
 }

tests/run-with-compiler/i3876.check

@@ -0,0 +1,39 @@
+6
+{
+  val x$1: Int = 3
+  {
+    x$1.+(x$1)
+  }
+}
+6
+{
+  val x$1: Int = 3
+  {
+    def f(x: Int): Int = x.+(x)
+    f(x$1)
+  }
+}
+6
+{
+  val x$1: Int = 3
+  {
+    val f: 
+      Function1[Int, Int] 
+        {
+          def apply(x: Int): Int
+        }
+     = 
+      {
+        (x: Int) => x.+(x)
+      }
+    (f: (x: Int) => Int).apply(x$1)
+  }
+}
+6
+{
+  val x$1: Int = 3
+  /* inlined from Test*/ 
+    {
+      x$1.+(x$1)
+    }
+}

tests/run-with-compiler/i3876.scala

@@ -0,0 +1,33 @@
+import dotty.tools.dotc.quoted.Runners._
+import scala.quoted._
+object Test {
+  def main(args: Array[String]): Unit = {
+    val x: Expr[Int] = '(3)
+
+    val f: Expr[Int => Int] = '{ (x: Int) => x + x }
+    println(f(x).run)
+    println(f(x).show)
+
+    val f2: Expr[Int => Int] = '{
+      def f(x: Int): Int = x + x
+      f
+    }
+    println(f2(x).run)
+    println(f2(x).show)
+
+    val f3: Expr[Int => Int] = '{
+      val f: (x: Int) => Int = x => x + x
+      f
+    }
+    println(f3(x).run)
+    println(f3(x).show) // TODO improve printer
+
+    val f4: Expr[Int => Int] = '{
+      inlineLambda
+    }
+    println(f4(x).run)
+    println(f4(x).show)
+  }
+
+  inline def inlineLambda: Int => Int = x => x + x
+}