Fix scala#4801: WIP

Author: nicolasstucki

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

@@ -2,10 +2,15 @@ package dotty.tools.dotc
 package transform
 
 import core._
-import Decorators._, Flags._, Types._, Contexts._, Symbols._, Constants._
+import Decorators._
+import Flags._
+import Types._
+import Contexts._
+import Symbols._
+import 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 +21,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.
@@ -78,7 +84,7 @@ class ReifyQuotes extends MacroTransformWithImplicits {
     if (ctx.compilationUnit.containsQuotesOrSplices) super.run
 
   protected def newTransformer(implicit ctx: Context): Transformer =
-    new Reifier(inQuote = false, null, 0, new LevelInfo, new mutable.ListBuffer[Tree])
+    new Reifier(inQuote = false, null, 0, new LevelInfo, new mutable.ListBuffer[Tree], null)
 
   private class LevelInfo {
     /** A map from locally defined symbols to the staging levels of their definitions */
@@ -108,16 +114,22 @@ class ReifyQuotes extends MacroTransformWithImplicits {
    *                     and `l == -1` is code inside a top level splice (in an inline method).
    *  @param  levels     a stacked map from symbols to the levels in which they were defined
    *  @param  embedded   a list of embedded quotes (if `inSplice = true`) or splices (if `inQuote = true`
+   *  @param  inlinedAtPos  if non null, the reifier is inside an inlined call with position `inlinedAtPos`
    */
   private class Reifier(inQuote: Boolean, val outer: Reifier, val level: Int, levels: LevelInfo,
-      val embedded: mutable.ListBuffer[Tree]) extends ImplicitsTransformer {
+      val embedded: mutable.ListBuffer[Tree], inlinedAtPos: SourcePosition) 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): Reifier = {
       val nestedEmbedded = if (level > 1 || (level == 1 && isQuote)) embedded else new mutable.ListBuffer[Tree]
-      new Reifier(isQuote, this, if (isQuote) level + 1 else level - 1, levels, nestedEmbedded)
+      new Reifier(isQuote, this, if (isQuote) level + 1 else level - 1, levels, nestedEmbedded, inlinedAtPos)
+    }
+
+    def inlined(inlinedAt: SourcePosition): Reifier = {
+      assert(level == 0)
+      new Reifier(true, this, 0, levels, embedded, inlinedAt)
     }
 
     /** We are in a `~(...)` context that is not shadowed by a nested `'(...)` */
@@ -126,6 +138,8 @@ class ReifyQuotes extends MacroTransformWithImplicits {
     /** We are not in a `~(...)` or a `'(...)` */
     def isRoot: Boolean = outer == null
 
+    def isInlined: Boolean = inlinedAtPos != null
+
     /** A map from type ref T to expressions of type `quoted.Type[T]`".
      *  These will be turned into splices using `addTags` and represent type variables
      *  that can be possibly healed.
@@ -418,14 +432,34 @@ class ReifyQuotes extends MacroTransformWithImplicits {
         val body1 = nested(isQuote = false).transform(splice.qualifier)
         body1.select(splice.name)
       }
-      else if (!inQuote && level == 0 && !ctx.owner.is(Inline)) {
-        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 (level == -1) {
+        // TODO add test
+        ctx.error("Cannot splice inside a top-level splice", splice.pos)
+        splice
+      }
+      else if (isInlined) { // level 0 in an inline call
+        val evaluatedSplice = Splicer.splice(splice.qualifier, inlinedAtPos, macroClassLoader).withPos(splice.pos)
+        if (ctx.reporter.hasErrors) splice else transform(evaluatedSplice)
+      } else if (ctx.owner.is(Inline)) { // level 0 in an inline definition
+        if (!Splicer.canBeSpliced(splice.qualifier))
+          ctx.error( // TODO adapt error message
+            """Malformed inline macro.
+              |
+              |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, splice.pos)
+        splice
+      }
+      else { // level 0
+        spliceOutsideQuotes(splice.pos)
+        splice
+      }
     }
 
     /** Transforms the contents of a nested splice
@@ -550,37 +584,10 @@ class ReifyQuotes extends MacroTransformWithImplicits {
             val last = enteredSyms
             stats.foreach(markDef)
             mapOverTree(last)
-          case Inlined(call, bindings, InlineSplice(spliced)) =>
-            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 tree: Inlined if !isInlined && level == 0 =>
+            inlined(tree.pos).transform(tree)
           case _: Import =>
             tree
-          case tree: DefDef if tree.symbol.is(Macro) && level == 0 =>
-            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 inline macro.
-                    |
-                    |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
-            }
           case _ =>
             markDef(tree)
             checkLevel(mapOverTree(enteredSyms))
@@ -614,18 +621,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

@@ -21,6 +21,7 @@ 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 +35,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 +71,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
 
@@ -210,7 +211,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 {
   inline def foo(inline 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 {
 
-  inline def foo1: Int = { // error
+  inline def foo1: Int = {
     println()
-    ~impl(1.toExpr)
+    ~impl(1.toExpr) // error
   }
 
-  inline def foo2: Int = { // error
-    ~impl(1.toExpr)
-    ~impl(2.toExpr)
+  inline def foo2: Int = {
+    ~impl(1.toExpr) // error
+    ~impl(2.toExpr) // error
   }
 
-  inline def foo3: Int = { // error
+  inline def foo3: Int = {
     val a = 1
     ~impl('(a))
   }
 
-  inline def foo4: Int = { // error
+  inline def foo4: Int = {
     ~impl('(1))
     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 {
+
+  inline 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))
+  }
+}