Fix #4801: Allow top-level splices not directly in the RHS

For example a transparent method can be defined as
```
transparent def foo(b: Boolean): Int =
  if (b) ~bar(true)
  else ~bar(false)
```

Removing this restriction also allows us to have a simpler implementation
of splicing and transparent def checking.

Author: nicolasstucki

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

@@ -5,7 +5,7 @@ import core._
 import Decorators._, Flags._, Types._, Contexts._, Symbols._, Constants._
 import Flags._
 import ast.Trees._
-import ast.{TreeTypeMap, untpd}
+import ast.{TreeTypeMap, tpd, untpd}
 import util.Positions._
 import tasty.TreePickler.Hole
 import SymUtils._
@@ -16,6 +16,7 @@ import typer.Implicits.SearchFailureType
 import scala.collection.mutable
 import dotty.tools.dotc.core.StdNames._
 import dotty.tools.dotc.core.quoted._
+import dotty.tools.dotc.util.SourcePosition
 
 
 /** Translates quoted terms and types to `unpickle` method calls.
@@ -230,10 +231,6 @@ class ReifyQuotes extends MacroTransformWithImplicits {
         !sym.is(Param) || levelOK(sym.owner)
     }
 
-    /** Issue a "splice outside quote" error unless we are in the body of a transparent method */
-    def spliceOutsideQuotes(pos: Position)(implicit ctx: Context): Unit =
-      ctx.error(i"splice outside quotes", pos)
-
     /** Try to heal phase-inconsistent reference to type `T` using a local type definition.
      *  @return None      if successful
      *  @return Some(msg) if unsuccessful where `msg` is a potentially empty error message
@@ -292,7 +289,7 @@ class ReifyQuotes extends MacroTransformWithImplicits {
               outer.checkType(pos).foldOver(acc, tp)
             }
             else {
-              if (tp.isTerm) spliceOutsideQuotes(pos)
+              if (tp.isTerm) ctx.error(i"splice outside quotes", pos)
               tp
             }
           case tp: NamedType =>
@@ -418,14 +415,28 @@ class ReifyQuotes extends MacroTransformWithImplicits {
         val body1 = nested(isQuote = false).transform(splice.qualifier)
         body1.select(splice.name)
       }
-      else if (!inQuote && level == 0 && !ctx.owner.is(Transparent)) {
-        spliceOutsideQuotes(splice.pos)
-        splice
-      }
-      else {
+      else if (level == 1) {
         val (body1, quotes) = nested(isQuote = false).split(splice.qualifier)
         makeHole(body1, quotes, splice.tpe).withPos(splice.pos)
       }
+      else if (enclosingInlineds.nonEmpty) { // level 0 in an inline call
+        val spliceCtx = ctx.outer // drop the last `inlineContext`
+        val pos: SourcePosition = Decorators.sourcePos(enclosingInlineds.head.pos)(spliceCtx)
+        val evaluatedSplice = Splicer.splice(splice.qualifier, pos, macroClassLoader)(spliceCtx).withPos(splice.pos)
+        if (ctx.reporter.hasErrors) splice else transform(evaluatedSplice)
+      }
+      else if (!ctx.owner.ownersIterator.exists(_.is(Transparent))) { // level 0 outside a transparent definition
+        ctx.error(i"splice outside quotes or transparent method", splice.pos)
+        splice
+      }
+      else if (Splicer.canBeSpliced(splice.qualifier)) { // level 0 inside a transparent definition
+        nested(isQuote = false).split(splice.qualifier) // Just check PCP
+        splice
+      }
+      else { // level 0 inside a transparent definition
+        ctx.error("Malformed macro call. The contents of the ~ must call a static method and arguments must be quoted or transparent.".stripMargin, splice.pos)
+        splice
+      }
     }
 
     /** Transforms the contents of a nested splice
@@ -550,39 +561,10 @@ class ReifyQuotes extends MacroTransformWithImplicits {
             val last = enteredSyms
             stats.foreach(markDef)
             mapOverTree(last)
-          case Inlined(call, bindings, InlineSplice(spliced)) if !call.isEmpty =>
-            val tree2 =
-              if (level == 0) {
-                val evaluatedSplice = Splicer.splice(spliced, tree.pos, macroClassLoader).withPos(tree.pos)
-                if (ctx.reporter.hasErrors) EmptyTree
-                else transform(cpy.Inlined(tree)(call, bindings, evaluatedSplice))
-              }
-              else super.transform(tree)
-
-            // due to value-discarding which converts an { e } into { e; () })
-            if (tree.tpe =:= defn.UnitType) Block(tree2 :: Nil, Literal(Constant(())))
-            else tree2
           case _: Import =>
             tree
-          case tree: DefDef if tree.symbol.is(Macro) && level == 0 =>
-            if (enclosingInlineds.nonEmpty)
-              return EmptyTree // Already checked at definition site and already inlined
-            markDef(tree)
-            tree.rhs match {
-              case InlineSplice(_) =>
-                mapOverTree(enteredSyms) // Ignore output, only check PCP
-                cpy.DefDef(tree)(rhs = defaultValue(tree.rhs.tpe))
-              case _ =>
-                ctx.error(
-                  """Malformed transparent macro.
-                    |
-                    |Expected the ~ to be at the top of the RHS:
-                    |  transparent 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
-            }
+          case tree: DefDef if tree.symbol.is(Macro) && level == 0 && enclosingInlineds.nonEmpty =>
+            EmptyTree // Already checked at definition site and already inlined
           case _ =>
             markDef(tree)
             checkLevel(mapOverTree(enteredSyms))
@@ -616,18 +598,6 @@ class ReifyQuotes extends MacroTransformWithImplicits {
         acc.select("::".toTermName).appliedToType(tpe).appliedTo(x)
       }
     }
-
-    /** InlineSplice is used to detect cases where the expansion
-     *  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
-      }
-    }
   }
 }
 

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

@@ -20,7 +20,7 @@ import dotty.tools.dotc.core.Constants.Constant
 import dotty.tools.dotc.tastyreflect.TastyImpl
 
 import scala.util.control.NonFatal
-import dotty.tools.dotc.util.Positions.Position
+import dotty.tools.dotc.util.SourcePosition
 
 import scala.reflect.ClassTag
 
@@ -34,7 +34,7 @@ object Splicer {
    *
    *  See: `ReifyQuotes`
    */
