Fix #5144: Avoid Expr of method type

Author: nicolasstucki

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -20,7 +20,7 @@ import config.Config
 
 object TreePickler {
 
-  case class Hole(idx: Int, args: List[tpd.Tree]) extends tpd.TermTree {
+  case class Hole(idx: Int, args: List[tpd.Tree]) extends tpd.Tree {
     override def fallbackToText(printer: Printer): Text =
       s"[[$idx|" ~~ printer.toTextGlobal(args, ", ") ~~ "]]"
   }

compiler/src/dotty/tools/dotc/transform/ReifyQuotes.scala

@@ -123,13 +123,13 @@ class ReifyQuotes extends MacroTransformWithImplicits {
    *  @param  rctx       the contex in the destination lifted lambda
    */
   private class Reifier(inQuote: Boolean, val outer: Reifier, val level: Int, levels: LevelInfo,
-      val embedded: mutable.ListBuffer[Tree], val rctx: Context) extends ImplicitsTransformer {
+      val embedded: mutable.ListBuffer[(Symbol, Tree)], val rctx: Context) extends ImplicitsTransformer {
     import levels._
     assert(level >= -1)
 
     /** A nested reifier for a quote (if `isQuote = true`) or a splice (if not) */
     def nested(isQuote: Boolean)(implicit ctx: Context): Reifier = {
-      val nestedEmbedded = if (level > 1 || (level == 1 && isQuote)) embedded else new mutable.ListBuffer[Tree]
+      val nestedEmbedded = if (level > 1 || (level == 1 && isQuote)) embedded else new mutable.ListBuffer[(Symbol, Tree)]
       new Reifier(isQuote, this, if (isQuote) level + 1 else level - 1, levels, nestedEmbedded, ctx)
     }
 
@@ -423,7 +423,12 @@ class ReifyQuotes extends MacroTransformWithImplicits {
       }
       else if (level == 1) {
         val (body1, quotes) = nested(isQuote = false).split(splice.qualifier)
-        makeHole(body1, quotes, splice.tpe).withPos(splice.pos)
+        // TODO improve code
+        val tpe = outer.embedded.toList.find(_._1 == splice.qualifier.symbol) match {
+          case Some((_, tree)) => tree.tpe.widen
+          case _ => splice.tpe
+        }
+        makeHole(body1, quotes, tpe).withPos(splice.pos)
       }
       else if (enclosingInlineds.nonEmpty) { // level 0 in an inlined call
         val spliceCtx = ctx.outer // drop the last `inlineContext`
@@ -478,14 +483,18 @@ class ReifyQuotes extends MacroTransformWithImplicits {
           (captured: mutable.Map[Symbol, Tree]) => {
             (tree: Tree) => {
               def newCapture = {
-                val tpw = tree.tpe.widen
+                val tpw = tree.tpe.widen match {
+                  case tpw: MethodicType => tpw.toFunctionType()
+                  case tpw => tpw
+                }
+                assert(tpw.isInstanceOf[ValueType])
                 val argTpe =
                   if (tree.isType) defn.QuotedTypeType.appliedTo(tpw)
                   else defn.QuotedExprType.appliedTo(tpw)
                 val selectArg = arg.select(nme.apply).appliedTo(Literal(Constant(i))).asInstance(argTpe)
                 val capturedArg = SyntheticValDef(UniqueName.fresh(tree.symbol.name.toTermName).toTermName, selectArg)
                 i += 1
-                embedded += tree
+                embedded += Tuple2(capturedArg.symbol, tree)
                 captured.put(tree.symbol, capturedArg)
                 capturedArg
               }
@@ -522,15 +531,15 @@ class ReifyQuotes extends MacroTransformWithImplicits {
      */
     private def split(tree: Tree)(implicit ctx: Context): (Tree, List[Tree]) = {
       val tree1 = if (inQuote) addTags(transform(tree)) else makeLambda(tree)
-      (tree1, embedded.toList)
+      (tree1, embedded.toList.map(_._2))
     }
 
     /** Register `body` as an `embedded` quote or splice
      *  and return a hole with `splices` as arguments and the given type `tpe`.
      */
     private def makeHole(body: Tree, splices: List[Tree], tpe: Type)(implicit ctx: Context): Hole = {
       val idx = embedded.length
-      embedded += body
+      embedded += Tuple2(NoSymbol, body)
       Hole(idx, splices).withType(tpe).asInstanceOf[Hole]
     }
 

tests/run-with-compiler/i5144.check

@@ -0,0 +1,4 @@
+{
+  def f(x: scala.Int): scala.Int = ((x: scala.Int) => f(x)).apply(42)
+  ()
+}

tests/run-with-compiler/i5144.scala

@@ -0,0 +1,17 @@
+import scala.quoted._
+
+object Test {
+  implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make
+
+  def eval1(ff: Expr[Int => Int]): Expr[Int] = '((~ff)(42))
+
+  def peval1(): Expr[Unit] = '{
+    def f(x: Int): Int = ~eval1('(f))
+  }
+
+  def main(args: Array[String]): Unit = {
+    val p = peval1()
+    println(p.show)
+  }
+
+}

tests/run-with-compiler/i5144b.check

@@ -0,0 +1,7 @@
+{
+  def f(x: scala.Int): scala.Int = {
+    val x$1: scala.Int = 42
+    f(x$1)
+  }
+  ()
+}

tests/run-with-compiler/i5144b.scala

@@ -0,0 +1,17 @@
+import scala.quoted._
+
+object Test {
+  implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make
+
+  def eval1(ff: Expr[Int => Int]): Expr[Int] = ff('(42))
+
+  def peval1(): Expr[Unit] = '{
+    def f(x: Int): Int = ~eval1('(f))
+  }
+
+  def main(args: Array[String]): Unit = {
+    val p = peval1()
+    println(p.show)
+  }
+
+}