Handle lifted arguments in splices correctly

Author: nicolasstucki

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

@@ -228,7 +228,7 @@ class ReifyQuotes extends MacroTransformWithImplicits {
         !sym.is(Param) || levelOK(sym.owner)
     }
 
-    /** Issue a "splice outside quote" error unless we ar in the body of an inline method */
+    /** Issue a "splice outside quote" error unless we are in the body of an inline method */
     def spliceOutsideQuotes(pos: Position)(implicit ctx: Context): Unit =
       ctx.error(i"splice outside quotes", pos)
 
@@ -584,6 +584,8 @@ class ReifyQuotes extends MacroTransformWithImplicits {
                     |
                     |Expected the ~ to be at the top of the RHS:
                     |  inline def foo(x: X, ..., y: Y): Int = ~impl(x, ... '(y))
+                    |
+                    |The contents of the splice must call a static method. Arguments must be quoted or inlined.
                   """.stripMargin, tree.rhs.pos)
                 EmptyTree
             }
@@ -625,13 +627,11 @@ class ReifyQuotes extends MacroTransformWithImplicits {
      *  consists of a (possibly multiple & nested) block or a sole expression.
      */
     object InlineSplice {
-      def unapply(tree: Tree)(implicit ctx: Context): Option[Tree] = {
-        tree match {
-          case Select(qual, _) if tree.symbol.isSplice && Splicer.canBeSpliced(qual) => Some(qual)
-          case Block(List(stat), Literal(Constant(()))) => unapply(stat)
-          case Block(Nil, expr) => unapply(expr)
-          case _ => None
-        }
+      def unapply(tree: Tree)(implicit ctx: Context): Option[Tree] = tree match {
+        case Select(qual, _) if tree.symbol.isSplice && Splicer.canBeSpliced(qual) => Some(qual)
+        case Block(List(stat), Literal(Constant(()))) => unapply(stat)
+        case Block(Nil, expr) => unapply(expr)
+        case _ => None
       }
     }
   }

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

@@ -105,7 +105,7 @@ object Splicer {
     protected def interpretTastyContext()(implicit env: Env): Object =
       new TastyImpl(ctx)
 
-    protected def interpretStaticMethodCall(fn: Tree, args: List[Object])(implicit env: Env): Object = {
+    protected def interpretStaticMethodCall(fn: Tree, args: => List[Object])(implicit env: Env): Object = {
       val (clazz, instance) = loadModule(fn.symbol.owner)
       val method = getMethod(clazz, fn.symbol.name, paramsSig(fn.symbol))
       stopIfRuntimeException(method.invoke(instance, args: _*))
@@ -225,7 +225,7 @@ object Splicer {
     def interpretTypeQuote(tree: tpd.Tree)(implicit env: Env): Boolean = true
     def interpretLiteral(value: Any)(implicit env: Env): Boolean = true
     def interpretTastyContext()(implicit env: Env): Boolean = true
-    def interpretStaticMethodCall(fn: tpd.Tree, args: List[Boolean])(implicit env: Env): Boolean = args.forall(identity)
+    def interpretStaticMethodCall(fn: tpd.Tree, args: => List[Boolean])(implicit env: Env): Boolean = args.forall(identity)
 
     def unexpectedTree(tree: tpd.Tree)(implicit env: Env): Boolean = {
       // Assuming that top-level splices can only be in inline methods
@@ -244,7 +244,7 @@ object Splicer {
     protected def interpretTypeQuote(tree: Tree)(implicit env: Env): Res
     protected def interpretLiteral(value: Any)(implicit env: Env): Res
     protected def interpretTastyContext()(implicit env: Env): Res
-    protected def interpretStaticMethodCall(fn: Tree, args: List[Res])(implicit env: Env): Res
+    protected def interpretStaticMethodCall(fn: Tree, args: => List[Res])(implicit env: Env): Res
     protected def unexpectedTree(tree: Tree)(implicit env: Env): Res
 
     protected final def interpretTree(tree: Tree)(implicit env: Env): Res = tree match {
@@ -261,18 +261,18 @@ object Splicer {
         interpretTastyContext()
 
       case StaticMethodCall(fn, args) =>
-        val interpretedArgs = args.map(arg => interpretTree(arg))
-        interpretStaticMethodCall(fn, interpretedArgs)
+        interpretStaticMethodCall(fn, args.map(arg => interpretTree(arg)))
 
+      // Interpret `foo(j = x, i = y)` which it is expanded to
+      // `val j$1 = x; val i$1 = y; foo(i = y, j = x)`
       case Block(stats, expr) =>
         val newEnv = stats.foldLeft(env)((accEnv, stat) => stat match {
-          case stat: ValDef => accEnv.updated(stat.name, interpretTree(stat.rhs)(accEnv))
+          case stat: ValDef if stat.symbol.is(Synthetic) =>
+            accEnv.updated(stat.name, interpretTree(stat.rhs)(accEnv))
           case stat => return unexpectedTree(stat)
         })
         interpretTree(expr)(newEnv)
-
       case NamedArg(_, arg) => interpretTree(arg)
-
       case Ident(name) if env.contains(name) => env(name)
 
       case _ => unexpectedTree(tree)

compiler/src/dotty/tools/dotc/typer/EtaExpansion.scala

@@ -49,7 +49,7 @@ abstract class Lifter {
       // don't instantiate here, as the type params could be further constrained, see tests/pos/pickleinf.scala
       var liftedType = expr.tpe.widen
       if (liftedFlags.is(Method)) liftedType = ExprType(liftedType)
-      val lifted = ctx.newSymbol(ctx.owner, name, liftedFlags, liftedType, coord = positionCoord(expr.pos))
+      val lifted = ctx.newSymbol(ctx.owner, name, liftedFlags | Synthetic, liftedType, coord = positionCoord(expr.pos))
       defs += liftedDef(lifted, expr).withPos(expr.pos)
       ref(lifted.termRef).withPos(expr.pos.focus)
     }

tests/pos/i4493-b.scala renamed to tests/neg/i4493-b.scala

@@ -1,6 +1,6 @@
 class Index[K]
 object Index {
-  inline def succ[K](x: K): Unit = ~{
+  inline def succ[K](x: K): Unit = ~{ // error
     implicit val t: quoted.Type[K] = '[K]
     '(new Index[K])
   }

tests/pos/i4493.scala renamed to tests/neg/i4493.scala

@@ -1,6 +1,6 @@
 class Index[K]
 object Index {
-  inline def succ[K]: Unit = ~{
+  inline def succ[K]: Unit = ~{ // error
     implicit val t: quoted.Type[K] = '[K]
     '(new Index[K])
   }

tests/neg/quote-complex-top-splice.scala

@@ -0,0 +1,29 @@
+import Test.impl
+
+import scala.quoted._
+
+object Test {
+
+  inline def foo1: Unit = ~{ // error
+    val x = 1
+    impl(x)
+  }
+
+  inline def foo2: Unit = ~impl({ // error
+    val x = 1
+    x
+  })
+
+  inline def foo3: Unit = ~impl({ // error
+    println("foo3")
+    3
+  })
+
+  inline def foo4: Unit = ~{ // error
+    println("foo4")
+    impl(1)
+  }
+
+  def impl(i: Int): Expr[Unit] = '()
+
+}