-  def splice(tree: Tree, pos: Position, classLoader: ClassLoader)(implicit ctx: Context): Tree = tree match {
+  def splice(tree: Tree, pos: SourcePosition, classLoader: ClassLoader)(implicit ctx: Context): Tree = tree match {
     case Quoted(quotedTree) => quotedTree
     case _ =>
       val interpreter = new Interpreter(pos, classLoader)
@@ -70,7 +70,7 @@ object Splicer {
   }
 
   /** Tree interpreter that evaluates the tree */
-  private class Interpreter(pos: Position, classLoader: ClassLoader)(implicit ctx: Context) extends AbstractInterpreter {
+  private class Interpreter(pos: SourcePosition, classLoader: ClassLoader)(implicit ctx: Context) extends AbstractInterpreter {
 
     type Res = Object
 
@@ -219,7 +219,7 @@ object Splicer {
     }
 
     /** Exception that stops interpretation if some issue is found */
-    private class StopInterpretation(val msg: String, val pos: Position) extends Exception
+    private class StopInterpretation(val msg: String, val pos: SourcePosition) extends Exception
 
   }
 

tests/neg/quote-exception/Macro_1.scala

@@ -4,5 +4,5 @@ object Macro_1 {
   transparent def foo(transparent b: Boolean): Unit = ~fooImpl(b)
   def fooImpl(b: Boolean): Expr[Unit] =
     if (b) '(println("foo(true)"))
-  else ???
+    else ???
 }

tests/neg/quote-macro-splice.scala

@@ -2,22 +2,22 @@ import scala.quoted._
 
 object Test {
 
-  transparent def foo1: Int = { // error
+  transparent def foo1: Int = {
     println()
-    ~impl(1.toExpr)
+    ~impl(1.toExpr) // error
   }
 
-  transparent def foo2: Int = { // error
-    ~impl(1.toExpr)
-    ~impl(2.toExpr)
+  transparent def foo2: Int = {
+    ~impl(1.toExpr) // error
+    ~impl(2.toExpr) // error
   }
 
-  transparent def foo3: Int = { // error
+  transparent def foo3: Int = {
     val a = 1
     ~impl('(a))
   }
 
-  transparent def foo4: Int = { // error
+  transparent def foo4: Int = {
     ~impl('(1))
     1
   }

tests/neg/quote-pcp-in-arg.scala

@@ -0,0 +1,6 @@
+import scala.quoted._
+
+object Foo {
+  transparent def foo(x: Int): Int = ~bar('{ '(x); x }) // error
+  def bar(i: Expr[Int]): Expr[Int] = i
+}

tests/neg/splice-in-top-level-splice-1.scala

@@ -0,0 +1,7 @@
+import scala.quoted._
+
+object Foo {
+  transparent def foo(): Int = ~bar(~x) // error
+  def x: Expr[Int] = '(1)
+  def bar(i: Int): Expr[Int] = i.toExpr
+}

tests/neg/splice-in-top-level-splice-2.scala

@@ -0,0 +1,6 @@
+import scala.quoted._
+
+object Foo {
+  transparent def foo(): Int = ~(~x) // error
+  def x: Expr[Expr[Int]] = '( '(1) )
+}

tests/run/i4801.check

@@ -0,0 +1,3 @@
+1
+0
+1

tests/run/i4801/Macros_1.scala

@@ -0,0 +1,11 @@
+import scala.quoted._
+
+object Macro {
+
+  transparent def foo(b: Boolean): Int = {
+    if (b) ~bar(true)
+    else ~bar(false)
+  }
+
+  def bar(b: Boolean): Expr[Int] = if (b) '(1) else '(0)
+}

tests/run/i4801/Test_2.scala

@@ -0,0 +1,8 @@
+object Test {
+  def main(args: Array[String]): Unit = {
+    println(Macro.foo(true))
+    println(Macro.foo(false))
+    val x: Boolean = true
+    println(Macro.foo(x))
+  }
+}