wip

Author: nicolasstucki

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

@@ -62,6 +62,30 @@ import dotty.tools.dotc.core.quoted._
  *     )
  *    ```
  *  and then performs the same transformation on `'{ ... x1$1.unary_~ ... x2$1.unary_~ ...}`.
+ *
+ *
+ *  For inline macro definitions we assume that we have a single ~ directly as the RHS.
+ *  We will transform the definition from
+ *    ```
+ *    inline def foo[T1, ...](inline x1: X, ..., y1: Y, ....): Z = ~{ ... T1 ... x ... '(y) ... }
+ *    ```
+ *  to
+ *    ```
+ *    inline def foo[T1, ...](inline x1: X, ..., y1: Y, ....): Seq[Any] => Object = { (args: Seq[Any]) => {
+ *      val T1$1 = args(0).asInstanceOf[Type[T1]]
+ *      ...
+ *      val x1$1 = args(0).asInstanceOf[X]
+ *      ...
+ *      val y1$1 = args(1).asInstanceOf[Expr[Y]]
+ *      ...
+ *      { ... T1$1.unary_~ ... x ... '(y1$1.unary_~) ... }
+ *    }
+ *    ```
+ *  Note: the parameters of `foo` are kept for simple overloading resolution but they are not used in the body of `foo`.
+ *
+ *  At inline site we will call reflectively the static method `foo` with dummy parameters, which will return a
+ *  precompiled version of the function that will evaluate the `Expr[Z]` that `foo` produces. The lambda is then called
+ *  at the inline site with the lifted arguments of the inlined call.
  */
 class ReifyQuotes extends MacroTransformWithImplicits with InfoTransformer {
   import ast.tpd._
@@ -444,13 +468,8 @@ class ReifyQuotes extends MacroTransformWithImplicits with InfoTransformer {
       val captured = mutable.LinkedHashMap.empty[Symbol, Tree]
       val captured2 = capturer(captured)
       outer.enteredSyms.foreach(s => capturers.put(s, captured2))
-      if (ctx.owner.owner.is(Macro)) {
-        outer.enteredSyms.reverse.foreach(s => {
-          assert(s.is(Param))
-          assert(s.owner == ctx.owner.owner)
-          captured2(ref(s))
-        })
-      }
+      if (ctx.owner.owner.is(Macro))
+        outer.enteredSyms.reverse.foreach(s => captured2(ref(s)))
       val tree2 = transform(tree)
       capturers --= outer.enteredSyms
       seq(captured.result().valuesIterator.toList, tree2)
@@ -524,15 +543,31 @@ class ReifyQuotes extends MacroTransformWithImplicits with InfoTransformer {
           case _: Import =>
             tree
           case tree: DefDef if tree.symbol.is(Macro) && level == 0 =>
-            if (!tree.symbol.isStatic)
-              ctx.error("Inline macro method must be a static method.", tree.pos)
-            markDef(tree)
-            val reifier = nested(isQuote = true)
-            reifier.transform(tree) // Ignore output, we only need the its embedding
-            assert(reifier.embedded.size == 1)
-            val macroLambda = reifier.embedded.head
-            // replace macro code by lambda used to evaluate the macro expansion
-            cpy.DefDef(tree)(tpt = TypeTree(defn.ObjectType), rhs = macroLambda)
+            tree.rhs match {
+              case InlineSplice(_) =>
+                if (!tree.symbol.isStatic)
+                  ctx.error("Inline macro method must be a static method.", tree.pos)
+                markDef(tree)
+                val reifier = nested(isQuote = true)
+                reifier.transform(tree) // Ignore output, we only need the its embedding
+                assert(reifier.embedded.size == 1)
+                val lambda = reifier.embedded.head
+                // replace macro code by lambda used to evaluate the macro expansion
+                cpy.DefDef(tree)(tpt = TypeTree(macroReturnType), rhs = lambda)
+              case _ =>
+                ctx.error(
+                  """Malformed inline macro.
+                    |
+                    |Expected the ~ to be at the top of the RHS:
+                    |  inline def foo(...): Int = ~impl(...)
+                    |or
+                    |  inline def foo(...): Int = ~{
+                    |    val x = 1
+                    |    impl(... x ...)
+                    |  }
+                  """.stripMargin, tree.rhs.pos)
+                EmptyTree
+            }
           case _ =>
             markDef(tree)
             checkLevel(mapOverTree(enteredSyms))
@@ -561,21 +596,25 @@ class ReifyQuotes extends MacroTransformWithImplicits with InfoTransformer {
   }
 
   def transformInfo(tp: Type, sym: Symbol)(implicit ctx: Context): Type = {
-    /** Transforms the return type
+    /** Transforms the return type of
      *    inline def foo(...): X = ~(...)
      *  to
-     *    inline def foo(...): Seq[Any] => Object = (args: Seq[Any]) => ...
+     *    inline def foo(...): Seq[Any] => Expr[Any] = (args: Seq[Any]) => ...
      */
     def transform(tp: Type): Type = tp match {
-      case tp: PolyType => PolyType(tp.paramNames, tp.paramInfos, transform(tp.resType))
       case tp: MethodType => MethodType(tp.paramNames, tp.paramInfos, transform(tp.resType))
+      case tp: PolyType => PolyType(tp.paramNames, tp.paramInfos, transform(tp.resType))
       case tp: ExprType => ExprType(transform(tp.resType))
-      case _ => defn.FunctionType(1).appliedTo(defn.SeqType.appliedTo(defn.AnyType), defn.ObjectType)
+      case _ => macroReturnType
     }
     transform(tp)
   }
 
-  override protected def mayChange(sym: Symbol)(implicit ctx: Context) = sym.is(Macro)
+  override protected def mayChange(sym: Symbol)(implicit ctx: Context): Boolean = sym.is(Macro)
+
+  /** Returns the type of the compiled macro as a lambda: Seq[Any] => Object */
+  private def macroReturnType(implicit ctx: Context): Type =
+    defn.FunctionType(1).appliedTo(defn.SeqType.appliedTo(defn.AnyType), defn.ObjectType)
 }
 
 object ReifyQuotes {

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

@@ -27,6 +27,8 @@ object Splicer {
   /** Splice the Tree for a Quoted expression. `~'(xyz)` becomes `xyz`
    *  and for `~xyz` the tree of `xyz` is interpreted for which the
    *  resulting expression is returned as a `Tree`
+   *
+   *  See: `ReifyQuotes`
    */
   def splice(tree: Tree, call: Tree, bindings: List[Tree], pos: Position)(implicit ctx: Context): Tree = tree match {
     case Quoted(quotedTree) => quotedTree
@@ -40,7 +42,12 @@ object Splicer {
     interpreted.flatMap(lambda => evaluateLambda(lambda, liftedArgs, pos)).fold(tree)(PickledQuotes.quotedExprToTree)
   }
 
-  private def getLiftedArgs(call: Tree, bindings: List[Tree])(implicit ctx: Context) = {
+  /** Given the inline code and bindings, compute the lifted arguments that will be used to execute the macro
+   *  - Type parameters are lifted to quoted.Types.TreeType
+   *  - Inline parameters are listed as their value
+   *  - Other parameters are lifted to quoted.Types.TreeExpr (may reference a binding)
+   */
+  private def getLiftedArgs(call: Tree, bindings: List[Tree])(implicit ctx: Context): List[Any] = {
     val bindMap = bindings.map {
       case vdef: ValDef => (vdef.rhs, ref(vdef.symbol))
     }.toMap
@@ -55,6 +62,7 @@ object Splicer {
           case (arg: Literal, tp) if tp.hasAnnotation(defn.InlineParamAnnot) => arg.const.value
           case (arg, tp) =>
             assert(!tp.hasAnnotation(defn.InlineParamAnnot))
+            // Replace argument by its binding
             new scala.quoted.Exprs.TreeExpr(bindMap.getOrElse(arg, arg))
         }
         args1 ::: liftArgs(tp.resType, args.tail)

tests/neg/quote-macro-splice.scala

@@ -0,0 +1,27 @@
+import scala.quoted._
+
+object Test {
+
+  inline def foo1: Int = { // error
+    println()
+    ~impl(1.toExpr)
+  }
+
+  inline def foo2: Int = { // error
+    ~impl(1.toExpr)
+    ~impl(2.toExpr)
+  }
+
+  inline def foo3: Int = { // error
+    val a = 1
+    ~impl('(a))
+  }
+
+  inline def foo4: Int = { // error
+    ~impl('(1))
+    1
+  }
+
+  def impl(n: Expr[Int]): Expr[Int] = ???
+
+}